Un capteur de niveau de cuve HC-SR04 dans Jeedom avec ESP Easy et ESP8266

L’envie du moment était de pouvoir connaître la quantité de mazout restante dans mes deux cuves et, au passage, ma consommation. J’avais tout d’abord songé à un compteur à impulsion (comme pour un compteur d’eau mais attention à la pression à supporter en entrée) mais je n’avais rien trouvé de satisfaisant. Finalement je suis parti vers l’option d’un capteur de distance pour mesurer le vide entre le dessus de la cuve et le niveau de mazout et, par là, calculer la quantité restante et les variations.

Pour réaliser ce besoin au moins cher et pour explorer au passage une technologie qui m’était inconnue, j’ai fait une plongée dans le monde de l’électronique. Mais je vous rassure d’emblée : ce n’est pas si compliqué que cela et vous n’avez pas besoin de savoir souder ou de savoir programmer.

Mon capteur de niveau se compose finalement d’un microcontrôleur ESP8266 et d’un capteur de distance HC-SR04 et coûte une dizaine d’euros (prix de l’alimentation non compris)

Introduction : à propos de ESP8266 et du firmware ESP Easy

Depuis la fin de mes études, le domaine de l’électronique a énormément évolué. Il est tout d’abord devenu plus accessible car il est plus facile de construire un module et c’est bien moins cher. Enfin, les microcontrôleurs sont maintenant disponibles avec un module WIFI et parfois une interface web. Ces microcontrôleurs sont donc facilement connectables au monde de la domotique et, la démocratisation faisant son oeuvre, une kyrielle de capteurs peuvent être contrôlés : température, humidité, pression atmosphérique, intensité lumineuse, distance, impulsions, pluie, ….

Parmi ces microcontroleurs nouvelle génération, on retrouve en bonne place le ESP8266, un microcontrôleur avec connexion WIFI développé par le fabricant chinois Espressif.

Voici la variante ESP8266 achetée sur Amazon et qui sera utilisée dans cet article.

Point de vue packaging, voici ce que donne celui du vendeur AZ-Delivery

L’ESP8266 peut se programmer avec plusieurs langages selon le firmware installé : script Lua avec le firmware NodeMCU, C++ avec l’IDE Arduino, Javascript avec Espruino,… Enfin on peut même se passer d’apprendre ces langages et configurer le microcontrôleur à travers une interface web avec le firmware ESP Easy. C’est cette solution, facile et rapide, que j’ai choisie.

ESP Easy est un firmware gratuit et open source pour microcontrôleur ESP8266. On l’utilise pour transformer les modules ESP8266 en des capteurs multi-functions programmables via une application web. Une fois le firmware installé, on n’a plus besoin que d’un navigateur internet pour configurer le tout parce que le firmware ESP Easy est livré avec toute une série de configuration “out-of-the-box” qui permettent de faire fonctionner des actionneurs et capteurs sans écrire une ligne de code.

Le bon choix des capteurs : attention à la tension d’alimentation

Il y a vraiment un grand nombre de capteurs compatibles avec l’ESP8266. On trouve d’ailleurs des kits de démarrage sur Amazon qui donne une idée de l’étendue des possibilités.

Pour mesurer le niveau de mes cuves à mazout, j’ai opté pour un capteur de distance HC-SR04.

C’était une petite erreur. Car il faut toujours faire attention au voltage. Le ESP8266 que j’ai acheté est alimenté en 5V mais fonctionne avec des signaux de 3,3V. Du coup, il faut lui coupler des capteurs 3,3V. Or, le HC-SR04 est un capteur 5V. Il aurait fallu commander le variante HC-SR04P qui peut, elle, fonctionner en 3,3V ou 5V.

Mais, trop tard, l’erreur était faite. J’avais toutefois lu certains dirent que le ESP8266 supporterait quand même le 5V, précisant bien “à vos risques et périls”. J’ai donc pris le risque, vu le faible coût des composants, de coupler les deux et d’utiliser le 5V. Après quelques jours, cela tient toujours ! C’est toutefois, bien entendu, à déconseiller et vous risquez de griller votre microcontrôleur ESP8266.

L’installation du firmware ESP Easy

Etape 1: Téléchargement des outils

