DS18B20 Temperatursensor am Arduino, ESP32 und Pico nutzen

Der DS18B20 ist ein digitaler Temperatursensor und eine der genauesten und flexibelsten Möglichkeiten, mit dem Arduino Temperaturen zu messen. Er misst von −55 °C bis +125 °C, ist zwischen −10 °C und +85 °C auf ±0,5 °C genau und überträgt das Ergebnis nicht als analoge Spannung, sondern direkt als digitale Zahl. Deshalb wird der Messwert auch über lange Kabel nicht verfälscht. Sein größter Trumpf ist die 1-Wire-Kommunikation: Du kannst Dutzende DS18B20 an einen einzigen Datenpin hängen und jeden über seine eigene, eindeutige Adresse einzeln auslesen.

In diesem Artikel erfährst du, wie der DS18B20 funktioniert, wie der 1-Wire-Bus arbeitet, warum er unbedingt einen 4,7-kΩ-Pull-up-Widerstand braucht und was es mit dem wasserdichten Fühler und seinen Aderfarben auf sich hat. Danach gehen wir Schritt für Schritt Code für einen und für mehrere Sensoren mit den Bibliotheken OneWire und DallasTemperature durch, lesen am ESP32 ohne Blockieren aus und nutzen den Sensor mit MicroPython auf dem Raspberry Pi Pico. Am Ende findest du Ursachen und Lösungen für die häufigen Fehlerwerte −127 °C und 85 °C.

Was ist der DS18B20 und wie funktioniert er?

Im DS18B20 stecken ein Temperaturfühler, ein Analog-Digital-Wandler, ein kleiner Speicher (Scratchpad) und eine ab Werk eingebrannte, eindeutige 64-Bit-Seriennummer. Sendet der Mikrocontroller den Messbefehl, misst der Sensor die Temperatur, legt das Ergebnis als Zwei-Byte-Zahl im Speicher ab und wartet darauf, ausgelesen zu werden. Weil der Sensor selbst misst, entstehen keine Fehler durch den Analogeingang des Arduino, seine Referenzspannung oder den Kabelwiderstand. Anders als bei einem NTC-Thermistor brauchst du auch keine Kalibriertabelle oder Formel: Der gelesene Wert ist direkt in Grad Celsius.

Die Auflösung des Sensors stellst du per Software ein. Je höher die Auflösung, desto feiner die Schritte, desto länger aber auch die Wandlungszeit. Standard sind 12 Bit, für die meisten Projekte die richtige Wahl; brauchst du sehr schnelle Messungen, kannst du auf 9 oder 10 Bit heruntergehen.

Was ist 1-Wire? Kommunikation über eine einzige Leitung

Wie der Name schon sagt, überträgt 1-Wire die Daten über eine einzige Leitung, die Masse (GND) ist gemeinsam. Am Bus hängen ein Master (der Arduino) und ein oder mehrere Slaves (die DS18B20). Ist der Bus frei, hält ihn ein Pull-up-Widerstand auf HIGH. Wer senden will, zieht die Leitung kurz auf LOW; die Bits stecken in der Länge dieser LOW-Impulse, gemessen in Mikrosekunden. Jede Übertragung beginnt mit einem Reset-Impuls, und die Sensoren antworten mit einem „Ich bin da“-Impuls (Presence Pulse).

Da kein Gerät die Leitung aktiv auf HIGH treibt (Open-Drain-Aufbau), kannst du beliebig viele Sensoren an denselben Bus hängen, ohne dass es Konflikte gibt. Der Master findet zuerst mit einem Suchbefehl alle 64-Bit-Adressen am Bus, wählt dann den gewünschten Sensor über seine Adresse aus und spricht mit ihm. So brauchst du für Temperaturen an fünf verschiedenen Stellen nicht fünf Pins, sondern nur einen.

DS18B20, DHT11, DHT22 und NTC im Vergleich

