Damals hatte ich sowohl auf Mastodon als auch unter dem Video den Tipp erhalten, mir mal den BME280 oder den DS18B20 anzuschauen. Diese Sensoren seien deutlich besser als der DHT22. Gesagt getan: Den BME280 gab es für ca. 6 Euro im 5er Pack aus Fernost, den DS18B20 habe ich für so ziemlich denselben Preis bei einem deutschen Händler bestellt.

Alle drei Sensoren sind im Detail ein bisschen anders. So ist der DHT22 der Klassiker, er ist nicht ganz schmal, sehr gut mit Bibliotheken für Android oder ESP-Boards unterstützt und liefert neben der Temperatur auch die relative Luftfeuchte.

Der BME280 ist, nimmt man nur den Sensor für sich, sehr klein. Er wurde von Bosch entwickelt vor dem Hintergrund dort verbaut zu werden, wo wenig Energie und wenig Platz zur Verfügung steht. Neben Temperatur und relativer Feuchte kann er auch den Luftdruck ermitteln. Es gibt auch ein Modell, welches auf den Namen BMP280 hört. Dieser ist hingegen nicht in der Lage, die Luftfeuchte zu ermitteln. Auch für diese Sensoren gibt es einige gute Bibliotheken, welche die Verwendung relativ einfach machen. Allerdings muss man wissen, auf welcher Adresse der Sensor mittels I²C zu erreichen ist: In diesem Fall ist es 0x76, bei anderen 0x77.

Der DS18B20 ist gefühlt der Vielseitigste was seine unterschiedlichen Bauformen angeht. Neben der von mir verwendeten Variante gibt es u.a. auch in einer Wasserdichten Version. Allerdings kann er, anders als der DHT22 oder der BME280 rein die Temperatur ermitteln, nicht die Luftfeuchte. Übermittelt werden die Daten mit dem 1-Wire-Protokoll. Dabei handelt es sich um eine serielle Datenübertragung welche von der Firma Dallas Semiconductor entwickelt wurde. Der Name ist Programm: Es wird eben neben der Spannungsversorgung nur ein weiteres Kabel benötigt. Wobei, das stimmt nicht ganz: Für die Schaltung wird zudem ein Pull-Up-Widerstand benötigt. Sonst funktioniert das Ganze nicht. Keine große Herausforderung, wenn man es noch nie gemacht hat, sollte man sich dem Thema einmal annehmen.

Für meinen Vergleich habe ich mir auf meinem Steckfeld 3 Teststrecken gebaut. Beide sind vom Aufbau identisch: Von jedem Sensor existiert pro Teststrang ein Exemplar. Angeschlossen sind sie an einen D1 Mini Clone, welcher die Daten an meine InfluxDb und damit an an ein Grafana-Dashboard sendet über das die Auswertung stattfindet. Den Code stelle ich euch gerne bereit. Auch wenn man vermutlich dieses Setup so nicht benötigt, kann man sich vielleicht für eigene Projekte etwas abschauen wenn man neu in der Materie ist:

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_BME280.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <ESP8266WiFi.h>
#include <InfluxDbClient.h>
#include "DHT.h"
#include "secrets.h" // Einfache Konstanten-Sammlung für Credentials


#define ONE_WIRE_BUS 2 // GPIO PIN 2

InfluxDBClient influx(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN);
Point bmeSensor("bme_1");
Point dsSensor("ds_1");
Point dhtSensor("dht_1");


Adafruit_BME280 bme;
Adafruit_Sensor *bme_temp = bme.getTemperatureSensor();
Adafruit_Sensor *bme_humidity = bme.getHumiditySensor();

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

DHT dht(14, DHT22); // GPIO PIN 14

