Comutador Gira + Z-Wave. Interruptor de rádio de 4 botões baseado em Z-Uno



Quais tarefas o comutador de rádio resolve:

  • Em uma sala com reparos prontos, os móveis foram movidos, o interruptor foi fechado com um armário
  • Na fase de reparo, eles não pensaram em um interruptor conveniente perto da cama
  • Em uma casa feita de madeira, não é estético puxar a fiação externa, são necessários interruptores de rádio, mas com um design específico
  • Integração com um sistema de automação existente

Atualmente, existem comutadores Z-Wave alimentados por bateria, como o Z-Wave.Me Wall Controller , mas esses comutadores vêm com um design de chave específico. Se você quiser usar os interruptores Legrand, Gira, etc., a placa Z-Wave Z-Uno será resgatada.

Mostrarei como fazer um comutador de rádio alimentado por bateria a partir de um comutador geralmente Gira que pode ser instalado em qualquer local conveniente. O vídeo do switch no final do artigo.

Eu uso o mecanismo do interruptor Gira para persianas com 4 botões e uma trava no meio. Escolhi o design das teclas e quadros da série System 55 apenas porque a linha Z-Wave de switches alimentados por bateria possui quadros com o mesmo design.



A adição de novas funções ao Z-Uno está em andamento e, na versão mais recente, foi adicionado o KeyScanner, que permite processar cliques de 112 botões ao mesmo tempo, limitando-me a ler 4 botões do comutador.

No esboço abaixo, o Z-Uno no modo de espera espera que um dos botões seja pressionado, depois de pressionar Z-Uno acorda e envia um comando de rádio, após o que adormece imediatamente para não consumir energia da bateria.



Esboce o interruptor de rádio de 4 botões com base no Z-Uno
// KeyPad 1x4
#include <ZMEKeypad.h>
// Count of rows
#define ROWS  1
// Count of columns
#define COLS  4

// Set rows pins
BYTE rowPins[1] = {17};
// Set columns pins
BYTE columnPins[4] = {9, 10, 11, 12};

// Create object KeyPad
ZMEKeypad kpd = ZMEKeypad(columnPins, COLS, rowPins, ROWS);

#define CONTROL_GROUP1 1  // number of Association Group 
#define CONTROL_GROUP2 2  // number of Association Group
#define SWITCH_ON 0xff
#define SWITCH_OFF 0

// Start holding flags for 4 buttons
byte button_0_start_holding = TRUE;
byte button_1_start_holding = TRUE;
byte button_2_start_holding = TRUE;
byte button_3_start_holding = TRUE;

ZUNO_SETUP_ASSOCIATIONS(ZUNO_ASSOCIATION_GROUP_SET_VALUE_AND_DIM, ZUNO_ASSOCIATION_GROUP_SET_VALUE_AND_DIM); // Send Turn On/Off and Dim commands to associated devices
ZUNO_SETUP_SLEEPING_MODE(ZUNO_SLEEPING_MODE_SLEEPING); // SLEEPING MODE

void setup() {
  zunoSetupKeyScannerWU(4); // turn INT1 wakeup into Key Scanner mode with two columns: pins 9 and 10
  // can also be called in any other place before zunoSendDeviceToSleep()
  kpd.begin();
  kpd.setHoldTime(50); // 100 ms for detect hold button, 10 = 100 ms
  kpd.setDebounceTime(2); // 20 ms debounce, 2 = 20 ms
}

