Temperaturmessung

Grundlagen
Basis-Code
Outdoor-Einsatz
Einsatz mit einer festen Spannungsquelle („Indoor-Einsatz“)

Grundlagen

Eine Temperatur mit einem passenden Sensor (meist DS18B20) zu messen ist grundsätzlich eine simple Angelegenheit. Möchte man das ganze preiswert halten und gleichzeitig die Messwerte weitergeben und verarbeiten, so landet man bei der Prozessorwahl beim ESP – für Messungen in der Nähe einer Steckdose reicht hier schon der Kleinste, der ESP-01.

Der Anschluss des Sensors ist schnell erledigt. Der Daten-Ausgang wird über einen 4,7K-Widerstand auf 3,3V gelegt und gleichzeitig mit dem IO02-Eingang des ESP verbunden:

Die ca. 3V (eigentlich 3.3V) Betriebsspannung können zwei 1,5V-Batterien liefern, aber die sind dann auch relativ schnell leer. Besser ist eine Versorgung über ein Netzteil.

Die Messwerte sind ebenfalls leicht auszulesen. Mithilfe der Arduino-IDE (erweitert für den ESP8266) ist ein einfaches Programm schnell geschrieben. Diesen und ähnlichen Code findet man im Netz zuhauf!

Basis-Layout für DS18B20 und ESP-01

Im einfachsten Fall könnte der Code so aussehen:

Basis-Code

#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2  // DS18B20 pin

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);

void setup()
{
  Serial.begin(115200);
  DS18B20.begin();
}

void loop()
{
  float temp = 85.0;
  do {
    DS18B20.requestTemperatures();
    temp = DS18B20.getTempCByIndex(0);
  } while (temp == 85.0 || temp == (-127.0));
// Wenn der DS18B20 Unsinn misst,
// wirft er häufig einen dieser Werte aus
  Serial.println("got DATA");
  Serial.print("Temperatur: ");
  Serial.println(temp);
  delay(1000);
}

Läd man dieses Programm über die Arduino-IDE, so kann man in der seriellen Ausgabe im Minutentakt die gemessene Temperatur ablesen:

Ausgabe des seriellen Monitors

Toll 😐 Wer lässt seinen Sensor schon ständig am PC und seriellen Monitor hängen.
Aber der ESP ist ja WLAN-fähig. Dieses Feature eröffnet eine Reihe vom Möglichkeiten:

  • Verschicken der Messwerte an einen MQTT-Broker
  • Aufbau einer Webpage und Anzeige der Messwerte
  • Verschicken der Messwerte per Mail

Außerdem bieten sich noch ein paar Verbeserungen an:
Der DS18B20 liefert zwar Temperaturwerte mit zwei Dezimalen, seine Genauigkeit beträgt aber +-0,5°C! Man sollte also die Ausgabe auf maximal 1 Dezimale runden.
Der Grundaufbau des Programms für ESP + DS18B20 unterscheidet sich nur wenig vom Aufbau mit anderen Sensoren (wie DHT22 für Temperatur und Feuchte, BMP/BME 280 für Temp., Feuchte und Druck, u.s.w.)
Es ist daher keine schlechte Idee, den Messvorgang in eine eigene Methode getData() auszulagern, dann kann man die anderen Programmteile weitgehend ohne Änderungen übernehmen.

Outdoor-Einsatz

Für den Outdoor-Einsatz sind noch ein paar Gedanken zur Energieversorgung notwendig. Naheliegend ist die Idee, dem ESP einfach eine Versorgung per Batterie zu spendieren – z.B. sollten zwei AA-Zellen die 3V liefern können. Das Problem dabei ist, dass er es problemlos schafft die beiden innerhalb von wenig mehr als einem Tag leerzusaugen – ein teurer Spass.

Nun gibt es ja den Deep Sleep Modus, in dem er kaum Energie benötigt. In einem Probebetrieb eines D1 mini Pro WeMos Modells mit einem BMP 180 (Temperatur und Luftdruck) mit Deep Sleep Modus und 15 min Intervallen hielt das Ganze immerhin ca 1 Monat – war mir allerdings auch noch zu teuer. Letzendlich hatte ich die Idee, mir eine billige Solarlampe zu kaufen (bei Ebay im zweier Pack für € 11,90). Drinnen liegt als Pufferbatterie ein Li-Ion-Akku (ca. 4V). Ich lötete an den Akku zwei zusätzliche Kabel an, nahm einen ESP-01, auf den ich eine Drahtbrücke zwischen GPIO16 und Reset gelötet habe (für den Deep-Sleep) und schaltete einen StepUp-StepDown-Regler dazwischen (Pololu 3,3V – bei Ebay ca. 8€), um für stabile 3,3V zu sorgen. Den DS18B20 kaufte ich in einer gekapselten Form für den Außeneinsatz und führte ihn aus der Lampe hinaus. Der Innenteil passte auf ein Platinenstück von 3,5cm x 2,0cm und damit perfekt in die Lampe, sogar mit Sockeln für den ESP und den Pololu – und das Ganze funktioniert prächtig.
Den Pololu-Regler habe ich wieder ausgebaut! Er hat auch in der Deep-Sleep-Phase des ESP ca. 20mA verbraten. So hat dann nicht der ESP, sondern der Pololu den Akku leergesaugt. Der Akku liefert ca. 3,6V und das liegt an der oberen Grenze dessen, was der ESP verträgt. Ich denke (hoffe), dass er das auch langfristig aushält 😉 .
Zwar hat der Pololu auch einen Pin, der ihn in eine Art Tiefschlaf versetzt, aber das führt zu einem Henne-Ei-Problem: Wenn ich den Pololu über den ESP in den Tiefschlaf versetze, bekommt der ESP wahrscheinlich nicht genug Energie, um aus dem Tiefschlaf hochzufahren, (und erst dann könnte er ja den Pololu wieder aufwecken).