void setup() {
  Serial.begin(9600);

  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(WiFi.SSID());
  Serial.print("IP address:\t");
  Serial.println(WiFi.localIP());


  
  Serial.println(F("BME280 Sensor event test"));

  // Erzwinge Adresse 0x76 statt 0x77, nutzt die SCL/SDA Pins des D1 mini
  if (!bme.begin(0x76)) { 
    Serial.println(F("Could not find a valid BME280 sensor, check wiring!"));
    while (1) delay(10);
  }
  
  bme_temp->printSensorDetails();
  bme_humidity->printSensorDetails();

  ds18b20.begin();

  dht.begin();

  influx.setInsecure();
}

void loop() {
  sensors_event_t temp_event, pressure_event, humidity_event;
  bme_temp->getEvent(&temp_event);
  bme_humidity->getEvent(&humidity_event);
  
  Serial.print(F("BME280 Temperature: "));
  Serial.print(temp_event.temperature);
  Serial.println(" °C");

  Serial.print(F("BME280 Humidity: "));
  Serial.print(humidity_event.relative_humidity);
  Serial.println(" %");

  bmeSensor.addField("temperature", temp_event.temperature);
  bmeSensor.addField("humidity", humidity_event.relative_humidity);
  if (!influx.writePoint(bmeSensor)) {
    Serial.print("InfluxDB write failed: ");
    Serial.println(influx.getLastErrorMessage());
  }

  ds18b20.requestTemperatures();
  Serial.println("DS18B20 Temperature: " + String(ds18b20.getTempCByIndex(0)) + "°C");

  dsSensor.addField("temperature", ds18b20.getTempCByIndex(0));
  if (!influx.writePoint(dsSensor)) {
    Serial.print("InfluxDB write failed: ");
    Serial.println(influx.getLastErrorMessage());
  }

  Serial.println("DHT22 Temperature: " + String(dht.readTemperature()));
  Serial.println("DHT22 Humidity: " + String(dht.readHumidity()));
  dhtSensor.addField("temperature", dht.readTemperature());
  dhtSensor.addField("humidity", dht.readHumidity());
  if (!influx.writePoint(dhtSensor)) {
      Serial.print("InfluxDB write failed: ");
      Serial.println(influx.getLastErrorMessage());
    }

  delay(1000);
}

Für meinen Test habe ich das ganze Setup kurz in die „Kälte“ gestellt. Das sollte dazu dienen um zu sehen wie schnell die Sensoren der Raumtemperatur annähern. Als Referenz diente ein Thermometer, was mehrere Stunden im Raum stand. Zugegeben: ist wieder nicht hochgradig wissenschaftlich, aber für die Stichprobe in meinen Augen ausreichend.

Am Ende bestätigten sich eure Aussagen: Sowohl der DS18B20 als auch der BME280 sind weniger träge als der DHT22. Der DS18B20 ist bei der Disziplin das Rennpferd. Nach etwa 2-3 Minuten hatte er sich bereits bereits wieder angeglichen. Der BME280 war mit 5 Minuten unwesentlich langsamer, während der DHT22 ca. 10 Minuten brauchte. Hinzu kommt die Frage nach der Güte der Daten. Zwischen den drei DHT22 Sensoren lagen am Ende mehr als 1 Grad Unterschied. Auch hier waren beide andere Sensortypen deutlich besser mit ca. 0.2 Grad beim DS18B20 bzw. nur ca 0.1 Grad beim BME280. Der BME280 war auch der Sensor, der am nächsten am Standthermometer lag. Und das sowohl in Bezug auf die Temperatur als auch auf die relative Luftfeuchte.

Somit ist das auch mein persönlicher Testsieger, wenngleich der DS18B20 unmittelbar danach kommt. Der DHT22 ist mit Sicherheit kein schlechter Sensor, aber mit dem Wissen ist seine Zeit bei mir zu Hause wohl vorbei. Ich werde ihn zeitnah gegen die BME280er tauschen.

Während der DHT 11 mit einer Auflösung von einem Grad etwas gröber unterwegs ist, kann der DHT 22 die Temperatur in 0.1 Grad Schritten messen. Oft bekommt man sie vormontiert für 5-10 Euro auf einer kleinen Platine, welche es ermöglicht den Sensor mit einer Spannung von 3.3 bis 5.5 Volt zu betreiben. Auch praktisch ist, dass es er nur einen Pin belegt. Sensoren anderer Bauart, die SPI/I2C verwenden, benötigen schnell mal 2 Pins.

Zudem gibt es für so ziemlich alle Plattformen fertige Bibliotheken, welche die Verwendung mit wenigen Zeilen Code ermöglichen, wie in diesem Mini-Arduino-Sketch:

#include "DHT.h"

DHT dht(1, DHT22); // 1 = GPIO Pin

void setup() {
  Serial.begin(9600);

  dht.begin();
}

void loop() {
  Serial.println(dht.readTemperature());

  delay(10000);
}

Bei mir sind auch zwei DHT 22 im Dauereinsatz. Sie sind an ein D1 Mini Clone Board angeschlossen, welche die Werte via Wifi an eine InfluxDB senden. Die Daten werden in einem Grafana-Dashboard ausgewertet. Und genau dort fiel mir kürzlich auf, dass einer der Sensoren mit knapp 90% eine sehr hohe Luftfeuchte ausgab, die einfach nicht stimmen konnte.

Also wechselte ich den Sensor. Und siehe da: ein neuer DHT 22 meldete schlagartig nur noch um die 60% Feuchte. Grund genug mich zu Fragen: Wie zuverlässig sind diese Sensoren eigentlich? Um das zu prüfen, habe ich 5 DHT 22 Sensoren unterschiedlichen Alters auf ein Steckbrett gepackt und die Werte verglichen.

Laut Datenblatt hat der DHT 22 eine Genauigkeit von +/- 0.5 Grad Celsius im in der Wohnung üblichen Temperaturbereich. Bei der Messung der relativen Luftfeuchte sollen es lediglich 2% sein. In meinem Test konnte ich das leider nicht bestätigen: Bei der gemessenen Temperatur wichen die Sensoren bis zu 2 Grad Celsius voneinander ab. Bei der Luftfeuchte war es noch extremer: Während zwei Sensoren um 90% anzeigten, lagen die anderen bei 55-60%.

Ein wie ich finde etwas überraschendes Ergebnis. Wenn ihr den Test in Gänze sehen möchtet, empfehle ich euch meinen kleinen Videobericht dazu.

-> DHT 22 Temperatur-Sensor-Vergleich auf YouTube

Die DHT22-Sensoren sind technisch nicht die besten weil sie recht träge sind. Aber sie sind günstig. Genau so wie die NodeMCU ESP8266-Boards, die man mit der Arduino IDE bespielen kann, recht viel Speicher mitbringen und auch direkt ein Wifi-Modul an Board haben.

Damit wären alle Voraussetzungen erfüllt, um Temperaturschwankungen in den heimischen vier Wänden zuverlässig zu überwachen. In diesem knackigen kurzen Filmchen zeige ich euch, wie ihr den Sensor mit dem Board verbindet und ihn mit dem entsprechenden Code als HTTP-Server ins Netzwerk bringt und die Verbindung mit eurem Homebridge-Setup herstellt.

Ziel war es am Ende ein schönes kleines Diagramm zu haben, welche Temperatur und Luftfeuchtigkeit über den Tag verteilt anzeigt. Die Wahl fiel auf das Google Spreadsheet, weil es sich gut als eine Art kostenfreie Datenbank in der Cloud verwenden und sich die Daten gut in ein eigenes Chart übertragen liessen. Die verwendeten Software-Komponenten bestehend u.a. aus der AdafruitDHT Bibliothek sind im Jahre 2021 vermutlich nicht mehr ganze State of the Art. Vielleicht wird es mal Zeit für eine Neuauflage. Das Video ist in englischer Sprache.