Les modules ESP sont en général vendus avec un firmware : souvent le AT firmware ou le NodeMCU LUA firmware. En choisissant d’utiliser ESP Easy, on va en fait remplacer le firmware existant par ESP Easy.

Pour flasher un firmware, plusieurs solutions existent. La plus facile consiste à utiliser l’outil ESP Easy Flasher.exe (qui n’existe hélas que sous Windows). Pour ceux qui souhaitent faire autrement, voici d’autres techniques (en anglais) : https://www.letscontrolit.com/wiki/index.php?title=Basics:_Connecting_and_flashing_the_ESP8266

On télécharge l’outil ESP Easy Flasher et les firmware sur cette page : https://github.com/letscontrolit/ESPEasy/releases. Dans la partie « Assets » (mot sur lequel il faut cliquer pour voir le sous contenu), on retrouve un fichier ZIP à télécharger. A l’heure d’écrire cet article, c’est le fichier ESPEasy_mega-20200426.zip. On décompresse ce fichier et on trouve l’outil ESP.Easy.Flasher.exe

L’outil ESP.Easy.Flasher.exe utilise les ports séries et beaucoup de PC n’ont plus. Il faut alors passer par une astuce : transformer les ports USB en ports séries COM virtuels. Cela se fait en installant le “CP210X Universal Windows Driver” tel que décrit ici https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers.. Vérifiez toutefois que votre ESP8266 peut communiquer au travers du CP210X (celui utilisé dans cet article implémente le CP2102 et cela fonctionne donc).

Etape 2: brancher le ESP8266 au PC

Pour cette seconde étape, il faut brancher son ESP8266 à l’aide d’un câble USB côté PC et micro USB côté ESP8266. 

Le PC doit, à ce stade, reconnaitre qu’un appareil a été branché et vous devriez voir un port COM dans le “Device Manager”. Ici il s’agit de “Silicon Labs CP210X USB to UART Bridge (COM4).

Si vous ne voyez pas ce port COM, c’est plutôt mauvais signe et il y a peu de chance que vous puissiez aller plus loin.

Etape 3: Flasher ESP Easy dans le module ESP8266

Dans cette troisième étape, il faut choisir la version du firmware ESP Easy à installer dans le module ESP8266.

Le firmware de ESP Easy est construit sur la version R120, réputée assez stable. Il y a d’autres versions en cours de développement (Mega). J’ai pris le risque d’installer une version en cours de développement (Mega) car la R120 datait de 2018. Cela a très bien fonctionné.

On lance donc le logiciel ESP.Easy.Flasher.exe. Le bon port COM doit se remplir automatiquement (COM4 ici). Dans la zone de texte Firmware (.bin), on choisit la version. J’ai pris “ESP_Easy_mega-20200426_normal_ESP8266_4M1M.bin”. Faites bien attention à choisir une version adaptée à la taille mémoire de votre ESP8266. Le mien étant de 4Mb, c’est un firmware _4M que j’ai choisi.

Ensuite, il faut cliquer sur le bouton “Flash ESP Easy FW” en bas à droite pour démarrer le processus.

Après environ 90 secondes, le message “DONE!” apparaît. On peut débrancher l’alimentation (USB) du ESP8266 et le rebrancher afin de redémarrer l’appareil.

A cette étape, il convient de connecter physiquement le capteur de distance. L’idéal est d’avoir le HC-SR04P et de l’alimenter en 3,3V. N’ayant que le HC-SR04, j’ai pris le risque de griller mon ESP8266 en travaillant en 5V. Voici donc le branchement du HC-SR04. Si vous travaillez avec le HC-SR04P, il faudra juste changer un câble en prenant une pin 3.3V au lieu de VIN sur le ESP8266. 

Pour les branchements, j’utilise des câbles Elegoo. J’en avais acheté sur Amazon par sécurité mais il y en avait quelques uns de livrés avec les capteurs.

On branche donc des PINs de l’ESP8266 avec des PINs du capteur HC-SR04(P) à l’aide de ces câbles. Le ESP8266 est un microcontrôleur dont certaines PIN ont une fonction prédéfinie qu’on ne peut pas changer (on songe à l’alimentation VIN, la masse GND, le reset,…). Mais, et c’est là toute la force, certaines PINs sont ce qu’on appelle GPIO c’est-à-dire “General Purpose Input/Output.” Ces PINs GPIO n’ont pas de fonctions spécifiques et peuvent donc être paramétrées. Il faut bien repérer quelles sont les PINs GPIO et les autres sur le schéma de son ESP8266. Le mien, fourni par le vendeur AZ Delivery, indiquait ceci:

Il y a quatre câbles à connecter: les deux premiers sont des PINs prédéfinies pour l’alimentation. Etant en 5V, j’ai donc pris GND et Vin (en bas à gauche sur l’image ci-dessus). Les deux autres PINS sont à choisir parmi les PINs GPIO afin de récupérer les mesures du capteur. J’ai choisi D6 (GPIO12) et D7 (GPIO13). Le câblage donne donc

ESP8266 VIN -> HC-SR04 VCC

ESP8266 Gnd -> HC-SR04 Gnd

ESP8266 D6 -> HC-SR04 Trig

ESP8266 D7 -> HC-SR04 Echo

1. Toujours dans le navigateur internet à l’URL de l’ESP8266 (voir étape 4 – point 5), cliquer sur “Devices” et appuyer sur “Add”

Il ne reste plus maintenant qu’à se trouver un petit boitier sympa pour y mettre son capteur et à l’alimenter de façon autonome à travers un petit transformateur 5V (du genre chargeur de téléphone). Pour le boitier, une imprimante 3D peut s’avérer ici bien utile. En ce qui me concerne, j’ai récupéré un bouchon en plastique de ma cuve à mazout. J’ai percé des trous à la foreuse et j’y ai collé les capteurs au silicone.

J’ai utilisé, de l’autre côté, une simple boite de dérivation pour y placer les ESP8266 et j’ai relié les ESP8266 et les capteurs HR-SC04 avec du câble réseau RJ45 CAT 6 qui trainait (celui-ci supportant le POE, il ne devrait pas y avoir de soucis pour du 5V et le faible ampérage requis par les ESP8266). Ce n’est pas très sexy mais cela fonctionne. Par mesure de sécurité, j’ai utilisé de l’isolant (après avoir pris la photo) pour bien séparer les deux ESP8266 afin que leurs PINs ne se touchent pas.

Bon, c’est clair c’est du bricolage. Certains font des choses bien plus belles avec une imprimante 3D comme par exemple ici : https://cults3d.com/fr/mod%C3%A8le-3d/divers/support-capteur-de-niveau-de-cuve. C’est du bien beau travail qui donne envie d’investir dans une imprimante 3D.

La remontée des mesures dans Jeedom

C’est le plugin Jeedom ESPeasy, gratuit, qui va gérer la remontée des mesures des capteurs dans Jeedom. Ce plugin se trouve sur le market officiel de Jeedom.

Après l’avoir installé, il faut l’activer et installer les dépendances. En bas de l’écran, dans la partie “configuration”, on voit les paramètres qu’il faut reporter dans le module ESP8266.

On se reconnecte donc, via un navigateur internet, au module ESP8266 pour le configurer (comme on l’a fait précédemment). On clique cette fois sur “Controllers” et puis sur “Add”.

Les valeurs à introduire sont:

• Generic HTTP
• Controlleur IP : l’adresse IP de Jeedom (qui est aussi celle que l’on peut lire dans “IP Controleur à saisir dans ESPeasy (onglet config)” sur la page de configuration du plugin Jeedom ESPEasy)
• Controlleur Port : 8121 (qui est aussi le numéro que l’on peut lire dans “Port Controleur à saisir dans ESPeasy (onglet config)” sur la page de configuration du plugin Jeedom ESPEasy)
• Controlleur Publish (plus bas dans l’écran): device=%sysname%&taskid=%id%&cmd=%valname%&value=%value% (qui est aussi ce qu’on voit sur la page du plugin)
• Cocher la case “Enabled”

Si vous vous arrêtez ici, vous ne verrez rien dans Jeedom. J’ai perdu pas mal de temps à comprendre pourquoi. Il faut encore remplir une dernière étape au niveau du capteur. Il faut cliquer sur “Devices”, cocher la case “Send to Controlleur” et cliquer sur le bouton “Submit” pour sauver les changements. Si vous avez plusieurs ESP8266, indiquez bien un IDX différent pour chacun.

