Un radiateur connecté et supervisable (Node-RED, BME280, ESP8266)

Voici maintenant quelques semaines que j’ai acheté un chauffage électrique d’appoint pour ma chambre. En effet, j’y passe une grande partie de mon temps à travailler et rester immobile dans celle-ci me donnait, à terme, froid.

C’est le tout premier prix de chauffage qu’il existe. Je l’ai reçu avec une télécommande infrarouge pour pouvoir le contrôler à distance. C’est à ce moment précis que m’est venue une idée.

Pourquoi pas transformer un chauffage bas de gamme en véritable chauffage connecté ?

Plus qu’un besoin primaire, c’était un défi que je me devais de relever. Alors oui, j’aurais très bien pu faire un simple système arduino avec une sonde de température pour l’automatiser. Mais ce n’est pas drôle !

Moi je veux avoir une véritable interaction avec l’objet. Je veux voir des graphiques, des informations sur les différents états, pouvoir tout contrôler et avoir la main sur tous ces objets. Voilà le véritable défi !

Le contrôle du chauffage ne se fera pas le biais d’une liaison infrarouge qui est déjà installé de base (utilisation de la télécommande).

Mon module WIFI communiquera donc avec grâce à cette technologie. Elle remplacera ainsi la télécommande infrarouge qui se fait un peu vieille de nos jours.

Cette première partie sera axée sur la réalisation du système de gestion de température (c’est lui le vrai défi). En effet, la température sera le terreau fertile dans lequel la plante qui sera le chauffage pourra évoluer dans le bon sens (cette métaphore est terriblement nul…).

Dans celle-ci, nous ne verrons pas comment communiquer avec le chauffage ! En effet, je n’ai pas encore reçu l’émetteur et le récepteur infrarouge donc difficile de la réaliser. J’ai donc remplacé toutes les actions par des LED qui feront office d’alerte.

CAHIER DES CHARGES

Avant chaque projet j’ai dû effectuer un choix de capteur. Je choisis toujours ceux-ci sur des critères bien précis que je n’évoque généralement pas. Cette fois-ci je vais le faire 😉

Capteurs d’humidité : BME280

J’ai choisi ce capteur et pas le DHT. Même ci, ces deux compères sont très similaire mon choix c’est porté sur le BME pour plusieurs raisons :

BME

Avantages

+ précis
+ relever nombreux (humidité, température, pression)

Désavantage

Solidité

chère

DHT

Avantages

+ solide
+ moins chère

Désavantage

Précision

Le BME comme vous pouvez le voir dans le tableau ci-dessus est selon moi un meilleur choix pour l’intérieur. Malgré son prix plus élevé que le DHT les mesure qu’il apporte en plus d’être plus nombreuses est plus précis. Avec le relevé de pression et d’humidité, on peut imaginer de nouveaux systèmes à exploiter plus tard qui sait.

Microcontrôleur : Wemos d1 mini

La carte Incontournable. Elle est simple d’utilisation, pas chère. Ce projet n’aura de grande limite de consommation puisqu’il ne sera pas sur batterie, ni de place. Pas besoin dans le cas présent d’utiliser un ESP01 ou un ESP12.

Des LED.

J’utiliserai comme dans le projet de plante connecté des LED d’indications non RGB. C’est des LED que je possède depuis longtemps (pas d’achat supplémentaire) et honnêtement je n’ai pas besoin d’ajouter des LED indicatives RGB (compliqué et + chère).

Émetteur/Recepteur infrarouge

Pour cette partie aussi je n’ai pas pris le moins puisque je me suis permis d’acheter pour la somme astronomique de 1,12 € un kit directement monté sur PCB. Pourquoi ?

Pour des raisons de simplicité encore une fois. Je sais que ces cartes sont faites pour fonctionner avec arduino donc je n’aurais pas besoin de me poser trop de questions, c’est limite du plug and play 😉.

Comme je l’ai dit plus haut dans cette première partie, nous allons traiter seulement la partie BME (j’ai pas encore reçu les émetteurs récepteurs infra).

Le branchement du BME

Premier problème que j’ai pu rencontrer a été assez compliqué à résoudre. C’est le branchement du BME. En effet celui que j’ai acheté ne dispose pas de documentation particulière et je n’ai jamais utilisé le bus de connexion I2C auparavant.

