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

 

Radio-réveil en bois…

20171230_174605

Mon radio-réveil ayant presque rendu l’âme, j’ai voulu construire moi-même le nouveau, mais en bois !!! Enfin presque ….
Je suis parti d’une base de boite à bijou, en bois brut, trouvée au rayon « loisirs créatifs » d’une grande chaine.

Jolies boite certes.. mais un peu triste. Comme l’aspect extérieur devait être sympa (quasi la première chose que je vois le matin.. après ma femme bien évidement 🙂 ), j’ai profité de la possibilité offerte par formulor.de d’utiliser un contre-plaqué de bouleau de 0.8mm (Cf. mes autres réalisations avec un casing fabriqué à partir de plaques d’acrylique découpées sur CNC laser) afin de réaliser un plaquage avec découpe et gravures sur deux faces (dessus et frontale).

img_1275

 

Pour l’électronique, rien de révolutionnaire pour le coup. Je suis parti de mon expérience avec la « RadioDuino » de ma cuisine. Le hardware est donc bâti à partir d’un arduino (un nano cette fois), d’un afficheur lcd 4×20 piloté par bus I2C, d’un tuner FM si4703 vendu par Sparkun (piloté également par bus I2C) et un petit ampli mono classe D basé sur un TPA2005D1 qui délivre 1.4W sous 8ohms.

20171230_174059

 

 

 

 

 

 

 

Afin de minimiser le nombre de pins utilisés sur l’arduino j’ai utilisé le principe des boutons poussoirs en parallèles munis, en série, d’une résistance afin de créer une pont diviseur de tension. Au final un seul port analogique permet de mesurer une tension différente pour chacun des boutons.

img_1596

Le changement d’heure d’été/hiver est assuré comme sur la domotique par la lecture régulière (chaque jour pendant la nuit) d’une table de dates de passage d’un mode à l’autre (déjà utilisé sur la domotique).

Pour la partie soft, le plus dur a été de trouver une police de très grand taille (en réalité une police composé de 3×3 caractères). Je me suis inspiré de l’article suivant: https://forum.arduino.cc/t/lcd-bigfont-numbers-over-2-or-4-lines/44538/12
en utilisant cette possibilité offerte par les afficheurs (sur base de contrôleur Hitachi HD44780) de pouvoir définir jusqu’à 8 caractères personnalisés (stockés dans la table interne du contrôleur sur les caractères de 0 à 7). 

les 10 chiffres utilisés sont stockés au sein de 3 tableaux de 10×3 valeurs. Par exemple pour afficher le chiffre 4 selon l’extrait de code ci-dessous, il suffira d’envoyer les caractères suivants (3 par ligne):
255,16,255
4,2,255
16,16,2

 

 

Ici les caractères 2 et 4 font partie de ceux crées. 255 est un rectangle plein (symbole en bas à droite du tableau ci-dessous b11111111) et le 16 un espace (1 symbole de la 3ème colonne b10000).
table ascii interne du controleur:

hd44780_characters_map

 

 

 

 

L’intégralité du code est disponible comme pour mes autres projets sur GITHUB:

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

img_1597

 

Horloge à mots

IMG_0928Pour la fin de l’année 2016, j’ai eu envie de créer une nouvelle horloge (ma dernière réalisation datant de fin 2013 avec une horloge à galvanomètre). Il y a quelques années j’avais lu cet article, dans la langue de Shakespeare, sur une horloge à mots . Le concept me plaisait et après une (très) longue gestation, j’ai décidé de concevoir la mienne, mais auf französisch !!
.
.

.,

Il me fallait donc commencer par créer un ensemble de mots disposés plus ou moins en carré permettant d’afficher l’heure courante. Pour éviter de dériver vers une solution difficile à gérer, j’ai pris le parti d’afficher l’heure par bloc de 5 minutes. Ce qui, avec l’utilisation des mots  « QUART », « MOINS », « LE » et « ET » m’a permis de n’utiliser que 9 mots pour exprimer les minutes, soit 23 mots au total avec les heures.
23 ? plutôt pas mal…et pourquoi ? parce que 24-1=23  bien évidement !!!
Plus sérieusement, 23 mots à illuminer c’est comme 23 bits à 0 ou 1. Et 23 bits tiennent dans 3 octets (24 bits)….on en reparlera plus loin quand il s’agira de penser à électronique qui prendra tout cela en charge.
Comme le montre la copie d’écran du fichier Excel ci-dessus, il m’a fallu ensuite assembler ces mots d’une part pour former ce « presque carré » recherché, mais aussi, pour faire en sorte que les chiffres(mots) apparaissent dans le désordre (ma touche perso 😉 )
.
J’avais donc mon assemblage. Maintenant, il me fallait le rendre présentable et en faire quelque chose d’esthétique. Ayant vu une publicité pour des impressions de photos sur plaque de plexiglas (acrylique), j’ai pris le risque de m’aventurer vers cette solution, en partant du principe que la plaque devait offrir une légère transparence pouvant être rétro-éclairée avec une ou plusieurs leds très lumineuses.
Comme j’avais trouvé un sympathique cadre en bois pour servir de support à l’ensemble de l’horloge, il ne me restait plus qu’a créer une image de  30x30cm. Pour ce faire, j’ai utilisé le « clone » libre d’Illustrator, c’est à dire: Inkscape. J’ai utilisé du noir pour le fond et du blanc pour la police de caractère afin d’obtenir le contraste le plus élevé possible. Ne sachant pas ce que j’allais obtenir en rétro-éclairant, c’était plus prudent (et au final un peu plus « design » <- à prononcer « déssigne » comme feu mon grand-père).

IMG_0827Une bonne dizaine de jours plus tard, j’ai reçu ma plaque imprimée, que je me suis empressé de placer à l’intérieur du cadre. Un premier test avec une lampe de poche placée derrière a fini de me rassurer, le concept était bon !

Pour l’étape suivante, il fallait en premier lieu créer une boite à l’arrière du cadre afin d’y placer un cloisonnement en carton permettant de séparer chaque mot. Pour réaliser les parois de la boite, j’ai utilisé une chute de medium retaillée et collée à la colle vinylique. J’ai pu utiliser la même colle pour assembler les différents morceaux de carton. Pour le fond, qui a vocation à accueillir les leds, j’ai utilisé le même carton épais.

IMG_0820

IMG_0822

IMG_0825

IMG_0824

 

 

 

 

 

 

 .

 .

 .

.

.

.

.

.

IMG_0826


.

Passons maintenant à l’électronique, comme je l’évoquais précédemment, 23 mots étaient à gérer. J’avais testé précédemment, dans la V2 de la domotique, une solution permettant de réduire le nombre de pins utilisé en sortie en utilisant des registres à décalage. Pour rappel, le registre à décalage transforme, en entrée,  un signal « série » sur deux fils (horloge et signal) sur lesquels on fait transiter les 8 bits d’un octet, et, en sortie, il active (ou pas) 8 sorties en parallèle. Dans le cas de l’horloge, 3 registres à décalage chainés les uns à la suite des autres permettent d’illuminer chacun des 23 mots (le tout étant commandé par seulement 3 pins d’un arduino).
Ce qui permet d’utiliser l’un des plus petits arduino de la gamme: le « nano ».
Je n’ai pas pu utilisé le 74HC595 comme modèle de registre à décalage  (comme pour ma domotique). En effet, celui-ci étant surtout conçu pour de la logique et non de la puissance, il n’était pas en mesure de délivrer le courant nécessaire à une dizaine de LEDs en simultané. J’ai donc opté pour un TPIC6B595N qui est capable de fournir 150mA par pin de sortie (de quoi subvenir largement aux besoins du montage). La grosse différence entre ces deux composants vient des sorties. Sur le  TPIC6B595N, un « 1 » logique se traduit par une mise à la  masse et non un +5v comme sur le 74HC595. Cela demande juste de câbler les cathodes des LEDs vers les pins de sortie, l’anode étant commune et alimentée en +5V.
Comme pour l’horloge à galvanomètre, la partie temps réel, s’appuie sur un chip DS3231 packagé en breakout (beaucoup plus précis qu’un DS1307 -> il ne dérive que d’une à deux minutes par an).  Pour rappel la communication avec l’arduino se fait via le bus I2C.

Ce qui donne le schéma suivant:

Pour la conception du schéma, du PCB et sa fabrication, j’ai utilisé Fritzing.
Le service de gravure de PCB en ligne offert dans ce logiciel est un peu onéreux mais la qualité du produit reçu est vraiment bonne: gravure double couche, vernis protecteur, cuivre étamé

 horloge_leds_circuit imprimé

Le PCB après conception prêt à être envoyé au service de gravure offert par Fritzing

 

 

 

Voila ce que cela donne suite à la mise en place des composants (le résultat est plutôt compact).

IMG_0846

Puis avant câblage des différents blocs de leds:

 

 

 

 

 

 

 

 

 

 

 

Une petite vidéo montrant le démarrage de la « bête ».
Afin de vérifier le bon fonctionnement de chaque bloc de leds, ceux-ci sont allumés en cascade. De même lors de la synchro entre l’arduino et l’horloge temps réel, le mot « ET » est illuminé si l’opération c’est déroulée correctement (le mots « MOINS » l’étant si la synchro est impossible).

Le code source est relativement court (350 lignes).
Il est dispo ici.

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

Afficheur moto 2

IMG_0258une petite modification de ma réalisation précédente…
Et oui, l’écran OLED, c’est très bien de nuit ou au fond du garage… mais en pleine journée, ce n’est pas vraiment l’idéal. Pour être franc, c’est totalement illisible !!

Je me suis donc tourné vers la plus simple des solutions: un écran LCD simple de 4×12.
Pour éviter un nombre de fils trop important, j’ai utilisé un petit module LCD-I2c afin de ne cabler que 4 fils entre le boitier et l’afficheur (+5v;GND;SDA;SCL)

A noter que ce type de d’écran n’est pas des plus fréquent. Ce sont les 4×20 que l’on trouve le plus facilement. Néanmoins, dans mon cas, la place libre entre mon compte-tour et le tachymètre étant plutôt restreinte, j’ai du opter pour cette version moins large.

Pour afficher la valeur du rapport engagé, je me suis tourné vers la possibilité qu’offre le HD44780 (chip le plus courant utilisé dans les afficheurs LCD en mode caractère) de créer jusqu’à 8 caractères personnalisés. Ensuite, il suffit de combiner ces caractère spéciaux pour créer un caractère « géant » sur 3 lignes et 4 colonnes.

le code source est dispo ici comme d’habitude 😉