Par mesure de précaution, je vous conseille de redémarrer votre ESP8266.

Vous pouvez maintenant retourner dans Jeedom : Plugins / Protocole Domotique / ESPeasy

Cliquer sur le bouton “+ Inclusion”. Un équipement, correspondant au capteur, devrait apparaitre.

Il faut configurer cet équipement en cliquant dessus, en lui donnant un nom, en cochant “Activer” et “Visible” et en lui attribuant une pièce (via Objet parent). On notera, au passage et si besoin, que son adresse IP est renseignée.

Au niveau des commandes, on voit la mesure de distance qui est remontée :

Si on se rend dans le Dashboard, on a voit également l’information du capteur de distance HC-SR04:

Utiliser un widget et calculer le volume dans les cuves

J’ai maintenant une distance qui m’indique combien d’espace vide il y a entre le niveau de mazout et le haut de la cuve. Mais un joli Widget qui me donnerait le niveau de remplissage, en litres, de chacune des deux cuves et le total, serait quand même bien plus joli.

Je suis passé par un équipement virtuel (via le plugin virtuel à installer). J’y ajoute consécutivement trois infos virtuelles (bouton “+ Ajouter une info virtuelle) de sous-type numérique. Dans le champ valeur, je réalise un calcul.

Mes cuves font 2500 litres et leur hauteur est de 150cm. Le calcul suivant me donnera donc le niveau de mazout dans chaque cuve : 2500*(150 – distance mesurée)/150. Cela donne, par exemple pour l’info virtuelle “Niveau cuve fond”, cette formule à mettre dans le champ “Valeur” : 2500*(150-#[Cave Garage][Cuve Mazout Fond][Distance]#)/150

Je coche bien entendu le “Afficher” et “Historiser”. J’affecte aussi, au niveau des options, les valeurs minimales, maximales et l’unité.

J’ai ensuite installé un Widget Jauge, assez joli je trouve, en suivant cette procédure: https://community.jeedom.com/t/partage-jauges-highcharts-parametrable-ouvert-aux-contributions/17303

La dernière étape consiste à configurer le virtuel, pour les trois infos virtuelles créées ci-dessus en cliquant sur le bouton engrenage (de chaque info virtuelle sur l’écran ci-dessus).

Par esthétique, j’arrondis le calcul pour ne pas voir de décimales, ce qui se fait en mettant 0 dans la zone de texte “Arrondi (chiffre après la virgule)” dans l’onglet “Configuration”.

Dans l’onglet “Affichage”, je choisis le Widget importé précédemment à savoir “JaugeHighChart”.

Et voilà le résultat dans mon Dashboard.

Pour être honnête et complet, la mesure n’est pas super stable. A cette période, la chaudière tourne peu. Les cuves, en métal, sont situées en cave et doivent peu se dilater. Il est donc difficile d’expliquer ces variations de mesure d’une minute à la suivante. La précision semble tourner autour des 10 litres, ce qui correspond en effet à la précision de 3mm près annoncée dans les spécifications du capteur. Les capteurs HR-SC04P donneront donc plus une indication et une tendance sur plusieurs jours qu’une consommation instantanée, ce qui est un peu dommage

Home Assistant et les ESP8266

ESPHome

ESPHome permet d’intégrer facilement les appareils basés sur les microcontrôleurs ESP8266 ou ESP32. Ses principaux usages et avantages sont :

• une Intégration simplifiée avec Home Assistant. Une fois configuré, ESPHome communique directement avec Home Assistant via MQTT ou via le protocole API natif, rendant l’intégration très fluide.
• les entités créées sur un appareil ESPHome apparaissent automatiquement dans Home Assistant.
• ESPHome utilise un fichier de configuration YAML pour définir le comportement et les fonctionnalités des appareils. Pas besoin de coder en C/C++ comme avec Arduino IDE.
• Mise à jour Over-the-Air (OTA): une fois le firmware initial installé, les mises à jour du code ou des fonctionnalités peuvent être effectuées sans connecter physiquement l’appareil à un ordinateur.
• ESPHome prend en charge les connexions sécurisées (SSL/TLS) et offre une intégration stable, même en cas de problèmes réseau.

Toutefois, mes ESP8266 étant déjà intégrés dans Jeedom et désirant conserver cette intégration en parallèle, je ne souhaitais pas les reflasher avec ESPHome. J’ai donc choisi de travailler avec MQTT dans Home Assistant.

L’intrégration en MQTT dans Home Assistant

La configuration MQTT dans le firmaware ESP Easy de l’ESP8266

L’idée est d’ajouter un contrôleur via l’interface de l’ESP8266 dans l’onglet « controllers ». Les informations à mentionner sont:

• Type de contrôleur:  Home Assistant (openHAB) MQTT 
• Adresse IP: celle du broker MQTT. En général, il est installé sur la même machine que Home Assitsant et on indique donc ici l’adresse IP de son instance Home Assistant
• Le port MQTT qui est, par défaut, 1883

On coche aussi les cases ci-dessous:

Enfin, on ajoute le nom d’utilisateur et le mot de passe pour se connecter au broker MQTT.  

Si vous n’avez plus ces informations, vous pouvez les récupérer en ouvrant le fichier /config/.storage/core.config_entries avec File Editor. Les informations se trouvent au niveau de la ligne “broker”:”core-mosquitto”.

Dans l’onglet “Devices”, on coche la case “Send to Controller 2”

Dans l’onglet “Config”, on s’assure que le Unit Number est bien unique. Un peu truc, j’utilise en général le dernier nombre de l’adresse IP de l’appareil.

Par sécurité, on redémarre l’ESP8266 et on se connecter à MQTT Explorer dans Home Assistant afin de vérifier que les trames de l’équipement «ESP_Easy_Cuve_Mazout_Avan» (dans ma configuration) apparaissent bien.

La configuration dans Home Assistant

Contrairement à ESPHome, les entités créées dans ESP Easy n’apparaissent automatiquement dans Home Assistant. Il faut donc procéder manuellement, dans un fichier de configuration .yaml comme documenté sur la page  MQTT Sensor: https://www.home-assistant.io/integrations/sensor.mqtt/

Il est toujours préférable d’organiser ses fichiers de configuration .yaml pour éviter de se retrouver avec un énorme fichier qui n’en finit plus. Je conseille donc de créer un fichier mqtt.yaml où se trouveront toutes les configuration MQTT. Au niveau du fichier configuration.yaml, on ajoute dès los cette ligne:

mqtt: !include mqtt.yaml

Avec File Editor, on crée ou on édite maintenant le fichier mqtt.yaml et on y ajoute ce contenu:

sensor:

#ESPEASY – Cuve à Mazout Avant

    – name: “Distance”

      state_topic: “ESP_Easy_Cuve_Mazout_Avan_242/ESP_Easy_Cuve_Mazout_Avant/Distance”

      unique_id: sensor.ESP_Easy_Cuve_Mazout_Avant_Distance

      device_class: distance

      unit_of_measurement: cm

      device:

        name: “Cuve Mazout Avant”

        identifiers: “cuvemazoutavant”

    – name: “Volume restant”

      state_topic: “ESP_Easy_Cuve_Mazout_Avan_242/ESP_Easy_Cuve_Mazout_Avant/Distance”

      value_template: ‘{{ 2500*(150-value | float + 2)/150 | round(0) }}’

      suggested_display_precision: 0

      unique_id: sensor.ESP_Easy_Cuve_Mazout_Avant_Volume

      device_class: volume_storage

      unit_of_measurement: L

      device:

        name: “Cuve Mazout Avant”

        identifiers: “cuvemazoutavant”

Cela donne, dans Home Assistant, un appareil avec deux capteurs :

• la mesure brute renvoyée par MQTT, à savoir la distance mesurée
• le volume restant dans la cuve, un volume calculé à l’aide d’une règle de trois sur la distance mesurée:

Sur un tableau de bord, on peut ajouter une carte de type gauge basée sur le volume restant:

Conclusions

Pour quelques euros, voici un bon moyen de mesurer le niveau de cuves même si cette solution souffre un peu d’un manque de précision. C’est aussi l’occasion d’appréhender une technologie pas si compliquée et qui ouvre beaucoup de portes, notamment avec les box domotiques comme Jeedom et Home Assistant.

Je recommandes vivement.