Je ne vais pas entrer dans le détail du bus I2C aujourd’hui, mais je vais quand même écrire quelques lignes expliquant rapidement de quoi il s’agit. I2C est un standard de communication réaliser pour simplifier les connexions entre des objets et le microcontrôleur.

Le bus I2C est constitué de 2 connexions, SDA (ligne de donnée bidirectionnelle) SCL (ligne de synchronisation bidirectionnelle). Ce couple de connexion est assisté du bon vieux Vcc et Gnd. Le microcontrôleur dispose généralement de plusieurs couples pour connecter un bus I2C (SDA, SCL).

Cependant, ces connexions ne sont pas tout le temps affichées et clairement définies sur la carte. Vous pouvez aller voir dans le datasheet de celle-ci pour pouvoir les trouver, mais si, comme moi vous commandé sur aliexpress, bye bye les datasheets. Soit vous faites confiance aux spécificités de la carte officielle ou alors il faudra les déterminer autrement.

Utiliser la liaison I2C

 

Pour ma part, j’ai utilisé un code arduino nommé I2Cscan.ino qui va scanner vos ports I2C. Ce programme va tous les afficher et préciser la broche GPIO ainsi que s’il y a un appareil connecté. De cette manière, vous pourrez à la fois voir qu’elles sont les différents ports SDA, SCL et par la suite vérifié que le BME est correctement branché.

J’ai pour ma part utilisé les broches GPIO2 et GPIO12. Le second scanI2C nous indique cette fois l’adresse à laquelle la connexion est établie.

Cette adresse est très importante, en effet le premier test à faire pour tester le bon fonctionnement du branchement et du capteur sera celui du BME.

Les librairies qu’il faudra ajouter pour utiliser ce capteur sont <Adafruit_Sensor.h> et <Adafruit_BME280.h>. Adafruit fournis aussi un code exemple bien fait que nous pouvons utiliser pour tester le bon fonctionnement du capteur.

La librairie Wire permet quant à elle de gérer les bus de connexion. Le code d’adafruit n’inclut pas de wire.begin(). Si vous ne le mettez pas, vous risquez d’avoir un message d’erreur puisqu’il est possible qu’il n’arrive pas à trouver le capteur.

Pour y remédier, je te conseille donc de le rajouter avec les GPIO correspondant entre les parenthèses (2, 12) pour ma part. Mais il ne fait pas non plus oublier d’ajouter l’adresse de la connexion I2C au moment d’annoncer le bme.begin() entre parenthèses.

Envoie/ traitement des données

 

Arduino

 

Dans cette partie, nous allons réaliser un travail similaire que pour ma plante connectée. Je ne vais pas détailler cette partie puisque je l’ai déjà fait dans cet article.

Voici un petit algorigramme pour comprendre le principe de fonctionnement :

L’une des particularités dans ce code sera l’utilisation de la fonction millis() à la place de delay pour attendre. En effet, l’ESP devra gérer plusieurs tâches en même temps. Écouter l’arrivée de requête, transmettre des données, vérifier certaines conditions, ect…

Le delay à un gros inconvénient puisque celui-ci stoppe complètement le programme pour attendre. La fonction millis() affiche depuis combien de temps le programme est lancé. Grâce à celle-ci on pourra savoir si cela fait 15 min qu’il soit lancé et dans ce cas envoyé une donnée. Tout ça sans pour autant stopper le fonctionnement du programme.

Pour réaliser ça, il faut définir une variable previous = 0. Cette variable sera incrémentée de millis() c’est-à-dire du temps écoulé depuis le lancement du programme à chaque itération de la fonction ManageBME() (càd toutes les 15 minutes).

  • De cette manière la première itération : previous = 0, current=15minutes
  • Seconde itération : previous = 15min, current = 30min

Ect…

Le reste du programme est assez basique, on publie simplement la mesure par le biais de MQTT au topic (/BME/hum, /BME/temp).

Node-RED

 

Le principe est le suivant :

  • Récupère la donnée envoyée puis on l’affiche immédiatement
  • Insère la donnée dans une BdD SQLite
  • Affiche les données présentes dans la BdD selon le choix de l’utilisateur.

Pour réaliser ce flow il faudra bien évidemment créer une base de données au préalable. Si vous vous demandez comment installer toutes ces fonctions sur raspberry alors je ne serais trop vous conseiller l’article que j’ai réalisé ici.

Une fois la BdD, quelques fonctions pour mettre en forme les données grâce à des requêtes SQL basiques. Enfin, il suffira de les connecter aux nœuds de la palette ‘dashboard’ pour permettre de les afficher.

Voici le genre de résultat vers lequel vous devriez vous rapprocher :

Vous n’avez plus qu’à attendre l’arrivée des premières données… La capture du vous voyez ci-dessus représente plusieurs semaines de mesure sans interruption.

Ce projet commence déjà à ressembler à quelque chose. J’aurais pu m’arrêter ici, mais j’ai voulu aller beaucoup plus loin. C’est bien joli, mais il ressemble pour le moment bien trop à l’article sur vicky.

La prochaine étape va être de rendre les mises à jour du programme faisable à distance.

Mise à jour du programme à distance

Grâce à cette fonctionnalité, quand le projet sera terminé je n’aurais pas besoin de cas de mise à jour logiciel de retirer le dispositif pour faire à mise à jour en physique. L’objectif est de pouvoir commander les mises à jour à distance depuis l’interface du BME.

Nous utiliserons dans ce cas la fonction mise à jour OTA de l’ESP.

C’est quoi la mise à jour OTA ?

La mise à jour OTA permet de mettre le code d’une carte ESP à jour sans passer par le port physique micro USB. Cette fonction peut être utilisée si vous avez des objets connectés sur lesquelles il est difficile d’avoir accès.

La mise à jour OTA fait intervenir de nouveaux ports de programmation. Pour le faire fonctionner, il faut cependant installer python. Je laisse ici un lien vers un article qui explique comment mettre en œuvre cette fonctionnalité.

Mise à jour OTA Arduino

Pour réussir à implémenter la mise à jour OTA il n’y a pas de secrets. Nous nous aiderons du programme exemple pour le réaliser.

Le programme exemple est fait pour pouvoir faire cette mise à jour en continu. Celui-ci utilise toutes les ressources de l’ESP afin de surveiller si des données sont envoyées. Cette méthode laisse donc impossible l’utilisation d’autres fonction (LED, capteurs ect…).

Notre but est de permettre à l’ESP de rentrer dans ce mode de fonctionnement sur commande. Pour cela, nous devrons être abonnée à un feed qui permet par l’action d’un bouton de rentrer en mode programmation à distance.

La fonction callback va surveiller l’arrivée de message sur le feed /BME/prog. Si un tel évènement se produit alors l’ESP passe en mode OTA par le biais d’une fonction nommée OTAprog().

Voici l’algorigramme :

Vous remarquerez surement que dans le code disponible sur github une LED traine dans la fonction. Celle-ci n’est pas obligatoire, je l’utilise pour avoir une indication visuelle du bon fonctionnement, et aussi parce que c’est cool !

 

Mise à jour OTA Node-RED

 

L’ESP est abonné au topic /BME/prog. Il nous faut donc un point d’entrée qui permet de lancer la fonction OTAprog() sur l’ESP.

Pour cela j’utiliserai un simple bouton. Celui-ci enverra le payload programming… directement dans un afficheur de texte qui informera l’utilisateur que l’ESP passe en mode programmation.

Ensuite, après 15 secondes d’attente, une fonction enverra de nouveau un payload qui indique que l’ESP est de retour en mode classique.

Au départ, j’ai voulu réaliser un vrai système permettant d’envoyer une fois le nouveau code upload, un accusé de réception. J’ai abandonné après plusieurs tentatives infructueuses, les raisons de cet échec sont encore inconnues.

Voici à quoi ressemble l’interface ! Nous avons un bouton qui permet d’activer le mode programmation. L’interface est aussi équipée d’un afficheur de texte qui indiquera si nous sommes en mode programmation ou pas.

Si tout s’est bien passé, nous pouvons désormais passer à la partie suivante. Dans celle-ci, nous allons voir comment programme le mode automatique.

Mode automatique

Mode automatique arduino

 

Le mode automatique va permettre d’activer automatique le chauffage si la température est en dessous un certain seuil. La température que l’on souhaite atteindre sera réglable quant à elle.

Étant donné que je n’ai pas encore l’émetteur infrarouge, j’utiliserai simplement une LED rouge pour m’indiquer s’il faut que j’allume ou non le chauffage. Dans le futur ce sera automatique bien évidemment !

