Temperatursensoren DS18B20 und DHT22/DHT11

Nachdem die ersten Schritte mit dem ESP32 erledigt sind, habe ich als ersten externen Sensor den Temperatursensor DS18B20 ausprobiert. Man kann ihn in mehreren Varianten kaufen, u.a. als halbrundes Kunststoffgehäuse mit drei Anschlusspins zur Montage auf Breadboards oder Platinen und in einer wasserdichten Edelstahlhülse mit dreiadrigem Kabel zum Messen der Temperatur von Flüssigkeiten.
Die Sensoren DHT11 und DHT22 messen neben der (Luft-)Temperatur auch die relative Luftfeuchtigkeit und sind einzeln oder als Modul erhältlich. Sie sind nicht wasserdicht und deshalb eher für den Innenbereich geeignet.

Der interne Temperatursensor des ESP32 ist nicht wirklich zu gebrauchen – zum einen misst er die Temperatur innerhalb des Gehäuses (also die Prozessortemperatur oder etwas ähnliches, das zumindest durch die Prozessortemperatur beeinflusst wird), zum anderen werden die Sensoren bei der Herstellung nicht kalibriert und zeigen je nach Chip andere Werte an. Maximal taugt der Sensor zur Ermittlung von Temperaturdifferenzen. ^[1]»The internal temperature sensor unfortunately has a pretty big random offset that differs from chip to chip. It can be useful to keep track of temperature deltas, but you can’t really … Continue reading Wie man ihn abfragt, habe ich an anderer Stelle beschrieben.

Varianten des DS18B20

Wie oben erwähnt, gibt es den DS18B20 in verschiedenen Ausführungen zu kaufen:

• Am günstigsten ist mit einem Preis von ca. 1 €der einfache Sensor als kleines Bauelement. Der Sensor befindet sich in einem halbrunden Kunststoffgehäuse (Bauform TO-92) mit drei Anschlusspins und kann einfach auf einem Breadboard (Steckplatine) eingesteckt werden. Damit er ausgelesen werden kann, muss zusätzlich ein Pull-Up-Widerstand montiert werden (siehe unten).
• Der DS18B20 wird auch in einer wasserdichten Edelstahlhülse mit Anschlusskabel angeboten. Auch dieser Typ benötigt den Pull-Up-Widerstand für die Datenleitung.
  Damit kann man die Temperatur von Flüssigkeiten messen, z.B. draußen im Gartenteich. Je nach Anbieter gibt es die Kabel ab 1 m bis zu mehreren Metern Länge (Preise ca. 5-8 €). Da der Sensor für einen sehr weiten Messbereich von -55 bis +125 °C ausgelegt ist, eignet er sich auch für heiße Flüssigkeiten. Bei korrosiven Flüssigkeiten (z.B. Salzlauge) muss man aufpassen, dass der Messfühler nicht angegriffen wird.
• Außerdem gibt es Module oder Shields, z.B. zur einfachen Nutzung auf einer Steckplatine oder zum Einstecken in auf einem Board vorhandene Anschlussbuchsen. Üblicherweise ist der Pull-Up-Widerstand dort bereits eingelötet. Ein einfaches Beispiel ist am Ende dieses Beitrags beschrieben.

Installation der Bibliotheken

Für beide Sensor-Typen – DS18B20 und DHT11/DHT22 – stehen passende Bibliotheken zur Nutzung mit der Arduino-IDE zur Verfügung. Die hier erwähnten Bibliotheken funktionieren sowohl mit dem ESP32 als auch mit Arduino-Modellen wie Nano oder Uno.

DS18B20

Zur Programmierung des DS18B20 verwende ich die häufig genutzte Bibliothek DallasTemperature. Diese setzt die OneWire-Library voraus. Alle in diesem Beitrag genannten Bibliotheken können mit der Bibliotheksverwaltung der Arduino-IDE eingerichtet oder manuell von GitHub heruntergeladen werden. Eine ausführliche Beschreibung zur Installation gibt der Beitrag »Arduino-IDE: Bibliotheken verwalten« – speziell am Beispiel dieser Bibliotheken.

