Premiers pas avec la carte z-uno. Comment fabriquer son propre module z-wave

Ca y est, j’ai enfin décidé de jouer avec mon Z-uno. Ce module est un petit module zwave avec un micro-controller. Ce micro controller peut être programmé avec Arduino. Donc voilà tout un univers de possible qui s’offre à nous.

Dans cet article, nous allons nous concentrer sur 2 exemples simple d’utilisation du module et sur sa configuration dans Jeedom.

Présentation

Ce module est une petit carte avec un ensemble d’entrée sortie.



zuno pins

 

Installation

Il faut commencer par configurer l’environnement Arduino.

ATTENTION, avant de commencer, il savoir qu’il faut utiliser la version v1.6.5 d’Arduino. Les versions plus récentes posent un problème de type:

recipe.preproc.macros est un schéma manquant

Ajouter une nouvelle url de board manager: http://z-uno.z-wave.me/files/z-uno/package_z-wave.me_index.json
zuno-board-manager

Puis ajouter la carte à votre environnement: Outils>Type de carte>Gestionnaire de carte:

zuno-gestionnaire-de-carte

Installer la carte en dernière version et vérifier l’installation en allant dans outils>type de carte. La carte zuno doit être présente, la selectionner:

zuno-type-de-carte

 

Brancher le Zuno et configurer correctement votre carte en choisissant Europe et le port correspondant:

zuno-freq

zuno-port

Sélectionner le bon module de programmation:

zuno-programmeur

 

Et enfin charger le bootloader:

Capture d’écran 2017-02-02 à 13.34.48

Si tout se passe bien, ce genre de message devrait être affiché:

zuno-booloaded

 

Premier test: allumer la led du Z-uno avec Jeedom

Une série d’exemples est disponible ici : https://z-uno.z-wave.me/examples/

Nous allons ici commencé par un exemple simple, allumer/éteindre la led sur le module via le réseau z-wave:

// LED pin number
// 13 pin - user LED of Z-Uno board
#define LED_PIN 13

// Last saved LED value
byte currentLEDValue;

ZUNO_SETUP_CHANNELS(ZUNO_SWITCH_BINARY(getter, setter));

// the setup routine runs once when you press reset:
void setup() {
  pinMode(LED_PIN, OUTPUT); // setup pin as output
}
// the loop routine runs over and over again forever:
void loop() {
  // loop is empty, because all the control comes over the Z-Wave
}
void setter(byte value) {
  // value is a variable, holding a "new value"
  // which came from the controller or other Z-Wave device
  if (value > 0) {               // if greater then zero
    digitalWrite (LED_PIN, HIGH); //turn the LED on (HIGH is the voltage level)
  } else {                         // if equals zero
    digitalWrite(LED_PIN, LOW);   //turn the LED off by making the voltage LOW
  }
  // we'll save our value for the situation, when the controller will ask us about it
  currentLEDValue = value;
}

byte getter() {
  return currentLEDValue;
}

Charger ce code sur Z-uno via Arduino IDE.

Et maintenant, il est temps de la configurer dans Jeedom:

Dans Jeedom passer en mode inclusion:

jeedom-inclusion

Appuyer 3 fois sur le bouton sur Z-uno pour le faire aussi passer en inclusion:

1413.300

Votre module sera détecté par Jeedom:

jeddom-zuno-inclu

Cliquer dessus et ouvrir le panel Configuration

jeedom-zuno-configuration

Aller dans l’onglet Valeurs:

Capture d’écran 2017-02-02 à 14.23.34

Vous pouvez allumer ou éteindre la led en changeant la valeur de switch (en cliquant sur la clef à molette) :



Deuxième test: récupérer l’état de l’interrupteur dans Jeedom

Dans ce deuxième exemple, nous allons remonter vers Jeedom l’appuie sur le bouton du Z-uno

// LED pin number
// 13 pin - user LED of Z-Uno board
#define LED_PIN     13

// button pin number
// 18 pin - button(BTN) of Z-Uno board
#define BTN_PIN     18

// channel number
#define ZUNO_CHANNEL_NUMBER_ONE   1

// variable to store current button state
byte lastButtonState;

ZUNO_SETUP_CHANNELS(ZUNO_SENSOR_BINARY(ZUNO_SENSOR_BINARY_TYPE_GENERAL_PURPOSE, getter));