Le principe est le même que pour la mise à jour OTA. La boucle loop() scan en permanence les différentes fonctions que vous voyez ci-contre.

Parmi elles, le callback qui surveille en permanence l’arrivée d’éventuel message. C’est dans le callback que se passera la majorité de cette partie.

En effet, l’interface utilisateur enverra des données que l’ESP traitera dans la fonction callback() puis utilisera/allumera ou non le chauffage.

Voici l’algorigramme du code arduino :

Le bloc d’envois d’ACK est fait pour assurer que la température réglée sur l’ESP a bien été changée. Nous réserverons sur node-RED un endroit où nous afficherons la valeur de tempMin reçus de l’ESP directement.

Je n’ai pas spécialement précisé pour cette partie, mais le principe reste le même en ce qui concerne l’attente avec la fonction millis(). L’interface utilisateur sera constituée d’un simple interrupteur qui activera ou non le mode automatique et un moyen de régler la température désirée.

Passons sans perdre de temps à la partie node RED.

 

Mode automatique Node-RED

Dans un premier temps, j’ai réalisé un simple switch on/off connecté directement à un nœud MQTT. Ce switch enverra dans le payload du message un ‘on’ pour activer le mode automatique et un ‘off’ pour le désactiver.

Pour régler la température j’ai utilisé un nœud slider qui, comme pour le switch, enverra une valeur numérique au topic adéquat. Ce slider est configuré pour fonctionner sur une plage entre 15 et 25 degrés !

Enfin, n’oublions pas la case qui affiche la valeur de la variable tempMin pour certifier que celle-ci a bien été changée. Pour cela, nœud qui reçois des données MQTT sera directement connecté à celui qui les affiches.

Cette partie est relativement simple puisque dans ce cas, node-RED ne traite rien et s’utilise comme un client.

La dernière partie du code est optionnel et super simple à réaliser si vous êtes arrivé jusqu’ici. Je vais en parler rapidement dans la partie ci-dessous, mais sans plus.

Conclusion code

Pour conclure, notre système est pour le moment en mesure de remonter et afficher des températures toute les 15 minutes. Ces températures seront mises en forment sous forme de graphique, mais également en instantanée.

Il y a aussi la possibilité d’interagir avec la carte pour réaliser diverses tâches. Nous aurons trois modes d’utilisation pour cet objet.

  1. Le premier sera le mode programmation. Celui-ci met en veille le code pendant 15 secondes pour pouvoir téléverser un nouveau code. Cette fonctionnalité va permettre de mettre à jour le programme sans pour autant s’y connecter physiquement.
  2. La seconde sera le mode automatique. Notre objet pourra réguler la température de la pièce automatique selon nos envies. En mode automatique, nous aurons juste à renseigner une température à atteindre et l’objet s’adaptera pour réaliser ce souhait sans aucun problème.
  3. Le dernier mode de fonctionnement est aussi celui par défaut. C’est le mode manuel. Dans celui-ci, c’est nous qui décidons depuis l’interface utilisateur si l’on active ou non le chauffage. Je ne l’ai pas détaillé dans cet article, car il fonctionne en envoyant une simple requête MQTT pour activer ou non le chauffage (rien de compliqué).

A NOTER

Dans cette première partie, je n’ai pas inclus le système capable de communiquer avec le chauffage. C’est une LED rouge qui remplacera cette fonction en s’allumant pour annoncer qu’il faut allumer le chauffage et en s’éteignant dans le cas contraire.

Le circuit dispose aussi d’une LED orange qui sera une indication des actions menées par l’utilisateur (ex : clignote quand on passe en mode automatique).

-> CODE ARDUINO/NODE-RED <-

Le câblage 

Dans ce premier article pas d’objet final. Le câblage restera donc sur breadboard. En effet, mis à part le problème pour câbler le BME rien de compliqué. Il faut une carte wemos d1 mini, un BME, et deux LED (optionnel).

Voici un petit schéma sur fritzing ;

Voici le rendu final sur plaque d’essai :

Une fois que tout est mis en place, vous pouvez tester le bon fonctionnement du programme comme le montre la petite vidéo ci-dessous :

Dans le prochain article sur le sujet, nous ajouterons simplement l’émetteur IR puis nous mettrons en forme le projet pour qu’il ressemble à un véritable objet connecté.

Reçois 1 un petit guide de réalisation DIY par semaine!

+

Du contenu bonus offert à chaque nouvel article!