OneWire
Die »OneWire«-Bibliothek stellt eine Schnittstelle zu bestimmten Sensoren und anderen Chips bereit, die über einen speziellen Eindraht-Bus kommunizieren.
Projektseite bei GitHub: github.com/PaulStoffregen/OneWire/

DallasTemperature
Die Bibliothek trägt ihren Namen nach dem amerikanischen Halbleiterhersteller Dallas Semiconductor, der u.a. den Temperatursensor DS18B20 entwickelt hat.
Projektseite bei GitHub: github.com/milesburton/Arduino-Temperature-Control-Library

DHT11 und DHT22

Die Sensoren DHT11 und DHT22 zur Temperatur- und Luftfeuchtigkeitsmessung können z.B. über die Bibliothek DHT Sensor von Adafruit abgefragt werden. In der Arduino-Bibliotheksverwaltung wird man mit dem Suchbegriff „dht” fündig.
Die DHT-Sensor-Bibliothek baut auf der Bibliothek Adafruit Unified Sensor Driver auf, die zusätzlich installiert werden muss. Das Vorgehen ist analog; als Suchbegriff kann man z.B. „adafruit” oder „unified” angeben und muss dann in der Liste noch etwas nach „Adafruit Unified Sensor” blättern.

Pull-Up-Widerstand

Die Datenleitung des DS18B20 und des DHT22 (und DHT11) muss über einen Vorwiderstand von 4,7 kΩ (auch als 4K7 bezeichnet) mit den 3,3 Volt des ESP32 verbunden werden. Hierduch wird die Leitung auf einen definierten HIGH-Pegel gezogen – daher der Name »Pull up«-Widerstand.
Verwendet man fertige Module, ist der Widerstand i.d.R. bereits vorhanden, sodass man die Module direkt einsetzen kann. Für den DS18B20 sieht man das sehr gut bei dem unten beschriebenen Shield.

DS18B20 – Schaltung und Programm

Der Vorwiderstand wird mit der Datenleitung des DS18B20 (der gelbe Draht des Sensorkabels; sonst der mittlere Pin) und 3,3 Volt verbunden. Die Datenleitung ist außerdem mit Pin 15 des ESP32 verbunden – oder mit einem anderen Pin, der für digitale Ein-/Ausgabe geeignet ist (am Arduino einer der Pins D2 … D13). Die anderen Pins bzw. Drähte des Sensors verbindet man mit 3,3 V (rote Ader bzw. rechter Pin – von der flachen, beschrifteten Seite aus gesehen) und Masse (GND; schwarze Ader; linker Pin). Am Arduino nutzt man statt des 3,3- den 5V-Pin zur Spannungsversorgung – sowohl der DS18B20 als auch die DHT-Sensoren vertragen beide Spannungen.

Grundsätzlich kann der DS18B20 seine Versorgungsspannung auch über den Datenpin beziehen (sog. parasitärer Modus; nur Masse und Daten sind verbunden)^[2]Im Datenblatt wird der parasitäre Modus ausführlich beschrieben. – es scheint sich aber durchgesetzt zu haben, den V_DD-Pin trotzdem zu verwenden.

Bei der wasserdichten Variante mit Anschlusskabel sind die Adern des Sensorkabels zu weich zur Verwendung in einem Breadboard – sinnvollerweise lötet man feste Drähte oder Pins an (und isoliert sie mit Schrumpfschlauch; siehe im Titelbild des Beitrags) oder behilft sich mit Schraubklemmen oder Krokodilklemmen und Jumperkabeln.

Eine Besonderheit des DS18B20 und verwandter OneWire-Geräte sollte man zum besseren Verständnis kennen: jeder Sensor hat eine eindeutige, 8 Byte lange feste Geräteadresse (ID). Diese ermöglicht es, die Datenpins mehrerer OneWire-Sensoren gleichzeitig an einen einzigen Controller-Pin anzuschließen und die Sensoren gezielt abzufragen. Eine Schaltung mit einem Arduino Nano und mehreren Sensoren findet sich unten. In diesem ersten Beispiel ist nur ein Sensor angeschlossen, deshalb ist keine Schleife zur Abfrage der Sensoren nötig.

