domotique -> rationalisation !

img_0391

Après une coupure de courant à la maison, mon précédent montage de domotique à connu… un petit soucis.
En oui, quand l’arduino qui pilotait les registres à décalage qui étaient en cascade (et suivi d’un ensemble de relais) a subi quelques bagots d’alimentation, il s’est produit un phénomène plutôt gênant que je m’explique encore mal dans les détails. Pour faire simple, la coupure à remis mes volets en mode apprentissage (procédure normale chez somfy) et s’est combinée à des activations intempestives des relais qui ont fait pedre l’ensemble des appairages aux volets (argh !!!). La piste, que je retiens, est liée à l’état indéfini des pins de l’arduino au moment du boot, suivi d’un effet de logique inversée sur les relais (+5v= relais « off » et 0v= relais « on »). Bref j’ai perdu beaucoup de temps à tout faire rentrer dans l’ordre, volet par volet.
Ce fut donc le coup de grâce de mes 27 relais (9 volets + 3 fonction par volets -> 9×3 >27 relais). L’idée maitresse était de trouver de quoi hacker une télécommande usine ou trouver un émetteur 433,42mhz (<- spécialité somfy puisque habituellement on trouve plutôt des émetteurs en 433,92mhz) afin de faire simuler par l’aduino: l’ID de chaque volet ainsi que son rolling code (simple incrément d’un nombre à chaque appui sur un la télécommande -> chiffre en mémoire à la fois sur le volet et sur le télécommande qui permet d’offrir une petite sécurité supplémentaire si l’ID de la télécommande venait à être copiée). Après de multiples et longues recherches sur le net, j’ai pu trouver un post sur le forum Arduino  et qui offrait une bibliothèque ainsi que de quoi se débrouiller avec une télécommande d’origine (by pass du microcontroleur à bord et interfaçage direct d’un pin de arduino sur l’émetteur). Le graal était trouvé !!!!!!

img_0393

 

Au passage, j’en ai profité pour changer le raspberry pi 1 qui servait à gerer l’IHM (python pygame et serveur apache/php) par un raspberry pi zero muni d’un petit hub micro-usb offrant un port ethernet 10/100.
Au final et comme les volets somfy RTS sont conçus pour accepter plusieurs télécommandes en parallèle, la domotique gère désormais un pool de 9 télécommandes virtuelles avec chacune une ID et un rolling code qui bouge (stockés dans l’EEPROM de l’arduino)

 

img_0392

Toutefois, il ne m’est pas possible de me passer de relais physiques, ne serait-ce que pour piloter mon poêle à granulés. Mais chat échaudé… j’ai pu trouver un petit module I2C spécifique pour gérer un bloc standard de 8 relais…. donc fini les relais qui claquent sans raisons !!!

 

 

 

 

 

 

le code de cette nouvelle version est disponible sur github:

https://github.com/Chnalex/arduino/blob/master/nouvelle_domotiquev2.ino

 

img_0395

 

Domotique revisitée ;-)

IMG_0926La première version de ma domotique m’a accompagné pendant 3 ans, mais il était temps de faire évoluer tout cela !!!

D’une part pour ces relais qui n’arrêtaient pas de « claquer » à chaque action sur les volets ou à chaque déclenchement du chauffage, et d’autre part pour cette interface graphique façon « minitel » d’un autre temps 😉

Ce qui a donné un cahier des charges en deux parties:
– trouver un moyen de remplacer les relais par une autre solution
– avoir une véritable interface graphique digne de ce nom

Les relais:
pour la V1 de la domotique j’avais utilisé deux cartes de 16 relais où chacune des 32 entrées de commande était relié à un pin de l’arduino méga. Au delà du problème de bruit des relais, cela utilisait un trop grand nombre de sorties du microcontrôleur (à mon gout). Pour réduire ce nombre, il fallait passer par un système permettant un quelconque multiplexage des commandes. J’ai cherché à utiliser en premier lieu une solution basée sur une carte avec des relais sur bus I2C. J’en ai trouvé facilement un modèle 8 relais en vente sur Ebay. Si cette solution était intéressante du point de vue du nombre de pin utilisés (2 pins: SDA et SCL), cela ne résolvait en rien mon problème de bruit.