Kurz gesagt: Brauchst du auch die Luftfeuchtigkeit, ist der DHT11 oder DHT22 die richtige Wahl. Willst du die Temperatur von Wasser, Erde, einem Rohr oder einer Gefriertruhe messen, mehrere Messstellen mit einem Pin überwachen oder mit Minusgraden arbeiten, ist der DS18B20 unschlagbar.

DS18B20 Pinbelegung und Aderfarben

DS18B20 anschließen: Arduino Uno, ESP32 und Pico

Der Pull-up-Widerstand ist in dieser Schaltung unverzichtbar. Geräte am 1-Wire-Bus können die Leitung nur auf LOW ziehen; erst dieser Widerstand bringt sie wieder auf HIGH. Fehlt er, hängt die Leitung in der Luft, der Sensor wird nicht gefunden und die Bibliothek liefert −127 °C. Ein Wert von 4,7 kΩ zieht die Leitung schnell genug hoch und hält den Strom trotzdem klein: Ist die Leitung LOW, fließen nach dem ohmschen Gesetz I = 5 V / 4700 Ω ≈ 1,06 mA. Ein 4,7-kΩ-Widerstand mit vier Ringen ist gelb, violett, rot und gold beringt; zur Sicherheit kannst du das Farbcode-Werkzeug nutzen. Manche DS18B20-Module (Sensor auf einer kleinen Platine mit Widerstand und LED) haben den Widerstand schon eingebaut; dann musst du keinen zusätzlichen einsetzen.

Bibliotheken installieren

1. Öffne in der Arduino IDE Werkzeuge > Bibliotheken verwalten.
2. Gib DallasTemperature in das Suchfeld ein und installiere die Bibliothek von Miles Burton.
3. Wenn nach Abhängigkeiten gefragt wird, wähle Install all; so wird auch die OneWire-Bibliothek von Paul Stoffregen installiert. Kommt keine Abfrage, suche OneWire und installiere sie separat.
4. Wenn du magst, öffne Datei > Beispiele > DallasTemperature > Simple, passe die Pinnummer an deine Schaltung an und probiere es aus.

Erster Sketch: einen DS18B20 auslesen

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // DS18B20 veri pini (DQ) / data pin (DQ)
5
6OneWire oneWire(ONE_WIRE_BUS);            // 1-Wire hattı / 1-Wire bus
7DallasTemperature sensors(&oneWire);      // sensör kütüphanesi / sensor library
8
9void setup() {
10  Serial.begin(9600);
11  sensors.begin();                        // hattaki sensörleri bul / find sensors on the bus
12  Serial.print(F("Sensor sayisi / Sensor count: "));
13  Serial.println(sensors.getDeviceCount());
14}
15
16void loop() {
17  sensors.requestTemperatures();          // ölçümü başlat, bitmesini bekle / start conversion and wait
18  float tempC = sensors.getTempCByIndex(0);  // ilk sensörün sıcaklığı / first sensor's temperature
19
20  if (tempC == DEVICE_DISCONNECTED_C) {   // -127: sensör yanıt vermedi / sensor did not respond
21    Serial.println(F("Hata: sensor yok / Error: no sensor"));
22  } else {
23    Serial.print(F("Sicaklik / Temperature: "));
24    Serial.print(tempC, 2);
25    Serial.println(F(" C"));
26  }
27  delay(1000);
28}

Stellst du den seriellen Monitor auf 9600 Baud, siehst du jede Sekunde eine Zeile wie „Sicaklik / Temperature: 23.44 C“. Dir wird auffallen, dass sich die letzten Stellen in Schritten von 0,0625 ändern, der Schrittweite bei 12 Bit. Hältst du den Sensor zwischen den Fingern, sollte die Temperatur innerhalb weniger Sekunden steigen. Zeigt der Monitor −127, wird der Sensor gar nicht gefunden; zeigt er 85, wurde er gefunden, aber ausgelesen, bevor die Messung fertig war. Die Lösung für beides steht in der Tabelle am Ende des Artikels.