Wichtig ist, im Programm den Aufruf von requestTemperatures() nicht zu vergessen – damit fordert man die aktuellen Messwerte an. Vergisst man das, kann man Glück haben und die Sensoren liefern trotzdem richtige (oder zumindest plausible) Werte. Es kann aber auch passieren, dass sie als Fehlercode konstant einen Wert von 85°C ausgeben.^[3]Das ist laut Datenblatt (PDF S. 6; unterhalb von Tabelle 1) der Registerwert nach dem Einschalten des Sensors: »The power-on reset value of the temperature register is +85°C.« Für einen … Continue reading Nach requestTemperatures() fragt man dann die Messwerte der angeschlossenen Sensoren ab, bspw. per getTempC() (für Grad Celsius) bzw. getTempF() (Fahrenheit).
Nutzt man getTempC(), muss man als Parameter die Sensor-Adresse angeben:

     temperatur = ds_sensor.getTempC(addr);

Stattdessen kann man auch die Methode getTempCByIndex() nutzen, der man den Index des Sensors auf dem Bus übergibt (0 für den ersten Sensor, 1 für den zweiten usw.):

     temperatur = ds_sensor.getTempCByIndex(0);

Das Programm ist ausführlich kommentiert, sodass es leicht anzupassen sein sollte. Grundsätzlich ist es nicht nötig, die Sensor-Adresse in jedem Durchlauf der Hauptschleife neu zu ermitteln. Eine einmalige Abfrage (und Anzeige) in der setup()-Routine würde genügen.

/*------------------------------------------------------------
 * Abfrage des DS18B20 Temperatur-Sensors
 *
 * 2021-01-24 Heiko (unsinnsbasis.de)
 *------------------------------------------------------------*/
 
/* ------------------------------------------------------------
 *  Einbinden der benötigten Bibliotheken, 
 *  Defintion des GPIO-Pins und anderer Konstanten,
 *  Anlegen der Datenobjekte
 * ------------------------------------------------------------ */
// Übertragungsrate für Ausgabe zum seriellen Monitor
#define SERIAL_BAUDRATE 9600 // Arduino: 9600, ESP32: z.B. 115200
 
// Einbinden der benötigten Bibliotheken
#include <OneWire.h>
#include <DallasTemperature.h>
 
// Datenleitung des Sensors ist mit Pin GPIO15 des ESP32 verbunden
#define SENSOR_PIN 15
// OneWire-Objekt erstellen ...
OneWire ow(SENSOR_PIN);
// ... und einen Zeiger darauf an ein Sensor-Objekt übergeben
DallasTemperature ds_sensor(&ow);
/* ------------------------------------------------------------ */
void setup(void) {
  Serial.begin(SERIAL_BAUDRATE);  // Baudrate für ser. Schnittstelle setzen
  delay(500);  // kurz warten, bis die ser. Schnittstelle bereit ist
  Serial.println("\n\n");  // Abstand zur vorigen Ausgabe
 
  ds_sensor.begin();     // Sensor initialisieren
}
/* ------------------------------------------------------------ */
void loop(void) {
  byte i;
  DeviceAddress addr;  // ID des Sensors (Adresse)
 
  // ROM-Adresse (ID) des Sensors auf dem OneWire-Bus ermitteln
  if (ds_sensor.getDeviceCount() == 0) {
    Serial.println("-- Kein Sensor gefunden --");
  } else {
    // Adresse des ersten (einzigen) Sensors abfragen (Index 0)
    ds_sensor.getAddress(addr, 0);
    Serial.print("Sensor-Adresse:");
    // Adress-Bytes als Hexadezimalwerte ausgeben
    for (i = 0; i < sizeof(DeviceAddress); i++) {
      Serial.write(' ');
      if (addr[i] < 16)
        Serial.print("0");  // ggf. führende Null ergänzen
      Serial.print(addr[i], HEX);
    }
 
    ds_sensor.requestTemperatures();  // Abfrage der Temperatur starten
    Serial.print("; Temperatur: ");
    Serial.print(ds_sensor.getTempC(addr), 1);  // eine Nachkommastelle
    Serial.println(" °C");
  }
  delay(5000);
}

Die Ausgabe im seriellen Monitor sieht dann wie folgt aus – jedenfalls wenn man den Sensor mangels Sonnenscheins auf der Heizung etwas erwärmt:

Mehrere DS18B20 an einer Datenleitung

Da die DS18B20 über ihre ID eindeutig identifizierbar und adressierbar sind, können mehrere Sensoren an der gleichen Datenleitung betrieben werden (die auch dann über einen Pull-Up-Widerstand mit der Versorgungsspannung verbunden ist). Das Beispiel zeigt die Abfrage von drei Sensoren an einem Arduino-Nano-Klon. Ändert man den Datenpin im Programm passend, kann man das Programm auch auf einem ESP32 laufen lassen.

/*------------------------------------------------------------
 * Mehrere DS18B20 am Arduino Nano
 * 
 * 2021-01-24 Heiko unsinnsbasis.de
 *------------------------------------------------------------*/
 
/* ------------------------------------------------------------
 *  Einbinden der benötigten Bibliotheken, 
 *  Definition des GPIO-Pins und anderer Konstanten,
 *  Anlegen der Datenobjekte
 * ------------------------------------------------------------ */
// Übertragungsrate für Ausgabe zum seriellen Monitor
#define SERIAL_BAUDRATE 9600 // Arduino: 9600, ESP32: z.B. 115200
 
/* ------------------------------------------------------------
 * DS18B20
 * ------------------------------------------------------------ */
#include <OneWire.h>
#include <DallasTemperature.h>
#define DS18B20_PIN 3  // GPIO-Pin für Daten des DS18B20
// OneWire-Objekt erstellen ...
OneWire ow(DS18B20_PIN);
// ... und einen Zeiger darauf an ein Sensor-Objekt übergeben
DallasTemperature ds18b20(&ow);
int ds18b20_num;  // Anzahl der gefundenen Sensoren
 
/* ------------------------------------------------------------ */
 
void setup() {
  int i;
  DeviceAddress ds18b20_id;  // ID des DS18B20 (Adresse)
 
  // Übertragungsrate zum seriellen Monitor setzen
  Serial.begin(SERIAL_BAUDRATE);
  delay(500);  // kurz warten, bis die ser. Schnittstelle bereit ist
  Serial.println("\n\n");  // Abstand zur vorigen Ausgabe
 
  ds18b20.begin();  // Sensoren initialisieren
  // wie viele DS18B20 sind angeschlossen?
  ds18b20_num = ds18b20.getDeviceCount();
  Serial.print("DS18B20: ");
  Serial.print(ds18b20_num);
  Serial.println(" Sensor(en) gefunden");
  // ROM-Adressen (IDs) ermitteln und anzeigen
  for (i=0; i < ds18b20_num; i++) {
    Serial.print("Sensor ");
    Serial.print(i+1);
    if (ds18b20.getAddress(ds18b20_id, i)) {
      Serial.print(": Adresse ");
      printDS18B20Address(ds18b20_id);
      Serial.println();
    } else {
      Serial.println(": Fehler bei Ermittlung der Adresse (Verkabelung ok?)");
    }
  }
  Serial.println();
}
/* ------------------------------------------------------------ */
void loop() {
  int i;
 
  // alle DS18B20 abfragen
  Serial.print("Sensor ");
  ds18b20.requestTemperatures();
  for (i=0; i < ds18b20_num; i++) {
    Serial.print(i+1);
    Serial.print(": ");
    Serial.print(ds18b20.getTempCByIndex(i));
    Serial.print("°C   ");
  }
  Serial.println();
  delay(5000);
}
 
/* ------------------------------------------------------------ 
 *  Ausgabe einer DS18B20-Adresse in den ser. Monitor
 *  byteweise in Hexadezimal-Darstellung
 * ------------------------------------------------------------ */
