Una lámpara inteligente para los "ricos" con sus manos "flojas", es "simple" y conveniente



Introducción


Hizo una iluminación "moderna" en la cocina para un fregadero, una estufa y una mesa de corte sobre la base de una tira de LED controlada por arduino (que se llame la lámpara 1). Este diseño funcionó durante 2 años, hasta que la parte de potencia de los "cerebros" se ha deteriorado. Esta es una excelente ocasión para reinventar la rueda de la "basura improvisada" nuevamente (lámpara 2). Es cierto que esta vez la "basura" será costosa y compatible con el hogar inteligente Z-wave. La siguiente es una historia sobre el reemplazo de arduino con ZUNo (un módulo compatible con arduino para crear un dispositivo de onda Z) con el máximo ahorro de código y una explicación de los cambios necesarios.

¿Qué pasó antes de que apareciera allí?


Érase una vez, para lavar los platos o cocinar, era necesario encender la lámpara sobre el fregadero. Era una lámpara de mesa renovada.

No me gustaba presionar el pequeño interruptor con las manos mojadas porque cambiaba 220 voltios a la lámpara incandescente.



Además, la luz de la lámpara cayó principalmente en el fregadero, pero quería iluminar mejor la mesa de cocina y la estufa.

Objetivos:

  • Haga que la luz de encendido / apagado en la cocina no tenga contacto;
  • Ilumina uniformemente el fregadero, la mesa de cocina y la estufa;
  • Ahorre energía reemplazando las bombillas incandescentes con LED.

Ensambló la lámpara 1. Consistía en una caja de aluminio de 2 metros con un difusor para cinta RGB y una unidad de control. Se compraron una caja y un difusor listos para usar en la tienda, había una cinta y la unidad de control llevaba mucho tiempo en la esquina y esperaba en las alas.

El estuche era industrial (a prueba de polvo, impermeable). Dado que la cinta es de 12 voltios, la unidad de fuente de alimentación de 220 V a 12 V se encuentra en la unidad, la placa de aislamiento galvánico para controlar la cinta basada en TLP250 (optoacoplador) también controla todo este arduino en un diseño compacto.
Obtuve el aislamiento galvánico del antiguo proyecto. Una vez hice una luz de fondo para un minibar en mi mesita de noche. Cuando se abrió la puerta, el panel táctil registró un cambio de capacidad y encendió una luz suave y brillante. Es decir, la junta era adecuada para el proyecto actual, todo lo que quedaba era cortar todo lo innecesario. Había un convertidor lineal de 5 voltios en el tablero, funcionaba con ZUNo.

Se planeó encender la lámpara con una bandeja manual para el medidor de distancia ultrasónico. Lo montó en la tapa, y todas las otras partes se metieron en la caja. Todo "confiablemente" fijado con adhesivo termofusible. En el momento de la prueba, hice un botón al lado de la fuente de alimentación a la unidad de control desde el interruptor de luz para la instalación externa.



Encender las luces se ha vuelto más conveniente y seguro. Estaba conectado boca abajo al fondo del armario de la cocina y era más difícil sacar agua de las manos mojadas desde el interior.

Conclusiones de la unidad de control anterior.


La iluminación del área de trabajo de la cocina se volvió más uniforme y placentera, debido a la reproducción de color no natural de mi tira de LED, el color de algunos productos cambió. Por ejemplo: las zanahorias parecían mucho más apetitosas debido al color más brillante. Pero no interfirió mucho, y espero que no haya hecho mucho daño.

Con el encendido / apagado sin contacto, todo resultó ser peor. Funcionó. Pero después de 5 minutos en estado apagado, comenzaron los destellos en la tira de LED. No comencé a rehacer el circuito con optoacopladores y dejé todo como está. Solo para encender y apagar comenzó a usar el nuevo interruptor. A todos les gustó su ubicación y forma.
Durante dos años de uso, la grasa y otros compuestos secretados durante la cocción se acumulan en el cuerpo y en su interior. Esta placa penetró parcialmente en la carcasa a través de los agujeros para la entrada de cables. Pero debido a la superficie brillante del cuerpo, esta sustancia se condensa en una masa gelatinosa. Es agradable al tacto, inodoro y ... (no lo probé). Tomé algunas fotos del lugar en forma de germen de dragón.





