Dans ce projet, nous allons voir comment « domotiser » votre consommation d’eau. A l’aide d’un compteur (débitmètre) eau à impulsion, d’une carte électronique et du wifi, je vais vous montrer comment être prévenu de fuites d’eau ou tout simplement surveiller sa consommation.

Dans mon cas, mon compteur d’eau est relié à la sortie d’une pompe à forage. L’eau sert à alimenter le jardin, les toilettes et le lave-linge.

Note

Utilité:	(4 / 5)
Simplicité:	(3 / 5)
Coût:	(2 / 5)

Outils

• Tournevis
• fer à souder
• Ordinateur avec ESPlorer pour le soft en lua

Achats

• 1 Compteur ou débitmètre eau à impulsion (~= 56€)
• 1 Nodemcu V1.0 (~=7€)
• 1 Plaque à trous (~=5€ les 5) –> 1€
• Module 4U DIN (~=8€)
• Pin header femelle (~=4€ les 10) –> 0.5€
• 1 Alimentation 12VDC DIN (~=20€)
• Résistances , LED, fil à souder, bornier … (~= 1€)

Total : ~= Moins de 95€

Bon ce n’est pas l’affaire du siècle, mais je trouve que le projet est assez intéressant et qu’il s’intègre parfaitement  dans l’esprit de la maison connectée.

L’investissement paraît important, mais si un jour vous avez une fuite d’eau (surtout les toutes petites qui ne se voient pas à l’oeil nu), vous verrez que le système est largement amorti.

Conception

La conception de la carte électronique est plutôt simple. Avec le NodeMCU en guise de coeur, vous n’avez plus qu’à vous préoccuper du fonctionnel.

Qu’est-ce que le NodeMCU ?

C’est une carte électronique à base de ESP8266 (ESP-12F) intégrant un microcontrôleur et un transceiver WIFI compatible Arduino

Grâce à son convertisseur USB et son régulateur intégrés, vous pourrez le brancher sur votre ordinateur dans le but de le programmer ou interagir facilement. Un simple câble USB / micro-USB vous suffit.

Voici toutes les fonctionnalités des pattes du NodeMCU. Pour approfondir toutes les fonctionnalités vous pouvez aller vous rendre le site officiel.

Attention, tous les GPIOs sont 3.3v compatibles. Ce qui signifie que vous ne devez pas « infliger » aux GPIOs une tension supérieure à 3.3v.

Compteur d’eau à impulsion

Passons maintenant au compteur d’eau à impulsion. Comment les impulsions sont-elles générées ? Eh bien, c’est assez simple, regardons le schéma de fonctionnement.

En effet, le compteur à impulsion fonctionne comme un interrupteur. En fait, la petite aiguille rouge du compteur est aimantée et à chaque fois qu’elle va passer au dessus d’un capteur à effet hall, les deux fils (marrons et blanc) vont être connectés.

Il suffit donc d’alimenter d’un côté un fil (marron ou blanc peu importe) et de connecter l’autre à un GPIO du NodeMCU configuré en entrée.

Vu que mon alimentation délivre du 12Vdc et que le NodeMCU n’accepte que du 3.3Vdc sur les IOs, il va falloir faire un petit pont diviseur de tension. Bien entendu, je peux me permettre d’utiliser cette technique car il n’y a pas ou peu de courant sur cette liaison.

PS: le NodeMCU sera alimenté directement par l’alimentation 12Vdc car il est muni d’un régulateur de tension pouvant aller jusqu’à 15Vdc me semble-t-il.

Voici le schéma général du NodeMCU

En fait, c’est dans ce schéma que l’on voit que tout à déjà été fait dans ce module. La gestion du RESET, ENABLE, L’alimentation, « USB to UART », le paramétrage des pattes pour le mode RUN ou FLASH…

Du coup, pas grand chose à faire, juste le fonctionnel (un pont diviseur de tension) pour récupérer les impulsions du compteur à eau.

Allez on est fou !!! On va rajouter une LED bleu (3.3v / 20mA) pour être averti visuellement lorsqu’une impulsion est générée.

Et voilà on change les valeurs des résistances + la LED et c’est OK !

Réalisation

