Cliquez sur l'image pour être redirigé vers le nouveau site...
vendredi 29 juin 2012
mercredi 27 juin 2012
Introduction aux réseaux Z-Wave
Dans un réseau ZWave on peut distinguer 3 types de devices :
Il n’y a qu’un seul contrôleur primaire par réseau, c’est lui qui va géré la partie ‘inclusion’ des autres composants dans le réseau. Par contre on peut ajouter des contrôleurs secondaires. c'est le cas par exemple des télécommandes.
Voila ce que je peu vous dire du protocole Z-Wave pour le moment.
Si vous souhaitez développer votre propre application Z-Wave je vous recommande l'utilisation de Open Z-Wave.
- Les Contrôleurs (Box Z-wave, Stick USB, télécommande etc…)
- Les Devices qui font un report (Capteurs détecteurs, contact, etc…)
- Les Devices qui sont contrôlés (Actionneurs, Lampes, Dimmer, etc…)
Les Devices de type contrôleur ont un ‘Home ID’ défini en usine et unique. Lors de l’inclusion d’un autre device le contrôleur primaire va donner son home ID aux autres composants pour signaler qu’il font maintenant partis du même réseau. (Le home Id est défini sur 4 octets (32 bits)
Lors de l’inclusion le Node ID est aussi défini (j’ai pas encore bien compris le mécanisme pour le moment) en tous cas c’est un paramètre défini sur 1 octet (8 bits). Il permet d’identifier le Device sur le réseau pour ensuite définir la route à utiliser pour acheminer la commande d’un Device A vers un Device B.
Certains devices peuvent servir de répéteur pour acheminer l’ordre au Device les plus éloigné du contrôleur (La gestion et l’optimisation des routes me semble assez complexe pour l’instant)
Ensuite, afin de garantir la compatibilité avec le protocôle Z-wave et donc une compatibilité entre les produits de différents fabricants chaque Device utilise des Classes.
Les Devices Classes (3 types)
- Basic Device classe
- Generique Device classe
- Specifique Device classe
Tous les devices supportent au moins la classe Basic, mais certains devices ont besoin de la classe Generique en plus pour offrir certaines fonctions classique et enfin les Devices les plus complexes ont aussi besoin de la classe Specifique.
La classe Basic sert principalement à définir si le Device est SLAVE ou ROUTING-SLAVE (en gros s’il est routing-slave il pourra servir de répéteur pour les devices les plus éloignés)
Dans la classe générique on trouve les fonctions :
• General controller (GENERIC_CONTROLLER)
• Static controller (STATIC_CONTROLLER)
• Binary switch (BINARY_SWITCH)
• Multi level switch (MULTI_LEVEL_SWITCH)
• Binary sensor (BINARY_SENSOR)
• Multilevel-Sensor (MULTILEVEL_SENSOR)
• Meter (METER)
• Input controller (ENTRY_CONTROL)
• Thermostat (THERMOSTAT)
• Window Venetian blind controller (WINDOW_COVERING)
Enfin voici quelques exemples de classes specifiques :
• Setback Thermostat (SETBACK_THERMOSTAT) is a specific device class of the generic device class “Thermostat“;
• Multi-level Power Switch (MULTILEVEL_POWER_SWITCH) is a specific device class of the generic device class Multilevel Switch;
Ensuite il y a les commandes classes :
Par exemple pour la classe binary switch il y a trois commandes.
- • Set : permet au contrôleur d’envoyer une commande ON ou OFF
- • Get : permet au contrôleur de demander le retour d'état au Module
- • Report permet au module de renvoyer son état en réponse à la demande précédente
Chaque Device Classe a donc plus ou moins de Commande classe associé.
Les contrôleurs primaires
Mon réseau Z-Wave utilise un Z-Stick d’Aeon Lab comme contrôleur primaire
Une télécommande Z-URC 500 de Remotec comme contrôleur secondaire.
+ une Zibase comme boxe Z-Wave
Note: Cette page n'est pas terminée, elle est amenée à évoluer prochainement!
Système de commande électrique basé sur un Arduino
Matériel :
- Carte Arduino UNO (ou Duemilanove)
- Shield Ethernet (avec Wiznet W5100)
- Coffret électrique (26 modules)
- Coffret montage Rail Din (code Farnell 4455903)
- Support relais (Code Farnell 9913521)
- Relais (Code Farnell 1629043)
- Un bout de carte ‘Stripboard’
- Connecteur bornier à viser et
- Alimentation Arduino
- Câble réseau
Assemblage :
· Assembler la Carte Arduino avec son Shield Ethernet,
· Clipser le coffret de montage et les supports relais sur le rail DIN du coffret électrique.
· Réaliser la petite carte d’interface connectique avec les borniers à vis. (Voir câblage plus bas)
· Puis l’ajouter sur les cartes Arduino.
· Glisser l’ensemble des cartes dans leur coffret de montage.
· Câbler les bobines des relais
· Câbler les sorties des relais
Carte d’interface :
A noter :
· Le logiciel utilisé pour modéliser la carte ne procédait pas de connecteurs au pas de 5.08mm dans sa bibliothèque j’ai donc utilisé des modèles de connecteur au pas de 2.54mm ce qui explique qu’il y ait 2 fois plus de bornes à viser sur le modèle que sur la carte réelle (qui en comporte seulement 9)
· Les câbles ne traversent pas le PCB et sont soudés directement du coté des pistes.
· A cause d’une petite erreur, la masse se retrouve à extrémité opposée par rapport à l’autre connecteur mais la mettre de l’autre coté serait plus judicieux !
Câblage des bobines des relais :
Câblage des sorties des relais :
Attention pensez à utiliser un dispositif de protection (disjoncteur) adapté aux sorties à commander !!
Ne multiplier pas le nombre de sortie sur une même ligne, si besoin recommencer le même câblage avec une seconde ligne pour les quatre autres sorties.
Principe de fonctionnement :
La carte Arduino est équipée d’un Shield Ethernet. Ceci lui permet d’être éloigné du PC. Elle sera configurer comme serveur pour répondre à des requêtes http du type http://192.168.1.177/?L=1 pour faire commuter la sortie N°1. Par contre elle a besoin d’une alimentation 5V et d’une connexion à votre réseau pour fonctionner.
Le serveur Web dispose d’une interface utilisateur (certes très basic), mais qui permet de piloter notre carte Arduino à partir d’un simple navigateur Web à condition d’être sur le même réseau interne.
Pour accéder à l’interface on appelle l’adresse du serveur défini dans le code source chargé dans l’Arduino, depuis le navigateur d’un PC ou d’un smartphone, tablette etc…Ensuite on appui sur le bouton correspondant à la sortie que l'on veut faire changer d'état (ON/OFF).
Code source de l’Arduino :
Les paramètres à renseigner dans le code source de l’Arduino sont l’adresse Mac et l’adresse IP.
Du code mis en commentaire dans le source permet également de recevoir les valeurs des entrées analogiques A0 à A5 si nécessaire.
La seconde étape sera d’interfacer le montage avec Homeseer. Pour cela je me suis basé sur les ‘modules’ qui utilisent le Framework Domotics. Il permet de créer automatiquement les Devices et les events qui remplaceront l’utilisation du navigateur en envoyant le même type de requête au serveur Arduino et d’avoir le retour d’état des sorties.
Le déclenchement des sorties pourra ainsi se faire en fonction de n’importe quels conditions dans Homeseer et être complètement intégré au reste de votre installation.
Télécharger le module Homeseer complet avec le code source pour l'Arduino ici :
Pour plus de renseignement consulter le forum TLD : http://www.touteladomotique.com/forum/viewtopic.php?f=24&t=6833
Les évolutions possibles sont :
Coté matériel: Il reste 2 E/S numériques de libre et toutes les entrées analogiques qui ne sont pas utilisées. Je pense qu’on doit pouvoir basculer facilement certaines broches numériques en entrée avec peu de modification si cela est nécessaire. On peut remplacer les LED et utiliser les sorties pour commander des relais. L’avantage des relais est de pouvoir commander à peu prêt tout ce qui s’alimente par une tension à condition de respecter quelques caractéristiques (tension, courant, isolation etc…) certains relais (type ON/ON) peuvent aussi être câblés en circuit Va et Vient avec un interrupteur traditionnel pour garder une commande physique en cas de problème avec le serveur. Par contre dans ce cas l’état ON/OFF de la sortie de représentera plus l’état de l’appareil à commander mais bien la position de l’interrupteur. (au risque de consommer du courant pour maintenir un circuit ouvert !)
Coté code là aussi je pense qu’il est tout à fait possible de le faire évoluer. Celui de l’Arduino pour avoir une interface web plus sympa, ou pour exploiter certaines broches en entrée, comme les entrées analogiques pour relever des capteurs ou les entrées numérique, voir pourquoi pas utiliser les PWM pour faire de la variation d’éclairage etc… mais également celui du module Homeseer pour pouvoir ajouter aux Devices un bouton qui déclenche l’event associé sans avoir à jongler d’un écran à l’autre.
Je pense aussi que le concept peut surement être adapté à d’autres box domotiques capables d’envoyer des requêtes http
Bref voici une base qui ne demande qu’à évoluer, libre à vous de l’utiliser, et de l’adapter comme bon vous semble. Si jamais vous l’améliorez, merci de partager.
Je n’ai évidement pas écris la totalité de ces codes mais plutôt adapté ce que j’ai trouvé ici ou la sur le web pour arriver à une solution de base qui fonctionne.
En cas de problème vous pouvez toujours me laisser vos questions, j’essayerai d’y répondre volontiers, mais je ne vous garantie pas de savoir répondre à tous.
mardi 26 juin 2012
Déjà 10 000 visiteurs!
Depuis son lancement en Février dernier ce Blog a déjà été
consulté par plus de 10 000 visiteurs.
Un grand MERCI à tous pour vos messages d’encouragement ou
de remerciement.
Cela me fait très plaisir de voir que ce que j’écris peut
être utile à d’autre et me motive donc à continuer à partager avec vous mon
expérience perso.
J’essaierais de respecter la devise du Blog (La domotique expliquée simplement!) et de toujours parler des choses le plus simplement possible pour les rendre accessibles au plus grand nombre.
J’essaierais de respecter la devise du Blog (La domotique expliquée simplement!) et de toujours parler des choses le plus simplement possible pour les rendre accessibles au plus grand nombre.
Malgré tout, si quelque chose n'est pas clair vous pouvez me poser vos questions, j’essaierais d'y répondre avec plaisir.
Et si le Blog vous plait, n’hésitez pas à poster vos commentaires.
Voici le TOP.5 des
articles les plus consultés :
|
A bientôt.
Domotiquement,
Peedjy
lundi 25 juin 2012
Arduino SwitchCase
Voici un tutoriel que j'ai écris pour un site de robotique. Il permet d'expliquer facilement comment communiquer entre une carte Arduino et un PC.
Présentation :
En robotique et plus généralement
en électronique on a souvent besoin d'échanger des informations entre différents
systèmes.
Par exemple si vous écrivez plusieurs fonctions (ou sous programmes) et que vous souhaitez les exécuter ou les tester à partir d'un système externe, vous aurez besoin d'échanger des infos entre le système de commande et le système à commander.
Par exemple si vous écrivez plusieurs fonctions (ou sous programmes) et que vous souhaitez les exécuter ou les tester à partir d'un système externe, vous aurez besoin d'échanger des infos entre le système de commande et le système à commander.
On peut évidement
utiliser des protocoles de communication courant comme l’I²C ou d’autre, mais
il est parfois plus simple et plus rapide de définir son propre protocole quand
il s’agit de quelque chose de simple.
Prenons un exemple à titre d’illustration.
Prenons un exemple à titre d’illustration.
Vous souhaitez faire une main robotisée capable de prendre, lâcher, se lever et se baisser. Elle sera commandée par un PC afin d’effectuer les différentes actions.
Dans un premier temps vous devez commencer par écrire vos 4 fonctions et les tester.
La liaison entre votre main et le PC de commande se fera par le port USB et les ordres seront envoyés avec n’importe quel logiciel qui peut envoyer des infos sur un port USB (L’environnement de développement Arduino intègre ce genre d’outils.) Si par la suite vous décidez de réaliser un logiciel de contrôle plus convivial pour l’utilisateur, il sera alors très simple d’envoyer les mêmes informations.
Dans un premier temps vous devez commencer par écrire vos 4 fonctions et les tester.
La liaison entre votre main et le PC de commande se fera par le port USB et les ordres seront envoyés avec n’importe quel logiciel qui peut envoyer des infos sur un port USB (L’environnement de développement Arduino intègre ce genre d’outils.) Si par la suite vous décidez de réaliser un logiciel de contrôle plus convivial pour l’utilisateur, il sera alors très simple d’envoyer les mêmes informations.
Pour seulement 4 ordres,
il est inutile de passer par un protocole compliqué. Le plus simple reste
d'envoyer l'ordre à exécuter sous la forme d’un caractère ASCII et d'écrire un
programme capable de reconnaitre le caractère reçu pour exécuter l'ordre
correspondant.
Pour cela on peut
utiliser un ‘SwitchCase’ Le programme exécutera la fonction choisie en fonction
du caractère qu'il a reçu.
A noter que le ‘SwitchCase a une particularité. Il n'accepte la réception que d'un seul caractère ASCII. Si on veut utiliser un ‘mot’ comme commande il faut passer par des chaines de caractères mais il faudra alors utiliser des If /Then/ Else
Pour visualiser la fonction qui sera exécutée on câble 4 LED
sur les sorties 10, 11, 12,13. On pourra facilement adapter ce code pour
commander des moteurs, des relais, des transistors etc…
Du PC on exécutera les
fonctions en envoyant la première lettre de la fonction souhaité (un ‘p’ pour
Prendre, ‘l’ pour Lâcher, ‘m’ pour monter, et ‘d’ pour descendre)
Regardons maintenant le code de notre exemple.
/*
Description:
Ce programme est un exercice d’initiation à la programmation
Il a pour fonction d'exécuter un sous programme en fonction d’un caractère
reçu par le port série.
Circuit: Arduino Duemilanove avec
connexion PC sur port USB
Câblage LED1 sur Pin 10
LED2 sur Pin 11
LED3 sur Pin 12
LED4 sur pin 13
Revision: V1.0
created by CROZEMARIE J.Pierre
Juin 2012
*/
//-----------------------------------------
// FONCTIONS
//-----------------------------------------
void Prendre()
{
digitalWrite(13, HIGH); // On
allume la LED1 pour vérifier que la fonction s'exécute correctement
delay(1000);
digitalWrite(13, LOW);
// pendent 1 seconde puis on l'éteint
}
//--------------------------------------
void Lacher ()
{
digitalWrite(12, HIGH); //On allume la LED2 pour vérifier que la
fonction s'exécute correctement
delay(1000);
digitalWrite(12, LOW); // pendent 1 seconde puis on l'éteint
}
//------------------------------------
void Monter ()
{
digitalWrite(11, HIGH); //On
allume la LED3 pour vérifier que la fonction s'exécute correctement
delay(1000);
digitalWrite(11, LOW); // pendent 1 seconde puis on l'éteint
}
//------------------------------------
void Descendre ()
{
digitalWrite(10, HIGH); //On allume la LED3 pour vérifier que la
fonction s'exécute correctement
delay(1000);
digitalWrite(10, LOW); // pendent 1 seconde puis on l'éteint
}
//------------------------------------------------
void setup()
{
Serial.begin(9600);
Serial.println("Connexion etablie"); // permet de vérifier la
connexion
pinMode(13, OUTPUT); // On
configure les broches sur lesquelles sont
pinMode(12, OUTPUT); // branchées
les LED en mode 'sortie'
pinMode(11, OUTPUT);
pinMode(10,
OUTPUT);
}
void loop()
{
if
(Serial.available() > 0) {
char code =
Serial.read();
switch (ordre) { //On analyse le caractère reçu
case 'p': // Si on reçoit le caractère
'P' on exécute la fonction Prendre
Prendre ();
break;
case 'l':
Lacher (); // Si on reçoit le caractère 'l'
on exécute la fonction Lâcher
break;
case 'm':
Monter (); // Si on reçoit le caractère 'm' on
exécute la fonction Monter
break;
case 'd':
Descendre (); // Si on reçoit le caractère 'd' on
exécute la fonction Descendre
break;
default:
Serial.println("Cette
commande n'est pas valide!"); //
Si on reçoit autre chose, alors on affiche un message d'erreur.
} // Fin du 'switch'
} // Fin du 'if serial'
} // Fin de 'loop'
Conclusion :
Voici donc une structure de programme qui est très simple à adapter en
fonction de son utilisation, qui permet de commander notre système à partir
d’un PC et que l'on peut facilement faire évoluer.
Inscription à :
Articles (Atom)