Mehrere DS18B20 an einem Pin betreiben

Um mehrere Sensoren anzuschließen, verbindest du einfach alle VDD-, GND- und DQ-Anschlüsse parallel; für den ganzen Bus genügt ein einziger 4,7-kΩ-Pull-up-Widerstand. Das Auslesen mit getTempCByIndex() ist bequem, die Reihenfolge richtet sich aber nach den Adressen der Sensoren, nicht danach, in welcher Reihenfolge du sie angesteckt hast. Tauschst du einen Sensor aus, kann sich die Reihenfolge ändern. Deshalb solltest du in dauerhaften Projekten jeden Sensor über seine eigene Adresse auslesen. Der folgende Sketch findet alle Sensoren am Bus, gibt ihre Adressen aus und liest die Temperatur jedes Sensors über seine Adresse:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // tüm sensörler aynı pinde / all sensors on the same pin
5
6OneWire oneWire(ONE_WIRE_BUS);
7DallasTemperature sensors(&oneWire);
8DeviceAddress addr;                       // 8 baytlık sensör adresi / 8-byte sensor address
9int count = 0;
10
11void printAddress(const DeviceAddress a) {
12  for (uint8_t i = 0; i < 8; i++) {
13    Serial.print(F("0x"));
14    if (a[i] < 0x10) Serial.print('0');   // tek haneyi sıfırla tamamla / pad single digit
15    Serial.print(a[i], HEX);
16    if (i < 7) Serial.print(F(", "));
17  }
18}
19
20void setup() {
21  Serial.begin(9600);
22  sensors.begin();
23  count = sensors.getDeviceCount();       // hatta kaç sensör var? / how many sensors on the bus?
24  Serial.print(F("Sensor sayisi / Sensor count: "));
25  Serial.println(count);
26  sensors.setResolution(12);              // hepsi 12 bit (0,0625 C) / all 12-bit (0.0625 C)
27}
28
29void loop() {
30  sensors.requestTemperatures();          // tüm sensörler aynı anda ölçer / all sensors convert at once
31  for (int i = 0; i < count; i++) {
32    if (!sensors.getAddress(addr, i)) continue;   // adresi al / get the address
33    Serial.print(F("Sensor "));
34    Serial.print(i);
35    Serial.print(F(" { "));
36    printAddress(addr);
37    Serial.print(F(" }: "));
38    Serial.print(sensors.getTempC(addr), 2);      // adrese göre oku / read by address
39    Serial.println(F(" C"));
40  }
41  Serial.println();
42  delay(2000);
43}

Lass den Sketch einmal laufen und erwärme die Sensoren nacheinander (zum Beispiel in der Hand), um herauszufinden, welche Adresse zu welcher Messstelle gehört. Trage dann die im seriellen Monitor angezeigte Adresse fest in deinen Code ein: Füge eine Zeile wie DeviceAddress wasserSensor = {0x28, 0xFF, 0x64, 0x1E, 0x0F, 0x16, 0x03, 0x90}; hinzu und lies sie mit sensors.getTempC(wasserSensor) aus. Beim DS18B20 ist das erste Byte der Adresse immer 0x28, das letzte Byte ist eine Prüfsumme (CRC), die die Gültigkeit der Adresse sicherstellt. So kommen die Werte für „Wasser“, „außen“ oder „Kessel“ immer von der richtigen Stelle, egal in welcher Reihenfolge die Sensoren liegen.

DS18B20 am ESP32: auslesen ohne zu blockieren

Am ESP32 funktioniert der DS18B20 mit denselben Bibliotheken OneWire und DallasTemperature. Für die Datenleitung ist GPIO 4 eine gute Wahl. Nutze nicht GPIO 34–39, denn diese Pins sind reine Eingänge und können die 1-Wire-Leitung nicht auf LOW ziehen; meide außerdem GPIO 0, 2, 12 und 15, deren Pegel beim Booten wichtig ist. Schließe Sensor und Pull-up-Widerstand unbedingt an 3V3 an: Hängst du den Pull-up an 5 V, legst du 5 V an einen ESP32-Pin.

requestTemperatures() wartet standardmäßig bei 12 Bit 750 ms. In dieser Zeit kann das Board nichts anderes tun; Webserver, Taster oder Display frieren ein. Die Lösung: Schalte das Warten mit setWaitForConversion(false) ab und lies das Ergebnis 750 ms später mit millis() aus. Im folgenden ESP32-Sketch blinkt die LED auch während der Temperaturmessung ruckelfrei weiter:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int ONE_WIRE_PIN = 4;               // ESP32 GPIO 4 (DQ)
5const int LED_PIN = 2;                    // dahili LED (çoğu kartta) / onboard LED (most boards)
6
7OneWire oneWire(ONE_WIRE_PIN);
8DallasTemperature sensors(&oneWire);
9
10unsigned long requestTime = 0;
11unsigned long lastBlink = 0;
12bool converting = false;
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17  sensors.begin();
18  sensors.setResolution(12);
19  sensors.setWaitForConversion(false);    // requestTemperatures() beklemesin / do not block
20}
21
22void loop() {
23  unsigned long now = millis();
24
25  if (!converting) {
26    sensors.requestTemperatures();        // ölçümü başlat, hemen dön / start and return at once
27    requestTime = now;
28    converting = true;
29  }
30
31  if (converting && now - requestTime >= 750) {   // 12 bit için 750 ms / 750 ms for 12-bit
32    float t = sensors.getTempCByIndex(0);
33    if (t == DEVICE_DISCONNECTED_C) {
34      Serial.println("Sensor yok / No sensor");
35    } else {
36      Serial.printf("Sicaklik / Temperature: %.2f C\n", t);
37    }
38    converting = false;                   // bir sonraki ölçüme geç / move to the next reading
39  }
40
41  if (now - lastBlink >= 250) {           // bu arada LED yanıp söner / meanwhile the LED blinks
42    lastBlink = now;
43    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
44  }
45}

Dieses Muster ist vor allem bei WLAN-Projekten wichtig: Der ESP32 kann Temperaturen messen und gleichzeitig eine Webseite ausliefern, Daten ins Internet schicken oder ein Display aktualisieren. Wenn du neu beim ESP32 bist, findest du Pinwahl und Einrichtung im Artikel Was ist der ESP32?; die Pinbelegung deines Boards zeigt dir das Pinout-Werkzeug.

DS18B20 mit Raspberry Pi Pico und MicroPython

In MicroPython für den Raspberry Pi Pico sind die Module onewire und ds18x20 bereits enthalten; du musst keine zusätzliche Datei hochladen. Schließe den Sensor an 3V3(OUT) und GND an, die Datenleitung an GP22, und vergiss den 4,7-kΩ-Pull-up zwischen DQ und 3V3 nicht. Die internen Pull-up-Widerstände des Pico sind für 1-Wire zu schwach.

1from machine import Pin
2import onewire, ds18x20, time, binascii
3
4ds_pin = Pin(22)                                   # DQ -> GP22 (fiziksel pin 29 / physical pin 29)
5sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
6
7roms = sensor.scan()                               # hattaki sensör adresleri / sensor addresses on the bus
8print("Sensor sayisi / Sensor count:", len(roms))
9
10while True:
11    sensor.convert_temp()                          # hepsi aynı anda ölçer / all sensors convert at once
12    time.sleep_ms(750)                             # 12 bit dönüşüm süresi / 12-bit conversion time
13    for rom in roms:
14        t = sensor.read_temp(rom)                  # adrese göre oku / read by address
15        print(binascii.hexlify(rom).decode(), "{:.2f} C".format(t))
16    time.sleep(2)

