Dauerkalender

Temperaturzentrale mit ESP32 und BLYNK

In dem Versuch konstruieren wir eine Zentrale, in der man Temperaturen von drei Sensoren beobachten kann. Diese Zentrale ist nichts anderes als ein Smartphone (oder Tablet), das via WLAN die Temperaturen abfragt und anzeigt. Bei dem Sender handelt es sich um den Mikrocontroller ESP32, der über eine WLAN-Schnittstelle verfügt. Er überwacht drei Temperatursensoren. Die ermittelten Temperaturen versendet er zyklisch über WLAN an die Endgeräte. Bei den Temperatursensoren handelt es sich um die DS18B20-Sensoren. Bei der WLAN-Übertragung stützen wir uns auf die IoT-Plattform BLYNK.

Aufgabe

Um die Aufgabe etwas bildlicher darzustellen, stellen wir uns eine Lagerhalle mit einem Vorraum vor. Der erste Temperatursensor meldet uns dann die Außentemperatur. Der zweite Sensor ist für den Vorraum zuständig. Der dritte Sensor zeigt uns dann schließlich die Lagertemperatur an. Da die Temperatur im Lager in gewissen Grenzen möglichst konstant gehalten werden muss, gibt es eine Heizung und einen Kühler, die je nach Bedarf zugeschaltet werden. Sie werden in unserer Schaltung mit zwei Leuchtdioden symbolisiert. Auf der Smartphone-Anzeige wollen wir außer Lagertemperatur auch die Tatsache erkennen, ob die Heizung oder der Kühler gerade im Betrieb sind. Zusätzlich soll der Temperaturverlauf im Lager in Form eines Diagramms dargestellt werden.

DS18B20

Der Sensor DS18B20 benötigt nur eine einzige Leitung, um die gemessene Temperatur an einen Mikrocontroller zu übermitteln. Eine weitere Eigenschaft des Sensors ist, dass man an die eine Leitung gleich mehrere Sensoren anschließen kann. Ein großer Vorteil, wenn man bei einem Projekt viele Ein- und Ausgänge benötigt. Damit das funktioniert, müssen die Adressen der Sensoren ermittelt werden. Bevor wir zu unserer Hauptaufgabe übergehen, folgt hier eine kurze Erläuterung, wie man diese Adressen aus den Sensoren auslesen kann. Dazu konstruieren wir eine ganz einfache Schaltung und nutzen ein kurzes Programm.

#include <OneWire.h>                        // Bibliothek OneWire.h einbinden
OneWire  DS18B20(25);                       // Datenleitung des Sensors an Pin 25

// **************************************************************************************
void setup() {

  Serial.begin(9600);                       // Seriellen Monitor aktivieren
}

// **************************************************************************************
void loop() {
    byte i;
    byte addr[8];
  
    while(DS18B20.search(addr)) {           // Adresse auslesen
        Serial.println("Gefundene Adresse lautet: ");
        for( i = 0; i < 8; i++) {
            Serial.print("0x");
            if (addr[i] < 16) {
                Serial.print('0');
            }
            Serial.print(addr[i], HEX);
            if (i < 7) {
                Serial.print(", ");
            }
        }
        Serial.println(" ");
    }
    DS18B20.reset_search();
    Serial.println(" ");
    delay(3000);
}
// **************************************************************************************        

Monitorausgabe

In unserem Beispiel wurden folgende Adressen ermittelt:

1. 0x28, 0x89, 0xB4, 0x56, 0xB5, 0x01, 0x3C, 0xB3
2. 0x28, 0x38, 0x65, 0x56, 0xB5, 0xFF, 0x3C, 0x55
3. 0x28, 0x52, 0x6B, 0x56, 0xB5, 0x01, 0x3C, 0xBE

Schaltplan

ESP32

Die ESP32-Mikrocontroller-Platine eignet sich sehr gut für WLAN-Anwendungen. Die entsprechende Schnittstelle ist direkt eingebaut. Es wird keine externe Erweiterungshardware benötigt. Für alle Arduino-Fans ist der Umstieg eine einfache Angelegenheit. Der ESP32 kann auch mit der Arduino-IDE programmiert werden. Was sich ändert, und hier muss jeder schön aufpassen, ist die Betriebsspannung. Alle Eingänge arbeiten mit 3,3 V und sind mit 5V nicht kompatibel.

In vielen Fällen reicht es aus, den ESP32 einfach via USB-Anschluss mit Spannung zu versorgen. Wenn jedoch WiFi-Anwendungen ins Spiel kommen, reicht oft die USB-Spannungsversorgung nicht aus. Hier kann es dazu kommen, dass Ströme angefordert werden, die ein einfacher USB-Anschluss nicht liefern kann. Um dem Problem vorzubeugen, bekommt der Mikrocontroller in unserem Beispiel eine separate Spannungsversorgung, die mit einem LM2596-Spannungsregler realisiert wird.

In unserem Versuch werden lediglich drei Pins des Mikrocontrollers in Anspruch genommen. An Pin 25 wird die Datenleitung der drei Temperatursensoren DS18D20 angeschlossen. Dieser Pin wird im Programm als Eingang deklariert.
Zwei weitere Pins mit den Nummern 32 und 33 werden als Ausgänge deklariert. Hier werden zwei Melde-Leuchtdioden, die eine Heizung (rote LED) und einen Kühler (blaue LED) symbolisieren, angeschlossen. Die Widerstände R2 und R3 begrenzen den Strom der Leuchtdioden und schützen sie vor der Zerstörung.

Testschaltung

Programm

#define BLYNK_PRINT Serial
                                            // Die folgenden Daten werden bei Erstellung  
                                            // eines neuen Gerätes generiert und müssen 
                                            // hier eingegeben werden.
#define BLYNK_TEMPLATE_ID "12345L4Fq_GqZNY"
#define BLYNK_TEMPLATE_NAME "Temperaturzentrale"
#define BLYNK_AUTH_TOKEN "12345B5W9q7Qjgut8CvV88KL"


#include "OneWire.h"                        // Bibliothek DS18B20 anbinden
    OneWire oneWire(25);
#include "DallasTemperature.h"
    DallasTemperature Sensoren(&oneWire);
#include "BlynkSimpleEsp32.h"
    BlynkTimer timer; 

                                            // Zugang zu dem Heim-Funknetz.
char ssid[] = "FRITZ!Box 7590";             // Dein Funknetz-SSID
char pass[] = "12345678902516646863";       // Dein Passwort
  
DeviceAddress Sensor_1 = { 0x28, 0x89, 0xB4, 0x56, 0xB5, 0x01, 0x3C, 0xB3 };
DeviceAddress Sensor_2 = { 0x28, 0x38, 0x65, 0x56, 0xB5, 0xFF, 0x3C, 0x55 };
DeviceAddress Sensor_3 = { 0x28, 0x52, 0x6B, 0x56, 0xB5, 0x01, 0x3C, 0xBE };

int Pin_Aussentemperatur = 25;              // Anschluss-Pin für Temperatursensoren
int Heizung = 33;                           // 1-Heizung An
int Kuehlung = 32;                          // 1 - Kühlung Ein