Wegen des Deep-Sleep-Modus ist ein Einsatz als Web-Server nicht sinnvoll – die meiste Zeit wäre der ESP nicht erreichbar! So wacht er nur kurz auf, schickt den aktuellen Messwert (und seine IP-Adresse – weil ich die immer schnell mit der der anderen Sensoren durcheinander werfe 😉 ) an den MQTT-Broker und geht wieder schlafen.

Die fast leere Platine …
… und die fertig bestückte Platine
Der DS18B20 für den Außeneinsatz

Der Code dafür ist immer noch übersichtlich (Download). Dass die loop-Methode leer ist hat den Grund, dass das Aufwachen aus dem Deep Sleep einen Reset auslöst und der ESP also wieder komplett von vorne beginnt. die loop-Methode würde also ohnehin maximal einmal durchlaufen. Deshalb kann man diesen Teil gleich in die setup-Methode hineinschreiben und den loop leer lassen.

#include <OneWire.h>
#include <DallasTemperature.h>

// Code für eigenen Aufbau

#include <PubSubClient.h>
#include <ESP8266WiFi.h>
#define ONE_WIRE_BUS 2  // DS18B20 pin

//**** Diese Daten müssen angepasst werden ***************

#define WIFI_AP "NW-Kennung"
#define WIFI_PASSWORD "NW-Passwort"

#define TOKEN "ESP8266_DS18B20_TOKEN"

char clientID[] = "DS18B20_LAMPE";
char mqttBroker[] = "192.168.xxx.yyy"; // Adresse des MQTT-Brokers
int subNetIP = xxx; //IP des Subnets
int myIP = zzz; //nur der letzte Block der IP ändert sich
String myHostname = "DS18B20_LAMPE";
String mySensor = "DS18B20";
char mqttSubjectTemperatur[] = "wetter/lampe/temperatur";
char mqttSubjectIP[] = "wetter/lampe/ip";

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

String temperature = "Ablesefehler";

WiFiClient wifiClient;

PubSubClient client(wifiClient);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int status = WL_IDLE_STATUS;

void setup()
{
  InitWiFi();
  client.setServer( mqttBroker, 1883 );
  if ( !client.connected() ) {
    reconnect();
  }
  getData();
  sendMQTTMessage(mqttSubjectTemperatur, temperature);
  delay(100);
  //Die IP wird mitgeschickt, damit man sie nicht so leicht vergisst ;-)
  // Kann man auch weglassen!
  sendMQTTMessage(mqttSubjectIP, "192.168."+String(subNetIP)+"."+String(myIP));
  client.loop();
  ESP.deepSleep(600000000); //sleep 10 min = 600.000.000 us
}

void loop(){}

String getFormattedFloat(float x, uint8_t precision) {
  char buffer[10];
  dtostrf(x, 7, precision, buffer);
  return (buffer);
}

void getData() {
  float temp;
  do {
    DS18B20.requestTemperatures();
    temp = DS18B20.getTempCByIndex(0);
  } while (temp == 85.0 || temp == (-127.0)); 
  //eine dieser Temperaturen erscheint bei einem Messfehler
  temperature = getFormattedFloat(temp, 1);
}

void sendMQTTMessage(char mqttSubject[], String message) {
  char payload[100];
  message.toCharArray( payload, 100 );
  //mit "true" wird das "Retain-Flag" gesetzt - d.h. der Broker merkt sich
  // die Payload bis sie mit der nächsten Lieferung überschrieben wird.
  //So bekommt ein neuer Abonnent immer sofort die letzte Payload ausgeliefert!
  client.publish( mqttSubject, payload , true);
}

