Domotique avec Raspberry Pi 2 et Node-RED

Node-RED est un outil visuel de raccordement de l’Internet des objets qui peut être exécuté sur un Raspberry Pi et permet de réaliser un prototypage rapide des projets. Dans ce tutoriel, nous allons d’abord configurer Node-RED sur un Raspberry Pi 2, avant de créer un flux capable de lire un capteur de température et de contrôler une prise secteur LightwaveRF.

Cela suppose que votre Pi est déjà configuré sur le réseau et que vous pouvez vous connecter en SSH à celui-ci. 
Assurez-vous que votre distribution est à jour :

$ sudo rpi-update

$ sudo reboot

Attendez que le Pi redémarre, connectez-vous à nouveau, puis exécutez :

$ sudo apt-get update
$ sudo apt-get upgrade

Hardware

Nous utiliserons le matériel suivant :

• Raspberry Pi 2 (832-6274)
• Capteur de température DS18B20+ (540-2805)
• Module émetteur 433 MHz (617-2072)
• Carte d’expérimentation de prototypage (102-9147)
• Fils volants - comme celui-ci (791-6454) et. celui-là (791-6450)
• Résistance 4 700
• Prise secteur LightwaveRF (disponible auprès de nombreux détaillants)
• 174 mm de câble rigide (utilisé comme antenne pour la carte sans fil)

Connectez le matériel comme indiqué sur le diagramme ci-dessous :

Nous connectons ici la sonde de température et l’émetteur sans fil au Raspberry Pi. Assurez-vous que chaque composant dispose d'une alimentation, d'une mise à la terre et de connexions de données, et qu’ils sont connectés aux bonnes broches de l’embase GPIO du Pi. Assurez-vous également que l’antenne est connectée au module sans fil.

Configuration du contrôle LightwaveRF

Afin de contrôler les prises secteur sans fil, nous devons installer wiringPi et lightwaverf-pi. Commencez par installer wiringPi :

$ git clone git://git.drogon.net/wiringPi
$ cd wiringPi
$ ./build

Vérifiez ensuite que wiringPi a été installé correctement :

$ gpio -v
$ gpio readall

Puis installez lightwaverf-pi :

$ git clone https://github.com/leachj/lightwaverf-pi.git
$ cd lightwaverf-pi
$ make
$ sudo make install

Exécutez la commande d’envoi du test :
$ sudo ./send 0
Celle-ci devrait s’exécuter sans erreurs. Nous testerons ensuite le contrôle sans fil en tentant d’associer le Pi à la prise secteur :
Branchez la prise secteur et mettez-la en mode association en appuyant sur le bouton sur le côté jusqu’à ce que l’indicateur lumineux commence à clignoter en orange/bleu. Transmettez ensuite un signal "actif" :
$ sudo ./send 1

La prise devrait s’associer avec le Pi. L'indicateur lumineux de statut clignote plus rapidement pour indiquer le succès de l’opération. Vous devriez maintenant pouvoir allumer et éteindre la prise à l’aide des commandes suivantes :
$ sudo ./send 1
$ sudo ./send 0

Installation de Node-RED

Commencez par installer Node.js (notez que cette procédure sur le Pi 2 n’est pas la même que pour les cartes Pi plus anciennes) :

$ curl -sL https://deb.nodesource.com/setup | sudo bash -
$ sudo apt-get install -y build-essential python-dev python-rpi.gpio nodejs

Ensuite, installez Node-RED :
$ sudo npm install -g node-red

Démarrez Node-RED :

$ node-red-pi --max-old-space-size=128

Cela lance le serveur Node-RED sur le Pi. Ouvrez un nouvel onglet du navigateur Web et accédez à l’adresse IP de votre Pi, port 1880. Vous devriez voir l’environnement de Node-RED chargé et prêt à l’emploi.

Ajoutez ensuite un nouveau nœud pour utiliser la sonde de température DS18B20 depuis l’intérieur de Node-RED. Deux modules de noyau sont nécessaires pour un fonctionnement correct. Commencez par les charger :

$ sudo modprobe w1-gpio
$ sudo modprobe w1-therm

