Schimmelprävention mit dem AZ-Envy - Teil 2

Der folgende Blogbeitrag wurde uns von dem Gastautor Niklas Heinzel zugesandt. Viel Spaß beim Lesen und Nachbasteln:

In dem zweiten Teil dieser Blog-Reihe geht es um die Nutzung des Umweltentwicklungsboards AZ-Envy zur frühzeitigen Schimmelprävention in Wohnräumen. Nachdem wir uns in Teil 1 die bautechnischen Faktoren angeschaut haben, unter denen eine Schimmelbildung mit erhöhter Wahrscheinlichkeit auftritt, geht es nun um die technische Betrachtung des Problems, bzw. die Umsetzung mit dem AZ-Envy Entwicklungsboard.

Aus Teil 1 haben wir die folgenden Grundlagen übernommen, die nun in der technischen Umsetzung Berücksichtigung finden müssen:

„In der technischen Auseinandersetzung muss versucht werden, eine Messung der Raumlufttemperatur, der relativen Luftfeuchtigkeit (<65%) und der Taupunkttemperatur (<Raumlufttemperatur) vorzunehmen. Diese Werte müssen entsprechend automatisiert ausgewertet, sowie gespeichert werden.“

Neben der korrekten Verschaltung aller Hardwarekomponenten ist für das Projekt also ein passender Algorithmus nötig, der über die Sensorik die drei genannten Werte prüft. Um den passenden Algorithmus zu schreiben, nutzte ich die Open-Source-Software Arduino IDE, mit der Anpassung für den genutzten ESP12-F Mikrocontroller aus der ESP8266 Familie.

Vorteil dieser Entwicklungsumgebung ist die einfache Einbindung von Bibliotheken, welche der Vereinfachung von Befehlen und der Praxistauglichkeit dienen. Diese Bibliotheken sind für verschiedenste Sensoren und weitere Bauteile verfügbar. Aber sie bieten auch eine Vielzahl an Programmierbeispielen zum Erlernen der Programmiersprache C++ bzw. C. Ich habe daher bewusst auf andere Entwicklungsumgebungen verzichtet, die ich sonst selber verwende, um unnötige Schwierigkeiten beim Upload, oder aufgrund der Syntaxbeschaffenheit, zu vermeiden.

Wie bei fast jeder Programmiersprache üblich, werden zunächst die Bibliotheken eingebunden. In meinem Fall sind es Bibliotheken zum einfacheren Auslesen von Sensorwerten des SHT30 und Bibliotheken, die es erlauben, mit dem ESP12-F Mikrocontroller eine eigene Website aufzubauen.

Nach der Initialisierung aller Sensoren wird versucht, sich via WLAN mit den im internen Speicher hinterlegten Anmeldedaten mit dem lokalen Netzwerk zu verbinden. Falls keine Anmeldedaten verfügbar sind, z. B. beim erstmaligen Start des Systems durch den Benutzer, wird eine Website aufgebaut, in der Informationen zum Gerät sowie eine Anmeldeseite vorhanden sind. Dort trägt man seinen WLAN-Namen (SSID) und sein WLAN-Passwort ein. Diese Daten werden im internen Speicher, dem EEPROM, hinterlegt und bleiben auch nach dem Ausschalten der Spannungsversorgung des Geräts erhalten. Ein EEPROM ist ein sogenannter Electrically Erasable Programmable Read-only Memory, also ein elektrisch löschbarer, programmierbarer, ausschließlich dem Lesevorgang vorbehaltener Speicher, der sich durch Spannungsunterschiede programmieren oder löschen lässt. Die Eigenschaft des dauerhaften Speicherns und die Möglichkeit, den Speicher zu modifizieren, sind ideal, um die Anmeldedaten sicher zu bewahren.

Nach der Eingabe der Daten durch den Benutzer sind diese nun dauerhaft hinterlegt und ein weiterer Login-Vorgang ist nach einem kurzen Neustart nicht nötig. Anschließend verbindet sich der Mikrocontroller über das Heimnetzwerk mit der Firebase-Datenbank von Google, einer kostenlosen Lösung zur Speicherung kleiner Datensätze. Hierzu muss nur ein Konto erstellt werden und über die damit verknüpfte API können Daten an diese gesendet werden. Eine API ist eine Programmierschnittstelle, die Daten von Benutzern oder Geräten aufnimmt und diese für den spezifischen Anwendungszweck, nach einer vorgegebenen Syntax, weiterleitet. Der einzigartige, zur Authentifizierung genutzte, API-Key wird ebenfalls im EEPROM gespeichert und ist mit dem Konto verbunden.  Nach der Etablierung der Verbindung zur Firebase-Datenbank, werden die Sensoren SHT30 und MQ-2 ausgelesen. Anschließend werden diese Daten auf zwei Nachkommastellen gerundet und in die Datenbank hochgeladen. Eine solche zentrale Speicherung in einer Datenbank ermöglicht es, auch außerhalb des Heimnetzes, im Urlaub oder über das Mobilfunknetz, die Daten jederzeit abrufen zu können.