DSCF4892Je suis donc tourné vers une solution en deux partie. La première partie a consisté a utiliser une carte équipée de 8 relais « OMRON SSR G3MB-202P ». Ces relais sont des SSR (Solid State Relay), c’est à dire qu’il sont composés de composants électroniques ne faisant pas appel à des pièces mécaniques (donc pas de bruit !! 😉 ). Plus précisément, il s’agit d’un opto-coupleur (led+detecteur) qui commande un ensemble de transistors MOSFET en mode relais.
C’est la solution idéale dans mon cas, plus de bruit, pas de mécanique, donc, virtuellement inusable.
Concernant la deuxième parie de ma solution, il fallait que je trouve un moyen de réduire le nombre de pins utilisés, pour cela, je me suis intéressée aux registres à décalage. Derrière ce gros mot se cache un composant simple d’emploi qui permet de transformer un signal série en signal parallèle. Pour être plus clair, on envoie un signal d’horloge sur une patte et sur une autre on envoie les différents bits constituant un octet, en conséquence le composant va retranscrire cet octet en activant ou pas (0 ou 1) 8 pattes de sortie. Le registre à décalage le plus commun est le 74HC595, il a l’avantage d’être facilement chainable (on peut en commander 4 à la suite avec les mêmes fils), et de fonctionner très bien avec la bibliothèque « ShiftOut » développée pour les arduino.
domotique1_bb

Le schéma ci-dessous montre comment à partir de 5 fils (+5V; 0V; data; clock; latch) commander 32 sorties. Ce qui signifie qu’avec quatre 74HC595, il est possible de commander 4 cartes de 8 relais, le tout à partir de 3 pins (hors alim). Afin de réaliser quelque chose de compacte, j’ai souhaité faire mon propre circuit PCB plutôt que d’utiliser une plaque de prototypage et une multitude de fils volants. Je l’ai conçu avec le logiciel Fritzing qui permet de faire toutes les étapes depuis le schéma, en passant par le PCB, jusqu’à la demande de fabrication sur le net.
domotique1_circuit imprimé

Comme le montre ce dessin du PCB, je l’ai fait graver en double couche afin de minimiser sa taille. En bas se trouvent les entrées (2 pins d’alim+3 pins) et au milieu, chaque barre fourni l’alim et la commande de 2 cartes relais (+-12345678).

.
.
.

.

.

.

Et voila le résultat: Les 4 cartes et le PCB en dessous (en blanc). Le relais 1 de la quatrième carte est activé dans cet exemple.

IMG_0319

L’interface graphique:

J’ai cherché pendant plusieurs mois une solution simple et peu onéreuse permettant d’avoir une interface graphique correcte, mais sans grand succès. Jusqu’au jour où je suis tombé sur un billet expliquant comment utiliser une liaison serie entre un arduino et un Raspberry Pi afin d’utiliser le Raspberry pi comme carte graphique HDMI moyennant un programme en python coté Pi interprétant les commandes passée sur le port série par l’arduino. Si c’est encore trop obscur, lisez l’article, le principe y est bien expliqué.
Le plus dur a été d’apprendre à programmer en python pour analyser les trames série, gérer l’écran tactile (vu comme une souris USB par le RasPi), afficher des images, rafraichir l’écran et renvoyer des trames à l’arduino en retour de toute action. Le code du programme python est dispo ici (le corps du programme commence à partie de la ligne 422).
Encore merci à Gilles pour sa maquette d’interface graphique 😉
La vidéo ci-dessous montre le fonctionnement de la chose:

L’énorme avantage d’un Raspberry Pi comme carte graphique est d’avoir pu réduire au maximum le code utile du coté de l’arduino. Par rapport à la V1 de la domotique le code passe d’environ 1700 lignes à 850. Avec cette nouvelle version la tache principale de l’arduino est désormais d’exécuter les taches planifiées (volets), et de gérer le chauffage.
Le code est dispo ici

L’ensemble de l’électronique avant remontage 😉

IMG_0457

Domotique – où comment gérer mes volets et ma chaudière…..

IMG_0378

La machine inutile n’était qu’un galop d’essai pour aborder l’arduino… pour  notre nouvelle maison, j’avais comme projet de gérer la future chaudière à granulés ainsi que l’ensemble des volets roulants (à commandes radios – cf photo)

– pour gérer la chaudière, un ou deux capteurs de température font l’affaire (un par étage, pour leur facilité d’utilisation et un nbr restreint de fils -2- j’ai opté pour des capteur DS18B20 sur bus Dallas Onewire). La commande de son coté est gérée par un simple relais. La chaudière à granulés ayant une inertie importante (mise en route sur 10minutes, temps de chauffe d’au moins 3/4 d’heure, extinction en 15 minutes), une régulation évoluée est inadaptée et pour tout dire, plutôt néfaste à ce type d’installation, donc pas de PID mais une simple régulation par hystérésis (ex: pour une consigne à 19°, déclenchement à 18.5° et arrêt à 19.5°)
– pour gérer les volets…rien de plus simple, en tout cas sur le papier ! Les télécommandes comprennent trois boutons poussoirs (monter-arret-descendre) donc 3 relais par télécommande, mais comme il y a 9 télécommandes….il faut 27 relais !!!!! Il est temps de IMG_0382penser à industrialiser les relais….le choix c’est donc porté sur deux cartes 16 relais pour microcontrôleur. Achat bien pratique sur Ebay, par contre le gros défaut est quelles fonctionnent en logique inversée. Il faut penser dès l’initialisation de l’arduino à placer toutes les sorties pilotant les cartes en HIGH, ce qui place les relais en OFF (un peu bête quand même)
Maintenant que la gestion de fond est faite, il est temps de penser à l’IHM…..est surtout d’éviter de poluer le salon (où se trouve la chaudière/poêle à granulés) avec des fils, des cartes, des alims et autre relais et LEDs. Un panneau de commande décorrélé de la partie « électronique » est la meilleure solution. Toujours dans un soucis de simplicité d’esthétique et d’utilisation, j’ai préféré me tourner vers un simple moniteur 10 pouces 16/9eme équipé d’un touchscreen resistif. Bon ok pour le touchscreen, le concept n’est pas trop compliqué, 4 fils à alimenter d’une certaine manière pour obtenir la valeur en X et d’une autre manière pour obtenir la valeur en Y en fonction de l’endroit où se situe la pression sur la dalle. Les convertisseurs analogique->numérique (ADC) des arduino’s savent très bien lire une valeur de tension en entrée (pont de résistance -> diviseur de tension généré par le touchscreen). Le problème est comment envoyer un signal sur le moniteur (qui accepte du composite, VGA ou HDMI). Là, oh miracle, d’autres ont déjà résolus le problème !!!! Il s’agit de la carte vidéo la plus basique du monde :  la Tellymate de chez Batsocks. Le concept est d’une simplicité déconcertante: on envoie sur un port série les textes à afficher (ainsi que leur emplacement sur une grille 38×25 caractères) et en sortie un signal vidéo composite est généré. Ce n’est pas très sexy, plutôt TTY, mais efficace (je pense néanmoins à faire évoluer la chose en utilisant un raspberry Pi en guise de carte video HDMI. l’article qui m’a mis la puce à l’oreille ).

Assez de blabla… un peu de photos

IMG_0377

– un arduino mega (bcp de ram de flash et surtout suffisamment d’entrées/sorties pour gérer les 32 relais)
– une horloge temps réel sur bus I2C de chez snootlab à  très faible dérive (10sec à 1minute max de décalage par an). Ce n’est pas le point fort des arduino, il faut donc en passer par là.

– un petit afficheur LCD 4×20 sur bus I2C, comme répéteur des infos vitales (puisque nous ne sommes pas dans la même pièce que le panneau de commande…).
– une carte vidéo tellymate
– 2 carte 16 relais
– 2 capteurs de température DS18B20

IMG_0380

le répéteur LCD

IMG_0381

un petit zoom, à droite l’horloge temps réel

Comme le programme est conséquent (un peu plus de 2700 lignes), il pèse 38ko compilé.
le code source sur mon espace GitHub: https://github.com/Chnalex/arduino/blob/master/domotique.ino

une petite vidéo de démo de l’IHM: