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:

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:

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.

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.

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…).