Bonjour à tous,
Je vous ai parlé dans un précédent article d'un projet qui me trotte dans la tête depuis plusieurs années, aujourd'hui on va regarder comment on va discuter avec ce jardin. Et si déjà j'utilise un microcontrôleur pour arroser, je vais aussi en profiter pour surveiller toute une ribambelle d'autres variables comme la température, l'humidité et la luminosité.
Tout d'abord, c'est un exercice pour moi, concevoir un système qui rentre dans la catégorie des objets connectés (IOT) qui est une thématique récurrente dans les projets électroniques portés en ce moment. Mais c'est aussi un moyen d'avoir une meilleure idée et de quantifier pourquoi une culture va bien ou mal en fonction des différents paramètres et d'en apprendre plus sur les besoins des plantes.
J'ai donc d'un côté un microcontrôleur équipé de nombreux capteurs et actionneurs (principalement des pompes et des lampes) et de l'autre un téléphone (ou un ordinateur). Entre les deux, j'ai besoin d'une interface graphique (facilement modifiable) sur laquelle je peux voir les mesures effectuées et activer les actionneurs.
J'ai cherché pendant un moment des services de tableaux de bord pour objets connectés, mais rien ne me convenais en rapport fonctionnalités/prix. Puis je suis tombé sur Node-RED, un outil de développement graphique basé sur Javascript et possédant de nombreux modules (appelés nodes) permettant de réaliser toutes les fonctionnalités que je souhaitais, de plus cela me donne une raison d'apprendre un nouveau langage de programmation, bref la solution parfaite ! (On peut aussi très bien utiliser Node-RED sans taper une ligne de code)
On va rentrer dans la partie très technique désormais, si vous avez la moindre question, n'hésitez pas à la poser en commentaire :)
J'ai choisi de faire tourner Node-RED sur un Raspberry Pi Zero W (qui possède un module wifi) ce qui permet de la laisser tourner en continu sans consommer beaucoup d'électricité. Pour installer Node-RED sur Raspeberry Pi, on utilise cette commande :
bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
Pour la communication entre la Raspberry et le micro-contrôleur, j'ai choisi le protocole MQTT qui est très utilisé dans l'Internet des Objets et que je n'avais jamais eu l'occasion de tester jusqu'à maintenant. MQTT fonctionne en séparant l'information en 2, d'un côté le sujet (topic) et de l'autre le message (content). Cela permet de facilement segmenter les informations (on peut apparenter ça à des dossiers vu qu'il est possible de créer une arborescence avec des topics : /capteurs/humidite par exemple).
Node-RED possède par défaut un node pour la communication MQTT mais qui nécessite un broker (serveur) externe, pour palier à ce problème, j'ai installé un autre node permettant d'intégrer un broker directement dans Node-RED.
Pour l'installer, il faut se rendre dans le dossier .node_red/ qui a été créé au moment de l'installation de Node-Red, puis de taper cette commande:
npm install node-red-contrib-aedesOn peut en profiter pour installer le node qui va nous permettre de créer l'interface graphique :
npm install node-red-dashboardJ'ai aussi installé un node pour communiquer avec Telegram, qui me parait être la solution la plus simple et la plus sûre pour communiquer avec Node-Red en dehors du réseau local (pas forcément envie d'exposer des ports à internet) :
npm install node-red-contrib-telegrambotPour créer un compte pour votre bot, vous devrez utiliser un autre robot qui vous guidera tout le long, et vous donnera les informations importantes pour communiquer avec votre robot, il s'appelle Bot Father.
Pour plus de sécurité, vous pouvez aussi suivre le guide fourni par Node-RED.
Si vous souhaitez plus d'informations sur chacun de ces nodes, vous pouvez consulter leurs pages dédiés en cliquant sur les liens suivant :
Maintenant que tout est installé, on va redémarrer Node-RED pour profiter de tous nos nouveaux nodes :
node-red-restartPuis on va se connecter à Node-RED depuis notre PC en utilisant l'adresse IP locale de la Raspberry Pi qui devrait être 192.168.1.XX où XX est un chiffre attribué par votre box. Vous pouvez la trouver sur le portail de votre box (accessible à l'adresse 192.168.1.1 ou 192.168.1.255) ou depuis la raspberry pi en tapant ifconfig en utilisant un écran et un clavier connecté à la RPi. Une fois que vous l'avez, allez dans votre navigateur internet et tapez l'adresse de votre raspberry pi suivie de ":1880" :
192.168.1.XX:1880Cette addresse vous permettra d'accéder à l'éditeur Node-RED depuis tout les appareils connectés au même réseau que votre Raspberry (évitez donc les réseaux publiques). Une fois la page chargée,elle devrait ressembler à ça (il vous demandera d'abord de vous identifier si vous avait configurer un mot de passe précédemment) :
Node-RED est donc un éditeur sous forme graphique, utilisant des nœuds qu'il va falloir relier et configurer. Pour notre premier programme (appelé flow), nous allons tout simplement envoyer le message "Hello World" dans le debugger (une fenêtre servant à obtenir des messages pour trouver plus facilement les erreurs).
On va placer un nœud Inject dont le champ "content" est une phrase (String) qui contient Hello World. Puis on le relie simplement à un nœud debug, ce qui devrait donc ressembler à ça :
Si jamais vous n'avez pas obtenu cela, vous importer directement cet exemple dans votre flow en copiant ce texte dans la fenetre accessible en cliquant sur les trois traits en haut à droite de la fenetre, puis sur Importer
[
{
"id": "693ad42b36a34b03",
"type": "tab",
"label": "Hello",
"disabled": false,
"info": "",
"env": []
},
{
"id": "47902d4a884764bf",
"type": "inject",
"z": "693ad42b36a34b03",
"name": "",
"props": [
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": 0.1,
"topic": "",
"payload": "Hello World",
"payloadType": "str",
"x": 150,
"y": 140,
"wires": [
[
"7246312988b8f033"
]
]
},
{
"id": "7246312988b8f033",
"type": "debug",
"z": "693ad42b36a34b03",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"statusVal": "",
"statusType": "auto",
"x": 330,
"y": 140,
"wires": []
}
]Une fois que votre programme est prêt, cliquez sur déployer, puis sur le petit carré bleu devant le module contenant votre phrase. Cela devrait déclencher son affichage dans l'onglet Debug sur la droite de la fenêtre.
Maintenant que l'on a les bases, on va essayer de contrôler une led sur le micro-contrôleur depuis notre téléphone en passant par MQTT et Telegram ou l'interface graphique accessible depuis le réseau.
Ce programme va être un peu compliqué au premier abord, mais je vais séparer les différentes fonctions pour que l'on puisse se renseigner sur comment communiquent chaque fonction. Vous pouvez retrouver le programme complet ici. Faites juste attention à créer votre robot Telegram avant et de bien le choisir dans chaque bloc concernant Telegram.
On commence par en haut, le bloc Aedes MQTT broker sert juste à intégrer le serveur MQTT, il contient le port MQTT ainsi que les informations de connexions au serveur.
Ensuite ces deux blocs servent à afficher dans le Debugger ce qui se passe sur le topic led du MQTT.
Ici, on permet d'envoyer des commandes MQTT sur le topic led depuis 2 boutons posés sur l'interface graphique qui ressemble à ceci :
Et connecté au même noeud MQTT on a les évenements de détections de commandes Telegram (/on et /off) qui vont déclencher l'envoie d'un message sur le topic led, qui sera ensuite interpréter par le mico-contrôleur.
Enfin, on a ces noeuds qui servent seulement à afficher les messages Telegram reçus et à renvoyer tout ce que nous a envoyé l'utilisateur. Il faudras renseigner dans ces blocs les informations fournies par Bot Father lors de la création de votre robot Telegram.
Une fois déployé, on peut donc envoyer les commandes au robot pour voir ce qu'il répond.
De ce côté, je voulais pouvoir me connecter facilement au wifi et disposer de suffisamment d'entrées et sorties pour communiquer avec tout ce qui y sera connecté. Mon choix s'est porté sur l'ESP32 qui est très répandu pour son intégration du wifi et du Bluetooth directement dans le microcontrôleur.
J'ai choisi de programmer en Python, pour cela j'utilise Thonny IDE sous Windows, ce logiciel permet d'envoyer facilement un programme vers le microcontrôleur et affiche l'ensemble des fonctions print() que vous mettrez dans votre programme. Faites juste attention que c'est le bon port COM qui est sélectionné dans Run->Select Interpreter -> Port of WebREPL
On va beaucoup utiliser internet dans ce projet donc c'est une bonne idée de ne pas avoir à ajouter sans cesse les lignes pour se connecter au wifi. Heureusement, pour nous, l'ESP32 stocke 2 programmes dans sa mémoire, le main.py qui est le programme principal et le boot.py qui est le premier programme à se lancer au démarrage de l'ESP32, nous allons donc placer dans ce dernier ces quelques lignes pour ne plus avoir besoin de les mettre dans le main.py (n'oubliez pas d'entrer le nom de votre wifi et son mot de passe):
import network
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
print('connecting to network...')
wlan.connect('nom de votre wifi', 'mot de passe')
while not wlan.isconnected():
pass
print('network config:', wlan.ifconfig())On enregistre ensuite ce programme en cliquant sur l'icône disquette, puis sur MicroPython device :
Et remplacez le fichier boot.py :
Pour notre premier programme MQTT nous allons simplement faire clignoter la LED qui se trouve sur la carte (pin 2 chez moi), à l'aide de ce programme :
from umqtt.simple import MQTTClient
from machine import Pin
import ubinascii
import machine
import micropython
import network
#Changez le numéro du pin en fonction de votre modèle
led = Pin(2, Pin.OUT)
# Serveur MQTT
SERVER = "192.168.1.00" #Changez l'IP en fonction de votre serveur
CLIENT_ID = ubinascii.hexlify(machine.unique_id())
TOPIC = b"led"
state = 0
def sub_cb(topic, msg):
global state
print((topic, msg))
if msg == b"on":
led.value(1)
state = 1
elif msg == b"off":
led.value(0)
state = 0
else:
print("Command unknown")
c = MQTTClient(CLIENT_ID, SERVER)
# Subscribed messages will be delivered to this callback
c.set_callback(sub_cb)
c.connect()
c.subscribe(TOPIC)
print("Connected to %s, subscribed to %s topic" % (SERVER, TOPIC))
try:
while 1:
c.wait_msg()
finally:
c.disconnect()
Et vous devriez voir une led s'allumer sur votre carte à chaque fois que vous appuyez sur le bouton ON ou que vous envoyez /on à votre bot Telegram
Donc aujourd'hui nous avons vu comment nous allons communiquer avec la partie connectée du jardin, ainsi que comment fonctionne Node-RED, les bots Telegram et le protocole MQTT. Dans le prochain article, je vais définir les capteurs et actionneurs que je souhaite utiliser et on va commencer à concevoir la carte électronique.
J'espère que cet article vous a plu et vous aura donné envie de jouer un peu avec Node-RED !
À bientôt !
Je me rappelle maintenant pourquoi je ne voulais pas de terreau en intérieur quand j'ai commencé ce projet :
Mais on a tout nettoyé et je trouve que ça rend vraiment sympa (même si je suis pas impartial ^^) :
On a :