void loop() {
  byte actions[4]; // Array that return all actions from keypad (hold, release, press, double press, etc.)
  byte go_to_sleep = FALSE; // go to sleep after button released;
  
  // Default value for buttons - inactive, then read real states
  byte button_0_active = FALSE;
  byte button_1_active = FALSE;
  byte button_2_active = FALSE;
  byte button_3_active = FALSE;

  byte num_touched_keys = kpd.scanKeys(actions);
  if (num_touched_keys) {
    bool hold = KEYPAD_IS_HOLDING(actions[0]);
    switch (KEYPAD_KEYINDEX(actions[0])) {
      case 0: // Button Left Down
        button_0_active = TRUE;
        if (hold && button_0_start_holding) { // If button 0 start holding
          button_0_start_holding = FALSE;
          zunoSendToGroupDimmingCommand(CONTROL_GROUP1, TRUE, TRUE); // start dimming down (group, direction, start_stop)
        }
        if (!hold) { // If button 0 not holding
          go_to_sleep = TRUE;
          zunoSendToGroupSetValueCommand(CONTROL_GROUP1, SWITCH_OFF);  
        }
        break;
      case 1: // Button Left Up
        button_1_active = TRUE;
        if (hold && button_1_start_holding) { // If button 1 start holding
          button_1_start_holding = FALSE;
          zunoSendToGroupDimmingCommand(CONTROL_GROUP1, FALSE, TRUE); // start dimming up (group, direction, start_stop)
        }
        if (!hold) { // If button 1 not holding
          go_to_sleep = TRUE;
          zunoSendToGroupSetValueCommand(CONTROL_GROUP1, SWITCH_ON);
        }
        break;
      case 2: // Button Right Down
        button_2_active = TRUE;
        if (hold && button_2_start_holding) { // If button 2 start holding
          button_2_start_holding = FALSE;
          zunoSendToGroupDimmingCommand(CONTROL_GROUP2, TRUE, TRUE); // start dimming down (group, direction, start_stop)
        }
        if (!hold) { // If button 2 not holding
          go_to_sleep = TRUE;
          zunoSendToGroupSetValueCommand(CONTROL_GROUP2, SWITCH_OFF);
        }
        break;
      case 3: // Button Right Up
        button_3_active = TRUE;
        if (hold && button_3_start_holding) { // If button 3 start holding
          button_3_start_holding = FALSE;
          zunoSendToGroupDimmingCommand(CONTROL_GROUP2, FALSE, TRUE); // start dimming down (group, direction, start_stop)
        }
        if (!hold) { // If button 3 not holding
          go_to_sleep = TRUE;
          zunoSendToGroupSetValueCommand(CONTROL_GROUP2, SWITCH_ON);
        }
        break;
    }
  }

  if(!button_0_start_holding && !button_0_active) { // If button 0 release holding
    button_0_start_holding = TRUE;
    zunoSendToGroupDimmingCommand(CONTROL_GROUP1, TRUE, FALSE); // stop dimming down (group, direction, start_stop)
  }
   if(!button_1_start_holding && !button_1_active) { // If button 1 release holding
    button_1_start_holding = TRUE;
    zunoSendToGroupDimmingCommand(CONTROL_GROUP1, FALSE, FALSE); // stop dimming up (group, direction, start_stop)
  }
   if(!button_2_start_holding && !button_2_active) { // If button 2 release holding
    button_2_start_holding = TRUE;
    zunoSendToGroupDimmingCommand(CONTROL_GROUP2, TRUE, FALSE); // stop dimming down (group, direction, start_stop)
  }
   if(!button_3_start_holding && !button_3_active) { // If button 3 release holding
    button_3_start_holding = TRUE;
    zunoSendToGroupDimmingCommand(CONTROL_GROUP2, FALSE, FALSE); // stop dimming up (group, direction, start_stop)
  }

  // if all buttons released
  if (kpd.isIdled()) {
    go_to_sleep = TRUE;
  }

  if (go_to_sleep) {
    zunoSendDeviceToSleep();  
  }
}
//        Z-Uno 2.0.6    /Volumes/Files/user/Library/Arduino15/packages/Z-Uno/hardware/zw8051/2.0.6/libraries/ZMEKeypad/ZMEKeypad.h  "BYTE isIdled(){return mon_keys == 0;};"   55 


O receptor do comando de rádio é configurado em cada um dos 4 botões com a ajuda de associações; pode ser um relé , dimmer , fita RGBW , lâmpada LED ou outro atuador. No esboço, crio 2 grupos de associações para controlar 2 dispositivos, os botões superiores enviam comandos de energia, os botões inferiores enviam comandos de energia.



Conectamos o mecanismo do switch GIRA aos pinos do Z-Uno 1,2,3,4. O Z-Uno vem com um plugue, o soldei no compartimento de bateria 1/2 AA e o pluguei no conector da bateria. A bateria 1 / 2AA (ER14250) tem capacidade compacta de 3,6 V, mas você pode usar 2 pilhas AA, elas também se encaixam perfeitamente no soquete.

O Z-Uno possui 2 conversores DC-DC, eles não são necessários para a operação com bateria, portanto, podem ser excluídos do circuito da fonte de alimentação pelo jumper de solda R12. Ao mesmo tempo, o consumo de energia do Z-Uno no modo de suspensão é reduzido em 143 vezes, de 1 mA para 7 μA.

Eu recomendo profundidade de 60 mm para soquetes, é mais conveniente trabalhar com eles, é difícil empurrar o Z-Uno com bateria, fios e o próprio interruptor em soquetes de 40 mm, mas é possível!





2 botões à direita controlam a tomada, enviam comandos ON e OFF para a tomada Z-Wave.Me .

Os 2 botões esquerdos controlam o dimmer, pressionando rapidamente , os comandos ON e OFF são enviados, com uma pressão longa UP ou DOWN, os comandos de escurecimento são enviados para o dimmer Z-Wave.Me .

Como você pode ver no dispositivo alimentado por bateria, a leitura do estado dos botões usando o Z-Uno é muito simples e, dessa maneira, você pode conectar um teclado inteiro ao Z-Uno, onde cada botão desempenhará uma função útil da sua casa inteligente.


Vídeo do interruptor da bateria com base no Z-Uno. Controle de dimmer e relé.

Source: https://habr.com/ru/post/pt396839/


All Articles