Il n’y a plus qu’à découper la carte à trous au format de votre boitier DIN. Ensuite, il faut souder les différents connecteurs, borniers, « pins header », les résistances, la LED et faire les trous pour la fixation au boitier.

Alors sur les photos, j’ai rajouté d’autres fonctionnalités (je ferai un article dédié) comme un capteur de température en 1wire (DS18B20) et un compteur monophasé (qui fonctionne différemment du compteur eau)

Software

Les outils

Une fois que la partie matérielle est réalisée, il faut maintenant passer à la partie logicielle. Et oui, vous pensiez quoi !!!. (Attention ! C’est la partie la plus complexe)

Plusieurs solutions existent pour développer avec le NodeMCU:

• La première, la plus répandue est d’intégrer le firmware Arduino et utiliser les librairies à base de ESP8266
• La deuxième, très répandue aussi, est de flasher le module avec un moteur LUA. J’ai choisi ce mode car je suis curieux.

Le LUA est un language script interprété (requiert un « moteur ») au même titre que du PHP, Python, Perl … mais en beaucoup moins gourmand. Cependant, dans les microcontrôleurs, on a pour habitude (pour des raisons de performance) de coder en C ou assembleur. C’est pour cette raison qu’il m’a paru très intéressant d’essayer cette méthode.

Afin de pouvoir programmer le module, plusieurs outils existent:

Je vous recommande tout d’abord le github de NodeMCU.

il faudra télécharger :

• le pilote USB to COM pour pouvoir connecté le NodeMCU à votre PC.
• le firmware du NodeMCU (Attention, j’ai testé uniquement la version 0.9.6-dev_20150704: Fix documents.)
• l’outil de flashage

Ensuite pour outil de développement, j’ai utilisé ESPlorer qui est, ma foi, bien utile. Avec le Getting started

Fonctionnement général

Comment rendre tout ce bordel compatible avec votre domotique ? Eh bien, grâce au Wifi. Voici le principe de fonctionnement.

Le module NodeMCU va se connecter à votre borne Wifi et monter un serveur Web, puis incrémenter un compteur à chaque impulsion du débitmètre.

Votre domotique n’a plus qu’à accéder à la page web du module pour récupérer la valeur distribuée en JSON (par exemple). La page web est bien entendu protégée par un système d’authentification basique. Une fois que la valeur est lue, il faut renvoyer « OK » pour remettre à zéro la valeur du compteur.

Le code

Une fois que vous avez tout installé, voici le programme en LUA répondant au fonctionnement général.
A chaque démarrage du module, c’est le fichier init.lua qui est appelé. (c’est obligatoire, le bootloader du NodeMCU lance cette page)

[pastacode lang= »c » manual= »–CONFIGURATION%20DES%20IOS%20EN%20ENTREES%0Agpio.mode(1%2Cgpio.INPUT)%0Agpio.mode(2%2Cgpio.INPUT)%0Agpio.mode(5%2Cgpio.INPUT)%0Agpio.mode(6%2Cgpio.INPUT)%0A%0A–PASSAGE%20DES%20IOS%20A%20L’ETAT%20BAS%0Agpio.write(1%2C%20gpio.LOW)%0Agpio.write(2%2C%20gpio.LOW)%0Agpio.write(5%2C%20gpio.LOW)%0Agpio.write(6%2C%20gpio.LOW)%0A–TABLEAU%20LISTAGE%20DES%20ENTREES%0AtabInput%3D%7B1%2C2%2C5%2C6%7D » message= »CONFIG DES ENTREES » highlight= » » provider= »manual »/]

En tout début de programme je paramètre 4 pattes en entrée à l’état bas (0). Attention, j’ai choisi ces pattes parce qu’elles n’ont pas de fonctions de config du NodeMCU comme D0 –> wake ou D4 –> qui doit être obligatoirement à 1 au démarrage. (Voir le schéma général plus haut)

En gros il faut éviter d’utiliser D0, D3, D4, D9 si vous avez besoin de garantir un état au démarrage. Je m’explique: imaginez que vous souhaitez utiliser une commande relais. Si vous le branchez sur D4, à chaque redémarrage de votre carte, le relai va s’actionner …

C’est pour cette raison que j’ai utilisé les pattes D1, D2, D5, D6.

