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

Ppr5hydv3sx36ymthgu8

Difficulté:

à base de ESP8266, de mqtt et de node-red


J’ai la fâcheuse habitude de mal refermer la porte du congélateur. Comme il s’agit d’un congélateur armoire, la punition est à chaque fois catastrophique : tout est décongelé!
Il y avait bien la solution de mettre un verrin sur la porte du congélateur, ou d’acheter un nouveau congélateur avec la fonction “intelligent”, voir même de faire attention à bien fermer la porte. Mais le plus simple m’a paru de simplement mesurer la température à l’intérieur du congélateur et de me prévenir s’il y a un problème.


J’ai testé plusieurs modes de fonctionnement ( arduino + 433 Mhz + scripts python sur raspberry pi + base de donnée) pour finir sur celle que je présente ici et qui fonctionne chez moi parfaitement depuis plusieurs mois (et qui m’a déjà éviter une décongélation!!!).


Et comme de réfrigérateur est à coté du congélateur, j’ai branché les deux ensemble.


Nous allons voir ici la mise en oeuvre de cette solution, mais j’ai créer chez moi une solution complète qui gère un tas d’objets connectés qui interagissent ensemble (voir à la fin).

Matériel

Budget:

12 €

J’ai utilisé:

  • un module basée sur le microcontrôleur ESP8622 programmable en LUA : (nodemcu) : 5€.
  • des capteurs de température numériques DS18x20: 1€ si vous achetez par 10
  • de la nappe électronique de récupération
  • un buzzer (par exemple chez Gotronic) : 1€80
  • des connecteurs ( mâle et femelle) : 2€
  • Une alimentation (récup portable)
  • un raspberri pi (mais qui ne fait pas que ça)
  • un NAS pour la BDD (mais on peut aussi envoyer les données sur le cloud ou sur le raspberry pi)

Vous aurez besoin de :


Etape 1 : Les capteurs de température

Naw8nvhdvwpbgfafdbzh

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.

Etape 2 : Le montage électronique

Vf3ksedmcbr1zizqk0st

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.

Etape 3 : Principes de fonctionnement

Dvorbzkhacxlo9maqnx3

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/

Etape 4 : Le module NodeMcu (avec de l’ESP8266 dedans)

Nmqgcixn6smi3si4qm9n

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 :

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…

Etape 5 : Du code LUA

Ktdxd63rrhjdnlowzqcl

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 :

433_switch Pour piloter des prises électriques en 433 Mhz
BMP_reader Pour lire la pression et la température d’un capteur BMP180
DTH_reader Pour lire un capteur Température-humidité DTH11 ou DTH22
i2c_display Pour piloter un écran oled en i2c
i2c_geste Pour lire le capteur grove geste (détection de gestes de la main)
i2c_lcd Pour piloter un écran type LCD1602
mcp3008 Pour lire les entrées analogiques d’un convertisseur MCP3008 (ou 3004)


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.

Etape 6 : Programmation du module

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.

Etape 7 : Retrouver les adresses des capteurs DS18b20

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"
}

Etape 8 : Mosquitto : un serveur MQTT

Wyy8bhe7lchgfnigqf2m

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/

Etape 9 : Node-red

V3jnjqbzfcn2bt2a2lcn

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…

Etape 10 : Flux Node-red

Hpxpgsbvkjsg17pymplj

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.

Etape 11 : Dashboard

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/

Etape 12 : Aller plus loin

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!!!).

Etape 13 : Mes autres objets connectés du même type

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

Etape 14 : Pour déboguer : telnet

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”.

Etape 15 : Conclusion

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.

Vous aimez ce tutoriel ?


Soyez le premier à poster un commentaire pour Mes réfrigérateur & congélateur en mode connecté


Recevez une fois par mois les meilleurs tutoriels Technologie dans votre boîte mail




Oh ça buzz

+ de 1 000 vues pour Mes réfrigérateur & congélateur en mode connecté



Gotronic

Voir l'espace DIY gotronic


S'inscrire:


  • Vues: 4084
  • J'aime: 11