void printDS18B20Address(DeviceAddress address) {
  for (int i = 0; i < 8; i++) {
    if (address[i] < 16)
      Serial.print("0");
    Serial.print(address[i], HEX);
    Serial.print(" ");
  }
}

DHT22 und DHT11 – Messung von Temperatur und relativer Luftfeuchtigkeit

Den DHT22 (andere Bezeichnung: AM2302) und den DHT11 erhält man einzeln oder als Modul. Im Beispiel verwende ich das DHT22-Modul direkt mit dem ESP32. Die drei Pins sind in der Vorder-Ansicht von links nach rechts: GND (Masse), V_CC (Versorgungsspannung) und DATA (Daten).

Beim Sensor „solo” schließt man die Pins 1 (V_CC), 2 (DATA) und 4 (GND) an; außerdem benötigt man einen Widerstand mit 4,7 kΩ, den man wie beim DS18B20 mit dem Datenpin des Sensors und V_CC (3,3 V) verbindet. Laut Datenblatt kann man gegen Störsignale noch einen 100 nF-Kondensator zwischen V_CC und GND setzen. Auf dem Modul sind beide Bauelemente bereits enthalten.

Der DHT22 kommuniziert zwar auch über ein Eindraht-Protokoll, das aber nicht kompatibel mit dem des DS18B20 ist. Deshalb muss man andere Bibliotheken als die für den DSB18B20 installieren (s.o.).

Laut Datenblatt sollte man den Sensor nicht öfter als einmal pro Sekunde abfragen; zwei Sekunden zwischen den Messungen werden empfohlen. Das ist im Programm berücksichtigt. Für die Ansteuerung wird der Pin GPIO25 genutzt. Mit ein paar Steckbrücken oder Jumperkabeln ist der Aufbau des Moduls ganz einfach.

/* Abfrage des DHT22-Sensors
 *
 * 2019-05-11 Heiko (unsinnsbasis.de)
 */
 
#include <Adafruit_Sensor.h>
#include <DHT.h>
 
#define DHTPIN 25     // Digital-Pin für Sensor-DATA
 
// Sensor-Typ: DHT11, DHT21 (AM2301) oder DHT22 (AM2302)
#define DHTTYPE DHT22
 
DHT dht(DHTPIN, DHTTYPE);  // Datenstruktur anlegen
 
float temp, hum;  // Variablen für Temperatur und Luftfeuchtigkeit
 
void setup(){
  Serial.begin(115200);
  dht.begin();
}
 
void loop(){
  /* Temperatur auslesen (Default: Grad Celsius)
   * je nach Erfolg Fehlermeldung (der Sensor hat keinen Zahlenwert geliefert)
   * oder Sensorwert ausgeben
   */
  temp = dht.readTemperature();
  if (isnan(temp)) {    
    Serial.println("Fehler beim Auslesen des DHT-Sensors.");
  } else {
    Serial.print("Temperatur: ");
    Serial.println(temp);
  }
 
  /* gleiches Vorgehen für die Luftfeuchtigkeit */
  hum = dht.readHumidity();
  if (isnan(hum)) {
    Serial.println("Fehler beim Auslesen des DHT-Sensors.");
  } else {
    Serial.print("Luftfeuchtigkeit: ");
    Serial.println(hum);
  }
  delay(2000); // vor der nächsten Messung etwas warten  
}

Der DHT11 ist weniger leistungsfähig als der DTH22; m.W. ist er dessen Vorgänger. Er hat kleinere Messbereiche für Temperatur und relative Luftfeuchtigkeit und misst deutlich ungenauer. Dafür ist er aber nur ungefähr halb so teuer – für das Modul zahlt man im deutschen Versandhandel etwa 3,50 €, während das DHT22-Modul ca. 7 € kostet – die Sensoren ohne Modul kosten jeweils rund 2 € weniger (Stand: November 2020). Die wichtigsten technischen Unterschiede listet die Tabelle unten auf. DHT11-Module findet man im Handel oft auch unter der Bezeichnung »KY-015«.