void connectToWiFi() {
  WiFi.begin(WIFI_AP, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
}

void InitWiFi()
{
  // Verbindungsversuch mit WiFi
  IPAddress ip(192, 168, subNetIP, myIP);
  IPAddress gateway(192, 168, subNetIP, 1);
  IPAddress subnet(255, 255, 255, 0);
  IPAddress dns(192, 168, subNetIP, 1);
  WiFi.config(ip, dns, gateway, subnet); // auf feste IP einstellen
  WiFi.hostname(myHostname); //Hostnamen setzen
  WiFi.persistent(false);
  WiFi.mode(WIFI_OFF);
  WiFi.mode(WIFI_STA);
  connectToWiFi();
}

void reconnect() {
  // Loop bis zum Reconnect
  while (!client.connected()) {
    status = WiFi.status();
    if ( status != WL_CONNECTED) {
      connectToWiFi();
    }
    if ( client.connect(clientID, TOKEN, NULL) ) {
    } else {
      // 5 Sekunden warten
      delay( 5000 );
    }
  }
}

Einsatz mit einer festen Spannungsquelle („Indoor-Einsatz“)

Beim „Indoor“-Einsatz habe ich mich letztendlich dazu entschieden, meine Daten sowohl über MQTT, als auch per Webpage anzubieten. Die MQTT-Daten können dann an einen Broker auf einem Raspberry Pi weitergereicht werden, der diese wiederum an NodeRed weitergibt. Letzteres ist für Messzwecke eine Offenbarung – man kann sich nach dem Lego-Prinzip Ein- und Ausgabemöglichkeiten zusammenschieben und die Messwerte wunderschön als Gauge, Chart, … darstellen, sie in eine Datei schreiben lassen, sie per Mail oder Messenger verschicken u.s.w.

Über die Webpage lasse ich neben den Temperaturwerten noch andere Informationen über den ESP ausgeben, außerdem kann man über die Webpage die Ableserate verändern. Manchmal möchte man vielleicht einmal ein Ereignis in kürzeren Schritten erfassen – z.B. den Temperaturverlauf in einem Raum, wenn das Fenster geöffnet wird, im Normalfall wird es einem meist reichen, in 10 / 15 oder 30min-Intervallen zu messen. Damit man eine Information über das Alter der Daten bekommt, lasse ich den ESP die Zeit von meinem häuslichen Timeserver abfragen und auf der Webpage zusammen mit den Messwerten anzeigen. Damit der Code nicht zu unübersichtlich wird, habe ich die Timeserver-Methoden in eine eigene Bibliothek ausgelagert.
Es gibt natürlich auch fertige Libraries zum Thema ntp-Server für den ESP8266, aber die haben mir nicht gefallen – außerdem hat mich der sportliche Ergeiz gepackt, mich einmal an einer eigenen Bibliothek zu versuchen. Zusammengefasst hat der ESP8266 mit dem DS18B20 die folgenden Features:

  • MQTT-Client
  • Zugriff auf ntp-Server
  • Webserver
  • Möglichkeit eines Web-Updates
  • Änderung des Mess-Intervalls über Webpage

Das Listing ist trotz Auslagerung der Timeserver-Methoden noch recht umfangreich. Daher lege ich nur einen Link zum Download.

So sieht die fertige Webpage dann aus.

Messgenauigkeit

Was mich etwas erstaunt hat, ist die Tatsache, dass man zwar im Netz unglaublich viele Anleitungen findet, mit dem DS18B20 und einem ESP, Arduino, Raspberry Pi, … die Temperatur zu messen und darzustellen, aber anscheinend brechen alle in Jubel aus, wenn dann letztendlich etwas angezeigt wird — und das war’s dann.
Ich habe mir einmal die Mühe gemacht, neben den DS18B20 ein relativ gutes Laborthermometer zu legen – nicht zuletzt, weil mir der Raum nie so warm vorkam, wie er lt. Messung sein sollte. Und siehe da – der Sensor gab immer Temperaturen aus, die etwa 2°C höher lagen, als die Temperatur lt. Laborthermometer sein sollte. Zunächst dachte ich, ich hätte vielleicht ein „Montags-Teil“ erwischt, aber der Vergleich mit anderen DS18B20 – auch von verschiedenen Händlern – zeigte für alle das gleiche Problem!
Die Lösung war so einfach wie niederschmetternd: Das teure Laborthermometer war fehlerhaft kalibriert. Ich habe gerade Vergleichsmessungen mit zwei anderen Thermometern durchgeführt und siehe da, die Temperaturwerte der Sensoren lagen im korrekten Fehlerfenster, das im Datenblatt ausgewiesen ist!

Mein nächster Gedanke war dann, dass sich die Dinger vielleicht beim Betrieb erwärmen. Ich testete das, indem ich einen Sensor klassisch anschloss, einen zweiten schloss ich so an, dass er über eine GPIO des ESP nur dann mit Spannung versorgt wurde, wenn wirklich gemessen werden sollte. D.h. der VCC-Pin kam an die GPIO0 des ESP und diese wurde nur kurz vor einer Messung auf HIGH gelegt und gleich danach wieder auf LOW. Das Ergebnis: Kein Unterschied.

Trotz intensiver Suche im Netz und Studium des Datenblatts habe ich keine Lösung für dieses Problem gefunden.
Meine „Notlösung“ besteht darin, vor der Ausgabe der Messwerte einfach 2°C herunter zu rechnen. Demnächst habe ich vor, einmal eine Messreihe zu starten und im Intervall von 0°C bis ca. 50°C die Messwerte Grad für Grad mit dem Labotthermometer zu verifizieren (und so vielleicht eine Kalibrierungskurve aufzunehmen…).

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.