[pastacode lang= »c » manual= »–%20INCLUSION%20DES%20FICHIERS%20DE%20CONFIG%0AINI%20%3D%20require%20’inifile’%3B%0Aconfigfile%20%3D%20INI.load(‘config.ini’)%3B%0Aprotect%20%3D%20INI.load(‘auth.ini’)%3B%0Ainputs%20%3D%20INI.load(‘inputs.ini’)%3B » message= »CONFIG » highlight= » » provider= »manual »/]

Le fichier config.ini regroupe les infos de connexion wifi

[network]
ssid=<SSID>
pass=<PASS>
ip=<IP>
mask=<MASK>
gateway=<GW>
mode=2

Le fichier auth.ini regroupe le login/pass de la connexion web

[AUTH]
pass=admin
user=admin

Le fichier inputs.ini regroupe le paramétrage des entrées

[INPUTS]
in2=1
in1=1
in4=1
in3=1
url=10.0.100.54
page=nodemcu.php

En effet, ce n’est pas utilisé pour le projet de compteur d’eau mais j’ai développé 3 types de fonctionnalités:

• soit comptage (0..65000)
• soit entrée simple (1 ou 0)
• soit évènementiel avec le lancement de l’url+page

[pastacode lang= »c » manual= »local%20wifiConfigStation%20%3D%20%7B%7D%0AwifiConfigStation.mode%20%3D%20wifi.STATION%20%20–%20CONFIG%20EN%20MODE%20STATION%20(%20PAS%20DE%20MODE%20AP%20dans%20ce%20cas)%0AwifiConfigStation.stationPointConfig%20%3D%20%7B%7D%0A–%20ON%20RECUPERE%20LES%20INFOS%20D’AUTHENTIFICATION%0AwifiConfigStation.stationPointConfig.ssid%20%3D%20configfile.network.ssid%0AwifiConfigStation.stationPointConfig.pwd%20%3D%20%20configfile.network.pass%0A–ON%20CHOISI%20LE%20MODE%20EN%20IP%20STATIQUE%20%2F%2F%20PAS%20DE%20DHCP%0Alocal%20mode%3B%0Amode%20%3D%20configfile.network.mode%0Alocal%20cfgip%20%3D%7B%7D%3B%0Acfgip.ip%20%3D%20configfile.network.ip%0Acfgip.netmask%20%3D%20configfile.network.mask%0Acfgip.gateway%20%3D%20configfile.network.gateway%0Awifi.sta.setip(cfgip)%0Awifi.sta.autoconnect(1)%0A–%20ON%20SE%20CONNECTE%0Awifi.sta.config(wifiConfigStation.stationPointConfig.ssid%2C%20wifiConfigStation.stationPointConfig.pwd)%0Alocal%20joinCounter%20%3D%200%0Alocal%20joinMaxAttempts%20%3D%205%0A–%20ON%20CREE%20UN%20TIMER%200%20QUI%20SE%20D2CLENCHE%20AU%20BOUT%20DE%203%20SEC%20ET%20SORTIR%20S’IL%20EST%20BIEN%20CONNECTE%0Atmr.alarm(0%2C%203000%2C%201%2C%20function()%0A%20%20%20local%20ip%20%3D%20wifi.sta.getip()%0A%20%20%20local%20status%20%3D%20wifi.sta.status()%0A%20%20%20if%20status%20~%3D%205%20then%0A%20%20%20%20%20%20print(‘Connecting%20to%20WiFi%20Access%20Point%20…’)%0A%20%20%20else%0A%09%09print(%22IP%20%3A%20%22..ip)%0A%20%20%20%20%20%20tmr.stop(0)%0A%20%20%20end%0Aend) » message= »WIFI » highlight= » » provider= »manual »/]

Voilà la partie connexion Wifi. Je l’ai vachement simplifié pour ce projet mais vous pouvez vous amuser à gérer le DHCP ou STATIQUE et le mode AP (point d’accès) ou STATION (client)

