Commandez vos prises électriques à distance avec le Raspberry Pi

Voici enfin venu le premier article traitant réellement de domotique. Il va être ici question de télécommander des prises électriques à commande radio depuis un RPi.

Nous verrons comment commander deux types de prises électriques:

• Modèle DI-O de marque Chacon
• Prise simple de marque Phenix

Ces deux modèles de prises ont en commun l’utilisation de la bande de radio-fréquence 433MHz, très courante en domotique, avec un codage simple des commandes sur cette bande de fréquence.

L’utilisation de prises électriques à commande radio va nous permettre de piloter facilement, c’est à dire sans avoir à tirer de câbles supplémentaires, tout équipement électrique de la maison branché sur une prise. La portée du dispositif présenté ici dépend de la puissance d’alimentation du module, des parois de votre maison, mais en principe on peut compter sur une portée minimale de 30m.

Je me sers de ces prises pour commander des lampes, et des radiateurs électriques (n’ayant pas de fil pilote). On prêtera bien attention à la puissance de coupure de ces prises, en particulier pour les radiateurs: les Chacon DI-O peuvent couper jusqu’à 2400W ce qui est largement suffisant pour mes radiateurs de 1500W.

Le matériel

---

D’abord les prises électriques radio commandées:

On trouve ce genre de prises assez facilement sur internet. Les Chacon DI-O sont plus chères, mais elles ont un pouvoir de coupure supérieur et on les trouvera sans doute plus facilement que le modèle de prise Phenix qui commence à dater un peu. Concernant les prises Phenix, bien que ce tutoriel ait été testé et validé uniquement avec le modèle présenté ici, il est fort probable que cela fonctionne aussi sur des modèles plus récents, ça serait à tester.

Ensuite, nous allons avoir besoin d’un émetteur radio-fréquence 433MHz. Ce petit composant étant assez répandu, il coûte peu cher, on le trouve par exemple sur Amazon (recherchez simplement « rf433 ») sous la forme d’un couple émetteur/récepteur. Nous n’aurons ici besoin que de l’émetteur:

Le principe

---

La fréquence de 433MHz n’est que la porteuse du signal, l’information en elle même est transmise à seulement quelques kilohertz, ce que les ports GPIO d’un RPi peuvent parfaitement atteindre. Le principe est donc de connecter un des ports GPIO du RPi sur la broche « DATA » de l’émetteur RF433, et d’envoyer sur ce port les bonnes trames de communication (trame: séquence de 1 et de 0 matérialisés par des états haut ou bas d’un signal électrique, ou par des fronts montant ou descendant, et ce pendant une certaine durée). Chaque marque ou modèle de prise utilise un protocole de communication propre, plus ou moins standard et plus ou moins bien documenté.

Les DI-O de Chacon, par exemple, utilisent le protocole HomeEasy, qui n’est apparemment pas bien documenté, mais sur lequel l’inénarrable Idleman a néanmoins effectué de la rétro-ingénierie afin de comprendre le codage utilisé et le format des trames (lien). Un travail similaire a été fait par d’autres personnes pour les modèles de prise Phenix.

On remercie donc tout ce beau monde de nous fournir les programmes qui permettent de communiquer avec nos modèles de prises.

Les branchements

---

On va commencer par souder une antenne sur l’émetteur RF433. L’antenne peut être faite à partir de n’importe quel type de fil conducteur électrique, dans l’idéal suffisamment rigide pour tenir droit. La taille idéale de l’antenne est dictée par la fréquence utilisée (ici 433.92MHz pour être précis). On choisira de faire une antenne de la taille d’un 1/4 d’onde:

longueur onde entière = vitesse de la lumière / fréquence en MHz
soit longueur d’onde = 300 000 / 433,92 = 691,37 mm
1/4 d’onde = 691,37 mm / 4 = ~ 173mm

On fera donc une antenne d’environ 17cm (si vous arrivez à faire 17,3cm, tant mieux). On soude cette antenne sur l’émetteur RF433 sur son bornier identifié « ANT »:

Pour la suite des branchements, on peut utiliser une plaque de prototypage (voir photo ci-dessus) qui permet de faire des connexions sans soudure pour les composants électroniques ayant un pas d’écartement standard entre leurs broches (2,54mm).

On relie l’émetteur RF433 au RPi:

• la broche « GND » du module à la masse du RPi (pin numéro 6)
• la broche « VCC » du module à l’alimentation 3.3V du RPi (pin numéro 1)
• la broche « DATA » du module au GPIO sur le pin numéro 11

– source http://blog.idleman.fr –

La partie logicielle

---

Nous allons maintenant télécharger, compiler, et installer sur le RPi les deux programmes correspondant à chacun des modèles de prise, ainsi que les modules ou bibliothèques dont ils dépendent. Il nous faut:

• La bibliothèque WiringPi, qui est une dépendance pour nos deux programmes
• Un programme de commande pour les prises Chacon DI-O
• Un programme de commande pour les prises Phenix

Installation de WiringPi:

Cette bibliothèque propose une interface de communication pratique pour le développement d’applications utilisant les ports GPIO des RPi. L’installation est expliquée sur la page mentionnée ci-dessous, elle est très simple et je suggère d’utiliser le « Plan B » proposé par le sieur Gordon. Le script d’installation compile la dernière version de WiringPi et l’installe sur le système automatiquement.

Tout est là: http://wiringpi.com/download-and-install/

Programme de commande des prises Chacon DI-O:

Idleman a développé un programme en C++ (sous licence CC-BY-SA) qui permet d’envoyer des ordres aux prises Chacon DI-O en implémentant une partie du protocole HomeEasy. Le package qu’Idleman propose en téléchargement contient plusieurs choses qui ne nous intéressent pas dans le cadre de cet article (mais allez jeter un œil à son blog, ça vaut vraiment le coup). J’ai légèrement modifié son code pour supprimer un appel système qui me générait une erreur. Je vous propose donc une petite archive zip contenant juste le fichier à compiler.

1. Télécharger le petit package que j’ai préparé ici puis copiez le sur le RPi
2. Dézipper l’archive et placez vous dans le répertoire résultant
3. Compiler le programme avec g++, le compilateur C++ fournit en standard sur le RPi. NB: l’installation de WiringPi ci-avant est indispensable.

Ce qui donne la séquence suivante, en ligne de commande:

pi@domopi ~ $ wget -q -O chacon_send.zip https://www.dropbox.com/s/cjk6iydb1ugizd4/chacon_send.zip?dl=0
pi@domopi ~ $ unzip chacon_send.zip
Archive:  chacon_send.zip
   creating: chacon_send/
  inflating: chacon_send/chacon_send.cpp
  inflating: chacon_send/wiringPi.h
pi@domopi ~ $ cd chacon_send/
pi@domopi ~/chacon_send $ g++ -o chacon_send chacon_send.cpp -lwiringPi
pi@domopi ~/chacon_send $ ls -la
total 40
drwxr-xr-x  2 pi pi  4096 Apr  1 20:11 .
drwxr-xr-x 11 pi pi  4096 Apr  1 20:10 ..
-rwxr-xr-x  1 pi pi 13177 Apr  1 20:11 chacon_send
-rw-r--r--  1 pi pi  5686 Apr  1 19:52 chacon_send.cpp
-rw-r--r--  1 pi pi  6405 Mar  8 18:59 wiringPi.h

Le résultat de la compilation est un fichier exécutable « chacon_send ». On verra dans le paragraphe suivant comment l’utiliser.

 Programme de commande des prises Phenix:

Pour les prises Phenix, il est possible d’utiliser le code du projet RCSwitch-Pi (dépôt Github), lui même basé sur le code du projet RCSwitch initialement développé pour les micro-contrôleurs Arduino. J’ai, à nouveau, légèrement modifié le code proposé afin de permettre de choisir, lors de l’appel du programme, quel port GPIO doit être utilisé. Je vous propose donc une petite archive zip contenant les modifications, le tout prêt à compiler.

1. Télécharger le petit package que j’ai préparé ici puis copiez le sur le RPi
2. Dézipper l’archive et placez vous dans le répertoire résultant
3. Lancer la commande « make all ». NB: l’installation de WiringPi ci-avant est indispensable

Ce qui donne la séquence suivante, en ligne de commande:

pi@domopi ~ $ wget -q -O phenix_send.zip https://www.dropbox.com/s/236v1hyx4icz2qm/phenix_send.zip?dl=0
pi@domopi ~ $ unzip phenix_send.zip
Archive:  phenix_send.zip
   creating: phenix_send/
  inflating: phenix_send/Makefile
  inflating: phenix_send/phenix_send.cpp
  inflating: phenix_send/RCSwitch.cpp
  inflating: phenix_send/RCSwitch.h

pi@domopi ~ $ cd phenix_send/

pi@domopi ~/phenix_send $ make all
g++    -c -o RCSwitch.o RCSwitch.cpp
RCSwitch.cpp: In member function ‘char* RCSwitch::getCodeWordB(int, int, boolean)’:
RCSwitch.cpp:194:61: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:194:61: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:194:61: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:194:61: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:194:61: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp: In member function ‘char* RCSwitch::getCodeWordA(char*, int, boolean)’:
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
RCSwitch.cpp:229:74: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
g++    -c -o phenix_send.o phenix_send.cpp
g++   RCSwitch.o phenix_send.o -o phenix_send -lwiringPi

