Uma lâmpada inteligente para os "ricos" com as mãos "preguiçosas", é "simples" e conveniente



Introdução


Ele fez uma iluminação “moderna” na cozinha para uma pia, fogão e mesa de corte com base em uma faixa de LED sob o controle do arduino (que seja chamada lâmpada 1). Esse design funcionou por 2 anos, até que a parte de poder dos "cérebros" se deteriorou. Esta é uma excelente ocasião para reinventar a roda do “lixo improvisado” novamente (lâmpada 2). É verdade que desta vez o "lixo" será caro e compatível com a casa inteligente Z-wave. A seguir, a história da substituição do arduino pelo ZUNo (um módulo compatível com arduino para criar um dispositivo de onda Z) com economia máxima de código e uma explicação das alterações necessárias.

O que aconteceu antes de eu aparecer lá


Era uma vez, para lavar a louça ou cozinhar alimentos, era necessário acender a lâmpada acima da pia. Era um candeeiro de mesa refeito.

Não gostei de pressionar o pequeno interruptor com as mãos molhadas, porque ele trocou 220 volts para a lâmpada incandescente.



Além disso, a luz da lâmpada caiu principalmente sobre a pia, mas eu queria iluminar melhor a mesa e o fogão.

Objetivos.

  • Faça a luz ligar / desligar na cozinha sem contato;
  • Iluminar uniformemente a pia, mesa de cozinha e fogão;
  • Economize energia substituindo lâmpadas incandescentes por LEDs.

Ele montou a lâmpada 1. Consistia em uma caixa de alumínio de 2 metros com um difusor para fita RGB e uma unidade de controle. Uma caixa e um difusor foram comprados prontos na loja, havia uma fita e a unidade de controle já estava há muito tempo no canto e aguardava nos bastidores.

O caso era industrial (à prova de poeira, à prova d'água). Como a fita tem 12 volts, a fonte de alimentação de 220 V a 12 V está localizada na unidade, o painel de isolamento galvânico para controlar a fita com base no TLP250 (acoplador óptico) também controlava todo esse arduino em um design compacto.
Consegui o isolamento galvânico do projeto antigo. Uma vez, criei uma luz de fundo para um minibar na minha mesa de cabeceira. Quando a porta foi aberta, o touch pad registrou uma alteração na capacidade e acendeu uma luz suave e cintilante. Ou seja, o conselho era adequado para o projeto atual, tudo o que restava era cortar tudo o que era desnecessário. Havia um conversor linear de 5 volts na placa, alimentado por ZUNo.

Foi planejado acender a lâmpada com uma bandeja manual no medidor de distância ultrassônico. Ele o montou na tampa e todas as outras partes entraram na caixa. Tudo "confiavelmente" fixado com adesivo hot melt. No momento do teste, apertei o botão ao lado da fonte de alimentação da unidade de controle do interruptor de luz para instalação externa.



Ligar as luzes se tornou mais conveniente e seguro. Estava preso de cabeça para baixo no fundo do armário da cozinha e era mais difícil conseguir água das mãos molhadas por dentro.

Conclusões da unidade de controle anterior


A iluminação da área de trabalho da cozinha tornou-se mais uniforme e agradável, devido à reprodução de cores não natural da minha faixa de LED, a cor de alguns produtos mudou. Por exemplo: as cenouras pareciam muito mais apetitosas devido à cor mais brilhante. Mas não interferiu muito e espero que não tenha causado muito dano.

Com o contato on / off, tudo ficou pior. Funcionou. Porém, após 5 minutos no estado desligado, os flashes começaram na faixa de LEDs. Não comecei a refazer o circuito nos acopladores ópticos e deixei tudo como está. Apenas para ligar e desligar começou a usar o novo interruptor. Todos gostaram de sua localização e forma.
Durante dois anos de uso, a gordura e outros compostos secretados durante o cozimento se acumularam no corpo e dentro dele. Esta placa penetrou parcialmente na carcaça através dos orifícios para a entrada dos fios. Porém, devido à superfície brilhante do corpo, essa substância condensa em uma massa gelatinosa. É agradável ao toque, inodoro e ... (eu não provei). Tirei algumas fotos do local na forma de um germe de dragão.





Nas paredes, essa substância se transforma em um terrível ataque, que não é apenas lavado.

O que se tornou


Depois de vasculhar os compartimentos, encontrei um módulo de expansão inacabado para o ZUNo. O ZUNo é uma placa do tipo arduino para projetar seu próprio dispositivo compatível com a casa inteligente Z-Wave. Está programado no ambiente do arduino.

Especificações do 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


O módulo de expansão faz do ZUNo uma placa de depuração completa que, após a depuração do protótipo, pode ser usada como um dispositivo completo.

Algumas informações do 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 o meu projeto, preciso de 3 transistores poderosos para alternar 12 volts para uma faixa de LED e um conversor de 12 volts para 5 volts para alimentar o ZUNo. O restante da periferia do módulo de expansão não é soldado ou testado.



Nesta parte do circuito, não há diodo suficiente para a fonte de alimentação, para proteção contra a "inversão de polaridade", e os resistores nas portas dos transistores de efeito de campo de potência tiveram que ser conectados ao portão, e não na frente do resistor limitador. Escreverei mais sobre isso nas conclusões.

Este módulo de expansão é fornecido em uma caixa da Gainta. Minha unidade de controle anterior também estava no caso desta empresa, mas de tamanho diferente. Infelizmente, as fixações no módulo não se encaixavam no gabinete antigo, e eu não queria perfurar um novo, deixei o gabinete antigo. A prancha foi "plantada" em adesivo hot melt.



Um pouco sobre como programar o Arduino e o ZUNo


Os dispositivos de onda Z devem ter um certo número de classes. As classes descrevem funções do dispositivo e interfaces de interação. Por exemplo, minha lâmpada controla uma faixa de LED composta por três cores (vermelho, verde, azul). Essas funções são executadas pela classe multinível Switch. Se o adicionarmos ao esboço, podemos alterar remotamente o brilho de uma das cores. Para controlar três cores, você precisa criar três instâncias dessa classe. Não vou falar sobre isso com mais detalhes e detalhes. Como a manipulação de rotina da classe está oculta para os usuários do ZUNo pela noção de "canal". Por exemplo, eu preciso de três classes de Switch multinível, portanto, no código devem aparecer 3 canais do Switch multinível e várias funções de retorno de chamada para controle de rádio. Como fazer isso? Você também precisa adicionar a classe básica Switch,para ligar e desligar a lâmpada com o toque de um botão (na interface do controlador de rede) e não para configurar 3 canais por vez.

Você precisa acessar o site dos desenvolvedores, onde são apresentados exemplos de z-uno.z-wave.me/Reference/ZUNO_SWITCH_MULTILEVEL . Cada classe suportada pelo ZUNo tem uma descrição e um exemplo. Em seguida, copie e cole as funções propostas no seu esboço. Agora, no esboço, existem três canais de vários níveis do switch e 6 funções de retorno de chamada para responder a comandos no rádio. Como não sou muito sofisticado nas aulas do Z-Wave, meu dispositivo de faixa de LED anterior funcionou com esse conjunto de aulas.

Os canais foram declarados assim:

Título 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)
);