[pastacode lang= »c » manual= »valin1%20%3D%200%0Avalin2%20%3D%200%0Avalin3%20%3D%200%0Avalin4%20%3D%200%0Aeventin1%3D0%0Aeventin2%3D0%0Aeventin3%3D0%0Aeventin4%3D0%0Atemperature%20%3D%20-99%0A–PARAMETRAGE%20DES%20ENTREES%20SELON%20LES%20MODES%0Adofile(%22inputs.lc%22)%0A–LANCEMENT%20DU%20SERVEUR%20WEB%0Adofile(%22httpserver.lc%22)(80)%0A–%20LANCEMENT%20D’UN%20TIMER%20TOUTES%20LES%2030%20SEC%20POUR%20FAIRE%20L’ACQUISITION%20D’UN%20CAPTEUR%20DE%20TEMPERATURE%0Atmr.alarm(3%2C30000%2C1%2C%0A%09%09function%20()%0A%09%09%09wifi.sta.connect()%0A%09%09%09dofile(%22temp.lua%22)%0A%09%09end) » message= »Fonctionnel » highlight= » » provider= »manual »/]

Voici le cœur du programme, la partie acquisition de température ne concerne pas le projet de comptage mais vous pouvez le garder de côté quand je ferai l’article sur le capteur de température (DS18B20).

A noter aussi que l’inclusion de fichier code comme dofile « inputs.lc » permet de rendre plus lisible le code. D’autres part, l’extension « lc » est du LUA compressé. Le logiciel ESPlorer permet de compresser vos fichiers LUA à la volée.

[pastacode lang= »c » manual= »collectgarbage()%0AtLastcount1%3D0%0AtLastcount2%3D0%0AtLastcount3%3D0%0AtLastcount4%3D0%0Afunction%20in1Count(level)%0A%20%20%20%20%20if%20%20(tmr.now()%3CtLastcount1)%20or%20%20(tmr.now()-tLastcount1%20%3E%2020000)%20then%20–%20only%201x%20per%200.2%20sec%2C%20or%20overflow%20of%20tmr.now%0A%20%20%20%20%20%20%20%20tLastcount1%3Dtmr.now()%0A%09%09if%20level%20%3D%3D%200%20then%20%0A%09%09%09valin1%20%3D%20valin1%20%2B1%0A%09%09%09%0A%09%09end%0A%20%20%20%20end%0Aend%0Afunction%20in2Count(level)%0A%20%20%20%20%20if%20%20(tmr.now()%3CtLastcount2)%20or%20(tmr.now()-tLastcount2%20%3E%2020000)%20then%20–%20only%201x%20per%200.2%20sec%2C%20or%20overflow%20of%20tmr.now%0A%20%20%20%20%20%20%20%20tLastcount2%3Dtmr.now()%0A%09%09if%20level%20%3D%3D%200%20then%20%0A%09%09%09valin2%20%3D%20valin2%20%2B1%0A%09%09end%0A%20%20%20%20%20end%0A%0Aend%0Afunction%20in3Count(level)%0A%20%20%20%20%20if%20%20(tmr.now()%3CtLastcount3)%20or%20%20(tmr.now()-tLastcount3%20%3E%2020000)%20then%20–%20only%201x%20per%200.2%20sec%2C%20or%20overflow%20of%20tmr.now%0A%20%20%20%20%20%20%20%20tLastcount3%3Dtmr.now()%0A%09%09if%20level%20%3D%3D%200%20then%20%0A%09%09%09valin3%20%3D%20valin3%20%2B1%0A%09%09%09%0A%09%09end%0A%20%20%20%20%20end%0Aend%0Afunction%20in4Count(level)%0A%20%20%20%20%20if%20%20(tmr.now()%3CtLastcount4)%20or%20%20(tmr.now()-tLastcount4%20%3E%2020000)%20then%20–%20only%201x%20per%200.2%20sec%2C%20or%20overflow%20of%20tmr.now%0A%20%20%20%20%20%20%20%20tLastcount4%3Dtmr.now()%0A%09%09if%20level%20%3D%3D%200%20then%20%0A%09%09%09valin4%20%3D%20valin4%20%2B1%0A%09%09end%0A%20%20%20end%0Aend%0Aif%20(tonumber(inputs.INPUTS.in1)%3D%3D1)%20then%20%0A%09gpio.mode(tonumber(tabInput%5B1%5D)%2Cgpio.INT)%0A%09gpio.trig(tonumber(tabInput%5B1%5D)%2C%20%22down%22%2Cin1Count)%20%0Aelse%0A%09gpio.mode(tonumber(tabInput%5B1%5D)%2Cgpio.INPUT)%0Aend%0Aif%20(tonumber(inputs.INPUTS.in2)%3D%3D1)%20then%20%0A%09gpio.mode(tonumber(tabInput%5B2%5D)%2Cgpio.INT)%0A%09gpio.trig(tonumber(tabInput%5B2%5D)%2C%20%22down%22%2Cin2Count)%20%0Aelse%0A%09gpio.mode(tonumber(tabInput%5B2%5D)%2Cgpio.INPUT)%0Aend%0Aif%20(tonumber(inputs.INPUTS.in3)%3D%3D1)%20then%20%0A%09gpio.mode(tonumber(tabInput%5B3%5D)%2Cgpio.INT)%0A%09gpio.trig(tonumber(tabInput%5B3%5D)%2C%20%22down%22%2Cin3Count)%20%0Aelse%0A%09gpio.mode(tonumber(tabInput%5B3%5D)%2Cgpio.INPUT)%0Aend%0A%0Aif%20(tonumber(inputs.INPUTS.in4)%3D%3D1)%20then%20%0A%09gpio.mode(tonumber(tabInput%5B4%5D)%2Cgpio.INT)%0A%09gpio.trig(tonumber(tabInput%5B4%5D)%2C%20%22down%22%2Cin4Count)%20%0Aelse%0A%09gpio.mode(tonumber(tabInput%5B4%5D)%2Cgpio.INPUT)%0Aend » message= »GESTION DES ENTREES » highlight= » » provider= »manual »/]