// *******************************************************************************************
void Temperatur_ablesen () {

    float Temperatur;
    String Temperatur_Ist;
    Sensoren.requestTemperatures();                               // Temperatur anfordern    

    Temperatur = Sensoren.getTempC(Sensor_1);                     // Außentemperatur auslesen
    Temperatur_Ist = String(Temperatur) + "  " + "°C ";           // String Ausgabe bilden
    Blynk.virtualWrite(V0, Temperatur_Ist);                       // Ergebnis abschicken
    Serial.println ("Außentemperatur =    " + Temperatur_Ist);    // Ausgabe serieller Monitor

    Temperatur = Sensoren.getTempC(Sensor_2);                     // Temperatur Vorraum 
    Temperatur_Ist = String(Temperatur) + "  " + "°C ";           // String Ausgabe bilden
    Blynk.virtualWrite(V1, Temperatur_Ist);                       // Ergebnis abschicken
    Serial.println ("Vorraum-Temperatur = " + Temperatur_Ist);    // Ausgabe serieller Monitor
    
    Temperatur = Sensoren.getTempC(Sensor_3);                     // Lagertemperatur auslesen
    Blynk.virtualWrite(V2, Temperatur);                           // Ergebnis abschicken
    Temperatur_Ist = String(Temperatur) + "  " + "°C ";           // String Ausgabe bilden
    Serial.println ("Lager-Temperatur =   " + Temperatur_Ist);    // Ausgabe serieller Monitor 

    if (Temperatur < 20) {                                        // Lager-Temperatur zu niedrig
        Blynk.virtualWrite(V3, "Temperatur im Lager ist zu niedrig.");    // Meldetext Teil 1
        Blynk.virtualWrite(V4, "Heizung wurde eingeschaltet.");           // Meldetext Teil 2
        Blynk.setProperty(V2, "color", "#5F7CD8");                // Widget blau färben
        digitalWrite (Heizung, HIGH);                             // Heizung einschalten
        digitalWrite (Kuehlung, LOW);                             // Kühlung ausschalten
        Serial.println ("Heizung AN");
    }

    if (Temperatur > 30) {                                        // Lagertemperatur zu hoch
        Blynk.virtualWrite(V3, "Temperatur im Lager ist zu hoch.");       // Meldetext Teil 1
        Blynk.virtualWrite(V4, "Kühlung wurde eingeschaltet.");           // Meldetext Teil 2        
        Blynk.setProperty(V2, "color", "#D3435C");                // Widget rot färben
        digitalWrite (Heizung, LOW);                              // Heizung ausschalten
        digitalWrite (Kuehlung, HIGH);                            // Kühlung einschalten
        Serial.println ("Kühlung AN");                            // Ausgabe serieller Monitor
    }

    if (Temperatur >= 20 && Temperatur <= 30) {                   // Lagertemperatur OK
        Blynk.virtualWrite(V3, "Temperatur im Lager ist OK.");    // Meldetext Teil 1
        Blynk.virtualWrite(V4, "Heizung und Kühlung sind AUS.");  // Meldetext Teil 2       
        Blynk.setProperty(V2, "color", "#23C48E"); // grün
        digitalWrite (Heizung, LOW);                              // Heizung ausschalten
        digitalWrite (Kuehlung, LOW);                             // Kühlung ausschalten
        Serial.println ("Lagertemperatur OK");                    // Ausgabe serieller Monitor
    }
}

// *******************************************************************************************
void setup() {
    Serial.begin(9600);                                           // Serieller Monitor
    Sensoren.begin();                                             // Temperatursensoren
    Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);                    // WLAN
    Sensoren.setResolution(Sensor_1, 8);
    timer.setInterval(1000L, Temperatur_ablesen);                 // Messung 1 pro Sekunde
    pinMode (Heizung, OUTPUT);                                    // Pin 32 als Ausgang
    pinMode (Kuehlung, OUTPUT);                                   // Pin 32 als Ausgang
}

// *******************************************************************************************
void loop() {

    Blynk.run();
    timer.run();
}    

// *******************************************************************************************
        

Das Programm wurde wegen besserer Kontrolle mit Ausgaben versehen, die auf dem seriellen Monitor erscheinen. Sie sehen wie folgt aus:

BLYNK

Die Vorgehensweise bei der Einrichtung einer Schalt- bzw. Meldeoberfläche auf dem Smartphone oder Tablet mithilfe der IoT-Plattform Blynk haben wir bereits besprochen. Zur Erinnerung können folgende Seiten aufgerufen werden:

In unserem Beispiel wurden fünf Datenströme (V0 bis V4) generiert. Mit dem Datenstrom V0 wird die Temperatur vom ersten Temperatursensor zum Smartphone übermittelt. Diese haben wir als Außentemperatur definiert. Als Datentyp wurde hier String gewählt. Im ESP32-Programm wird demnach die Temperatur als Zahl ermittelt, in einen String umgewandelt und in dieser Form über WLAN weiter verschickt. Identisch verfahren wir mit dem Datenstrom V1, der für die Vorraum-Temperatur zuständig ist.
Der Datenstrom V2 steht für die Lagertemperatur. Da in der Smartphone-Oberfläche für diese Anzeige ein Maßstab-Widget gewählt wurde, wird der Temperaturwert nicht als String, sondern als Doppelt übermittelt. Dabei handelt es sich um eine Zahl mit zwei Stellen nach dem Komma.
Mit den Datenströmen V3 und V4 werden einfache Textnachrichten gesendet. Bei ihnen wird als Datentyp auch String gewählt.

Die Anzeige-Oberfläche auf dem Smartphone wurde in dem Beispiel mit zehn Widgets aufgebaut.

Das Endergebnis könnte wie folgt aussehen:

Kurzvideo

Kurzvideo

Weitere Themen: