Test MQTT + Domoticz avec ESP 32

Installation du Pi

cf procédure usuelle

Note : il faut que le Pi soit sur un réseau connecté à internet au moins pour la mise en place.

Installation MQTT sur le Pi

Installation du brocker Mosquitto

Installation sur le Pi se fait en 3-4 lignes de commande : https://randomnerdtutorials.com/how-to-install-mosquitto-broker-on-raspberry-pi/

< Autre page très complète ici : https://projetsdiy.fr/mosquitto-broker-mqtt-raspberry-pi/

sudo apt-get update
sudo apt-get install  mosquitto
sudi apt-get install mosquitto-clients

Activation avec :

sudo systemctl enable mosquitto.service
sudo service mosquitto start

Une fois installé, on peut tester que tout ok en faisant :

sudo service mosquitto status

Au lancement suivant, il sera actif au démarrage.

Test du broker

https://randomnerdtutorials.com/testing-mosquitto-broker-and-client-on-raspbbery-pi/

On dispose de 2 commande pour s'abonner (subscribe) ou publier (publish). Logiquement, la commande "subscribe" va écouter et la commande "publish" est exécutée en attendant la suivante.

On va ici faire un test de bon fonctionnement du broker sur le poste lui-même qui ressemble à un test de serveur sur le poste lui-même.

Abonnement

On va commencer par lancer un abonnement de test que l'on va nommer :

mosquitto_sub -d -t testTopic

On a ce moment là une activité dans le terminal qui reste ouverte, en écoute, un peu comme un serveur qu'on lance.

Publication

On peut dès lors publier dans un second terminal en faisant :

mosquitto_pub -d -t testTopic -m "Hello world!"

On remarque du coup qu'à chaque envoi d'un "Hello World!", il est reçu dans le terminal précédent "subscribe".

Test avec ESP 32 ?

OK, on va essayer de faire çà dans l'interpréteur... à priori, à partir du moment où on a toujours notre MQTT qui écoute le "testTopic", on devrait pouvoir écrire dessus.

On commence par se connecter au réseau local (qui devra ici avoir accès à internet) :

>>> import network
>>> wifi=network.WLAN(network.STA_IF)
>>> wifi.active(True)
True
>>> wifi.connect("ssid","password")
>>> wifi.isconnected()
True

>>> import upip as pip
>>> pip.install('micropython-umqtt.robust')
>>> pip.install('micropython-umqtt.simple')

Une fois fait, on peut utiliser mqtt sur l'ESP :

from umqtt.robust import MQTTClient

Ensuite, on crée le client (l'ESP est un client, et tout ce qui n'est pas le broker est un client).

>>> client = MQTTClient("123456789","192.168.0.52") # id,ipdubroker
>>> client.connect() # renvoie 0 ou erreur
0
>>> client.publish('testTopic', "72")
>>> client.publish('testTopic', "Hello  !")

Si tout est OK, vous devez voir dans la fenêtre de "subscribe" créée précédemment arriver les messages envoyés...

On peut aussi s'abonner à un "topic" et le topic ici est "testTopic".

>>> client.publish('testTopic', "72")
>>> client.publish('testTopic', "Hello  !")
>>> def reception(topic,msg):
    print(topic,":",msg)

>>> client.set_callback(reception)
>>> client.connect()
0
>>> client.publish('testTopic', "Hello  !")
>>> client.subscribe('testTopic')
>>> client.connect()
0
>>> client.publish('testTopic', "Hello  !")

Ensuite, on peut envoyer message sur "testTopic" depuis terminal du Pi.

Pour moi, je n'arrive pas voir le message qui censé être reçu par ESP envoyé depuis terminal "publish" du Pi. quelque chose ne doit pas être OK, mais c'est déjà très bien de pouvoir avoir la data en provenance de l'ESP.

En fait, il faut que le nom du topic soit au format bytes suivi d'un '/#' selon :

>>> topic='testTopic'.encode()+b"/#"
>>> topic
b'testTopic/#'
>>> client.subscribe(topic)
b'testTopic' : b'Hello world!'
b'testTopic' : b'Hello  !'
b'testTopic' : b'Hello world!'
>>> client.subscribe(topic)
>>> client.subscribe(topic)
b'testTopic' : b'Hello world!'
b'testTopic' : b'Hello world!'
b'testTopic' : b'Hello world!'
b'testTopic' : b'Hello world!'

https://www.programcreek.com/python/example/115319/umqtt.simple.MQTTClient

Installation de Domoticz et test

cf déjà fait... ?

curl -sSL install.domoticz.com | sudo bash
sudo apt-get upgrade

voir : https://projetsdiy.fr/installer-domoticz-raspbian-raspberry-pi3/

Ensuite, on peut se connecter sur ip.du.poste:8080 en http et 443 en https

On obtient assez facilement l'interface de domoticz.

Ensuite, si on veut utiliser avec MQTT : https://www.domoticz.com/wiki/MQTT

Il y a une procédure liée à l'interface à prendre en main :

• ajouter un hardware qui va être un Virtual MQTT
• ensuite créer via setup > hardware un Dummy (via liste déroulante)
• dans la liste qui apparaît, le nouvel item a un bouton créer nouveu device > créer un "température"
• ensuite créer un message de la forme : mosquitto_pub -h localhost -m '{ "idx" : 1, "nvalue" : 0, "svalue" : "25.0" }' -t 'domoticz/in' si depuis un terminal de test

ou bien si on envoie depuis l'interpréteur :

client.publish('domoticz/in', '{ "idx" : 1, "nvalue" : 0, "svalue" : "43.0" }')

C'est la forme minimale de message. Le "fléchage" de la donnée reçue se fait via l'index

Point important : il faut que l'idx soit le numéro du devive obtenu à partir de MQTT.

Noter qu'il est possible de configurer assez finement ce que l'on reçoit par MQTT ou ce que l'on ré-envoie. MQTT to Domiticz ou l'inverse.

Un truc important : domoticz reçoit bien mais ne "mémorise" que toutes les 5 minutes. Et le graphique ne se met pas à jour à l'arrivée d'une nouvelle data. Donc Domoticz, c'est pour du datalogging longue durée.

Ce qui est cohérent, c'est de faire un serveur du capteur lui-même qui permet le visuel live du capteur. Et d'utiliser MQTT vers Domoticz pour avoir la data longue-durée.

Des alternatives à Domoticz : https://alternativeto.net/software/domoticz/

notamment :

• openHAB
• Jeedom

Test avec Node JS

Node JS, notamment avec le JS Chart est une bonne alternative pour de la visualisation "multi-canal" dans une même interface.

D'autant que c'est assez léger au final lorsque çà tourne sur un Pi.

De plus, les messages MQTT peuvent être traités simultanément par MQTT et NodeJS, le broker faisant le lien.