Mes réfrigérateur et congélateur en mode connecté

Le capteur Dallas DS18b20 est à la fois précis et économique.
Il existe des tonnes de littérature sur le web sur ce capteur : je ne vais pas m’étendre ici.
Juste à savoir :

• ça a trois pattes : 0V, +5V (ou +3.3V dans notre cas), datas (que l’on va brancher sur une entrée digitale du micro-contrôleur)
• on peut brancher autant de capteur que l’on souhaite sur la même entrée
• il faut mettre une résistance de 4.7kOhm entre l’entrée et le +5V.
• le protocole de communication est 1-wire
• chaque capteur a une adresse unique

Les capteurs seront l’un dans le réfrigérateur, l’autre pour le congélateur. Je n’ai pas oser percer les appareils, ma solution pour “sortir” les fils est de passer par la porte entre le joint et le corps. Mais comme il faut que ça reste étanche, j’ai utilisé une nappe fine (récup. d’un vieux scanner HS en découpant des tranches de 3 pistes).
Le plus difficile à été de souder les pattes du ds18b20 à la nappe, puis la nappe aux fils du connecteur.
Puis de la gaine thermo autour de tout ça et nous avons de beaux thermomètres prêts à être branchés comme sur la photo.

Note : On alimente le capteur en 3.3V et non 5V car le module ESP8266 n’accepte que 3.3V sur ces entrées.

A votre guise, vous fabriquez le circuit sur une breadboard, sur un circuit bricolé comme moi, ou vous imprimez un circuit.

A noter que j’ai ajouté aussi (mais facultatif)

• une led (et sa résistance de 1kOhms) qui ne va pas servir à grand chose
• un buzzer
• un connecteur pour l’alimentation 5V. On peut aussi brancher sur le port usb (c’est d’ailleurs plus prudent car ça évite de brancher à la fois une alimentation et un PC).

Les entrées du micro-contrôleur sont :

• D1 : buzzer
• D3 : LED
• D4 : Thermomètres 1-wire
• D0 : utilisé pour déboguer : si 0V, le code ne s’execute pas.

Notre module ESP8622 va gérer ses capteurs et communiquer avec un serveur node-red (hebergé sur un raspberry pi) via MQTT (broker hébergé aussi sur le raspberry pi).
Le serveur node-red va
– enregistrer des données de températures sur une base de données (ici maria-db sur NAS synology)
– gérer les alertes

Je vous laisse installer un serveur node-red et le paramétrer. La documentation officielle est très bien faite : http://nodered.org/docs/creating-nodes/

La puce ESP8266 est un micro-contrôleur qui embarque une fonction WIFI qui a le gros avantage de ne pas coûter grand chose. Il existe plusieurs modules basés sur cette puce. La plus économique coûte moins de 4€, doit être alimentée en 3.3V (pas de régulateur) et tous les GPIO ne sont pas accéssibles (à moins de savoir souder directement sur la puce, ce que mes yeux et mes mains m’empêchent de faire : beaucoup trop petit!).
Je préfère travailler sur un module un peut plus pratique : le module nodemcu (6.11$ sur Ebay). Pour l’écart de prix, ça vaut vraiment la peine : un port usb, un régulateur de tension, l’accés à tous les GPIO. Par contre ce module est un peu plus gros : prévu pour du prototypage. Il existe aussi les modules WeMos qui sont très bien (mes nouveaux projets sont avec eux).

