DHT22 Failed to Read: Ursachen und Lösungen für DHT11 und DHT22
DHT22 failed to read oder nan? Falscher Pin oder Typ, fehlender Pull-up, Leseintervall, ESP32 und lange Kabel: Ursachen, Lösungen und ein Diagnose-Sketch.
Wenn im seriellen Monitor immer wieder Failed to read from DHT sensor! steht oder statt Temperatur und Luftfeuchtigkeit nur nan erscheint, ist das der häufigste Fehler mit DHT11 und DHT22. Die gute Nachricht: Der Sensor ist fast nie kaputt. Die Ursache ist meist eines von sechs Dingen: Die Pinnummer im Code passt nicht zur Verkabelung, der Sensortyp ist falsch (DHT22 statt DHT11 oder umgekehrt), am nackten Sensor fehlt der Pull-up-Widerstand, der Sensor wird zu oft oder direkt nach dem Einschalten gelesen, der ESP32 hat Versorgungs- oder Timingprobleme oder das Kabel ist zu lang.
In dieser Anleitung siehst du zuerst, was die Fehlermeldung genau bedeutet, dann die richtige Verkabelung und eine Tabelle mit Symptom, Ursache und Lösung. Danach gehen wir jede Ursache einzeln durch und schreiben einen Diagnose-Sketch, der den Sensortyp selbst erkennt und die Erfolgsquote misst, einen fehlertoleranten Lese-Sketch und ein MicroPython-Skript für den Raspberry Pi Pico, das die Fehlerarten unterscheidet. Zum Schluss klären wir, wann du den DHT gegen einen I2C-Sensor wie den AHT20 oder SHT31 tauschen solltest.