pi@domopi ~/phenix_send $ ls -la
total 80
drwxr-xr-x  2 pi pi  4096 Apr  2 09:43 .
drwxr-xr-x 12 pi pi  4096 Apr  2 09:43 ..
-rw-r--r--  1 pi pi   138 Apr  2 09:09 Makefile
-rwxr-xr-x  1 pi pi 16982 Apr  2 09:43 phenix_send
-rw-r--r--  1 pi pi   880 Apr  2 09:12 phenix_send.cpp
-rw-r--r--  1 pi pi  1980 Apr  2 09:43 phenix_send.o
-rw-r--r--  1 pi pi 16706 Aug 12  2012 RCSwitch.cpp
-rw-r--r--  1 pi pi  3838 Aug 12  2012 RCSwitch.h
-rw-r--r--  1 pi pi 12400 Apr  2 09:43 RCSwitch.o

Le résultat de la compilation, hormis quelques warning sans conséquence, est un fichier exécutable « phenix_send ». On verra dans le paragraphe suivant comment l’utiliser.

Envoyer les ordres aux prises

---

A ce stade, l’émetteur RF433 est bien connecté au RPi, et on dispose de deux programmes permettant d’envoyer des ordres à chacun des deux modèles de prises.

Toute prise, quel que soit le modèle et quel que soit le protocole de communication, doit se voir attribuer un numéro qui permet de l’identifier. Lorsqu’une commande est émise sur la fréquence de communication, ce numéro d’identification est envoyé dans la trame, entre autre information, afin que la prise concernée et uniquement elle, réagisse à la commande. C’est en quelque sorte l’ « adresse » de la prise.

Prises Chacon DI-O

Pour les prises Chacon DI-O, l’attribution du numéro d’identification de la prise se fait lors du branchement sur le secteur. Celle-ci passe temporairement dans un mode de programmation qui fait que la première trame de commande qu’elle reçoit lui fixe son numéro d’identification.

On utilise le programme « chacon_send » que nous avons préalablement compilé. La commande se présente comme suit:

chacon_send <wiringPI pin> <controler_code> <outlet_code> <on|off>

• wiringPi pin : Il s’agit du numéro wiringPi sur lequel on a branché la broche « DATA » de l’émetteur RF433. On a vu avant qu’il s’agissait du pin physique 11, qui correspond au wiringPi pin 0, c’est donc ce numéro qu’on spécifiera
  
• controler_code : numéro identification de l’émetteur, d’une longueur de 26 bits. C’est arbitraire dans notre cas, on mettra n’importe quel nombre qui sera ramené à 26 bits
• outlet_code : numéro d’identification de la prise. Si une prise vient juste d’être mise sur le secteur, elle prendra ce code comme identifiant et le gardera en mémoire
• on|off : commande à envoyer, ON ou OFF pour allumer ou éteindre la prise

Exemple: Branchez une prise Chacon DI-O sur secteur et de suite après, entrez les lignes suivantes le RPi.

pi@domopi ~/chacon_send $ sudo ./chacon_send 0 12325261 1 on
pi@domopi ~/chacon_send $ sudo ./chacon_send 0 12325261 1 off

Si tout se passe bien, la prise Chacon DI-O devrait s’allumer et s’éteindre 🙂

Prises Phenix

Pour les prises Phenix, l’attribution du numéro d’identification se fait par le biais de petits « switch dip« , situés dans la prise:

• Les switchs dip marqués 1 à 5 servent à identifier l’émetteur auquel la prise répondra
• Les switchs dip marqués A à D servent à identifier la prise elle-même. Le switch A étant le bit de poids le plus faible et le switch D le bit de poids le plus fort. Sur la photo: A=0, B=1, C=0, D=0, ce qui donne, en binaire et en remettant les bits dans le sens naturel de lecture : 0010, soit 2 en décimal

On utilise le programme « phenix_send » que nous avons préalablement compilé. La commande se présente comme suit:

phenix_send <wiringPi pin> <controler_code> <outlet_code> <1|0>

• wiringPi pin : Il s’agit du numéro wiringPi sur lequel on a branché la broche « DATA » de l’émetteur RF433. On a vu avant qu’il s’agissait du pin physique 11, qui correspond au wiringPi pin 0
• controler_code : numéro identification de l’émetteur tel que définit par les dip switch correspondant. On l’écrit directement sous représentation binaire correspondante
• outlet_code : numéro d’identification de la prise tel que définit par les dip switch correspondant. On le spécifie en format décimal (selon l’explication du calcul ci-avant)
• 0|1 : commande à envoyer, 0 pour éteindre la prise ou 1 pour allumer

Exemple: Branchez une prise Phenix sur secteur, configurez le dip switch comme sur la photo, puis entrez les lignes suivantes le RPi.

pi@domopi ~/phenix_send $ sudo ./phenix_send 0 10110 2 1
pi@domopi ~/phenix_send $ sudo ./phenix_send 0 10110 2 0

Si tout se passe bien, la prise Phenix devrait s’allumer et s’éteindre 🙂

Commande par le réseau

---

On pourrait bien sûr en rester là et créer localement des scripts qui déclenchent les prises de manière autonome et programmée. Mais dans le cadre de mon installation (voir cet article), j’ai besoin de pouvoir actionner les prises depuis un autre RPi.

J’avais détaillé dans cet article comment faire communiquer les deux RPi: le RPi frontal et le DomoPi. Nous avons donc là de nouveaux services domotiques tout désignés à rajouter au script permettant d’y accéder à distance.

Voici donc une version plus complète, intégrant mes commandes de lampes (branchées sur des prises Phenix) et de radiateurs (branchés sur des prises Chacon DI-O):

#!/bin/bash
# Author: Arno0x0x
# Description:
#       This script executes some domotic orders based on the command passed as argument.
#       The network wrapper is Xinetd on port 6868/tcp (domoservices)
# Dependencies:
#       This script depends on two binaries to send RF433 commands to remote controled outlets
#       1. chacon_send : Used to control "Chacon - D-IO" outlets.
#                                        Usage: chacon_send <wiringPI pin> <controler code> <outlet code> <on|off>
#                                        Ex:    chacon_send 0 12325261 1 on
#       2. phenix_send : Used to control "PHENIX type" outlets. WiringPi pin used is forced to 0 at compile time.
#                                        Usage: phenix_send <wiringPI pin> <controler code> <outlet code> <1|0>
#                                        Ex:    phenix_send 0 10110 1 1

#-----------------------------------------------------------------------
# Initialize main variables
# ligth1 = salle a manger | light2 = salon
# heater1 = salon | heater2 = entree
#-----------------------------------------------------------------------
export LANG=en_GB.UTF-8
_rootDir="/home/pi/Domotique"
_domoServicesLogFile="${_rootDir}/domoservices.log"
_light1_ON="sudo ${_rootDir}/phenix_send 0 10110 1 1"
_light1_OFF="sudo ${_rootDir}/phenix_send 0 10110 1 0"
_light2_ON="sudo ${_rootDir}/phenix_send 0 10110 2 1"
_light2_OFF="sudo ${_rootDir}/phenix_send 0 10110 2 0"
_heater1_ON="sudo ${_rootDir}/chacon_send 0 12325261 1 on"
_heater1_OFF="sudo ${_rootDir}/chacon_send 0 12325261 1 off"
_heater2_ON="sudo ${_rootDir}/chacon_send 0 12325261 2 on"
_heater2_OFF="sudo ${_rootDir}/chacon_send 0 12325261 2 off"

#-----------------------------------------------------------------------
# Read the command passed on stdin
read _command

case ${_command} in
	case ${_command} in
   light1ON)
                ${_light1_ON}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   light1OFF)
                ${_light1_OFF}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   light2ON)
                ${_light2_ON}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   light2OFF)
                ${_light2_OFF}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   heater1ON)
                ${_heater1_ON}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   heater1OFF)
                ${_heater1_OFF}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   heater2ON)
                ${_heater2_ON}
                [[ $? -eq 0 ]] || echo "[ERROR]" >> ${_domoServicesLogFile}
                ;;
   heater2OFF)
                ${_heater2_OFF}
                [[ $? -eq 0 ]] || echo "[ERROR]"  >> ${_domoServicesLogFile}
                ;;
   *) echo "[ERROR] UNKNOWN COMMAND"
          ;;
esac

Il y aurait bien sûr moyen d’optimiser ça en ayant qu’une seule commande associée à une variable passée en paramètre indiquant quelle prise on souhaite allumer ou éteindre, mais vu que je n’ai que 4 prises à commander, je vous laisse cette idée comme exercice 😉

Tout ceci n’est qu’un début. Il est possible de faire d’autres choses amusantes sur cette base. A titre d’exemple, j’ai défini plusieurs programmes d’allumage/extinction des prises en fonction des jours/heures/minutes, chaque programme étant « Activable / Désactivable » via le même mécanisme de commande à distance.

In fine, dans un prochain article, une fois que j’aurai couvert un exemple de lecture de température, je montrerai un exemple d’interface web basique que j’ai créé permettant de commander tout ça, d’activer/désactiver les programmes automatiques, de vérifier les journaux (log) d’exécution de ces programmes :

A bientôt !

Vous aimez cet article ? Faites le savoir avec quelques bitcoins !