En las paredes, esta sustancia se convierte en una incursión terrible, que no solo se lava.

Lo que se ha convertido


Habiendo hurgado en contenedores encontré un módulo de expansión inacabado para ZUNo. ZUNo es una placa tipo arduino para diseñar su propio dispositivo compatible con el hogar inteligente Z-Wave. Se programa desde el entorno de arduino.

Especificaciones del fabricante:
  • 28 kB Flash memory for your sketches
  • 2 kB RAM available
  • Z-Wave RF transmitter at 9.6/40/100 kbps
  • 26 GPIO (overlaps with special hardware controllers)
  • 4 ADC
  • 5 PWM
  • 2 UART
  • 1 USB (serial port)
  • 16 kB EEPROM
  • 1 SPI (master or slave)
  • 4 IR controllers, 1 IR learn capability
  • 1 TRIAC/ZEROX to control dimmer
  • 3 Interrupts
  • 1 Timer 4 MHz
  • I2C (software)
  • 1-Wire (software)
  • 8x6 Keypad Scanner (software)
  • 2 service LED, 1 service button
  • 1 user test LED


El módulo de expansión convierte a ZUNo en una placa de depuración completa que, después de depurar el prototipo, puede usarse como un dispositivo completo.

Alguna información del fabricante:
  • One 0-10 V analog output — control industrial dimmers
  • Up to four PWM or switch outputs (up to 5 A per channel) — control contactors, switches, halogen bulbs or LED strips
  • Up to eight digital 0/3 V inputs or outputs — connect various low voltage digital senors and actors
  • Up to four digital 0/3, 0/5 or 0/12 V digital or analog inputs — connect industrial 10 V sensors or any Arduino-compatible sensor
  • RS485 or UART — for industial meters
  • OneWire — for DS18B20 or other sensors


Para mi proyecto, necesito 3 transistores potentes para cambiar 12 voltios a una tira de LED y un convertidor de 12 voltios a 5 voltios para alimentar ZUNo. El resto de la periferia del módulo de expansión no está soldado ni probado.



En esta parte del circuito, no hay suficiente diodo para la fuente de alimentación, para la protección contra la "inversión de polaridad", y las resistencias en las puertas de los transistores de efecto de campo de potencia debían conectarse a la puerta, y no frente a la resistencia limitadora. Escribiré más sobre esto en las conclusiones.

Este módulo de expansión se suministra en una carcasa de Gainta. Mi unidad de control anterior también era en el caso de esta compañía, pero de un tamaño diferente. Desafortunadamente, las fijaciones en el módulo no se ajustaban al caso anterior, y no quería perforar uno nuevo, dejé el caso anterior. El tablero se "plantó" sobre adhesivo termofusible.



Un poco sobre la programación de Arduino y ZUNo


Los dispositivos de onda Z deben tener un cierto número de clases. Las clases describen las funciones del dispositivo y las interfaces de interacción. Por ejemplo, mi lámpara controla una tira de LED que consta de tres colores (rojo, verde, azul). Estas funciones son realizadas por la clase Switch multinivel. Si lo agregamos al boceto, podemos cambiar de forma remota el brillo de uno de los colores. Para controlar tres colores, debe hacer tres instancias de esta clase. No hablaré sobre esto con más detalle y detalle. Debido a que la manipulación de clase de rutina está oculta para los usuarios de ZUNo por la noción de "canal". Por ejemplo, necesito tres clases de Switch multinivel, por lo que en el código deben aparecer 3 canales de Switch multinivel y varias funciones de devolución de llamada para el control de radio. ¿Como hacer esto? También necesita agregar la clase básica Switch,para encender y apagar la lámpara con solo tocar un botón (desde la interfaz del controlador de red), y no configurar 3 canales cada vez.

Debe ir al sitio web de desarrolladores, donde se presentan ejemplos de z-uno.z-wave.me/Reference/ZUNO_SWITCH_MULTILEVEL . Cada clase admitida por ZUNo tiene una descripción y un ejemplo. Luego, copie y pegue las funciones propuestas en su boceto. Ahora en el boceto hay tres canales multinivel de conmutación y 6 funciones de devolución de llamada para responder a comandos en la radio. No soy muy sofisticado en las clases de Z-Wave, por lo que mi dispositivo de tira de LED anterior funcionaba con este conjunto de clases.