Isso levou à geração dos seguintes widgets no controlador após adicionar à rede:



Para ajustar a cor, era necessário abrir e configurar cada cor no menu do controlador separadamente. Não é conveniente e lento. No entanto, tive sorte. Acabou que não estou sozinha. Eles pensaram em nós e criaram o canal z-uno.z-wave.me/Reference/ZUNO_SWITCH_COLOR . Agora, há apenas um canal e duas funções de retorno de chamada no sketch. No menu do controlador, a configuração de cores é realizada separadamente para cada cor e também de uma só vez, selecionando na paleta.

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

E no menu do controlador fica assim:



A próxima função responde a solicitações via rádio. Pode haver uma solicitação para ler o status de um dos canais de cores.

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;
}

E esta é uma função para definir cores na interface do 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;
}

Esse é todo o código que você precisa adicionar para transformar um esboço do arduino em um esboço do ZUNo.

Conclusão


Após a montagem e instalação, todas as tarefas declaradas foram concluídas. No entanto, o hábito de acender a luz com o interruptor permaneceu (acabou sendo muito conveniente). A opção de inclusão sem contato também funciona. Entre as deficiências, quero observar a oscilação da lâmpada LED por um segundo após aplicar energia à unidade de controle. Isso ocorre devido à longa inicialização dos periféricos ZUNo. Neste ponto, as pernas são imprevisíveis. Acho que o resistor pull-up no portão do transistor corrigirá a situação se você o colocar após o resistor limitador. Se o código de inicialização ajustar as pernas à saída e alterar os níveis lógicos intencionalmente, você poderá experimentar o filtro RC, que não passará pulsos curtos. Ainda não o fiz e talvez nunca o faça!

achados


O ZUNo e seu módulo de expansão simplificam bastante a "criatividade técnica doméstica". No entanto, considero esses produtos muito caros e, se trabalhasse em outro lugar e o equipamento Z-Wave não estivesse por aí, faria tudo no ESP8266. Durante o desenvolvimento, aprendi um novo "padrão" para marcar os fios da fonte de alimentação.



Agora, não apenas a terra está marcada com uma faixa preta, mas, como no meu caso, o fio "positivo". Para o módulo de expansão, isso foi importante. O conversor LM2594 de 5 volts falhou (o preço no Chip and Dip é de cerca de 200 rublos). Espero que na próxima versão do módulo de expansão haja um diodo de proteção contra a "inversão de polaridade". E vou verificar a polaridade dos fios de alimentação. Outra desvantagem está associada ao corpo. O gabinete parece bom, mas não consegui conectar os fios sem pinça aos blocos de terminais. Espero que exista uma versão com outros blocos de terminais (para conectar os fios de cima ou em ângulo).

Não gosto de armazenar fotos em serviços na nuvem e fazer backups com frequência. Portanto, a maioria das fotografias associadas ao processo de design e a lâmpada 1 estão irremediavelmente corrompidas.



Isso é tudo o que resta do processo de montagem e depuração.

E parece que a luz de fundo é posta em operação, se você dobrar um pouco. Se você endireitar, a caixa e o interruptor não estarão visíveis.



Esboço para o ZUNo. Anexo, apenas para confirmar que tudo é elementar
#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