Commutateur Gira + Z-Wave. Commutateur radio à 4 boutons basé sur Z-Uno



Quelles tâches le commutateur radio résout-il:

  • Dans une pièce avec une réparation prête, le mobilier a été déplacé, l'interrupteur a été fermé avec une armoire
  • Au stade de la réparation, ils ne pensaient pas à un interrupteur pratique près du lit
  • Dans une maison en bois, il n'est pas esthétique de tirer du câblage externe, des interrupteurs radio sont nécessaires, mais avec une conception spécifique
  • Intégration avec un système d'automatisation existant

Il existe actuellement des commutateurs Z-Wave alimentés par batterie, tels que le contrôleur mural Z-Wave.Me , mais ces commutateurs sont livrés avec une conception de clé spécifique. Si vous souhaitez utiliser les commutateurs Legrand, Gira, etc., la carte Z-Wave Z-Uno vient à la rescousse.

Je vais montrer comment fabriquer un commutateur radio alimenté par batterie à partir d'un commutateur généralement Gira qui peut être installé à n'importe quel endroit pratique. La vidéo de l'interrupteur à la fin de l'article.

J'utilise le mécanisme de commutation Gira pour les stores avec 4 boutons et un verrou au milieu. J'ai choisi la conception des clés et des cadres de la série System 55 uniquement parce que la gamme de commutateurs alimentés par batterie Z-Wave a des cadres de même conception.



L'ajout de nouvelles fonctions à Z-Uno est en cours, et dans la dernière version, KeyScanner a été ajouté, ce qui vous permet de traiter les clics à partir de 112 boutons en même temps, je me limiterai à lire 4 boutons du commutateur.

Dans l'esquisse ci-dessous, Z-Uno en mode veille attend que l'un des boutons soit pressé, après avoir appuyé sur Z-Uno se réveille et envoie une commande radio, après quoi il s'endort immédiatement afin de ne pas consommer la batterie.



Sketch Switch radio à 4 boutons basé sur 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 


Le récepteur de la commande radio est configuré sur chacun des 4 boutons à l'aide d'associations, il peut s'agir d'un relais , variateur , bande RGBW , lampe LED ou autre actionneur. Dans l'esquisse, je crée 2 groupes d'associations pour contrôler 2 appareils, les boutons supérieurs envoient des commandes d'alimentation, les boutons inférieurs envoient des commandes d'alimentation.



Nous connectons le mécanisme de commutation GIRA aux broches de Z-Uno 1,2,3,4. Le Z-Uno est livré avec une fiche, je l'ai soudé au compartiment de la batterie 1/2 AA et je l'ai branché sur le connecteur de la batterie. La batterie 1 / 2AA (ER14250) a une capacité compacte de 3,6 V, mais vous pouvez utiliser 2 piles AA, elles s'intègrent également parfaitement dans la prise.

Z-Uno dispose de 2 convertisseurs DC-DC, ils ne sont pas requis pour le fonctionnement sur batterie, ils peuvent donc être exclus du circuit d'alimentation en soudant le cavalier R12. Dans le même temps, la consommation électrique de Z-Uno en mode veille est réduite de 143 fois, de 1 mA à 7 μA.

Je recommande une profondeur de 60 mm pour les prises, il est plus pratique de travailler avec elles, il est difficile de pousser le Z-Uno avec une batterie, des fils et le commutateur lui-même dans des prises de 40 mm, mais vous pouvez!





2 boutons de droite contrôlent la prise, envoient des commandes ON et OFF à la prise Z-Wave.Me .

2 boutons de gauche contrôlent le variateur, avec une pression courte sur ON et OFF, les commandes sont envoyées, avec un appui long HAUT ou BAS, les commandes de variation sont envoyées au gradateur Z-Wave.Me .

Comme vous pouvez le voir sur l'appareil alimenté par batterie, la lecture de l'état des boutons à l'aide de Z-Uno est très simple, et de cette façon, vous pouvez connecter un clavier entier à Z-Uno, où chaque bouton remplira une fonction utile de votre maison intelligente.


Vidéo du coupe-batterie basé sur Z-Uno. Variateur et commande de relais.

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


All Articles