Los canales fueron declarados así:

Encabezado de spoiler
ZUNO_SETUP_CHANNELS(
      ZUNO_SWITCH_MULTILEVEL(getRed, setRed),
      ZUNO_SWITCH_MULTILEVEL(getGreen, setGreen),
      ZUNO_SWITCH_MULTILEVEL(getBlue, setBlue),
      ZUNO_SWITCH_BINARY(switch_getter, switch_setter)
);


Esto llevó a la generación de los siguientes widgets en el controlador después de agregarlos a la red:



Para ajustar el color, era necesario abrir y configurar cada color en el menú del controlador por separado. No es conveniente y lento. Sin embargo, tuve suerte. Resultó que no estoy solo. Pensaron en nosotros e hicieron el canal z-uno.z-wave.me/Reference/ZUNO_SWITCH_COLOR . Ahora solo hay un canal y dos funciones de devolución de llamada en el boceto. En el menú del controlador, la configuración de color se realiza por separado para cada color, así como para todos a la vez, seleccionando desde la paleta.

ZUNO_SETUP_CHANNELS(ZUNO_SWITCH_COLOR(SWITCH_COLOR_FLAGS_RED|SWITCH_COLOR_FLAGS_GREEN|SWITCH_COLOR_FLAGS_BLUE, getterFunction, setterFunction));

Y en el menú del controlador se ve así:



la siguiente función responde a las solicitudes por radio. Puede llegar una solicitud para leer el estado de uno de los canales de color.

BYTE getterFunction(BYTE component) {
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      return pwmR;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      return pwmG;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      return pwmB;
      break;
  }
  return 3;
}

Y esta es una función para configurar colores desde la interfaz del controlador.

void setterFunction(BYTE component, BYTE newValue) 
{
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      pwmR = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      pwmG = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      pwmB = newValue;
      break;
  }
  radio_action = 1;
}

Ese es todo el código que necesita agregar para convertir un boceto arduino en un boceto para ZUNo.

Conclusión


Después del montaje y la instalación, se completaron todas las tareas declaradas. Sin embargo, el hábito de encender la luz con el interruptor se mantuvo (resultó ser muy conveniente). La opción de inclusión sin contacto también funciona. Entre las deficiencias, quiero notar el parpadeo de la lámpara LED por un segundo después de aplicar energía a la unidad de control. Esto se debe a la larga inicialización de los periféricos ZUNo. En este punto, las piernas son impredecibles. Creo que la resistencia pull-up en la puerta del transistor corregirá la situación si la pones después de la resistencia limitadora. Si el código de inicialización ajusta los tramos a la salida y cambia los niveles lógicos a propósito, puede experimentar con el filtro RC, que no pasará pulsos cortos. ¡Todavía no lo he hecho, y tal vez nunca lo haga!

recomendaciones


ZUNo y su módulo de expansión simplifican enormemente la "creatividad técnica doméstica". Sin embargo, considero que estos productos son muy caros y si trabajara en otro lugar y el equipo Z-Wave no estuviera por ahí, haría todo en ESP8266. Durante el desarrollo aprendí un nuevo "estándar" para marcar cables desde la fuente de alimentación.



Ahora no solo la tierra está marcada con una franja negra, sino como en mi caso el cable "positivo". Para el módulo de expansión, esto resultó ser importante. El convertidor LM2594 de 5 voltios ha fallado (el precio en Chip y Dip es de aproximadamente 200 rublos). Espero que en la próxima versión del módulo de expansión haya un diodo protector contra la "inversión de polaridad". Y comprobaré la polaridad de los cables de alimentación. Otro inconveniente está asociado con el cuerpo. El caso se ve bien, pero no pude conectar los cables sin pinzas a los bloques de terminales. Espero que haya una versión con otros bloques de terminales (para conectar cables desde arriba o en ángulo).

No me gusta almacenar fotos en servicios en la nube y, a menudo, hacer copias de seguridad. Por lo tanto, la mayoría de las fotografías asociadas con el proceso de diseño y la lámpara 1 están irremediablemente corrompidas.



Esto es todo lo que queda del proceso de montaje y depuración.

Y parece que la luz de fondo se pone en funcionamiento, si se dobla un poco. Si se endereza, la caja y el interruptor no son visibles.



Boceto para ZUNo. Adjunto, solo para confirmar que todo es elemental
#include "EEPROM.h"
#include "EEPR.h"

int readPin = 9;
int triggerPin = 10;
byte controlState = 0;
word lastValue;
#define REDPIN   PWM1     // pin connection R 
#define GREENPIN PWM2     // pin connection G
#define BLUEPIN  PWM3     // pin connection B

ZUNO_SETUP_CHANNELS(ZUNO_SWITCH_COLOR(SWITCH_COLOR_FLAGS_RED|SWITCH_COLOR_FLAGS_GREEN|SWITCH_COLOR_FLAGS_BLUE, getterFunction, setterFunction));

#define ON 1
#define OFF 0
uint8_t switch_=OFF;

uint8_t pwmR=0;
uint8_t pwmG=0;
uint8_t pwmB=0;
uint8_t b_pwmR=0;
uint8_t b_pwmG=0;
uint8_t b_pwmB=0;

enum
{
  DEF_R = 255,
  DEF_G = 255,
  DEF_B = 255
};
uint8_t radio_action = 0;

void setup() 
{ 
  init_EEPROM();
  Serial.begin();
  pinMode(readPin, INPUT);
  pinMode(triggerPin, OUTPUT);
  digitalWrite(triggerPin, LOW);
  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN, OUTPUT);
  analogWrite(REDPIN, pwmR & 0xff);
  analogWrite(GREENPIN, pwmG & 0xff);
  analogWrite(BLUEPIN, pwmB & 0xff);
  
} 
int act=1;
int actf = 0;
int cnt=57; 

void loop()
{
  int tmp;
  // trigger measurement
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(10);
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  // read pulse width
  tmp = pulseIn(readPin, HIGH, 100000);
  lastValue = tmp / 58;
  Serial.print(" cm= ");
  Serial.println(lastValue);
  if (lastValue < 30)
  {
    cnt++;
  }
  else
  {
    cnt--;
  }
  if (cnt > 55)
  { 
    act=1;
  }
  if (cnt > 60)
    cnt= 60;
  if (cnt < 50)
  {
    act=0;
    actf=0;
  }
  if (cnt < 45 )
    cnt = 45;
  
  if ((act == 1) && (actf == 0))
  {  
    actf = 1;
    if (switch_ == OFF)
    {
      switch_=ON;
      b_pwmG = pwmG;
      b_pwmB = pwmB;
      b_pwmR = pwmR;
    }
    else
    {
      switch_=OFF;
      b_pwmR=0;
      b_pwmG=0;
      b_pwmB=0;
    }
    analogWrite(REDPIN, b_pwmR & 0xff);
    analogWrite(GREENPIN, b_pwmG & 0xff);
    analogWrite(BLUEPIN, b_pwmB & 0xff); 
  } 
  
  Serial.print("cnt = ");    
  Serial.print(cnt);  
  Serial.print(" || ");    
  Serial.print(pwmR);  
  Serial.print(" ");      
  Serial.print(pwmG);  
  Serial.print(" ");
  Serial.print(pwmB);  
  Serial.print(" ");
  Serial.println("");
 // delay(10);

 if(radio_action)
 {
    radio_action = 0;
    eepr_save_col();
    analogWrite(REDPIN, pwmR & 0xff);
    analogWrite(GREENPIN, pwmG & 0xff);
    analogWrite(BLUEPIN, pwmB & 0xff);
 }
}

BYTE getterFunction(BYTE component) {
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      return pwmR;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      return pwmG;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      return pwmB;
      break;
  }
  return 3;
}

void setterFunction(BYTE component, BYTE newValue) 
{
  switch(component)
  {
    case SWITCH_COLOR_COMPONENT_RED:
      pwmR = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_GREEN:
      pwmG = newValue;
      break;
    case SWITCH_COLOR_COMPONENT_BLUE:
      pwmB = newValue;
      break;
  }
  radio_action = 1;
}


All Articles