Superviser l’humidité de votre plante connectée avec Node-RED

Il y a deux semaines nous avons vu les bases du fonctionnement de node red sur un raspberry pi3.

Le projet de cette semaine se fera en grande partie sur node-red. J’ai difficilement réussi à le dompter cependant, notamment parce qu’il nécessite des connaissances en java script.

Cette semaine je vais vous présenter comment réaliser un capteur qui fera des relevés de taux d’humidité sur votre plante favorite. Ce projet est le début d’un autre plus grand visant l’automatisation et le contrôle d’un jardin par exemple.

C’est aussi le sujet de mon projet tuteuré DUT cette année (un jardin connecté). C’est pourquoi j’y ai consacré une attention particulière qui a entrainé un retard d’une semaine.

En contrepartie l’article sera le plus précis possible sur la réalisation de ce projet. J’y énoncerai également les différents problèmes rencontrés dans le processus pour que vous ayez également un support sur lequel vous appuyer.

Le projet sera décliné en 4 parties:

  • Introduction
  • Programmation capteur humidité (ESP8366)
  • Mise en place de node-red sur raspberry
  • Réalisation du flow node-red
  • Rendu final

INTRODUCTION

La première question que je me suis posée c’est : comment récolter ces données ?

MOISUTRE SENSOR

J’ai très vite vu qu’il me fallait un moisture sensor. Un moisture sensor n’est rien de plus que deux branches de métal parallèle, l’une qui se gorge de charge + et l’autre de charge –. Il ne mesure pas le taux d’humidité a proprement parler, mais le taux d’électron qui passe de la branche + à la branche -, c’est-à-dire la résistivité du milieu. Plus le milieu est résistif plus la terre sera sèche et au contraire plus le milieu est conducteur plus la terre sera humide.

Mais avant de faire votre choix parmi la large gamme de produits qu’il existe, il faut prendre en compte un paramètre non négligeable dans l’équation. Si deux broches de métal se trouvent dans un milieu humide 24h/24h alors il faut s’attendre à ce qu’elle s’oxyde avec le temps. Qui dit oxydation, dis perte de fiabilité du capteur, dis à terme, capteur en panne.

J’ai donc choisi un capteur qui est recouvert d’une fine couche de protection visant à empêcher ce processus.

🔧 Acheter 🔧

ESP8266

Pour transférer les données, j’ai opté pour la technologue WIFI et donc la fameuse ESP8266. Là aussi il m’a fallu faire un choix de capteurs. Pour des raisons de praticité, j’ai éliminé d’ores et déjà des capteurs tels que l’ESP01 qui ne possède pas nativement de sortie analogique (primordiale pour faire fonctionne le moisture sensor) ainsi que la nodeMCU qui est pour moi trop grande et chère.

En effet même il est possible d’ajouter à l’ESP01 des sorties pour le faire fonctionner le moisture sensor mais c’est assez technique. Je n’ai pas envie de perdre du temps là-dessus et c’est pourquoi je préfère largement utiliser une wemos D1 mini. Plus petite que la nodeMCU, mais possédant également une entrée analogique, elle est pour moi le parfait intermédiaire entre taille et fonctionnalité.

🔧 Acheter 🔧

Node-RED

Node-RED sera le centre de contrôle. Il est simple, pratique et fonctionnel. Grâce à lui je pourrais afficher en temps réel la donnée qu’envoie la wemos d1 mini, mais également stocker celles-ci dans une base de données qui pourra les afficher sur une période de temps donnée.

De plus, étant donné que node-red se trouve sur un serveur en fonctionnement permanent il me sera assez simple dans le futur d’ajouter d’autres objets connectés.

Le transport des données

Le protocole de transport de donnée que je compte utiliser pour ce projet est MQTT. Dans l’article précédent j’ai utilisé pour HTTP avec node-red. Avec du recul c’était une erreur. En effet HTTP est plus destiné pour des pages web (pas très adapté aux objets connectés).

MQTT est utilisé par les industrielles pour leurs objets connectés. Il a l’avantage d’être simple à comprendre et à utiliser (voir article MQTT). Je pense donc qu’il sera idéal pour ce projet ainsi que pour les projets à venir.

Programmation capteur humidité (ESP8366)

Le circuit est très simple ! Voici le schéma de câblage :

Le capteur d’humidité ci-dessus n’est pas celui que j’ai utilisé

A NOTER

Dans cet article nous n’allons pas nous étaler sur la réalisation de l’objet. Nous verrons ça dans un futur article, ce n’est pour le moment qu’un prototypage.

Cette partie sera différente des autres articles. En effet les notions de programmation sont vues et revues à chaque article et j’estime qu’avec en plus le code source vous n’avez pas besoin des détails ligne par ligne.

Pour celui-ci je vais plus détailler, comment le concevoir, à savoir l’algorithme que j’ai pensé. Selon moi le plus important dans un programme informatique est de bien saisir comment le faire. Ensuite il suffit de s’aider de notre ami google pour trouver comment le réaliser.

Notre capteur d’humidité à 3 objectifs principale à réaliser :

  1. Récolter des données cohérentes
  2. Transmettre ces données à intervalle de temps régulier
  3. Dormir le reste du temps

Je récolte dans un premier les temps données brutes depuis l’entrée A0. Pour que ces valeurs soient lisibles par n’importe qui j’ai décidé de les envoyer en pourcentage. Il faut donc les transcrire…

Pour transcrire celle-ci j’ai fait une simple règle de 3. En effet, après avoir branché correctement le moisture sensor je suis allé faire un tour dans ma salle de bain pour m’humidifier la main. J’ai ensuite serré le capteur avec celle-ci et observé la valeur qu’il me donne quand je le serre. Cette valeur correspondra donc à un taux de 100% d’humidité !

J’ai ensuite relâché puis essuyé le moisture sensor. La valeur que j’ai lue sera celle qui correspond à un taux de 0% d’humidité !

Je vais ensuite les envoyé à l’aide du protocole MQTT au rapsberry !

Pour t’aider à comprendre le code, j’ai confectionné un algorigramme.

Une fois la partie client du projet terminé je vais m’attaquer à la plus conséquente, j’ai nommé… La partie serveur !

-> VOICI LE CODE <-

Mise en place de Node-RED sur Raspberry 

Installation SE DietPI

 

Dans mon premier article sur node-red j’utilisai un simple raspbian sur lequel j’avais installé node-red.

Cette semaine je vais un peu plus pousser l’expérience ! En effet j’ai tout d’abord installé un SE nommé DietPI. Celui-ci a la réputation d’allier rapidité et légèreté à toute épreuve. Dans l’optique de réaliser un véritable serveur réunissant moult objets connectés j’estime que dietPI est une alternative parfaite à raspbian.

En effet même si avec le stockage ainsi que la puissance actuelle des raspberry pourra très largement suffire à cette tâche je préfère être prévenant ! Il n’y a rien de plus chiant que de réinstaller un SE…

Je t’invite donc à télécharge DietPI puis de flasher micro SD avec le logiciel Etcher par exemple. Dietpi va se lancer et il faudra faire quelques réglages avant de pouvoir continuer sur celui-ci.

Une fois la carte microSD flasher tu n’auras plus qu’à mettre sous tension ta rasp équipée d’un clavier et d’un écran (pas besoin de souris cette fois puisqu’il n’y a pas d’interface graphique).

Dietpi se lance d’abord un programme de configuration. Dans celui-ci il est possible de déjà configurer de nombreuses choses.

Je vous conseille de changer la langue, la zone géographique ainsi que le timestamp. Ça nous sera utile pour la suite. C’est également plus facile d’utiliser un clavier azerty en tant que français 😊.

Étant donné que le Raspberry jouera le rôle de serveur, il faut absolument que celui-ci soit configuré en adresse IP statique. Pour cela rendez-vous dans le menu Network Options adapter. Il ne vous restera plus qu’à valider les configurations que nous aurons apportées puis redémarrer la carte.

Au redémarrage de l’appareil, nous pouvons bien voir que l’adresse IP a été modifiée.

Voilà ! Si c’est le cas, tu peux retirer clavier, souris et écran puis passer par le SSH avec putty sur windows.

 

Le package IoT

 

Je suis tombé par hasard en me baladant sur divers sites un script de Peter Scargill nous venant tout droit de bitbucket. Celui-ci est une sorte de packaging de programmes et de plugins dédié à l’IoT. Il contient notamment Node-red (avec pleins d’addons) mosquitto (en tant que broker MQTT), etc… J’en reparle plus tard.

Parmi tous les programmes qu’il nous propose, 4 sont particulièrement intéressants pour nous ! Node-RED, Mosquitto qui va servir à communiquer en MQTT, SQlite une base de données idéale pour stoker les valeurs qu’on va recevoir et PHPLiteAdmin pour gérer la BD SQlite.

Ceci étant dit je n’ai pas perdu de temps et je l’ai installé. Pour ce faire, j’utilise la commande suivante dans un premier temps qui va permettre d’écrire toutes ces lignes dans un fichier que tu pourras lancer comme un programme classique.

