La semaine passée, nous avons vu qu'il est désormais possible d'envoyer des commandes à nos modules depuis un broker MQTT. Pour illustrer cette fonctionnalité, cette semaine, nous allons voir comment réaliser une "veilleuse" à l'aide d'un Yocto-Color-V2 et Node-RED.
Le but est d'allumer les LEDs du Yocto-Color-V2 au coucher du soleil et de les éteindre au lever. Le Yocto-Color-V2 est branché à un Yocto-Hub-Ethernet afin que l'on puisse déporter cette veilleuse où cela nous arrange.
Il y a plusieurs de moyens de réaliser une telle application, mais aujourd'hui nous allons utiliser le protocole MQTT pour les communications entre l'application et le Yocto-Hub-Ethernet. Pour l'application, nous allons utiliser le langage de programmation graphique Node-RED, car ce dernier supporte nativement le protocole MQTT.
Au final l'architecture de notre veilleuse ressemble à ça:
L'architecture du système
Le Broker MQTT
Pour utiliser le protocole MQTT, il nous faut un broker MQTT. Nous avons utilisé mosquitto, un broker open source qui fonctionne sur tous les OS. La procédure d'installation est simple et documentée sur leur site web. Dans notre cas, le broker sera installé sur un Raspberry Pi qui à l'adresse 192.168.1.96.
La configuration du Yocto-Color-V2
Afin de nous simplifier la vie dans notre flow Node-RED, nous avons attribué le nom logique nightlight au Yocto-Color-V2. De cette manière nous pouvons référencer le Yocto-Color à l'aide de ce nom.
Le nom logique nightlight est attribué au module
La configuration du YoctoHub
La deuxième étape est de configurer le YoctoHub pour qu'il se connecte automatiquement à notre broker. Pour se faire, il faut configurer un Outgoing callback avec les paramètres suivants:
- Type de callback est MQTT
- On utiliser l'adresse et le port de notre broker mosquitto (dans notre cas 192.168.1.96 et 1883
- On met le Root topic à yocto afin de regrouper le trafic sous un seul topic
- L'option Allow MQTT clients to control Yoctopuce devices est activée afin d'autoriser la modification de l'état du Yocto-Color-V2 depuis MQTT
- L'option Disable instant values for sensors (use timed reports only) est activée pour réduire le trafic généré par le Yocto-Hub. Pour cette application ces notifications ne sont pas utiles.
La configuration du callback du YoctoHub
Une fois ces paramètres entrés, on peut vérifier que le YoctoHub arrive à se connecter au broker MQTT et, si c'est le cas, sauver la configuration. Il ne nous reste plus qu'à écrire l'application en Node-RED pour envoyer les bonnes commandes.
Node-RED
Comme pour mosquitto, nous n'allons pas décrire en détail l'installation et le fonctionnement de Node-RED. La procédure est documentée sur leur site et nous avons déjà plusieurs articles qui parlent de Node-RED.
Il faut ajouter un nœud mqtt out à notre flow et le configurer pour qu'il envoie un message au Yocto-Color. Les paramètres du broker MQTT sont les mêmes que l'on a utilisés dans le YoctoHub.
Les paramètres du broker
L'autre paramètre à configurer est le topic du message MQTT. En se référant à l'article de la semaine passée, on trouve qu'il faut envoyer le message avec le topic yocto/nightlight/colorLed1/set/rgbColor. Le payload du message est la couleur RGB que Yocto-Color doit afficher.
- Topic: yocto/nightlight/colorLed1/set/rgbColor
- Payload: 0xffffff
Le reste des paramètres du nœud MQTT
Maintenant que nous avons un nœud MQTT qui nous permet de contrôler la LED du Yocto-Color-V2, il faut "coder" le reste de l'application.
Pour déterminer si le soleil est couché, nous avons utilisé le nœud nighttime qui calcule les heures de coucher et de lever du soleil en fonction des coordonnées GPS. Nous allons utiliser la première sortie de ce nœud, qui est un booléen indiquant si le soleil est couché.
On ne peut pas relier directement la sortie de ce nœud à notre nœud MQTT. Il faut insérer un nœud fonction entre les deux. Ce nœud contient 5 lignes de JavaScript qui convertissent le booléen du nœud nighttime en couleur RGB.
msg.payload = 0xffffff;
}else{
msg.payload = 0;
}
return msg;
Au final nous avons le flow suivant:
Le flow Node-RED
Si vous voulez l'importer dans votre installation Node-RED voici le code source:
{
"id": "77367932292fc50c",
"type": "tab",
"label": "Flow 1",
"disabled": false,
"info": "",
"env": []
},
{
"id": "ad8db877ec355015",
"type": "nighttime",
"z": "77367932292fc50c",
"name": "",
"lon": "-68",
"lat": "34.052235",
"start": "sunrise",
"end": "sunset",
"x": 360,
"y": 220,
"wires": [
[
"d2e0b60ff5997daf"
],
[]
]
},
{
"id": "d2e0b60ff5997daf",
"type": "function",
"z": "77367932292fc50c",
"name": "function 1",
"func": "if(msg.payload){\n msg.payload = 0xffffff;\n}else{\n msg.payload = 0;\n}\nreturn msg;",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 540,
"y": 220,
"wires": [
[
"e1ce8981f8ecd5fb"
]
]
},
{
"id": "e1ce8981f8ecd5fb",
"type": "mqtt out",
"z": "77367932292fc50c",
"name": "",
"topic": "yocto/nightlight/colorLed1/set/rgbColor",
"qos": "",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "02da79a0e03267fd",
"x": 800,
"y": 220,
"wires": []
},
{
"id": "02da79a0e03267fd",
"type": "mqtt-broker",
"name": "",
"broker": "192.168.1.96",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
}
]
Conclusion
L'option "Allow MQTT clients to control Yoctopuce devices" permet de contrôler les modules Yoctopuce depuis n'importe quelle application ou langage qui utilise MQTT sans nécessiter l'utilisation nos librairies de programmation.
Si vous n'avez pas d'autres périphériques qui utilise MQTT, il est probablement plus simple d'utiliser nos librairies de programmation et de communiquer directement avec nos modules. Cependant, si vous avez déjà une infrastructure MQTT existante, cette option permet d'intégrer assez facilement nos modules dans un système existant.