Bien qu’il soit relativement simple de charger ces modules manuellement, nous allons les configurer pour qu'ils se chargent automatiquement au démarrage. Pour cela, nous pouvons éditer le fichier /etc/modules :

$ sudo nano /etc/modules

Ajoutez les noms des modules, chacun sur une ligne :

Installons ensuite un nœud pour lire les données du module ds18b20 :

$ cd /usr/lib/node_modules/node-red
$ sudo npm install node-red-contrib-ds18b20 --save

À l'étape suivante, nous devons ajouter une ligne au fichier /boot/config.txt :

$ sudo nano /boot/config.txt

À la fin du fichier, ajoutez la ligne suivante :

dtoverlay=w1-gpio,gpiopin=4

Enregistrez et fermez le fichier, puis redémarrez et connectez-vous à nouveau sur votre Pi.
Nous allons ensuite vérifier que la sonde de température est correctement connectée au Pi et que les données peuvent être récupérées :

$ cd /sys/bus/w1/devices
$ ls

Vous devriez pouvoir voir quelque chose qui ressemble à l'image ci-dessus. Le capteur apparaît ici sous le nom 28-000006439bd5. Remplacez-le par le répertoire du capteur :

$ cd 
e.g.
$ cd 28-000006439bd5

Le capteur inscrit les informations dans le fichier w1_slave. Nous pouvons donc le consulter pour voir s'il contient des données :

$ cat w1_slave

Il devrait contenir deux lignes. Si c’est le cas, la sonde est connectée au Pi et lui transmet des données.

Créer un flux Node-RED

Vérifiez que le nœud du capteur est installé correctement, afin que nous puissions récupérer nos données de température dans Node-RED :

$ node-red-pi

Ouvrez votre navigateur Web et accédez à l’adresse IP de votre Pi, port 1880. Vous devriez voir le nouveau nœud "ds18b20" en bas du menu de gauche. Faites glisser le nœud dans l’espace de travail. Nous devons configurer le nœud et lui indiquer quel ID de capteur utiliser. Pour cela, double-cliquez sur le nœud pour ouvrir le volet d’édition. Vous devriez pouvoir sélectionner l’ID du circuit dans le premier onglet déroulant. Notez que vous pouvez également modifier l’intervalle de durée entre les relevés de température (la valeur par défaut est de 1 minute). Vous devrez attendre que l’intervalle se soit écoulé pour que le premier message parvienne à la console de débogage. Il peut donc être utile de choisir une durée d’intervalle courte, comme 0,1, pendant les tests. 

Faites glisser un nœud de débogage et connectez les deux nœuds. Plusieurs nœuds connectés dans l’espace de travail Node-RED deviennent un flux. Avant que le flux ne s’exécute sur le serveur, il doit être déployé. Cliquez sur le bouton Deploy (Déployer) en haut à droite de l’espace de travail pour déployer le flux. Si vous effectuez des modifications, vous devrez le redéployer avant que ces changements prennent effet sur ce qui est en cours d’exécution sur le serveur.

Maintenant que nous avons testé un flux basique utilisant le capteur, nous pouvons créer un flux plus complexe capable de :

• Lire la température indiquée par le capteur
• Décider s'il fait assez froid pour activer la prise (chauffage)
• Décider si c’est le bon jour pour activer la prise
• Décider si c’est la bonne heure pour activer la prise
• Modifier le statut de la prise (actif ou inactif)

Node-RED est fourni avec de nombreux nœuds utiles, notamment le nœud de débogage utilisé ci-dessus. Nous utiliserons aussi le nœud d’injection pour nous aider lors des tests. Celui-ci permet d’envoyer des charges de message en cliquant simplement sur un bouton sur le nœud, ce qui signifie que vous n’avez pas besoin d’attendre les données temporelles pour tester votre code. 

Nous utiliserons un nœud de fonction pour mettre en œuvre notre logique et décider quand la prise doit être activée et désactivée.

Enfin, le nœud d’exécution nous permet d’exécuter des commandes shell depuis Node-RED. Nous utiliserons ce nœud pour exécuter la commande d’envoi que nous avons utilisée plus tôt pour contrôler la prise sans fil.

Faites glisser un nœud d’exécution dans l’espace de travail. Double-cliquez dessus pour ouvrir le volet de l’éditeur et ajoutez les détails suivants dans le champ "Commande" : 

sudo //send 
e.g.
sudo /home/pi/SW/lightwaverf-pi/send

Ajoutez du texte dans le champ "Nom". Nous avons utilisé "switchExec". Le fait de nommer vos nœuds permet de les rendre plus lisibles, en particulier avec les flux plus importants et plus complexes. Ce nœud d’exécution essaye alors d’exécuter la commande donnée chaque fois qu’il reçoit un message d’entrée. Nous pouvons envoyer à la commande des arguments supplémentaires avec les données du message. Notez que notre commande n’inclut pas l’argument "0" ou "1" utilisé précédemment, parce que nous transmettrons ces arguments au nœud d’exécution dans notre flux.

Nous demanderons à notre nœud de fonction de le faire plus tard, mais pour le moment nous pouvons utiliser les nœuds d’injection pour vérifier que le nœud d’exécution fonctionne correctement. Faites glisser deux nœuds d’injection. Double-cliquez sur chacun et assurez-vous que le type de "charge" est "chaîne", et que chacun contient la valeur 0 ou 1 dans le champ "charge".

Connectez la sortie de chaque nœud d’injection au nœud d’exécution, la sortie d’exécution supérieure au nœud de débogage, et déployez le flux. Maintenant, lorsque vous cliquez sur le bouton sur l’un des deux nœuds d’injection, vous devriez voir le nœud d’exécution écrire "sending command" (envoi de la commande) sur la console de débogage. Vous devriez également remarquer que votre prise secteur est activée et désactivée en fonction de vos clics. Notez qu’il est recommandé de ne pas l'activer/désactiver trop rapidement, car cela risquerait de l’endommager.

Maintenant que le contrôle sans fil fonctionne, nous pouvons créer notre flux et ajouter notre code personnalisé à notre nœud de fonction. Faites glisser un nœud de fonction et câblez le tout comme indiqué ci-dessous.

Double-cliquez sur votre nœud de fonction et ajoutez-y le code suivant :

//Control mains socket based on day, hour and temperature

//create date object
var d = new Date();
var day = d.getDay();
var hour = d.getHours();
var DAY = day;
var HOUR = hour;

//line to accept numbers in for testing
//var day = parseInt(msg.payload);

// change var DAY to 0 or 1 depending on day - we want Monday-Friday
if (day >= 1 && day <= 5) {
  DAY = 1;
}
else{
DAY = 0;
}

// change var HOUR to 0 or 1 depending on hour - we want 0700-1800
if (hour >= 7 && hour <= 17) {
  HOUR = 1;
}
else{
HOUR = 0;
}

// Format payload out to 0 or 1 depending on HOUR, DAY and temp/msg.payload - we want day/time as above and temperature setting of 23 degrees C
if (HOUR == 1 && DAY == 1 && msg.payload <= 23) {
  msg.payload = 1;
}
else{
msg.payload = 0;
}

return msg;

Déployez le flux. Vous disposez désormais d'une prise secteur activée et désactivée en fonction de la température relevée par votre Pi. Pour finir, nous allons configurer Node-RED pour qu’il s’exécute au démarrage. Nous utiliserons PM2, un gestionnaire de processus pour Node.js :

$ sudo npm install -g pm2

Déterminez où Node-RED est installé sur votre Pi :

$ which node-red
$ pm2 start /node-red --node-args="max-old-space-size=128" -- -v

Cela démarrera Node-RED en arrière-plan.

Vous pouvez vérifier le statut du processus PM2 de plusieurs façons :

$ pm2 status
$ pm2 info node-red
$ pm2 logs node-red

Maintenant indiquez à PM2 de se lancer au démarrage :

$ pm2 startup

Redémarrez et vérifiez que tout fonctionne. Node-RED devrait démarrer et commencer à exécuter le flux.

Le nœud de fonction peut être modifié comme vous le souhaitez. Testez différentes valeurs ou différentes conditions. Vous pouvez également ajouter facilement d’autres nœuds de sortie, comme le nœud Twitter qui peut être utilisé pour vous avertir lorsqu’une prise est activée ou désactivée.