curl -o script.sh https://bitbucket.org/api/2.0/snippets/scargill/ekon6o/master/files/script.sh

Il faudra que tu fasses aussi attention avec quel utilisateur tu lances de programme. En effet il faudra être en utilisateur pi pour que le programme fonctionne.

ATTENTION

L’installation prend entre 2 et 3 heures ! Je te conseille vivement de le faire depuis un client SSH tel que Putty (histoire de faire autre chose entre temps 😉).

Initialisation

 

Quand l’installation sera terminée n’hésiter par à faire un petit : apt update histoire de mettre à jours tout ça et tu sera bon pour redémarrer la rasp.

Quand celle-ci aura redémarré je te conseille vivement d’ajouter aux programmes à lancer automatiquement au démarrage des programmes tels que node-red et mosquitto (/etc/Dietpi/dietpi/postboot) !

dans le fichier :

Si toute à bien fonctionner et une fois node-red lancée, tu devrais avoir un serveur web à l’adresse ip de ta rasp. Celui-ci est l’interface de navigation regroupant toutes les fonctionnalités que ce petit programme aura ajoutée à notre raspberry. Tu verras notamment la section Node-red et SQLite administrator qui va être très rapidement utile !

Je ne sais pas si je suis le seul à avoir eu ce problème, mais j’ai dû changer le port d’écoute de mosquitto de 1883 à autre chose avec la commande : mosquitto -p n°port je te conseille de la faire aussi pour qu’il fonctionne correctement par la suite.

On peut désormais passer à la partie réalisation du flow.

Réalisation du flow Node-RED

Base de données SQlite

Dans un premier temps nous allons configurer node-red pour récupérer les données envoyées depuis l’ESP.

Avant tout chose j’ai créée une base de données sur PHPliteadmin. Pour se rendre sur l’interface il faudra se rendre au lien : @IP/phpliteadmin ou par le menu depuis le portail de votre rasp.

Chaque donnée envoyée à la base SQlite sera caractérisée par son id (unique) son ‘emplacement’ c’est-à-dire l’emplacement du capteur, le ‘sensor’ si on souhaite en ajouter plusieurs, sa value (transmise par l’ESP) ainsi que son epoch et son timestamp qui seront l’indicateur temps (j’en reparle plus tard).

A NOTER

Le timestamp est une date lisible par un humain contrairement à epoch qui sera le temps UNIX non lisible. Il sert surtout présent pour la bonne lecture de la BdD.

Réception MQTT 

 

Pour récupérer les données venant de l’ESP il va falloir utiliser le nœud MQTT. Il faut vérifier deux prérequis pour que les données soient correctement envoyées au serveur node-RED.

La première c’est de bien configurer son broker MQTT (mosquitto) en précisant l’adresse IP et le port d’écoute. Ensuite il suffit de préciser le topic sur lequel l’ESP publie.

Pour tester si tout cela fonctionne correctement, tu peux rédiger un court programme de test simulant la transmission de donnée depuis l’ESP.  Si tout fonctionne bien, en connectant un nœud de debug au nœud MQTT on devrait recevoir des messages !

Passons à l’étape suivante. Il faut maintenant mettre en forme les données reçues par l’ESP pour confectionner une requête SQL qui injectera celle-ci dans la base de données.

 

Requête SQL INJECT

 

Comme je l’ai dit ci-dessus la seule valeur qui est transmise par l’ESP est le taux d’humidité. Mon objectif principal est de réaliser un graphique du taux d’humidité en fonction du temps, il faut pour cela qu’on injecte dans la BdD la date l’heure, la minute et la seconde à laquelle la donnée a été reçue.

C’est dans le nœud fonction qu’on va pouvoir traiter ces problématiques. Dans celui-ci j’ai juste défini l’Heure UNIX. C’est-à-dire le nombre de secondes depuis le 1er janvier 1970 (un moyen universel de récupérer les valeurs de temps dans les programmes informatique).

J’ai ensuite créé un nouveau message qui transportera le topic de la requête ayant des paramètres définis à la main tels que la ‘place’ ou le ‘sensor’. Les deux autres seront la variable de temps (définis au-dessus) ainsi que le payload du message qui contient la valeur d’humidité.

Si la requête est correctement définie, tu pourras remarquer aux prochains envois de donnée qu’il y a bien une mise à jour de la BdD.

Un baromètre en temps réel

 

Avant de passer à la partie de récupération et mise en forme des données de la BdD j’ai décidé de réaliser un petit baromètre qui affichera la dernière valeur transmise depuis l’ESP.