Ces modules peuvent se programmer en LUA avec l’envirronment de développement autour de nodemcu (voir http://www.nodemcu.com/) avec :

• Un driver windows https://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx
• Un firmware a personnaliser soit même : http://frightanic.com/nodemcu-custom-build/
• Un flasher : https://github.com/nodemcu/nodemcu-flasher
• un module de développement : http://esp8266.ru/esplorer/

Le problème principale étant la mémoire vive disponible, il faut bien choisir le firmware dont on a besoin avec uniquement les modules nécessaires pour faire tourner son programme. Dans notre cas, nous avons besoin de :

• file
• GPIO
• net
• node
• timer
• UART
• WIFI
• MQTT
• 1-wire (pour option mesure température avec capteur DS18x20)

Je vous laisse installer tous ça…

J’ai développé un tas de fonctionnalités autours de ces petits micro-contrôleurs (voir plus bas).
Tous les programmes communs sont à la racien du projet sur Github : https://github.com/FredThx/nodemcu_iot.git

Il n’y a qu’un seul fichier qui change d’un projet à l’autre : params.lua . Dans le cas présent, il faut prendre celui dans le répertoire ./cuisine .

C’est ce fichier que nous allons adapter à votre installation.

Pour dégoguer :

LOGGER = false

Si true : un fichier log.txt est créé et toutes les print y sont écrits.

Le hard :

LED_PIN = 3
BUZZER_PIN = 1
gpio.mode(LED_PIN, gpio.OUTPUT)
gpio.write(LED_PIN, gpio.LOW)

Pour les capteurs de température :

-- Capteur température DSx20
DS1820_PIN = 4 
sensors = { 
    [string.char(40,255,74,144,81,20,0,250)] = "frigo",
    [string.char(40,255,143,78,80,20,0,181)] = "congelateur",
    [string.char(40,255,50,226,80,20,0,173)] = "cuisine",
    [string.char(40,255,202,79,80,20,0,1)] = "test"
}

Là vous voyez les adresses de mes capteurs : aucune chance que vous ayez les mêmes. Pour l’instant laissez les : le programme affichera les adresses des capteurs détectés.

Pour les modules à charger, se limiter au strict minimum :

modules={
	"ds1820_reader"
	}

Pour d’autres projets, on peut ajouter les modules suivants :

Paramètres WIFI :

SSID = {"WIFI_THOME1",'WIFI_THOME2'}
PASSWORD = "xxxx"
HOST = "NODE-CUISINE"
wifi_time_retry = 10 -- minutes

(maintenant vous connaissez mon code WIFI!!!, vous n’avez plus qu’a trouver l’adresse!)
Pour le SSID, soit vous n’avez qu’un réseau, dans ce cas SSID = “MON_WIFI” est suffisant. Si comme moi, vous avez plusieurs points d’accés avec des SSID distinct, utiliser une table pour lister les SSID. Si tous les points d’accés ont le même mot de passe, PASSWORD = “xxxx” est suffisant, sinon PASSWORD = {“code1″,”code2”}.
Le microcontrôleur se connectera au premier réseau WIFI qui répond.

Paramètres MQTT :

mqtt_host = "192.168.10.155"
mqtt_port = 1883
mqtt_user = "aaaa"
mqtt_pass = "xxx"
mqtt_client_name = HOST
mqtt_base_topic = "T-HOME/CUISINE/"

Adapter a votre serveur MQTT (IP, PORT, user).
Adapter à votre arborescence de messages MQTT.

Messages MQTT sortants

mesure_period = 10*60 * 1000
mqtt_out_topics = {}

mesure_periode (ici 10 minutes) défini la période d’envoie des données de température.
Chaque donnée à envoyer est décrite par :

mqtt_out_topics[mqtt_base_topic.."REFRIGERATEUR/temperature"]={
                message = function()
                        t = readDSSensors("frigo")
                        return t
                    end,
                qos = 0, retain = 0, callback = nil}

Adaptez à vos topics MQTT (pour moi, ça donne “T-HOME/CUISINE/REFRIGERATEUR/temperature” pour la température du réfrigérateur).
Le nom “frigo” doit être celui de la table des capteurs DS18b20 (sensors).

Messages MQTT entrants

mqtt_in_topics = {}
mqtt_in_topics[mqtt_base_topic.."LED"]={
            ["ON"]=function()
                        gpio.write(LED_PIN, gpio.HIGH)
                    end,
            ["OFF"]=function()
                        gpio.write(LED_PIN, gpio.LOW)
                    end}
mqtt_in_topics[mqtt_base_topic.."BUZZER"]={
            ["ON"]=function()
                        gpio.write(BUZZER_PIN, gpio.HIGH)
                    end,
            ["OFF"]=function()
                        gpio.write(BUZZER_PIN, gpio.LOW)
                    end}

Ici, on décrit que si on envoie le message MQTT avec comme topic “/T-HOME/CUISINE/LED” et comme valeur “ON”, la led va s’allumer. Idem pour OFF et pour le buzzer.
Adaptez comme vous voulez.

A noter qu’à chaque message sortant, il va être créé automatiquement une action sur le message sortant “topic_” qui va envoyer le message sortant avec sa valeur mesurée si la valeur du message est “SENDIT”.
Exemple :
Nous avons un message sortant “T_HOME/CUISINE/REFRIGERATEUR/temperature” dont la valeur est la température du réfrigérateur.
Si on envoie le message MQTT “T_HOME/CUISINE/REFRIGERATEUR/temperature_” avec la valeur “SENDIT”, le micro-contrôleur va envoyer un message “T_HOME/CUISINE/REFRIGERATEUR/temperature” sans attendre les 10 minutes.

Avec ESPlorer,
– charger tous les fichiers du répertoire standard_projet dans le micro-contrôleur (même s’ils ne servent pas, autant tout charger, il y a de la place dans la mémoire flash).
– charger votre fichier standard_projet/cuisine/params.lua dans le micro-contrôleur.
– exécuter ‘compile.lua’ (les programmes chargés prendront un peu moins de place en mémoire).
– rebooter le module.

Sauf si l’entrée D0 est à 0V, le programme démarre (pratique pour stopper l’exécution du programme s’il plante). A noter que certains module (dont le nodecmu) a un bouton qui permet de passer D0 à la masse : si on appuie dessus quand le module boot : nos programmes ne sont pas exécutés.

Quand le programme s’exécute, on peut voir sur la sortie série tout le débogage :

NodeMCU firmware detected.
=node.heap()
41584
> ******************************
**   NODE-CUISINE              **
******************************

Load ds1820_reader
Waiting for Wifi connection
Waiting for Wifi connection
ESP8266 mode is: 1
The module MAC address is: 5e:cf:7f:01:8a:25
Config done, IP is 192.168.10.145
MQTT Connection...
T-HOME/CUISINE/temperature_ : subscribed
T-HOME/CUISINE/_LUA : subscribed
T-HOME/CUISINE/LED : subscribed
T-HOME/CUISINE/TEST/temperature_ : subscribed
T-HOME/CUISINE/CONGELATEUR/temperature_ : subscribed
T-HOME/CUISINE/REFRIGERATEUR/temperature_ : subscribed
T-HOME/CUISINE/BUZZER : subscribed
MQTT Connected.
Reception MQTT =>T-HOME/CUISINE/BUZZER:OFF

Soit vous attendez 10 minutes pour la prochaine lecture de la température, soit vous executer :

=readDSSensors()

La réponse est alors :

cuisine	24
40-255-202-79-80-20-0-1	22.125
table: 0x3fff28e8

Un nouveau capteur a été détecté : le “40-255-202-79-80-20-0-1”.
=> vous pouvez modifier le fichier params.lua en conséquence.
(et le charger sur le module + compiler).

sensors = { 
    [string.char(40,255,202,79,80,20,0,1)] = "Mon_frigo"
}

Il vous faut un serveur MQTT (en fait on appelle ça un broker).
Soit vous utiliser un broker en ligne (pour tester ça peut être une option).
Soit vous en installer un à la maison. Sur un raspberry pi par exemple.
Il en existe plusieurs. Pour ma part, j’utilise mosquitto.
Je vous conseil cet article pour bien comprendre (et surtout installer) : http://www.framboise314.fr/linternet-des-objets-iot-sur-raspberry-pi-avec-mqtt/

Node-red est un outil open source développé par IBM et installé par défaut sur les dernières distributions raspian. Il est très léger : le plus simple est de le faire tourner sur un raspberry pi. Sinon, ça tourne sur tout ce qui peut faire fonctionner node.js.

Vous vous débrouillez pour installer tout ça…

Avec Node-red, on gère des flux entre des “node” qui de repassent un objet msg.
C’est assez simple et bien documenté.
Il existe des nodes de base + des nodes communautaires (regroupés dans une Library). Si ce n’est pas suffisant, il est possible de créer ses propres nodes.
Le tout se code en javascript.

Pour notre cas présent, on va juste récupérer les messages mqtt, envoyer les valeurs à une base de donnée et traiter les alertes (buzzer et email).

mqtt et email sont des nodes installés par defaut, par contre pour l’accés à une base de donnée, il faut installer un connecteur. Pour ma part, j’ai installé node-red-node-mysql .

Pour partager entre nous des flow, c’est super simple :
– ouvrer le .json ci-dessous
– copier le texte
– dans node-red : menu/import/clipboard
– coller

Je vous laisse modifier, adapter, simplifier, améliorer tout ça.

Pour réaliser un petit dashboard rapidement :

http://flows.nodered.org/node/node-red-contrib-graphs

Installer le plugin (npm install node-red-contrib-graphs) et redémarrer node-red (pm2 restart node-red).

Importer le json ci-dessous.

Votre dashboard est prêt : http://ip_du_serveur_node:1880/dash/

Personnellement, je préfère tout gérer en local et réaliser mon propre cloud.
Mais vous pouvez tout aussi bien envoyer vos données chez amazon ou azure ou chez qui vous voulez.

Ci-dessus la courbe de température de mon congélateur (avec la dernière date de mon oublie de fermer la porte!!!).

Dans le même principe, j’ai créer ces objets connecté à base de module ESP8266.
Toutes les sources (et schémas) sont sur github : https://github.com/FredThx/nodemcu_iot

Avec des capteurs :

• 1-wire DS18x20
• DTHxx pour température et humidité
• Détecteur de mouvement IR
• BMP180 pour pression et température
• Luminosité

Avec des Sorties :

• Pilotage d’un FAN pour refroidir ma baie
• Envoie signal 433Mhz pour piloter prises electriques
• Pilotage relais

Avec des interface Homme-Machine :

• Display OLED ou LCD 1602 via i2c
• Boutons
• Grove gesture

Chaque module est accessible via telnet.
On peut y voir les print.
Et surtout y exécuter des commandes en LUA.

A noter que l’on peut aussi envoyer des commandes LUA au modules via MQTT par le topic :”T-HOME/CUISINE/_LUA”.

J’ai choisit comme principe de ne mettre dans les modules que le code lié à la gestion des capteurs et actionneurs.
MQTT sert de facteur (très fiable et très simple).
Toute intelligence est dans node-red.

Ça me parait la bonne solution. En tous les cas je trouve que la maintenance-amélioration est très facile à faire.
Et le tout est très fiable.