En fonction du mode d’entrée (compteur ,entrée simple ou évènement), je vais gérer les entrées différemment. Pour notre cas, c’est ce code qui nous intéresse :

[pastacode lang= »markup » manual= »function%20in1Count(level)%0A%20%20%20%20%20if%20%20(tmr.now()%3CtLastcount1)%20or%20%20(tmr.now()-tLastcount1%20%3E%2020000)%20then%20–%20only%201x%20per%200.2%20sec%2C%20or%20overflow%20of%20tmr.now%0A%20%20%20%20%20%20%20%20tLastcount1%3Dtmr.now()%0A%20%20%20%20%20%20%20%20if%20level%20%3D%3D%200%20then%0A%20%20%20%20%20%20%20%20%20%20%20%20valin1%20%3D%20valin1%20%2B1%0A%20%20%20%20%20%20%20%20%20%20%20%20%0A%20%20%20%20%20%20%20%20end%0A%20%20%20%20end%0Aend%0A%0Aif%20(tonumber(inputs.INPUTS.in1)%3D%3D1)%20then%0A%20%20%20%20gpio.mode(tonumber(tabInput%5B1%5D)%2Cgpio.INT)%0A%20%20%20%20gpio.trig(tonumber(tabInput%5B1%5D)%2C%20%22down%22%2Cin1Count)%0Aelse%0A%20%20%20%20gpio.mode(tonumber(tabInput%5B1%5D)%2Cgpio.INPUT)%0Aend » message= »COMPTAGE » highlight= » » provider= »manual »/]

La première fonction permet d’incrémenter le comptage pour chaque impulsion. Elle permet aussi de gérer les rebonds. (Bien que le compteur d’eau fonctionnant avec un système à un effet hall, les impulsions sont normalement stables). Cependant, pour régler une éventuelle instabilité (appelée rebonds) je prend en compte la première impulsion mais pas celle qui arrive dans les 20ms suivantes. (C’est utile si vous souhaitez faire des tests en court-circuitant l’entrée avec un fil)

Le code après la fonction permet de paramétrer l’entrée en fonction du fichier ini « inputs.ini »

Pour la partie serveur Web, j’ai utilisé un code déjà tout fait en LUA. vous pouvez le retrouver ici.

Il n’y a plus qu’à coder la page HTML en LUA. (vous pouvez suivre l’exemple du site)