Die Programmierung erfolgt genau wie beim DHT22 – man ändert lediglich den Sensortyp in der #define-Anweisung im Programmkopf:

Eine Beispielschaltung mit dem DHT11 und einem Arduino Nano enthält der Beitrag zum OLED-Display SSD1306 – sie bietet aber nichts Neues gegenüber obigem Beispiel mit dem DHT22.

Beim Aufbau auf der Steckplatine muss man die unterschiedliche Anordnung der Pins beachten. Sie lautet (jeweils v.l.n.r. in der Frontansicht der Module):

• DHT11-Modul: VCC – DAT – GND (+ OUT –)
• DHT22-Modul: GND – VCC – DAT

Es gibt auch Module, bei denen die Sensoren anders (über Kopf) eingelötet sind, dann ändert sich die Anordnung der Pins entsprechend (meist sind linker und rechter Pin getauscht). Wie immer sollte man sich an der Beschriftung des Bauteils orientieren, das man in der Hand hält – nicht daran, was irgendwo im Web steht! 😉
Auch der DHT11 „solo” benötigt einen ca. 5 kΩ großen Vorwiderstand (also 4,7 oder 5,1 kΩ) zwischen DATA-Pin und V_CC, der auf dem Modul bereits eingelötet ist, und kann höchstens einmal pro Sekunde abgefragt werden (empfohlen werden ebenfalls mindestens 2 s zwischen den Messungen).

Vergleich verschiedener Temperatur-Sensoren

Die folgende Tabelle enthält eine Übersicht der technischen Daten verschiedener Sensoren zur Messung von Temperatur (und Luftfeuchtigkeit).
Eine Gegenüberstellung der Messwerte mehrerer Sensoren zeigt der Beitrag »13 Temperatursensoren im Vergleich«.

Material-Liste

• ESP32 und Breadboard
• ein paar Jumperkabel und Steckbrücken
• DS18B20 oder DHT22/DHT11
• Widerstand 4,7 kΩ (Farbcode gelb – lila – rot – gold oder gelb – lila – schwarz – braun – braun) – bei den DHT-Modulen ist er bereits eingelötet

Datenblätter

• DS18B20
• DHT22
• DHT11

Platine zur einfachen Nutzung des DS18B20

Unter dem Namen Shield, ^[4]Streng genommen sind Shields Platinen, die auf die Pinleisten, die auf anderen Platinen angebracht sind, aufgesteckt werden. Oft sind die Pins durchgeführt, sodass man mehrere Shields übereinander … Continue reading Modul oder Breakout Board gibt es für viele Sensoren kleine Platinen zur einfachen Montage zu kaufen, meist bereits mit fest verlöteten Sensoren. Da bereits alle zusätzlichen Bauteile wie z.B. Widerstände und Kondensatoren vorhanden sind, müssen nur noch die Anschlüsse mit dem Mikrocontroller verbunden werden – i.d.R. Masse, Versorgungsspannung und je nach Sensor ein oder zwei Datenleitungen. Mit passenden Jumper-Kabeln (female-female; zwei Buchsen) braucht man dann nicht einmal ein Breadboard.

Diese unbestückte Platine für den DS18B20 (und andere OneWire-Komponenten) kostet pro Stück je nach Händler und Anzahl weniger als 50 Cent bis zu 2 oder 3 Euro (zuzüglich des Preises für den Sensor). ^[5]Es empfiehlt sich eine Produktsuche z.B. nach „ds18b20 shield” – mit der Bezeichnung „YL-10” auf der abgebildeten Platine findet man nichts Sinnvolles. Man steckt das Bauteil ein und verbindet die Versorgungs- und Datenleitungen – fertig. Der nötige Widerstand ist bereits vorhanden, und die Platine hat auch noch eine LED zur Funktionskontrolle an Bord. Auch eine Bohrung zur stabilen Befestigung ist vorhanden. Wegen der LED eignet sich so ein Shield aber nicht unbedingt für Projekte mit Batterie- oder Akkubetrieb, wo es auf minimalen Stromverbrauch ankommt.