Um das Abrufen und Auswerten der Daten benutzerfreundlich, sowie einfach für den Nutzer umzusetzen, habe ich für diesen Zweck eine Android-App mit der Entwicklungsumgebung Android Studio programmiert.

Da die App keinerlei User-Inferface besitzt, mit der es möglich wäre, den API-Key usw. zu ändern, soll dies nur einen Gedankenanstoß geben für die Entwicklung einer eigenen App.

Diese ermöglicht den automatischen und wenige Sekunden verzögerten Download der aktuellen Daten des Schimmelwarnsystems, sowie die vollständige Auswertung derer. Benutzerfreundlich und übersichtlich sind Luftfeuchtigkeit (links), Raumluftqualität (rechts), aber auch die generelle Schimmelgefährdung (oben) dargestellt. Der die Werte umgebende Kranz färbt sich je nach Gefährdungspotenzial von grün bis rot und zeigt noch einmal, z. B. bei der relativen Luftfeuchtigkeit, den Wert von 0 bis 100 % an.

Um ohne Fachwissen schnell und effektiv reagieren zu können, ist unter den Werten ein sich ständig aktualisierender und animierter Button integriert. Dieser zeigt, je nach Gefährdungslage, einen grünen Haken oder ein rotes Kreuz, um dem Nutzer rasch die Gefährdung zu verdeutlichen.

Bei einem Klick auf den Button werden, passend zu den Gefährdungsparametern, Maßnahmen wie Lüften, Heizen oder andere bautechnische Maßnahmen vorgeschlagen. Mithilfe einer Navigationsleiste im unteren Blickfeld, ist es dem Nutzer der Anwendung zudem möglich, zwischen der dargestellten Home-Seite, einer Kontakt-Seite und einer Seite für weiterführendes Infomaterial zu wechseln.

Die Applikation ist somit eine All-in-one-Lösung zur IoT-basierten Schimmelprävention, die die Messwerte von der Platine intelligent und benutzerfreundlich darstellt und auswertet.

Hier habe ich das Ganze noch einmal als Fließdiagramm verdeutlicht:

So ist es dem Benutzer ebenfalls ohne spezielles Fachwissen möglich, durch die Beachtung der von der App vorgeschlagenen Maßnahmen, effektiv den Großteil der Faktoren, die zur Schimmelbildung führen, präventiv zu vermeiden.

Da mehrfach auf die Temperaturinterferenz zwischen beheiztem Gassensor und Temperatursensor hingewiesen wurde:

Bei der aktuellen Version des AZ-Envy ist dies leider ein bekanntes Problem, welches eingedämmt werden kann durch das Schaffen von Offset-Werten, um die Temperatur künstlich nach unten zu korrigieren oder durch bauliche Veränderungen. Hierzu gehört ein passendes 3D-Druck-Gehäuse mit einer Wand zwischen den beiden Sensoren oder alternativ kann der Gassensor herausgelötet werden und per Kabel weiter entfernt platziert werden.

Da nun alle Details geklärt wären, finden Sie hier den Code für die Arduino IDE, der mit wenigen Anpassungen (SSID, Passwort, API-Key) auch bei Ihnen funktioniert!

Hier zunächst noch einmal die Verkabelung zum Upload:

Es folgt der Sketch für die Arduino IDE:

 //AZEnvy
 //© Niklas Heinzel
 //2021
 //Ver.3.1
 ​
 //-Libaries-//
 #include <Wire.h> //I2C Bibliothek
 #include <WEMOS_SHT3X.h> //SHT30 Libary
 #include <ESP8266WiFi.h> //Esp8266 WLAN Libary        
 #include <DNSServer.h> //DNS-Server Libary
 #include <ESP8266WebServer.h> //Server Libary
 #include <ESP_WiFiManager.h> //Wifi-Manager Libary
 #include <math.h> //Mathe-Libary
 #include "FirebaseESP8266.h"
 ​
 SHT3X sht30(0x44);
 ​
 #define FIREBASE_HOST "hier den Link einfügen" //Link zur Firebase-Echtzeitdatenbank
 #define FIREBASE_AUTH "hier secret code einfügen" //Secret-Code für das Lesen und Schreiben in die Cloud
 FirebaseData firebaseData;
 ​
 const int analogInPin = A0;  //ADC-Pin des ESP-12F
 int sensorValue = 0;  //Integer Wert für ADC-Pin (Auslesen des Gassensors)
 String ssid = "AZEnvy"; //SSID des Konfigurationsportals
 const char* password = "AZENVY"; //Password des  Netzwerks des ESP12´s
 ​
 String Router_SSID; //String Router SSID
 String Router_Pass; //String Router Password
 ​
 ​
 //Funktion zum Anzeigen des Verbindungsstatus
 void heartBeatPrint(void)
 {
   static int num = 1;
 ​
   if (WiFi.status() == WL_CONNECTED){
     Serial.print("Mit WLAN verbunden.");  //bedeutet verbunden mit WLAN
   }else{
     Serial.print("Mit WLAN nicht verbunden!");} //bedeutet nicht verbunden mit WLAN
   
   if (num == 80) 
   {
     Serial.println();
     num = 1;
   }
   else if (num++ % 10 == 0) 
   {
     Serial.print(" ");
   }
 } 
 //Funktion zum Überprüfen des Status im Intervall
 void check_status()
 {
   static ulong checkstatus_timeout = 0;
   #define HEARTBEAT_INTERVAL    30000L
   //Intervall von 10 Sekunden
   if ((millis() > checkstatus_timeout) || (checkstatus_timeout == 0))
   {
     heartBeatPrint();
     checkstatus_timeout = millis() + HEARTBEAT_INTERVAL;
   }
 }
 ​
 void setup() {
 ​
  Serial.begin(115200); //Serielle Verbindung mit einer Baud-Rate von 115200 starten
  Serial.println("------------------------------"); //Ausgabe an seriellen Monitor
  Serial.println("------------AZEnvy------------"); //Ausgabe an seriellen Monitor
  Serial.println("------by Niklas Heinzel-------"); //Ausgabe an seriellen Monitor
  Serial.println("------------------------------"); //Ausgabe an seriellen Monitor
  
  //-Wifi-Manager-//
  unsigned long startedAt = millis();
  
   ESP_WiFiManager ESP_wifiManager; //Intizialiserung des WIFI-Managers
 ​
   Router_SSID = ESP_wifiManager.WiFi_SSID(); //Variable zum Speichern im EEPROM
   Router_Pass = ESP_wifiManager.WiFi_Pass(); //Variable zum Speichern im EEPROM
   
   Serial.println("Öffne Konfigurationsportal des WLAN´s!"); //Ausgabe an Seriellen Monitor
   Serial.println("------------------------------");
   
   if (Router_SSID != "")
   {
     ESP_wifiManager.setConfigPortalTimeout(10); //Timeout des Konfigurationsportals
     Serial.println("Timeout:10 Sekunden"); //Ausgabe an Seriellen Monitor
   }
   else{
     Serial.println("Kein Timeout!");} //Ausgabe an Seriellen Monitor
     Serial.println("---------------------------");
 ​
   if(!ESP_wifiManager.startConfigPortal((const char *) ssid.c_str(), password)){ //Starten des Konfigurationsportals und warten auf Nutzereingabe
     Serial.println("Keine Verbindung zu Netzwerk herstellen können."); //Ausgabe an Seriellen Monitor
     Serial.println("---------------------------");}
   else{ 
     Serial.println("Mit WLAN verbunden!"); //Ausgabe an Seriellen Monitor
     Serial.println("---------------------------");}
 ​
   //Konstanten//
   #define WIFI_CONNECT_TIMEOUT        10000L
   #define WHILE_LOOP_DELAY            200L
   #define WHILE_LOOP_STEPS            (WIFI_CONNECT_TIMEOUT / ( 3 * WHILE_LOOP_DELAY ))
   
   startedAt = millis();
   
   while ( (WiFi.status() != WL_CONNECTED) && (millis() - startedAt < WIFI_CONNECT_TIMEOUT ) )
   {   
     int i = 0;
     while((!WiFi.status() || WiFi.status() >= WL_DISCONNECTED) && i++ < WHILE_LOOP_STEPS)
     {
       delay(WHILE_LOOP_DELAY);
     }    
   }
 ​
   Serial.print((millis()- startedAt) / 1000); //Ausgabe an Seriellen Monitor
   Serial.print("Verbindungsstatus ist "); //Ausgabe an Seriellen Monitor
 ​
   if (WiFi.status() == WL_CONNECTED) //Wenn verbunden dann etwas ausgeben
   {
     Serial.print("Verbunden, lokale IP-Adresse:"); //Ausgabe an Seriellen Monitor
     Serial.println(WiFi.localIP()); //Ausgabe an Seriellen Monitor der IP
   }
   else{
     Serial.println(ESP_wifiManager.getStatus(WiFi.status()));} //Ausgabe an Seriellen Monitor des Status
 ​
   //-Firebase-//
   Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH); //Verbinden mit der Cloud unter den deklarierten Login-Infos
 ​
   pinMode(sensorValue,INPUT); //ADC-Pin auf Input festlegen 
   pinMode(2,OUTPUT); //Integrierte LED auf Output Setzen
 ​
 }
 ​
 ​
 void loop() {
 ​
  check_status(); //Funktion zum Statuscheck
 ​
  float firebasetemp = roundf((sht30.cTemp) * 100) / 100;
  float firebasehum = roundf((sht30.humidity) * 100) / 100;
 ​
  //-SHT30-//
    if(sht30.get()==0){
     Serial.print("Innentemperatur= ");
     Serial.println(sht30.cTemp);
     Serial.print("Luftfeuchtigkeit= ");
     Serial.println(sht30.humidity);
     Serial.println();
     digitalWrite(2,HIGH); //Integrierte LED ausschalten
   }
   else
   {
     Serial.println("Fehler beim Auslesen des SHT30!");
   }
 ​
 ​
  //-MQ-2-//
   Serial.println("----------------------------------------------"); //Ausgabe an seriellen Monitor
   sensorValue = analogRead(analogInPin); //Auslesen des ADC-Pins (analog-digital-Konverter) vom MQ-2
   Serial.print("Gassensor-Wert:"); // Ausgabe im Seriellen Monitor
   Serial.println(sensorValue); // Ausgabe des Analogwerts im Seriellen Monitor
   Serial.println("----------------------------------------------"); //Ausgabe an seriellen Monitor
 ​
  if(Firebase.setFloat(firebaseData, "mold-preventer/Temperatur", firebasetemp)){
      Serial.println("Upload der Daten erfolgreich!");
   }else{
     Serial.print("Fehler beim Hochladen:");
     Serial.println(firebaseData.errorReason());
   }
   
   if(Firebase.setFloat(firebaseData, "mold-preventer/Luftfeuchtigkeit", firebasehum)){
      Serial.println("Upload der Daten erfolgreich!");
   }else{
     Serial.print("Fehler beim Hochladen:");
     Serial.println(firebaseData.errorReason());
   }
   
  if(Firebase.setFloat(firebaseData, "mold-preventer/Gas", sensorValue)){
      Serial.println("Upload der Daten erfolgreich!");
   }else{
     Serial.print("Fehler beim Hochladen:");
     Serial.println(firebaseData.errorReason());
   }
 ​
 ​
  delay(5000);
 ​
 }

Den Sketch können Sie hier herunterladen.

Nach dem erstmaligen Upload des Sketches bauen Sie mit einem Handy z.B. eine Verbindung zum WLAN-Netzwerk des AZ-Envy auf und gelangen auf eine Anmeldewebsite. Dort wählen Sie Ihr gewünschtes Netzwerk aus, mit dem sich das Board nach dem Setup immer verbinden soll und nach einem Neustart werden die Daten gesendet!

Um eine entsprechende Datenbank herzustellen ist es nur nötig auf https://firebase.google.com eine Echtzeitdatenbank anzulegen. In den Einstellungen finden Sie dann auch den Secret-Code mit dem das Board auf die Datenbank zugreifen kann. Ein mögliches Layout ist das folgende hier (entsprechend muss bei anderer Benennung auch der Arduino Code geändert werden):

Von diesem Punkt aus können Sie die Daten für viele Anwendungszwecke verwenden, z.B. Android-Apps auslesen, auf einen Display anzeigen lassen, usw..

Somit wünsche ich viel Spaß mit dem AZ-Envy Entwicklungsboard und bin schon sehr gespannt, welche neuen Projekte darauf aufbauend entstehen werden!

Niklas Heinzel