Il n’y a rien de plus simple. En effet, le fait de connecter simplement le point de collecte MQTT des données à une gauge suffira. Après c’est à vous de configurer la gauge pour la rendre agréable à l’œil. Celle-ci va simplement récupérer le payload du message de l’ESP pour le l’afficher sur une échelle que vous pouvez également définir.

De cette manière en plus d’un graphique répertoriant les données récoltées au cours du temps. J’aurais une petite gauge qui affichera la valeur courante ! Nous sommes désormais fin prêts à passer à la dernière partie de ce flow.

Sélectionner l’échelle de temps

 

L’un des prérequis pour obtenir un graphe c’est d’avoir une échelle de temps définis. Dans mon cas il sera possible de voir dans un premier temps les valeurs transmises dans la journée, le jour d’avant ou dans la semaine.

Pour réaliser cette commande, il faut adapter une requête SQL à chaque directive. La requête SQL sélectionnera les données de la BdD sur une fourchette de temps allant de n a n-1 jour, n-2 jours et n-7jours.

Pour ce faire, j’ai réalisé 3 boutons, chacun inscrit à un topic différent. Je les ai ensuite tous reliés à une fonction qui analysera les topic reçus. Il les adaptera ensuite pour envoyer la bonne requête SQL à la BdD.

En mettant un nœud de debug en sortie de BdD. Je remarque que le message transmis par la BdD est un tableau contenant toutes les données demandées. Tous c’est bien passé! Le but est maintenant de les mettre en forme pour ensuite les afficher dans un graphique.

Créer un graphique

 

Pour créer un graphique, j’utilise le nœud chart. Il est primordial de respecter un format de donnée précisé si l’on veut qu’elle soit affichée ! Celui-ci n’est bien évidemment pas tout à fait celui que nous retourne la BdD. C’est notre boulot de les mettre en forme avec l’aide d’une petite fonction. Voici à quoi elle devra ressembler:

En effet le payload du message devra contenir le tableau séries, data et labels. La série, c’est le message qui sera indiqué quand on survolera la courbe pour avoir des informations complémentaires sur les données affichées.

En effet le payload du message devra contenir le tableau séries, data et labels. La série, c’est le message qui sera indiqué quand on survolera la courbe pour avoir des informations complémentaires sur les données affichées.

Les donnée seront transmises sous forme de tableau. Pour remplir celui-ci. J’ai push dans un tableau data le la valeur timestamp associée a la clé x et la valeur value associé au y. Enfin, il ne reste plus qu’a associé au message.payload les 3 tableaux série, label, data.

format de données en sortie de la BdD

format de données en entrée de chart

Si tout se passe bien il ne reste plus qu’à injecter le tout dans un chart. En ce qui concerne le chart, presque rien à configuré, juste quelques fonctions graphiques.

Une fois le tout relier et configuré. Il ne te reste plus qu’à aller voir du côté de l’interface visuelle pour savoir si le tout fonctionne.

Voici à quoi ressemble le Flow final:

–> CODE <–

Rendu final

Pour pouvoir tester le bon fonctionnement du graphique il faut ajouter dans la table de fausses informations (de préférence sur une semaine) pour simuler la prise régulière de donnée.

J’ai utilisé le site generatedata pour générer des data bidon comme le montre la screen ci-dessous :

Ce site est très pratique puisqu’il permet de générer des données factices. Le seul problème sera qu’il ne synchronise pas le timestamp et l’epoch. J’ai donc utilisé un site qui convertit le timestamp en date du jour pour ensuite l’ajouter manuellement à la requête.

Une fois la BdD remplie on peut maintenant utiliser l’interface graphique pour vérifier que celui-ci fonctionne bien. Si tous fonctionnent correctement, il ne te reste plus qu’à brancher le prototype puis le mettre dans un pot de plante.

Quand vous avez validé le bon fonctionnement de l’ensemble vous pouvez l’appliqué à un cas réel. Je l’ai laissé pendant quelques temps faire son affaire et j’ai obtenu des résultats assez concluants comme vous pouvez le voir ci-dessous. Je posterai surement sur mon twitter des résultats plus récents de temps, venez! (@julfiofficial):

La screen ci-dessus n’a pas été prise pendant mon test préalable avec la fake BdD mais en condition réel, d’où le taux constant.

Cet article est à présent terminé! C’est celui qui m’a prit le plus de temps à ce jour et j’en suis plutôt fière! Attendez vous à une partie 2 ou j’améliore ce prototype (en ajoutant d’autres capteurs peut-être). En attendant celui-ci est parfaitement fonctionnel!

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

+

Du contenu bonus offert à chaque nouvel article!