[pastacode lang= »c » manual= »return%20function%20(connection%2C%20args)%0A%09%20connection%3Asend(%22HTTP%2F1.0%20200%20OK%5Cr%5CnContent-Type%3A%20text%2Fhtml%5Cr%5CnCache-Control%3A%20private%2C%20no-store%5Cr%5Cn%5Cr%5Cn%22)%0A%20%20%20connection%3Asend(‘%3C!DOCTYPE%20html%3E%3Chtml%20lang%3D%22en%22%3E%3Chead%3E%3Cmeta%20charset%3D%22utf-8%22%3E%3Ctitle%3ECOMPTEUR%20EAU%20WIFI%3C%2Ftitle%3E%3C%2Fhead%3E’)%0A%20%20%20connection%3Asend(‘%3Cbody%3E’)%0A%20%20%20local%20input1%0A%09local%20input2%0A%09local%20input3%0A%09local%20input4%0A%09if%20(tonumber(inputs.INPUTS.in1)%20%3D%3D1)%20then%0A%09%09input1%20%3D%20valin1%0A%09else%0A%09%09input1%20%3D%20gpio.read(tonumber(tabInput%5B1%5D))%0A%09end%0A%09if%20(tonumber(inputs.INPUTS.in2)%20%3D%3D1)%20then%0A%09%09input2%20%3D%20valin2%0A%09else%0A%09%09input2%20%3D%20gpio.read(tonumber(tabInput%5B2%5D))%0A%09end%0A%09if%20(tonumber(inputs.INPUTS.in3)%20%3D%3D1)%20then%0A%09%09input3%20%3D%20valin3%0A%09else%0A%09%09input3%20%3D%20gpio.read(tonumber(tabInput%5B3%5D))%0A%09end%0A%09if%20(tonumber(inputs.INPUTS.in4)%20%3D%3D1)%20then%0A%09%09input4%20%3D%20valin4%0A%09else%0A%09%09input4%20%3D%20gpio.read(tonumber(tabInput%5B4%5D))%0A%09end%0A%09connection%3Asend(%22%7B1%3A%22..input1..%22%2C2%3A%22..input2..%22%2C3%3A%22..input3..%22%2C4%3A%22..input4..%22%7D%22)%0A%20%20%20connection%3Asend(‘%3C%2Fbody%3E%3C%2Fhtml%3E’)%0A%20%20%20connection%3Aclose()%0A%09%0A%20end » message= »page WEB » highlight= » » provider= »manual »/]

C’est presque fini !!! Il ne vous reste plus qu’à uploader avec ESPlorer tout le code dans votre NodeMCU

Enfin ouvrez un navigateur pour tester et tapez l’URL suivante :

http:///getinput.lua

Si vous avez cette page, c’est gagné !

Vous pourrez retrouver l’ensemble du code sur mon github :

https://github.com/fairecasoimeme/Compteur_eau_wifi.

Conclusion

Enfin c’est terminé ! ce projet est assez simple en définitive mais prend pas mal de temps et vous devez maîtriser pas mal de concepts, mais c’est ça qui est bien parce que vous avez presque tout fait vous même !

Après, vous avez plusieurs possibilités pour installer tout ça mais moi j’ai choisi de placer l’électronique dans un boitier DIN dans un tableau électrique. C’était dans mon cas la manière la plus propre pour mettre en œuvre ce projet. A vous de trouver la meilleure méthode !

Enfin, mon ressenti par rapport au langage LUA. Je trouve que le langage est assez rudimentaire mais le moteur ultra performant. L’ESP8266 ne semble pas à l’agonie mais par contre, parfois, lorsque l’on utilise trop les ressources. Exemple : rafraichir violemment les pages web servies par le NodeMCU, il plante et Redémarre. Je pense qu’il y a peut-être une gestion du Watchdog à faire. Pareillement, sur les fichiers, vous ne pouvez pas dépasser une certaine taille sans que cela crache le système. On peut tout de même contourner en compressant les fichiers (extension LC) ou en multipliant ces derniers en faisant des inclusions.

Cependant, je maintiens que c’est pour moi un mini exploit ce système et que ça permet à beaucoup de monde d’obtenir de bon résultats sans avoir de grosses connaissances dans le domaine.

Par contre, oubliez cette méthode si vous pensez faire un produit industriel.

D’ailleurs, j’ai vu qu’il existait un SDK avec visual studio ou un autre IDE dans le genre et dès que le temps me le permet, j’approfondirai cette méthode. A suivre …

Bonus : une petite vidéo pour illustrer tout le projet :