Michel est un fidèle de framboise314 et il intervient en particulier sur le forum à propos de MQTT.
MQTT est un protocole machine à machine (M2M) utilisé pour l’IoT (Internet des objets). Il a été conçu pour être très léger et pour utiliser une bande passante réseau minime.
Michel nous propose dans cet article la mise en œuvre de MQTT sur Raspberry PI.

L’Internet des objets, le protocole MQTT, le Raspberry PI Mosquitto et la puce ESP8266.

On entend de plus en plus parler l’Internet des objets (IoT : Internet Of Things).
Ces objets peuvent communiquer sans fil (Radio, Bluetooth ou Wifi).
Un des protocoles utilisable pour faire dialoguer ces objets est MQTT (M2M Machine to Machine).

MQTT

• MQTT est un service de messagerie TCP/IP simple
• Les messages sont envoyés par des publieurs (les publishers) sur un canal (une chaîne d’information) appelé Topic. Ces messages peuvent être lus par les souscripteurs (les subscribers) qui surveillent certains Topics.
• Un serveur (Broker) se charge de faire la liaison entre les publieurs et les souscripteurs.
• On peut évidemment installer un Broker sur notre Framboise, par exemple Mosquitto.

Mosquitto sur la Framboise.

Installation par :

sudo apt-get install mosquitto mosquitto-clients python-mosquitto

• Mosquitto est le serveur MQTT (Broker).
• Mosquitto-clients installe les clients MQTT « mosquitto_sub » , « mosquitto_pub » , « mosquitto_passwd »
• Python-mosquitto ajoute la partie Python avec des API permettant de créer des clients et d’interroger des serveurs.
• Pour commencer avant de configurer Mosquitto sur le Rasberry, on peut simplement d’utiliser le serveur de test de Mosquitto « test.mosquitto.org ».
• Il n’y a pas de compte à créer sur mosquito.org et aucun paramétrage n’est nécessaire pour lancer des tests.

Exemples d’appels de Mosquitto.

On lance en premier sur le Rasberry le client MQTT : mosquitto_sub en lui demandant de se mettre à l’écoute d’un ensemble de Topics dans l’exemple, SMBA38 et les sous Topics de SMBA38 (en utilisant le #):

$mosquitto_sub -h test.mosquitto.org -t "SMBA38/#" –v

Ensuite on lance dans une autre console, plusieurs fois le client MQTT pour publier des valeurs sur ce même Topic (option –m).

pi@raspberrypi:~$ mosquitto_pub -h test.mosquitto.org -t SMBA38/temps/Ext -m 17

pi@raspberrypi:~$ mosquitto_pub -h test.mosquitto.org -t SMBA38/temps/Ext -m 15

pi@raspberrypi:~$ mosquitto_pub -h test.mosquitto.org -t SMBA38/temps/Int -m 21

Et voici les données affichées par le subscripteur (option –v), les données arrivent immédiatement après leur publication.

pi@raspberrypi:~$ mosquitto_sub -h test.mosquitto.org -t
"SMBA38/#" -v
SMBA38/temps/Ext 17
SMBA38/temps/Ext 15
SMBA38/temps/Int 21

Le port utilisé par défaut est le 1883.

Dans cet exemple on n’utilise pas de nom d’utilisateur et de mot de passe, les transmissions ne sont pas codées.
La QoS (qualité de service n’est pas utilisée).

Si on lance la commande :

mosquitto_sub -h test.mosquitto.org -t "#" –v

On récupère tous les topics du serveur de test de Mosquitto ( même ceux non créés par nous même).
Et avec :

pi@raspberrypi:~$ mosquitto_sub -h test.mosquitto.org -t "+/temp/#" -v
random/temp 22
project4fun/temp typeA
ccdata/temp 19.3

On récupère les tests sur des capteurs de température car c’est en général ce genre de test quel les développeurs affectionnent.

Fonctionnalités de MQTT.

Le protocole MQTT dispose d’autres fonctionnalités.

• La notion de QoS dans les messages qui transitent via MQTT.
  • =0 Le message envoyé n’est pas stocké par le Broker, il n’y a pas d’accusé de réception, perte du message si arrêt du serveur ou du client.
  • =1 message livré au moins une fois le client renvoi le message jusqu’à ce que le broker envoi en retour un accusé de réception.
  • =2 le broker sauvegarde le message et le transmettra jusqu’a ce que les souscripteurs connectés le reçoive (avec un mécanisme évitant la duplication de messages).
• Persistance des messages, si la persistance est demandée sur un Topic, les messages sont conservés sur le Broker.
• On peut configurer un message testament (Last Will Testament), si un client perd la connexion au Broker le message testament pourra être récupéré par les souscripteurs à l’écoute du topic LWT.
• On peut définir qui a le droit de publier sur tel ou tel Topic et également qui a le droit de s’y abonner.
• La sécurité peut se faire au niveau transport en SSL/TLS, et au niveau authentification, par certificats SSL/TLS ou couple user/mot de passe.
• On peut utiliser les jokers ‘+’ et ’#’ dans les Topics pour s’abonner à un ensemble de Topics. Par exemple « SMBA38/+/# »
• On peut laisser le choix aux publieurs de définir l’arborescence des Topics et dans ce cas, il n’y a rien à configurer sur le Broker, le publieur indique les Topics qu’il renseigne et le souscripteur indique les Topics qu’il veut surveiller.

Une fois installé sur le Raspberry, Mosquitto fonctionne sans problème.

• On peut utiliser « mosquitto_passwd » pour configurer les utilisateurs et les mots de passe.
• L’exemple suivant interroge le Broker sur les pertes de connexion des clients, on indique un utilisateur (-u) et un mot de passe (-P)

pi@raspberrypi:~$ mosquitto_sub -q 2 -h 192.168.1.22 -u util -P motdepasse -t "lwt/#" -v

Il existe plusieurs Clients MQTT pour, Linux, Apple, Smartphones et même pour Windows .

MQTT.fx sous Windows.

Voici un exemple avec le client Windows MQTT.fx (Programmé en Java).

On peut avec MQTT.fx Publier , souscrire, écrire des scripts (En java) Avoir des informations sur le Broker ou lire les logs.

Conclusions.

A la différence d’un serveur avec une base de données relationnelle qui conserve les données d’une façon permanente, un Broker est surtout prévu pour mettre en relation des objets, les messages ne sont en général pas conservés sur la base (Sauf demande de messages persistants).

C’est un peu le même principe que les flux RSS.

Par contre la création et la consultation des Topics est très simple et aucune configuration n’est nécessaire pour ajouter un Topic. (Sauf demande explicite de contrôles par le Broker de l’utilisation des Topics).

On peut facilement faire communiquer plusieurs Framboises sans trop d’efforts de programmation, une simple ligne de commande suffit.

Mais on peut également développer en Python pour des projets plus complexes.

Toutes sortes d’objets disposant d’une interface Wifi peuvent également utiliser le protocole MQTT, c’est le cas de puces ESP8266 d’Espressif.

PUCE ESP8266 Nodemcu, Lua et MQTT.

Puce ESP8266 ESP-01 (14,3 mn x 24.8 mn)

Avec Puce ESP8266 ESP-12 avec ADC.

Puce ESP8266.

• La société Espressif propose une puce ESP8266 disposant de deux interfaces réseau Wifi.
  L’ESP8266 :
•  Dispose de 32Kbytes de Ram, 96Kbytes de data RAM, 64 KBytes de BOOT ROM.
• Le Processeur 32 bits a une architecture Harward, La fréquence est de 80MHZ.
• La puce est généralement accompagnée d’une mémoire Flash SPI de 512MO à 4GO.
• L’alimentation est de 3V.
• La puce peut se mettre en sommeil pour ne pas trop tirer sur l’alimentation.

On trouve ces puces sur Ebay à partir de 2€, Il existe des cartes de développement à 10€, par exemple Nodemcu.

Il existe plusieurs implémentations de ces puces sur des PCB ESP-01 à ESP-12 l’antenne Wifi peut être sur le PCB, céramique ou externe.

Firmwares utilisables :

On peut Flasher plusieurs firmwares sur cette puce :

• Commandes AT (la puce se comporte comme un modem Wifi), il existe des librairies pour utiliser le protocole MQTT à partir d’un Arduino.
• Serveur WEB développés en C.
• Micro Python.
• Nodemcu embarquant le langage orienté réseau Lua avec des fonctions MQTT.

La société Espressif propose une machine virtuelle sous VirtualBox avec l’environnement de développement déjà installé (ToolChain) , il suffit de rajouté le SDK livré également par Espressif.

Nodemcu et Lua.

La carte de tests Nodemcu est reliée par USB à un ordinateur (Nodemcu embarque un convertisseur USB / Série).
La mémoire flash est organisée en fichiers (format SLIP).
On dispose de fonctions pour piloter les GPIO (SPI, I2C, oneWire, ADC, PWM).

Lua est un langage orienté réseau.

• On peut en Lua envoyer des mails d’une façon autonome.
• Développer des clients et des serveurs UDP ou TCP.
• On peut également programmer un serveur Telnet en une douzaine de lignes de code pour pouvoir prendre la main à distance via le Wifi sur la console de l’interpréteur Lua.

MQTT et Lua.

Exemple de code d’appels à MQTT en Lua sur le la carte de développement Nodemcu.

m=mqtt.Client("test", 30,"","") -- création du client

--Evénements
m:on("connect", function(con) print ("Connexion OK") end)
m:on("offline", function(con) print ("offline") m:close() end)
m:on("message", function(conn, topic, data)
if data ~= nil then
print("réception topic: ".. topic .. ":" .. data) end end)

-- Connexion + écoute + envoi
m:connect("test.mosquitto.org", 1883, 0, function(conn) print("Connexion lancée")
m:subscribe("SMBA38/#",1, function(conn) print("Subscription OK, je suis à l'écoute")
m:publish( "SMBA38/temps/ext",15,0, 0,function(conn) print ("SMBA38/temps/ext publié")
end)
end)
end)

Et la trace dans la console Lua

>dofile("mqtt_mosquitto.lua")
Connexion lancée
Subscription OK, je suis à l'écoute
SMBA38/temps/ext publié
réception topic: SMBA38/temps/ext:15
réception topic: SMBA38/temps/Int:21
offline

Dans le même code on teste :

• La Connexion au BroKer.
• Le souscripteur (mis en premier pour recevoir les données du publieur).
• Le publieur.

La valeur : « réception topic: SMBA38/temps/Int:21 »
Correspond à une valeur publiée en même temps que le test avec Lua depuis le Raspberry par :

mosquitto_pub -h test.mosquitto.org -t SMBA38/temps/Int -m 21

Dans la vraie vie, il y aura plusieurs ESP8266, un qui envoie des données et un (ou plusieurs) qui les traite.

Conclusions

Il est donc très facile en quelques lignes de Lua de mettre à jour la base de données d’un Broker MQTT , ce broker publiant immédiatement les données.

Et pour une puce à deux euros, c’est pas mal et cette puce peut gérer les communications réseau d’une façon autonome avec une alimentation de deux piles de 1,5V.

J’ai publié sur le Forum de Framboise 314 plusieurs exemples en code Lua.

SMBA38.

Merci à Michel pour cet article très intéressant