// the setup routine runs once when you press reset:
void setup() {
  pinMode(LED_PIN, OUTPUT); // set LED pin as output
  pinMode(BTN_PIN, INPUT_PULLUP); // set button pin as input
}
// the loop routine runs over and over again forever:
void loop() {
  // sample current button state
  byte currenButtonState = digitalRead(BTN_PIN);

  if (currenButtonState != lastButtonState) { // if state changes
    lastButtonState = currenButtonState; // save new state
    zunoSendReport(ZUNO_CHANNEL_NUMBER_ONE); // send report over the Z-Wave to the controller
    if (currenButtonState == LOW) { // if button is pressed
      digitalWrite(LED_PIN, HIGH);  // turn the LED on
    } else {                        // if button is released
      digitalWrite(LED_PIN, LOW);   // turn the LED off
    }
  }
}

byte getter() {
  if (lastButtonState == 0) { // if button is pressed
    return 0xff;              // return "Triggered" state to the controller
  } else {                    // if button is released
    return 0;                 // return "Idle" state to the controller
  }
}

Charger ce code sur le Z-uno.

Attention, une fois l’opération terminé, dans Jeedom, il faut rafraichir le noeud, en effet, nous avons changé le code, il faut que Jeedom mette à jour la configuration.

Pour cela aller dans configuration et cliquer sur l’onglet Action.

jeedom-zuno-configuration

Action-zuno-jeedom

Dans cette interface cliquer sur le bouton « Rafraichir les infos du noeud ».

Voilà maintenant vous pouvez retourner dans l’onglet valeur et voir l’état de « Switch » changer quand vous appuyez sur le bouton de du Zuno:

zuno-button-off

zuno-button-on

Troisième test: faire une vrai commande dans Jeedom

Nous avons vu vu comment communiquer dans un sens et puis dans l’autre sens. Maintenant nous allons creer une vraie commande dans Jeedom. Pour cela nous allons nous baser sur ce second test et allons simplement ajouter la commande dans l’interface de Jeedom.

Notons que

  • la classe du switch est 37 (0x25):
  • l’instance est 1
  • l’index 0
  • Par ailleurs c’est une commande binaire (et oui un bouton c’est binaire)

zuno-info
Nous allons donc configurer tout cela. Pour cela vous pouvez fermer cette popup et cliquer sur la zone commande:

zuno-conf-commande

A partir d’ici, les informations notées précédemment vont nous permettre de configurer une commande Jeedom. Cliquer sur « + Commandes » et ajouter les infos suivantes:

  • Nom : ce que vous voulez, c’est le mon de la commande dans votre Jeedom
  • Type :
    • Info : nous faisons du read only
    • Binaire : comme nous l’avons vu, c’est un bouton.
  • Instance ID: 1 (nous l’avons relevé tout à l’heure)
  • Classe : 0x25 comme relevé
  • Commande : ici il faut que l’on dise à Jeedom où lire les données. Comme relevé tout à l’heure, l’index de donnée est 0 donc nous allons remplir ce champs avec data[0].val (nous voulons lire la valeur de la data à l’index 0)
  • Paramètres : à vous de voir si vous voulez historiser, etc…

command-zuno-configuree

Vous pouvez maintenant sauver et tester la commande avec le bouton tester en bout de ligne. Quand l’interrupteur est relaché le test devrait renvoyer 0 et quand il est appuyé, 1.

command-ok-1

command-ok-0

Voilà il n’y a plus qu’a ajouter ca sur votre dashboard et à vous de jouer:

dash-command-ok2 dash-command-ok

 

 

 

A ce point je sens que certains d’entre vous sont un peu frustré. Je n’ai pas expliqué le code Arduino dans cette article. Je m’y attacherai dans un futur post.

Acheter un Z-Uno



Sur Amazon

One thought on “Premiers pas avec la carte z-uno. Comment fabriquer son propre module z-wave

  • 4 décembre 2017 at 1 h 46 min
    Permalink

    Bonjour,

    Merci pour ce tutoriel!
    J’ai testé ma Z-uno avec le code qui simule l’appuis d’un bouton, la valeur est bien mise a jour dans « configuration » « valeur ».
    Par contre, je n’ai pas de resultat quand je créé ma commande (ma config est type = info/binaire, instance = 2, classe = 48, index = data[0].val, afficher/historiser)
    C’est pourtant bien ce que j’ai dans valeur…

    une idée? :s

    Merci d’avance

    Reply

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *