Prévention des moisissures avec l'AZ-Envy - Partie 2

L'article de blog suivant nous a été envoyé par l'auteur invité Niklas Heinzel. Amusez-vous à le lire et à vous l'approprier :

La deuxième partie de cette série de blogs porte sur l'utilisation du panneau de développement environnemental AZ-Envy pour la prévention précoce des moisissures dans les espaces de vie. Après avoir examiné dans la première partie les facteurs liés au bâtiment dans lesquels la formation de moisissures est plus propice, nous allons maintenant nous pencher sur les aspects techniques du problème, ou plutôt sur la manière de le mettre en œuvre avec la carte de développement AZ-Envy.

Dans la première partie, nous avons repris les bases suivantes, qui doivent maintenant être prises en compte dans la mise en œuvre technique :

" Lors du conflit technique, il faut essayer de mesurer la température de l'air ambiant, l'humidité relative (<65%) et la température du point de rosée (< température de l'air ambiant). Ces valeurs doivent être évaluées et stockées automatiquement.

Outre le câblage correct de tous les composants matériels, le projet nécessite également un algorithme adapté qui vérifie les trois valeurs mentionnées via les capteurs. Pour écrire l'algorithme approprié, j'ai utilisé le logiciel libre Arduino IDE, avec l'adaptation pour le microcontrôleur ESP12-F de la famille ESP8266.

L'avantage de cet environnement de développement est l'intégration simple de bibliothèques, qui contribuent à simplifier les commandes et l'aspect pratique. Ces bibliothèques sont disponibles pour une grande variété de capteurs et autres composants. Mais ils offrent également un grand nombre d'exemples de programmation pour apprendre le langage de programmation C++ ou C. J'ai donc délibérément évité d'utiliser d'autres environnements de développement que j'utilise normalement moi-même, afin d'éviter des difficultés inutiles lors du téléchargement ou dues à la syntaxe.

Comme c'est le cas avec presque tous les langages de programmation, les bibliothèques sont intégrées en premier. Dans mon cas, il s'agit de bibliothèques qui facilitent la lecture des valeurs des capteurs du SHT30 et de bibliothèques qui vous permettent de construire votre propre site web avec le microcontrôleur ESP12-F.

Après l'initialisation de tous les capteurs, une tentative de connexion au réseau local via WLAN est effectuée avec les données de connexion enregistrées dans la mémoire interne. Si aucune donnée de connexion n'est disponible, par exemple lorsque l'utilisateur démarre le système pour la première fois, un site web est créé avec des informations sur l'appareil et une page de connexion. Vous y saisissez le nom de votre WLAN (SSID) et votre mot de passe WLAN. Ces données sont enregistrées dans la mémoire interne, l'EEPROM, et sont conservées même après la coupure de l'alimentation de l'appareil. Une EEPROM est une mémoire dite " Electrically Erasable Programmable Read-only Memory ", c'est-à-dire une mémoire programmable effaçable électriquement qui peut être programmée ou effacée par des différences de tension. La fonction de stockage permanent et la possibilité de modifier la mémoire sont idéales pour assurer la sécurité des informations d'identification.

Une fois que l'utilisateur a saisi les données, celles-ci sont stockées de manière permanente et un nouveau processus de connexion n'est pas nécessaire après un court redémarrage. Le microcontrôleur se connecte ensuite, via le réseau domestique, à la base de données Firebase de Google, une solution gratuite pour le stockage de petits ensembles de données. Il suffit de créer un compte, et les données peuvent lui être envoyées via l'API qui lui est liée. Une API est une interface de programmation qui prend les données des utilisateurs ou des dispositifs et les transmet aux fins d'une application spécifique, selon une syntaxe prédéfinie. La clé API unique utilisée pour l'authentification est également stockée dans l'EEPROM et est liée au compte.  Après avoir établi la connexion avec la base de données Firebase, les capteurs SHT30 et MQ-2 sont lus. Ces données sont ensuite arrondies à deux décimales et téléchargées dans la base de données. Ce stockage central dans une base de données permet de retrouver les données à tout moment, même en dehors du réseau domestique, en vacances ou via le réseau de téléphonie mobile.

Afin de rendre la récupération et l'évaluation des données conviviales et faciles pour l'utilisateur, j'ai programmé une application Android à cette fin avec l'environnement de développement Android Studio.

Étant donné que l'application ne dispose pas d'une interface utilisateur permettant de modifier la clé API, etc., il s'agit uniquement de donner une idée pour le développement d'une propre application.

Cela permet le téléchargement automatique des données actuelles du système d'avertissement de moisissures avec un délai de quelques secondes, ainsi que l'évaluation complète des données. L'humidité de l'air (à gauche), la qualité de l'air intérieur (à droite), mais aussi le risque général de moisissure (en haut) sont affichés de manière conviviale et claire. La couronne entourant les valeurs change de couleur, passant du vert au rouge, en fonction du potentiel de risque, et indique à nouveau, par exemple dans le cas de l'humidité relative, la valeur de 0 à 100 %.

Afin de pouvoir réagir rapidement et efficacement sans connaissances spécialisées, un bouton animé et constamment mis à jour est intégré sous les valeurs. En fonction de la situation de danger, ce bouton affiche une coche verte ou une croix rouge pour que l'utilisateur comprenne rapidement le danger.

En cliquant sur le bouton, des mesures telles que la ventilation, le chauffage ou d'autres mesures structurelles sont proposées en fonction des paramètres de danger. À l'aide d'une barre de navigation située dans le champ de vision inférieur, l'utilisateur de l'application peut également alterner entre la page d'accueil, une page de contact et une page d'informations complémentaires.

L'application est donc une solution tout-en-un pour la prévention des moisissures basée sur l'IoT qui affiche et évalue intelligemment les valeurs mesurées de la carte de manière conviviale.

Ici, j'ai clarifié le tout une fois de plus sous forme d'organigramme :

Ainsi, il est possible pour l'utilisateur, même sans expertise particulière, de prévenir efficacement la plupart des facteurs qui conduisent au développement des moisissures en suivant les mesures suggérées par l'application.

Puisque l'interférence de température entre le capteur de gaz chauffé et le capteur de température a été soulignée à plusieurs reprises :

Il s'agit malheureusement d'un problème connu avec la version actuelle de l'AZ-Envy, qui peut être maîtrisé en créant des valeurs de compensation pour corriger artificiellement la température vers le bas ou en apportant des modifications structurelles. Il s'agit notamment d'un boîtier imprimé en 3D avec une paroi entre les deux capteurs, ou bien le capteur de gaz peut être retiré par soudure et placé plus loin par un câble.

Maintenant que tous les détails ont été clarifiés, voici le code pour l'IDE Arduino, qui fonctionnera également pour vous avec seulement quelques ajustements (SSID, mot de passe, clé API) !

Tout d'abord, voici à nouveau le câblage pour le téléchargement :

Ce qui suit est le sketch pour l'IDE Arduino :

 // azenvy
 // © Niklas Heinzel
 //2021
 //Ver.3.1
 ​
 // - libireies - //
 #include  // bibliothèque I2C
 #include  // sht30 librey
 #include  // ESP8266 Wi-Fi génération
 #include  // serveur DNS Lary
 #include  // serveur libery
 #include  // gestionnaire wifi liber
 #include  // mathe-libreau
 #include "firebaseesp8266.h"
 ​
 Sht3x Sht30(0x44);
 ​
 #define firebase_host "Insérez le lien ici" // Lien vers la base de données Firebase Real-Time
 #Define firebase_auth "Insérez le code secret ici" // code secret pour la lecture et l'écriture au cloud
 Firebasedata Firebasedata;
 ​
 contam int analoginpin = Août;  // broche ADC de l'ESP-12F
 int SensorValue = 0;  // valeur entière pour la broche ADC (lecture du capteur de gaz)
 Chaîne de caractères SSID = "Azenvy"; // SSID du portail de configuration
 contam Char * le mot de passe = "Azenvy"; // mot de passe du réseau de l'ESP12
 ​
 Chaîne de caractères Routeur_ssid; // string routeur SSID
 Chaîne de caractères Routeur_pass; // mot de passe de routeur de chaîne
 ​
 ​
 // fonction pour afficher l'état de la connexion
 annuler battement de coeur(annuler)
 {
   statique int engourdi = 1;
 ​
   SI (Wifi.statut() == Wl_connected){
     En série.imprimer("Connecté à WLAN.");  // signifie connecté à WLAN
   }Autre{
     En série.imprimer("Non connecté à WLAN!");} // ne signifie pas connecté à WLAN
   
   SI (engourdi == 80) 
   {
     En série.Imprimeur();
     engourdi = 1;
   }
   Autre SI (engourdi++ % 10 == 0) 
   {
     En série.imprimer(" ");
   }
 } 
 // fonction pour vérifier l'état dans l'intervalle
 annuler Check_status()
 {
   statique ulong CheckStatus_timeout = 0;
   #define heartbeat_Interval 30000L
   // intervalle de 10 secondes
   SI ((millis() > CheckStatus_timeout) || (CheckStatus_timeout == 0))
   {
     battement de coeur();
     CheckStatus_timeout = millis() + Heartbeat_Interval;
   }
 }
 ​
 annuler installer() {
 ​
  En série.Commencer(115200); // Démarrer la connexion série avec un débit en bauds de 115200
  En série.Imprimeur("------------------------------"); // problème sur le moniteur série
  En série.Imprimeur("--------------- Azenvy -------------"); // problème sur le moniteur série
  En série.Imprimeur("------ par Niklas Heinzel -------"); // problème sur le moniteur série
  En série.Imprimeur("------------------------------"); // problème sur le moniteur série
  
  // - WiFi Manager - //
  non signé longue date de début = millis();
  
   Esp_wifimanager Esp_wifimanager; // Intétryisation du gestionnaire WiFi
 ​
   Routeur_ssid = Esp_wifimanager.Wifi_sid(); // variable pour économiser dans l'EEPROM
   Routeur_pass = Esp_wifimanager.Wifi_pass(); // variable pour économiser dans l'EEPROM
   
   En série.Imprimeur("Portail de configuration ouverte des WLAN!"); // problème sur le moniteur série
   En série.Imprimeur("------------------------------");
   
   SI (Routeur_ssid != "")
   {
     Esp_wifimanager.setconfigportaltimeout(10); // délai d'attente du portail de configuration
     En série.Imprimeur("Timeout: 10 secondes"); // problème sur le moniteur série
   }
   Autre{
     En série.Imprimeur("Pas de délai!");} // problème sur le moniteur série
     En série.Imprimeur("---------------------------");
 ​
   SI(!Esp_wifimanager.Startconfigportal((contam Carboniser *) SSID.C_str(), le mot de passe)){ // Démarrez le portail de configuration et attendez l'entrée de l'utilisateur
     En série.Imprimeur("Impossible de ne pas se connecter au réseau."); // problème sur le moniteur série
     En série.Imprimeur("---------------------------");}
   Autre{ 
     En série.Imprimeur("Connecté à WLAN!"); // problème sur le moniteur série
     En série.Imprimeur("---------------------------");}
 ​
   // constant //
   #define wifi_connect_timeout 10000L
   #define whilee_loop_delay 200l
   #define wehene_loop_steps (wifi_connect_timeout / (3 * tandis_loop_delay))
   
   date de début = millis();
   
   Tandis que ( (Wifi.statut() != Wl_connected) && (millis() - date de début < Wifi_connect_timeout ) )
   {   
     int je = 0;
     Tandis que((!Wifi.statut() || Wifi.statut() >= Wl_disconnected) && je++ < Tandis que_loop_steps)
     {
       retard(Tandis que_loop_delay);
     }    
   }
 ​
   En série.imprimer((millis()- date de début) / 1000); // problème sur le moniteur série
   En série.imprimer("L'état de la connexion est"); // problème sur le moniteur série
 ​
   SI (Wifi.statut() == Wl_connected) // si connecté passe alors quelque chose
   {
     En série.imprimer("Adresse IP connectée et locale:"); // problème sur le moniteur série
     En série.Imprimeur(Wifi.Localip()); // sortie sur moniteur série de l'IP
   }
   Autre{
     En série.Imprimeur(Esp_wifimanager.obtenir(Wifi.statut()));} // sortie sur le moniteur série du statut
 ​
   // - Firebase - //
   Firebase.Commencer(Firebase_host, Firebase_auth); // Connectez-vous avec le nuage sous les informations de connexion déclarées
 ​
   punaise(SensorValue,Saisir); // Définissez la broche ADC sur l'entrée 
   punaise(2,PRODUCTION); // place LED intégrée sur la sortie
 ​
 }
 ​
 ​
 annuler boucle() {
 ​
  Check_status(); // fonction à l'état d'état
 ​
  flotter Firebasemp = Ronds((Sht30.Ctemp) * 100) / 100;
  flotter Firebasehum = Ronds((Sht30.humidité) * 100) / 100;
 ​
  // - sht30 - //
    SI(Sht30.avoir()==0){
     En série.imprimer("Inn Température =");
     En série.Imprimeur(Sht30.Ctemp);
     En série.imprimer("Humidité =");
     En série.Imprimeur(Sht30.humidité);
     En série.Imprimeur();
     denadewrite(2,HAUTE); // Éteignez la LED intégrée
   }
   Autre
   {
     En série.Imprimeur("Erreur lors de la lecture du SHT30!");
   }
 ​
 ​
  // - MQ-2 - //
   En série.Imprimeur("----------------------------------------------"); // problème sur le moniteur série
   SensorValue = analogique(analoginpin); // lisant la broche ADC (convertisseur analogique-numérique) de MQ-2
   En série.imprimer("Valeur Gassensor:"); // problème dans le moniteur série
   En série.Imprimeur(SensorValue); // sortie de la valeur analogique dans le moniteur série
   En série.Imprimeur("----------------------------------------------"); // problème sur le moniteur série
 ​
  SI(Firebase.setfloat(Firebasedata, "Mould-Pavait / température", Firebasemp)){
      En série.Imprimeur("Téléchargez les données avec succès!");
   }Autre{
     En série.imprimer("Erreur lors du téléchargement:");
     En série.Imprimeur(Firebasedata.Erreur erronée());
   }
   
   SI(Firebase.setfloat(Firebasedata, "Molle-prévenant / humidité", Firebasehum)){
      En série.Imprimeur("Téléchargez les données avec succès!");
   }Autre{
     En série.imprimer("Erreur lors du téléchargement:");
     En série.Imprimeur(Firebasedata.Erreur erronée());
   }
   
  SI(Firebase.setfloat(Firebasedata, "Moulin-prévenant / gaz", SensorValue)){
      En série.Imprimeur("Téléchargez les données avec succès!");
   }Autre{
     En série.imprimer("Erreur lors du téléchargement:");
     En série.Imprimeur(Firebasedata.Erreur erronée());
   }
 ​
 ​
  retard(5000);
 ​
 }

Vous pouvez télécharger le croquis ici.

Après avoir téléchargé le croquis pour la première fois, utilisez un téléphone mobile pour vous connecter au réseau WLAN de l'AZ-Envy, par exemple, et vous serez dirigé vers un site Web de connexion. Vous y sélectionnez le réseau souhaité auquel la carte doit toujours se connecter après la configuration et après un redémarrage, les données seront envoyées !

Pour créer une base de données correspondante, il suffit de créer une base de données en temps réel sur https://firebase.google.com. Dans les paramètres, vous trouverez alors également le code secret avec lequel le conseil peut accéder à la base de données. Une disposition possible est la suivante (le code Arduino doit également être modifié en conséquence si le nom est différent) :

À partir de là, vous pouvez utiliser les données à de nombreuses fins applicatives, par exemple pour lire les applications Android, les afficher sur un écran, etc.

Je vous souhaite donc beaucoup de plaisir avec la carte de développement AZ-Envy et je suis déjà très impatient de voir quels nouveaux projets seront basés sur elle !

Niklas Heinzel