Précédemment, nous avons découvert la librairie Homie qui permet de simplifier l’écriture de code Arduino pour développer des objets connectés ESP8266 qui communiquent par messages MQTT. Dans cet article nous allons aborder plus en détail comment utiliser la librairie dans un programme Arduino. La librairie met à disposition un très grand nombre de fonctions qui permettent de personnaliser son code au maximum. C’est probablement la librairie la plus puissante pour écrire des programmes basés sur MQTT. Ici, nous allons aborder uniquement les fonctions essentielles qui permettent d’écrire un programme avec le minimum de code. Comme c’est toujours plus facile de partir d’un exemple, nous allons fabriquer une petite sonde de température à base d’un DHT22.

Matériel utilisé pour ce tutoriel

Structure d’un programme Homie pour ESP8266

Homie est une librairie qui simplifie l’écriture des programmes Arduino. Elle prend en charge le protocole de communication MQTT présenté ici. Homie prend en charge les aspects techniques suivants :

• La connexion au réseau Wi-Fi et au serveur MQTT
• Homie est capable de gérer la re-connexion au réseau Wi-Fi / serveur MQTT
• La structuration des messages MQTT
• Mise à jour sans fil par message MQTT

Le programme minimal

Voici le programme minimal pour faire fonctionner Homie.

#include <Homie.h>

void setup() {
  Serial.begin(115200);
  Serial << endl << endl;

  Homie_setFirmware("bare-minimum", "1.0.0"); // The underscore is not a typo! See Magic bytes
  Homie.setup();
}

void loop() {
  Homie.loop();
}

Il faut tout d’abord inclure la librairie en début de programme.

Puis dans la boucle setup() du code Arduino :

• Depuis la version 2, il est nécessaire de démarrer explicitement le moniteur série Serial.begin(115200). Homie intègre un gestionnaire de message (logger) que nous verrons plus tard dans l’article
• La méthode Homie.setup() initialise la librairie. Plusieurs paramètres peuvent être permet indiqués avant d’appeler cette méthode. Nous allons les voir en détail au prochain paragraphe. Le seul paramètre obligatoire et le nom du firmware et sa version. Autrement dit, le nom de votre programme et son numéro de version.

Enfin dans la boucle loop() du code Arduino, on actualise les traitements avec la méthode Homie.loop() .

Maintenant, nous allons ajouter une sonde de température DHT22 et publier les mesures de température et d’humidité.

Ajouter un noeud (Node)

Chaque événement (appui sur un contacteur, un bouton, un capteur de fin de course…) ou mesure (température, humidité, taux de CO2, quantité de particules dans l’air…) est appelé un Node. Pour définir un Node, on utilise la méthode HomieNode (documentation). Tous les Nodes doivent être définis en début de programme (avant le setup du code Arduino).

HomieNode(const char* id, const char* type, std::function<bool(const String& property, const HomieRange& range, const String& value)> handler = );

Le constructeur a besoin des paramètres suivants :

• id : ID du Node
• type : type du Node. Il n’y a pas de type imposé
• handler (optionnel)

Ce qui donne pour un DHT22 qui publie deux mesures

HomieNode temperatureNode("temperature","temperature");
HomieNode humidityNode("humidity","humidity");

Publier des données – des messages MQTT

Pour publier régulièrement les mesures, on va simplement tester un intervalle de temps. La librairie Homie n’utilise pas de Timer (la librairie SimpleTimer par exemple). On va indiquer à Homie la fonction Handler qu’il devra exécuter à chaque cycle. On indique le Handler au moment du setup Arduino

Homie.setLoopFunction(loopHandler);

Maintenant, il suffit de tester assez classiquement le temps écoulé entre deux passage dans la fonction.

void loopHandler() {
  if (millis() - lastTemperatureSent >= TEMPERATURE_INTERVAL * 1000UL || lastTemperatureSent == 0) {
    float t = dht.readTemperature();
    float h = dht.readHumidity();
    
    // Affiche les mesures dans le journal - send values to the logger
    Homie.getLogger() << "Temperature: " << t << " °C | humidity: " << h << "%" << endl;
    if ( !isnan(t) ) {
      temperatureNode.setProperty("temperature").send(String(t));
      humidityNode.setProperty("humidity").send(String(h));
    }    
  }
}

Pour publier des mesures, on doit utiliser la méthode setProperty(“nom_propriete”).send(valeur)

Structure des messages MQTT Homie

Il est temps de regarder à quoi vont ressembler les messages publiés par Homie. D’une manière générale, il prenne la forme suivant

homie / nom du device / nom du node / nom de la propriété  valeur

ou de manière plus formelle

homie/Device ID/Node ID/Property value

Le préfixe homie et le Device ID sont définis au moment de la configuration (lire l’article précédent)

Le Node ID est attribué par la méthode HomieNode

Enfin la propriété est attribuée au moment de la publication par la méthode setProperty()

Voici ce qu’on va obtenir par exemple

homie/demohomie-projetsdiy/temperature/temperature 27.50

Publier des données au format JSON

Si coté serveur vous désirez récupérer les données au format JSON, il n’y a aucune fonction proposée par Homie qui permet de regrouper et structurer les données au format JSON. Cela ne pose cependant aucun problème puisqu’il suffit de construire sa propre chaine. Vous pouvez également utiliser la librairie ArduinoJSON présentée dans ce tutoriel. Attention toutefois aux performances. De nombreux traitements sont réalisés de manière asynchrone par la librairie. Si la fréquence de mesure est trop rapide, l’envoi des messages MQTT risque d’être ralenti.

Voici un petit morceau de code qui envoi la température et l’unité de mesure au format JSON

temperatureNode.setProperty("json").send("{\"t:\"" + String(t) + ", \"unit\":\"c\"}");

Et voilà ce qu’on obtient en s’abonnant au topic homie/# avec la commande suivante

mosquitto_sub -h localhost -t "homie/#" -v

Si vous avez mis en place un authentification, compléter et exécutez cette commande

mosquitto_sub -h localhost -t "homie/#" -v -u "UTILISATEUR" -P "MOT-DE-PASSE"

Code complet du projet Homie DHT22

Voici le code complet du projet qu’il vous suffit de teléverser sur l’ESP8266. N’oubliez pas de modifier la broche sur laquelle est branché le DHT22. Ici, il est branché sur la broche D4 car j’ai utilisé un shield DHT22 pour Wemos d1 mini.

#include <Homie.h>
#include <DHT.h>

const int TEMPERATURE_INTERVAL = 300;
unsigned long lastTemperatureSent = 0;

const int PIN_DHT22 = D4;    // Broche - Pin DHT22
DHT dht(PIN_DHT22, DHT22);

HomieNode temperatureNode("temperature", "temperature");
HomieNode humidityNode("humidity", "humidity");

void loopHandler() {
  if (millis() - lastTemperatureSent >= TEMPERATURE_INTERVAL * 1000UL || lastTemperatureSent == 0) {
    float t = dht.readTemperature();
    float h = dht.readHumidity();
    
    // Affiche les mesures dans le journal - send values to the logger
    Homie.getLogger() << "Temperature: " << t << " °C | humidity: " << h << "%" << endl;
    if ( !isnan(t) ) {
      temperatureNode.setProperty("temperature").send(String(t));
      temperatureNode.setProperty("json").send("{\"t\":" + String(t) + ",\"unit\":\"c\"}");
      humidityNode.setProperty("humidity").send(String(h));
      humidityNode.setProperty("json").send("{\"h\":" + String(t) + ",\"unit\":\"%\"}");
      lastTemperatureSent = millis();
    }
    lastTemperatureSent = millis();
  }
}

void setup() {
  Serial.begin(115200);
  Serial << endl << endl;

  Homie_setFirmware("demo-dht22", "1.0.0");
  Homie.setLoopFunction(loopHandler);

  Homie.setup();
}

void loop() {
  Homie.loop();
}

Voilà, vous pouvez déjà réaliser un grand nombre de projets avec cette base de code.

• Inclure un objet connecté ESP8266 + DHT22 + Homie MQTT dans Home Assistant (HASS)
• Premier projet Homie ESP8266, publier en MQTT des mesures d’une sonde DHT22
• Bien débuter avec la librairie Homie (MQTT) pour objets connectés à base d’ESP8266