Was bedeutet "Failed to read from DHT sensor"?
Die Meldung stammt nicht aus der Bibliothek selbst, sondern aus dem Beispiel DHTtester, das mit der Adafruit-DHT-Bibliothek geliefert wird. Das Beispiel gibt sie aus, wenn readTemperature() oder readHumidity() statt einer Zahl NaN (Not a Number, keine Zahl) zurückgibt. Die Bibliothek liefert NaN in zwei Fällen: wenn der Sensor gar nicht auf das Startsignal antwortet (Timeout) oder wenn die Prüfsumme der empfangenen 40 Bit nicht stimmt (beschädigte Daten). Ersteres deutet meist auf Verkabelung, Pin, Typ oder Versorgung hin, Letzteres auf Timing, Störungen und lange Kabel.
Warum das so oft passiert, zeigt ein Blick auf das Protokoll. Der Arduino weckt den Sensor, indem er die Datenleitung eine Zeit lang auf LOW hält; der Sensor antwortet mit 80 µs LOW und 80 µs HIGH und sendet dann 40 Bit: 16 Bit Feuchte, 16 Bit Temperatur und 8 Bit Prüfsumme. Jedes Bit beginnt mit 50 µs LOW; dauert das folgende HIGH etwa 26–28 µs, ist das Bit 0, dauert es etwa 70 µs, ist es 1. Der Mikrocontroller muss also Unterschiede von wenigen zehn Mikrosekunden lückenlos messen; ein lockeres Kabel, ein schwacher Pull-up oder ein dazwischenfunkender Interrupt bringen das leicht durcheinander.
| Eigenschaft, die das Lesen beeinflusst | DHT11 | DHT22 (AM2302) |
|---|---|---|
| Gehäusefarbe | Blau | Weiß |
| Versorgung | 3–5,5 V | 3,3–6 V |
| Startimpuls der Bibliothek | 20 ms LOW | 1,1 ms LOW |
| Kürzestes Leseintervall | 1 Sekunde | 2 Sekunden |
| Wartezeit nach dem Einschalten | Mindestens 1 Sekunde | Mindestens 1 Sekunde, sicherer 2 |
| Typ im Code | DHT11 | DHT22 |
Richtige Verkabelung: Arduino Uno, ESP32 und Pico
| DHT-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+) | 5V | 3V3 | 3V3 (OUT) |
| DATA (OUT, S) | D2 | GPIO 4 | GP15 |
| GND (−) | GND | GND | GND |
| Pull-up (nur beim nackten Sensor) | 10 kΩ zwischen DATA und 5V | 10 kΩ zwischen DATA und 3V3 | 10 kΩ zwischen DATA und 3V3 |
| Sensor über einen Pin versorgen (zuverlässiger Lese-Sketch) | D7 | GPIO 25 | Nicht genutzt |
Tabelle: Symptom, Ursache und Lösung
Die folgende Tabelle ordnet die häufigsten Symptome ihren Ursachen zu. Such dein Symptom und probiere zuerst die Lösung in dieser Zeile; die Details stehen in den Abschnitten danach:
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Jede Messung nan, gar keine Werte | Anderer Pin im Code, Datenkabel am falschen Pin oder keine Versorgung | Pinnummer mit der Verkabelung vergleichen, Spannung zwischen VCC und GND mit dem Multimeter messen |
| Sensor ist ein DHT11, immer nan | Im Code steht DHT22; der 1,1-ms-Startimpuls ist für den DHT11 zu kurz | Im Code DHT11 eintragen |
| Kein Fehler, aber unsinnige Werte (z. B. 0,1 °C und 16 %) | Sensor ist ein DHT22, im Code steht DHT11 | Im Code DHT22 eintragen |
| Mal klappt es, mal nan | Kein Pull-up am nackten Sensor, lockeres Steckbrett oder Jumperkabel | 4,7–10 kΩ zwischen DATA und VCC setzen, Kabel sichern |
| Nur die erste Messung ist nan | Der Sensor wird direkt nach dem Einschalten gelesen | Nach begin() 2 Sekunden warten |
| Nach einem Fehler 2 Sekunden lang nan | Zu häufiges Lesen; die Bibliothek wiederholt innerhalb von 2 s das letzte Ergebnis | Mindestens 2 Sekunden zwischen den Messungen lassen |
| Ab und zu nan am ESP32 | WLAN und Tasks stören das Timing, langes Kabel an 3,3 V | Erneut versuchen, letzten gültigen Wert behalten, Kabel kürzen |
| ESP32 liest nie | GPIO 34–39 gewählt oder ein 5-V-Modul zieht die Datenleitung auf 5 V | Einen bidirektionalen Pin wie GPIO 4 nutzen, Modul an 3V3 betreiben |
| Fehler bei langem Kabel (ab 3 m) | Die Kabelkapazität verschleift die Signalflanken, die Spannung fällt ab | Mit 5 V versorgen, 4,7-kΩ-Pull-up nehmen, verdrilltes Kabel wählen |
| Nach Stunden nur noch nan, Reset hilft | Der Sensor hat sich aufgehängt | Sensor über einen GPIO versorgen und nach einer Fehlerserie aus- und einschalten |
1. Falscher Pin oder falscher Sensortyp
Auf dem Arduino Uno bedeutet #define DHTPIN 2 den Digitalpin 2, also D2; nicht A2 und nicht das zweite Bein auf der Platine. Beim ESP32 sind die Zahlen GPIO-Nummern und stimmen meist mit der Beschriftung des Entwicklungsboards überein. Bei ESP8266-Boards (NodeMCU, Wemos D1 mini) lauert eine Falle: Der mit D4 beschriftete Pin ist in Wirklichkeit GPIO 2; im Code musst du D4 oder 2 schreiben, mit 4 spricht die Bibliothek einen anderen Pin an. Am ESP32 sind GPIO 34–39 reine Eingänge und daher für den DHT ungeeignet, dessen Datenleitung als Aus- und Eingang dient. GPIO 6–11 sind für den Flash-Speicher reserviert und bringen das Board zum Absturz.
Der Typ ist genauso wichtig wie der Pin. Schreibst du DHT11, weckt die Bibliothek den Sensor mit einem 20-ms-LOW-Impuls, bei DHT22 mit einem 1,1-ms-Impuls. Ein DHT11 braucht mindestens 18 ms; liest du einen DHT11 als DHT22, bekommst du meist gar keine Antwort und das Ergebnis ist nan. Umgekehrt ist es tückischer: Der DHT22 antwortet auch auf den langen Impuls, die Bibliothek dekodiert die Bytes aber im DHT11-Format. Es gibt keine Fehlermeldung, nur unsinnige Werte: In einem Raum mit 23,5 °C und 65 % Luftfeuchte siehst du 0,1 °C und 16 %. Ein blaues Gehäuse heißt DHT11, ein weißes DHT22; auch der weiße AM2302 mit Kabel ist ein DHT22.
2. Pull-up-Widerstand: Modul oder nackter Sensor?
Die Datenleitung des DHT arbeitet als Open-Drain: Der Sensor zieht die Leitung nur auf LOW, den HIGH-Pegel liefert ein Pull-up-Widerstand. Bei 3-poligen Modulen auf einer kleinen Platine ist dieser Widerstand (meist 10 kΩ, manchmal 4,7 kΩ) schon vorhanden. Beim 4-beinigen nackten Sensor musst du ihn selbst zwischen DATA und VCC setzen; das Datenblatt empfiehlt etwa 5 kΩ, in der Praxis funktionieren 4,7 bis 10 kΩ gut. Die Bibliothek schaltet den Pin beim Lesen auf INPUT_PULLUP, doch der interne Pull-up des Mikrocontrollers liegt bei etwa 20–50 kΩ und ist viel zu schwach. Bei einem kurzen Kabel reicht er manchmal, und genau deshalb bedeutet "mal klappt es, mal nan" fast immer einen fehlenden Pull-up. Die Grundlagen erklären wir in Pull-up- und Pull-down-Widerstand, den Wert eines Widerstands liest du mit dem Werkzeug Widerstands-Farbcode ab.

3. Leseintervall und Startzeit
Ein DHT11 schafft höchstens eine neue Messung pro Sekunde, ein DHT22 eine alle zwei Sekunden. Die Adafruit-Bibliothek schützt das für dich: Sind seit der letzten Messung keine 2 Sekunden vergangen, fragt sie den Sensor gar nicht und gibt das letzte Ergebnis zurück. Hier steckt das Detail, das viele übersehen: War das letzte Ergebnis ein Fehler, liefert auch jeder Aufruf in den nächsten 2 Sekunden nan. Ein Sketch, der alle 100 ms liest, macht aus einem einzigen Fehler einen Block von 20 nan-Zeilen. Die Lösung ist einfach: Lass mindestens 2 Sekunden zwischen den Messungen und lies im selben Durchlauf zuerst die Temperatur, dann die Feuchte; der zweite Aufruf nutzt dieselbe Messung.
Auch der Start ist eine Falle. Laut Datenblatt ist der Sensor in der ersten Sekunde nach dem Einschalten instabil und nimmt keine Befehle an. Liest du in setup() direkt nach dht.begin(), ist der erste Wert oft nan. 2 Sekunden Wartezeit nach begin() beseitigen das Problem vollständig. Willst du den 2-Sekunden-Cache der Bibliothek bewusst umgehen, nimm readTemperature(false, true); der zweite Parameter erzwingt eine neue Messung.
4. DHT am ESP32: 3,3 V und Timing
Am ESP32 treten zwei Probleme am häufigsten auf. Das erste ist die Spannung: Versorgst du ein 3-poliges Modul mit 5 V, zieht sein Pull-up-Widerstand auch die Datenleitung auf 5 V, die Pins des ESP32 vertragen aber nur 3,3 V. Versorge das Modul über den 3V3-Pin; DHT11 und DHT22 funktionieren mit dieser Spannung. Brauchst du wegen eines langen Kabels 5 V, schließe die Datenleitung über einen Pegelwandler an. Das zweite ist das Timing: Die Bibliothek sperrt beim Lesen die Interrupts, am ESP32 betrifft das aber nur den Kern, auf dem dein Code läuft. Der WLAN-Stack auf dem anderen Kern und Wartezeiten des Flash-Speichers können trotzdem gelegentlich eine Messung verfälschen. In einem WLAN-Projekt ist es normal, dass einige von 100 Messungen scheitern; deshalb solltest du am ESP32 immer erneut lesen und den letzten gültigen Wert behalten.
Ist die Fehlerquote hoch, lies den Sensor nicht in den Momenten mit der meisten WLAN-Last, etwa mitten in einer Web-Anfrage, und achte auf Anzeichen eines Brownouts: Eine 3,3-V-Schiene, die beim Start des WLANs einbricht, senkt auch die Versorgung des Sensors. Die für ESP32 und ESP8266 geschriebene Bibliothek DHTesp stimmt das Timing auf diese Chips ab und liefert auf manchen Boards stabilere Ergebnisse.
5. Lange Kabel und Störungen
Setzt du den Sensor ans andere Ende des Raums oder nach draußen, steigt die Fehlerquote. Dafür gibt es zwei Gründe: Die Kapazität eines langen Kabels verlangsamt die steigende Flanke und verwischt den Unterschied zwischen 26 µs und 70 µs, der 0- und 1-Bits trennt, und in einem dünnen Kabel fällt zusätzlich Spannung ab. Bei Kabeln über ein paar Meter versorgst du den Sensor mit 5 V, senkst den Pull-up auf 4,7 kΩ und führst die Datenleitung als verdrilltes Paar mit GND; ein Adernpaar eines Netzwerkkabels ist dafür ideal. Das Datenblatt empfiehlt für Kabel bis 20 Meter einen Pull-up von etwa 5 kΩ, mit Jumperkabeln musst du aber schon ab 3–5 Metern mit Problemen rechnen. Brauchst du über größere Entfernung nur die Temperatur, kommt der DS18B20 viel besser mit langen Kabeln zurecht.
Diagnose-Sketch zum Testen des Sensors (Uno und ESP32)
Der folgende Sketch nutzt Pin D2 am Arduino Uno und GPIO 4 am ESP32; das Board erkennt er selbst. Beim Start versucht er, den Sensor zuerst als DHT22 und dann als DHT11 zu lesen, und wählt den Typ, der physikalisch mögliche Werte liefert (−40 bis 80 °C, 0 bis 100 %). Danach liest er alle 2,5 Sekunden und gibt die Erfolgsquote aus. Öffne den seriellen Monitor mit 115200 Baud:
1// DHT teşhis kodu: tipi bulur, başarı oranını ölçer (Uno ve ESP32) / DHT diagnostic: finds the type, measures the success rate (Uno and ESP32)
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4; // ESP32: GPIO 4 (34-39 olmaz / never 34-39)
6#else
7const int DHT_PIN = 2; // Uno ve Nano: D2 / Uno and Nano: D2
8#endif
9
10DHT asDht22(DHT_PIN, DHT22);
11DHT asDht11(DHT_PIN, DHT11);
12DHT *sensor = nullptr; // bulunan tip / detected type
13unsigned long okCount = 0, failCount = 0;
14
15bool plausible(float t, float h) { // fiziksel olarak mümkün mü? / physically possible?
16 return !isnan(t) && !isnan(h) && t > -40 && t < 80 && h >= 0 && h <= 100;
17}
18
19bool tryRead(DHT &d) {
20 float t = d.readTemperature(false, true); // force: 2 sn önbelleğini atla / force: skip the 2 s cache
21 float h = d.readHumidity(); // aynı ölçümü kullanır / reuses the same reading
22 return plausible(t, h);
23}
24
25void detect() {
26 for (int i = 0; i < 2 && !sensor; i++) { // önce iki kez DHT22 gibi dene / first try twice as DHT22
27 if (tryRead(asDht22)) sensor = &asDht22;
28 delay(2500);
29 }
30 if (!sensor && tryRead(asDht11)) sensor = &asDht11; // sonra DHT11 gibi / then as DHT11
31 if (sensor == &asDht22) Serial.println(F("DHT22 / AM2302 bulundu / found"));
32 else if (sensor == &asDht11) Serial.println(F("DHT11 bulundu / found"));
33 else Serial.println(F("Yanit yok: pin, kablo, besleme, pull-up / no reply: pin, wiring, power, pull-up"));
34}
35
36void setup() {
37 Serial.begin(115200);
38 asDht22.begin();
39 asDht11.begin();
40 delay(2000); // açılıştan sonra bekle / wait after power-up
41 detect();
42}
43
44void loop() {
45 delay(2500); // DHT22 için en az 2 sn / at least 2 s for the DHT22
46 if (!sensor) {
47 detect(); // bulunana kadar yeniden dene / retry until found
48 return;
49 }
50 float t = sensor->readTemperature(false, true);
51 float h = sensor->readHumidity();
52 if (isnan(t) || isnan(h)) failCount++;
53 else okCount++;
54 Serial.print(F("T: "));
55 Serial.print(t, 1);
56 Serial.print(F(" C H: %"));
57 Serial.print(h, 1);
58 Serial.print(F(" Basari / success: %"));
59 Serial.println(100.0 * okCount / (okCount + failCount), 0);
60}So deutest du das Ergebnis: Steht dort Yanit yok / no reply, antwortet der Sensor als keiner der beiden Typen; prüfe Pin, Versorgung und Pull-up in der Reihenfolge oben. Wurde ein Typ gefunden, schau auf die Erfolgsquote. Am Arduino Uno mit kurzem Kabel sollte sie 100 % betragen. An einem ESP32 mit WLAN ist alles über 95 % in Ordnung. Unter 90 % liegt das Problem sehr wahrscheinlich am Pull-up, an einem Wackelkontakt oder am langen Kabel. Tauschst du den Sensor und siehst dieselbe Quote, liegt es nicht am Sensor, sondern an der Schaltung.
Fehlertolerantes Lesen: Wiederholungen und Sensor aus- und einschalten
In einem echten Projekt darf ein einzelnes nan nie auf dem Display, in einer Datenbank oder in einer Relaisentscheidung landen. Der folgende Sketch liest alle 3 Sekunden, nutzt nach einer fehlgeschlagenen Messung weiter den letzten gültigen Wert und schaltet den Sensor nach fünf Fehlern in Folge aus und wieder ein. Dazu hängt VCC des Sensors statt an 5V oder 3V3 an einem GPIO (D7 am Uno, GPIO 25 am ESP32). Ein DHT braucht höchstens 2,5 mA, ein Pin versorgt ihn also problemlos, und Sensoren, die sich nach Stunden aufhängen, erholen sich so ohne Reset. delay() kommt nur beim Neustart des Sensors vor; den Rest der Zeit ist die Schleife frei für andere Aufgaben.
1// Güvenilir DHT okuma: son iyi değer, hata sayacı, sensörü kapatıp açma / reliable DHT reading: last good value, error counter, sensor power cycle
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4;
6const int DHT_POWER_PIN = 25; // sensörün VCC'si bu pinden / the sensor's VCC comes from this pin
7#else
8const int DHT_PIN = 2;
9const int DHT_POWER_PIN = 7;
10#endif
11#define DHT_TYPE DHT22 // DHT11 kullanıyorsan DHT11 yaz / write DHT11 for a DHT11
12
13DHT dht(DHT_PIN, DHT_TYPE);
14const unsigned long READ_EVERY_MS = 3000; // 3 sn'de bir oku / read every 3 s
15const int MAX_FAILS = 5; // 5 hata = 15 sn / 5 errors = 15 s
16unsigned long lastRead = 0;
17float lastTemp = NAN, lastHum = NAN; // son geçerli değerler / last valid values
18int failStreak = 0;
19
20void powerCycleSensor() {
21 pinMode(DHT_PIN, OUTPUT);
22 digitalWrite(DHT_PIN, LOW); // veri hattından beslenmesin / no power through the data line
23 digitalWrite(DHT_POWER_PIN, LOW); // sensörü kapat / switch the sensor off
24 delay(1000);
25 digitalWrite(DHT_POWER_PIN, HIGH); // yeniden aç / switch it back on
26 dht.begin(); // veri pinini yeniden hazırlar / sets the data pin up again
27 delay(2000); // açılış süresi / start-up time
28}
29
30void setup() {
31 Serial.begin(115200);
32 pinMode(DHT_POWER_PIN, OUTPUT);
33 digitalWrite(DHT_POWER_PIN, HIGH);
34 dht.begin();
35 delay(2000);
36}
37
38void loop() {
39 if (millis() - lastRead >= READ_EVERY_MS) {
40 lastRead = millis();
41 float t = dht.readTemperature();
42 float h = dht.readHumidity();
43 if (isnan(t) || isnan(h)) {
44 failStreak++;
45 Serial.print(F("Okuma hatasi / read error #"));
46 Serial.println(failStreak);
47 if (failStreak >= MAX_FAILS) {
48 Serial.println(F("Sensor yeniden baslatiliyor / power-cycling the sensor"));
49 powerCycleSensor();
50 failStreak = 0;
51 }
52 } else {
53 failStreak = 0;
54 lastTemp = t;
55 lastHum = h;
56 }
57 if (!isnan(lastTemp)) { // ekranda hep son iyi değer / always show the last good value
58 Serial.print(F("T: "));
59 Serial.print(lastTemp, 1);
60 Serial.print(F(" C H: %"));
61 Serial.println(lastHum, 1);
62 }
63 }
64 // diğer işler burada bekletilmeden çalışır / other tasks run here without waiting
65}Test mit dem Raspberry Pi Pico (MicroPython)
Die MicroPython-Firmware des Pico enthält ein fertiges dht-Modul für DHT11 und DHT22, du musst also keine Bibliothek installieren. Das Schöne daran: Es unterscheidet die beiden Fehlerarten. Antwortet der Sensor gar nicht, kommt OSError: [Errno 110] ETIMEDOUT; kommen Daten an, aber die Prüfsumme stimmt nicht, kommt checksum error. Ersteres deutet auf Verkabelung, Pin und Versorgung, Letzteres auf Störungen, einen schwachen Pull-up und lange Kabel. Schließe den Sensor an 3V3, GND und GP15 an und starte das Skript in Thonny:
1# DHT testi (Raspberry Pi Pico, MicroPython): hata türlerini ayırır / DHT test: tells the error types apart
2import dht
3import time
4from machine import Pin
5
6sensor = dht.DHT22(Pin(15)) # GP15; DHT11 için dht.DHT11 / dht.DHT11 for a DHT11
7time.sleep(2) # açılış süresi / start-up time
8ok = 0
9fail = 0
10
11while True:
12 try:
13 sensor.measure()
14 t = sensor.temperature()
15 h = sensor.humidity()
16 ok += 1
17 print("T: {:.1f} C H: {:.1f} %".format(t, h))
18 except OSError as e: # ETIMEDOUT: sensör cevap vermedi / the sensor did not answer
19 fail += 1
20 print("Cevap yok / no reply:", e)
21 except Exception as e: # checksum error: veri bozuk geldi / the data arrived corrupted
22 fail += 1
23 print("Bozuk veri / corrupted data:", e)
24 print("Basari / success: {}%".format(100 * ok // (ok + fail)))
25 time.sleep(2.5) # DHT22 için en az 2 sn / at least 2 s for the DHT22Wann lohnt sich der Umstieg auf AHT20 oder SHT31?
Bleibt die Fehlerquote nach all diesen Prüfungen hoch oder brauchst du genauere Messwerte, ist es vielleicht Zeit, den DHT abzulösen. Sensoren wie AHT20, SHT31 und BME280 kommunizieren über I2C: Das Timing übernimmt der Sensor selbst, der Mikrocontroller liest nur das fertige Ergebnis. Deshalb laufen sie am ESP32 auch bei eingeschaltetem WLAN stabil und können sich die beiden Leitungen mit einem OLED-Display teilen. Einen Vorteil hat der DHT noch: Er lässt sich mit einer einzigen Leitung ein paar Meter entfernt betreiben; I2C ist für kurze Kabel gedacht.
| Sensor | Schnittstelle | Temperaturgenauigkeit | Feuchtegenauigkeit | Wann wählen? |
|---|---|---|---|---|
| DHT11 | Eindraht | ±2 °C | ±5 % | Schulversuche, grobe Raumüberwachung |
| DHT22 (AM2302) | Eindraht | ±0,5 °C | ±2–5 % | Wo ein Kabel von ein paar Metern nötig ist |
| AHT20 | I2C (0x38) | ±0,3 °C | ±2 % | Günstiger, stabiler Ersatz für den DHT |
| SHT31 | I2C (0x44 oder 0x45) | ±0,3 °C | ±2 % | Genaue Messung, draußen, Kondensat dank eingebauter Heizung |
| BME280 | I2C oder SPI | ±1 °C | ±3 % | Wenn du auch den Luftdruck brauchst |
Kurz gesagt: Für Projekte in Innenräumen, bei denen der Sensor nah am Board sitzt, ist der AHT20 der einfachste Umstieg; Details findest du in AHT10 und AHT20. In Gewächshaus, Bad oder draußen, wo die Feuchte über 90 % steigt, hält der SHT31 länger, weil seine Heizung Kondensat entfernen kann. Willst du auch den Luftdruck, liefert der BME280 alle drei Messwerte in einem Sensor. Alle Temperatursensoren nebeneinander siehst du im Vergleich der Temperatursensoren.
Zusammengefasst stecken hinter "DHT22 failed to read" fast immer Pin, Typ, Pull-up, Leseintervall, Versorgung oder Kabel, und der Diagnose-Sketch zeigt in wenigen Minuten, was davon. Die Grundlagen zum Sensor findest du in DHT11 Temperatur- und Feuchtigkeitssensor. Sobald dein Sensor zuverlässig misst, kannst du in der BlueGrays-App mit den Projekten zu Temperatur und Feuchte mit dem DHT11, zum ESP32 mit DHT22 und LCD und zum ESP32-Temperaturlogger weitermachen, jeweils mit Schaltplan und fertigem Code.
Häufige Fragen
Warum zeigt mein DHT22 nan an?
nan bedeutet, dass die Bibliothek keine gültige Antwort vom Sensor bekommen hat. Die häufigsten Ursachen sind eine Pinnummer, die nicht zur Verkabelung passt, ein falscher Typ im Code, ein fehlender Pull-up am nackten Sensor und Messungen im Abstand von weniger als 2 Sekunden. Der Diagnose-Sketch grenzt die Ursache in wenigen Minuten ein.
DHT22 failed to read am ESP32: was tun?
Versorge den Sensor über 3V3, nutze einen bidirektionalen Pin wie GPIO 4 statt GPIO 34–39 und lass mindestens 2 Sekunden zwischen den Messungen. Mit WLAN scheitern gelegentlich einzelne Messungen; lies erneut und behalte den letzten gültigen Wert. Bei hoher Fehlerquote hilft oft die Bibliothek DHTesp.
Braucht der DHT22 einen Pull-up-Widerstand?
Der nackte 4-beinige Sensor braucht ihn; setze 4,7–10 kΩ zwischen DATA und VCC. 3-polige Module haben ihn schon auf der Platine. Der interne Pull-up des Mikrocontrollers ist zu schwach, wer sich nur auf ihn verlässt, bekommt sporadische Fehler.
Läuft der DHT22 mit 3,3 V?
Ja, der DHT22 arbeitet mit 3,3–6 V und der DHT11 mit 3–5,5 V; am ESP32 und Pico empfiehlt sich 3V3. Bei 3,3 V solltest du das Kabel kurz halten, weil der Spannungsabfall auf langen Leitungen die Messung stört. Für mehrere Meter Kabel ist eine 5-V-Versorgung mit Pegelwandler sicherer.
Wie oft darf man einen DHT22 auslesen?
Einen DHT22 höchstens alle zwei Sekunden, einen DHT11 höchstens einmal pro Sekunde. Bei Aufrufen in kürzerem Abstand gibt die Adafruit-Bibliothek ohne Messung das letzte Ergebnis zurück, und war es ein Fehler, wiederholt sich auch das nan. Für die Raumüberwachung genügt eine Messung alle 5–60 Sekunden völlig.
Welcher Sensor ist besser als der DHT22?
Für stabilere und genauere Messungen sind die I2C-Sensoren AHT20 und SHT31 eine gute Wahl; sie steuern ihr Timing selbst und laufen am ESP32 auch mit WLAN zuverlässig. In sehr feuchter Umgebung ist der SHT31 mit Heizung besser, für zusätzlichen Luftdruck der BME280. Brauchst du nur die Temperatur über ein langes Kabel, nimm einen DS18B20.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

Punktmatrix-Uhr, Kalender und Wetterstation (MAX7219, DS1307)
Eine Laufschrift-Tafel für Tisch oder Wand, die abwechselnd Uhrzeit, Datum und das Raumklima zeigt.

Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

ESP32 HTTPClient + Wetter-API (mit LCD-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