scan() liefert eine Liste mit den 8-Byte-Adressen aller Sensoren am Bus. convert_temp() schickt allen Sensoren gleichzeitig den Messbefehl, deshalb wartest du danach 750 ms. read_temp(rom) liest die Temperatur des Sensors mit dieser Adresse in Grad Celsius. Bleibt die Liste leer, prüfe zuerst den Pull-up-Widerstand und die Pinnummer. Wenn du neu beim Pico bist, hilft dir der Artikel Was ist der Raspberry Pi Pico? bei der Einrichtung von MicroPython.

Der wasserdichte DS18B20-Fühler

Die beliebteste Bauform des DS18B20 ist der wasserdichte Fühler, bei dem der Chip in einem Edelstahlröhrchen sitzt und mit Harz vergossen ist. Er besteht meist aus einer Spitze mit 6 mm Durchmesser und 50 mm Länge und einem 1 Meter langen, dreiadrigen Kabel (es gibt auch Versionen mit 2, 3 und 5 Metern). Er eignet sich ideal für Aquarien, Wassertanks, Warmwasserspeicher, Erde, Kühlschränke und Gefriertruhen. Die Edelstahlspitze kannst du kurz in kochendes Wasser halten; da das Kabel aber meist aus PVC besteht, sollten Kabel und Übergang nicht lange über 85–100 °C bleiben. Das Fühlergehäuse verzögert den Wärmeübergang zum Sensor; nach einem plötzlichen Temperaturwechsel kann es einige Sekunden bis einige Dutzend Sekunden dauern, bis sich der Wert eingependelt hat.

Auf dem Markt gibt es viele DS18B20-Nachbauten. Manche erreichen die angegebene Genauigkeit nicht oder funktionieren nicht im parasitären Betrieb. Zwei Sensoren in dasselbe Glas Wasser zu tauchen und ihre Werte zu vergleichen, ist ein einfacher Weg, um zu erkennen, ob deiner zuverlässig ist. Weichen sie um mehr als 0,5 °C ab, kannst du im Code einen kleinen Korrekturwert (Offset) verwenden.

Projektideen mit dem DS18B20

• Aquarium-Thermostat: Schalte mit dem wasserdichten Fühler und einem Relaismodul die Heizung ein und aus; mit einer Hysterese hältst du das Wasser zwischen 25 und 26 °C.
• Temperaturüberwachung an mehreren Stellen: Hänge fünf Sensoren an einen Pin und überwache gleichzeitig Raum, außen, Kühlschrank sowie Vor- und Rücklauf der Heizung.
• OLED-Thermometer: Zeige die Temperatur mit großen Ziffern auf einem OLED-Display an, zusammen mit dem Tagesminimum und -maximum.
• LCD-Temperaturanzeige: Gib die Werte zweier Sensoren auf den beiden Zeilen eines I2C-LCD-Displays aus.
• WLAN-Temperaturseite: Verfolge die vom ESP32 gemessene Temperatur live auf einer Webseite, die du auf dem Handy öffnest.
• Gewächshaus-Steuerung: Miss die Bodentemperatur mit einem DS18B20 und die Bodenfeuchte mit einem Bodenfeuchtesensor und entscheide, wann gegossen wird.

Häufige Fehler und Lösungen

Dank seiner Robustheit, des wasserdichten Fühlers und der Möglichkeit, viele Sensoren an einem Pin zu betreiben, gehört der DS18B20 zu den nützlichsten Temperatursensoren in der Hobbyelektronik. Du kannst die Temperatur auf einem Display anzeigen, mit einem Relais eine Heizung oder einen Lüfter schalten oder sie mit dem ESP32 ins Internet bringen. In der BlueGrays-App findest du Projekte zur Temperaturmessung mit DHT11 und NTC, mit I2C-LCD-Displays, einen ESP32-Temperaturlogger und eine smarte Bewässerung für Arduino und ESP32 mit Schritt-für-Schritt-Schaltplänen und Code.