ESP32 DHT22 Webserver: Temperatur, Luftfeuchte und 24h-Diagramm
ESP32 DHT22 Webserver bauen: Anschluss, Code für WebServer und AsyncWebServer, Seite mit Auto-Refresh, 24h-Diagramm mit Chart.js und Hilfe bei nan-Werten.
Ein ESP32 DHT22 Webserver ist der schnellste Weg, einen Temperatur- und Feuchtesensor ins WLAN zu bringen und die Werte im Browser deines Handys abzulesen. Der ESP32 misst und betreibt gleichzeitig einen kleinen Webserver; du brauchst weder einen zusätzlichen PC noch eine App oder einen Cloud-Dienst. Jedes Handy, Tablet oder Notebook im selben Netz sieht die aktuellen Werte, sobald es die IP-Adresse des ESP32 aufruft.
In dieser Anleitung gehen wir Schritt für Schritt vor: Zuerst schließen wir den DHT22 richtig an und lesen ihn zuverlässig aus, dann bauen wir eine einfache Seite, die sich selbst neu lädt, und zum Schluss zeichnen wir mit Chart.js den Verlauf von Temperatur und Luftfeuchtigkeit der letzten 24 Stunden. Denselben Server schreibst du einmal mit der Standardbibliothek WebServer und einmal mit ESPAsyncWebServer. Außerdem klären wir, woher der berüchtigte "nan"-Wert kommt und was sich mit einem DHT11 ändert.

Wie funktioniert ein ESP32 DHT22 Webserver?
Das System besteht aus drei Teilen. Der ESP32 meldet sich als Client (Station-Modus) in deinem Heimnetz an und bekommt vom Router eine IP-Adresse. Im Hintergrund liest er den DHT22 in festen Abständen aus und merkt sich den letzten gültigen Wert. Ruft der Browser deines Handys diese IP-Adresse auf, schickt der ESP32 eine HTML-Seite; ein paar Zeilen JavaScript darin holen danach alle paar Sekunden nur noch die Zahlen (JSON) und aktualisieren die Anzeige, ohne die ganze Seite neu zu laden. Für das Diagramm schreibt der ESP32 alle 5 Minuten einen Mittelwert in einen Ringpuffer; der Browser holt diese Liste ab und zeichnet sie mit Chart.js.
| Adresse | Was kommt zurück? | Wer fragt wann? |
|---|---|---|
| / | Die HTML-Seite (Layout und JavaScript) | Der Browser beim ersten Aufruf |
| /data | Letzter Messwert, z. B. {"t":23.4,"h":51.2} | JavaScript, alle 5 Sekunden |
| /history | 5-Minuten-Mittelwerte der letzten 24 Stunden | JavaScript, einmal pro Minute |
Bauteile und technische Daten des DHT22
Du brauchst ein ESP32-Entwicklungsboard (DevKit V1, NodeMCU-32S o. Ä.), einen DHT22-Sensor oder ein 3-poliges DHT22-Modul, beim nackten Sensor einen 10-kΩ-Widerstand, ein Steckbrett, Jumperkabel und ein 2,4-GHz-WLAN. Der DHT22 wird auch als AM2302 verkauft; in der Version mit Kabel ist der Pull-up-Widerstand bereits eingebaut. Die Tabelle vergleicht den DHT22 mit seinem günstigeren Bruder DHT11:
| Eigenschaft | DHT22 (AM2302) | DHT11 |
|---|---|---|
| Temperaturbereich | −40 … 80 °C | 0 … 50 °C |
| Temperaturgenauigkeit | ±0,5 °C | ±2 °C |
| Feuchtebereich | 0 … 100 % rF | 20 … 90 % rF |
| Feuchtegenauigkeit | ±2 … 5 % rF | ±5 % rF |
| Auflösung | 0,1 °C / 0,1 % | 1 °C / 1 % |
| Kürzestes Leseintervall | 2 Sekunden | 1 Sekunde |
| Versorgungsspannung | 3,3 … 6 V | 3,3 … 5,5 V |
| Stromaufnahme (Messung / Ruhe) | 1–1,5 mA / 40–50 µA | 0,5–2,5 mA / 100–150 µA |
ESP32 DHT22 Anschluss
| DHT22-Pin | ESP32-Pin | Hinweis |
|---|---|---|
| VCC (+, Pin 1) | 3V3 | Nicht an 5 V; die Datenleitung wird auf diese Spannung hochgezogen |
| DATA (OUT, Pin 2) | GPIO 4 | Beim nackten Sensor 10 kΩ zwischen DATA und VCC |
| NC (Pin 3) | Frei | Nur beim 4-poligen nackten Sensor |
| GND (−, Pin 4) | GND | Gemeinsame Masse mit dem ESP32 |
Beim 3-poligen Modul sitzen der Pull-up-Widerstand und meist ein kleiner Kondensator schon auf der Platine; du kannst es direkt anschließen. Beim 4-poligen nackten Sensor gehört ein Widerstand von 4,7–10 kΩ zwischen DATA und VCC; ohne ihn hängt die Leitung in der Luft und die meisten Messungen schlagen fehl. Bei 3,3 V sollte das Kabel kürzer als 1 Meter sein; für längere Strecken nimm 4,7 kΩ und ein verdrilltes Kabel. Setz den Sensor außerdem nicht direkt neben den ESP32: WLAN-Chip und Spannungsregler erwärmen das Board, und der Sensor misst dann 1–2 °C zu viel.
Bibliotheken installieren
- Installiere das ESP32-Boardpaket in der Arduino IDE (Details in Was ist der ESP32?) und wähle unter Werkzeuge > Board ESP32 Dev Module.
- Suche im Bibliotheksverwalter nach DHT sensor library (Adafruit) und installiere sie; bestätige die Abhängigkeit Adafruit Unified Sensor.
- Die WebServer-Bibliothek ist im ESP32-Paket enthalten und muss nicht extra installiert werden.
- Für die Async-Version installierst du ESP Async WebServer und Async TCP (von ESP32Async). Die alten, nicht mehr gepflegten me-no-dev-Versionen lassen sich mit neuen ESP32-Paketen oft nicht kompilieren.
Schritt 1: DHT22 auslesen und "nan" vermeiden
Teste den Sensor zuerst allein, bevor du den Webteil ergänzt. Schlägt eine Messung fehl, liefert die Adafruit-Bibliothek statt einer Zahl NaN (not a number), und im seriellen Monitor steht "nan". Prüfe deshalb jeden Wert mit isnan(), verwirf die fehlerhafte Messung und versuche es nach 2 Sekunden erneut. Die Funktion readDHT() im folgenden Code versucht es dreimal; scheitern alle drei Versuche, gibt sie false zurück und du arbeitest einfach mit dem letzten gültigen Wert weiter.
1#include <DHT.h>
2
3#define DHT_PIN 4 // DHT22 DATA → GPIO 4
4#define DHT_TYPE DHT22 // DHT11 için DHT11 yaz / write DHT11 for a DHT11
5
6DHT dht(DHT_PIN, DHT_TYPE);
7
8// 3 denemeli güvenli okuma / safe read with 3 attempts
9bool readDHT(float &t, float &h) {
10 for (int i = 0; i < 3; i++) {
11 h = dht.readHumidity();
12 t = dht.readTemperature();
13 if (!isnan(t) && !isnan(h)) return true; // ikisi de geçerli / both valid
14 delay(2100); // DHT22 iki okuma arası en az 2 sn ister / DHT22 needs 2 s between reads
15 }
16 return false;
17}
18
19void setup() {
20 Serial.begin(115200);
21 dht.begin();
22 delay(2000); // sensörün açılmasını bekle / let the sensor power up
23}
24
25void loop() {
26 float t, h;
27 if (readDHT(t, h)) {
28 float hi = dht.computeHeatIndex(t, h, false); // hissedilen sıcaklık / heat index
29 Serial.printf("Sicaklik / Temp: %.1f C Nem / Humidity: %.1f %% Hissedilen / Feels like: %.1f C\n", t, h, hi);
30 } else {
31 Serial.println("DHT okunamadi, kabloyu ve pini kontrol et / DHT read failed, check wiring and pin");
32 }
33 delay(5000);
34}Öffne den seriellen Monitor mit 115200 Baud. Alle 5 Sekunden sollte eine Zeile mit Temperatur, Luftfeuchte und gefühlter Temperatur (Hitzeindex) erscheinen. Kommt ständig "DHT read failed", liegt es fast immer an der Hardware: DATA am falschen Pin, fehlender Pull-up, Sensor an 5 V oder falscher DHT_TYPE. Vereinzelte Aussetzer sind dagegen normal: WLAN-Interrupts können das Mikrosekunden-Timing des Sensors stören, und ein zweiter Versuch löst das.
Schritt 2: einfache Webseite mit Auto-Refresh (WebServer)
Unser erster Server ist so einfach wie möglich: Der ESP32 verbindet sich mit dem WLAN und schickt bei Aufruf der Startadresse (/) eine HTML-Seite mit dem letzten Messwert in großen Ziffern. Das meta refresh-Tag im Kopf sagt dem Browser, die Seite alle 10 Sekunden neu zu laden; so bekommst du eine fast live laufende Anzeige, ohne eine Zeile JavaScript zu schreiben. Trag dein WLAN und Passwort ein, lade den Sketch hoch und öffne die IP-Adresse aus dem seriellen Monitor auf dem Handy.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <DHT.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8DHT dht(4, DHT22); // DATA → GPIO 4
9WebServer server(80);
10
11float t = NAN, h = NAN; // son geçerli ölçüm / last valid reading
12unsigned long lastRead = 0;
13
14void handleRoot() {
15 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
16 "<meta name='viewport' content='width=device-width,initial-scale=1'>"
17 "<meta http-equiv='refresh' content='10'>" // 10 sn'de bir yenile / reload every 10 s
18 "<title>ESP32 DHT22</title></head>"
19 "<body style='font-family:sans-serif;text-align:center'><h2>ESP32 + DHT22</h2>";
20 if (isnan(t) || isnan(h)) {
21 html += "<p>Sensor okunamadi / Sensor read failed</p>";
22 } else {
23 html += "<p style='font-size:44px'>" + String(t, 1) + " °C</p>";
24 html += "<p style='font-size:44px'>" + String(h, 1) + " %</p>";
25 }
26 html += "</body></html>";
27 server.send(200, "text/html", html);
28}
29
30void setup() {
31 Serial.begin(115200);
32 dht.begin();
33 WiFi.mode(WIFI_STA);
34 WiFi.begin(ssid, password);
35 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
36 Serial.print("\nIP: ");
37 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
38 server.on("/", handleRoot);
39 server.begin();
40}
41
42void loop() {
43 server.handleClient(); // gelen istekleri cevapla / answer incoming requests
44 if (millis() - lastRead >= 5000) { // 5 sn'de bir oku / read every 5 s
45 lastRead = millis();
46 float nt = dht.readTemperature();
47 float nh = dht.readHumidity();
48 if (!isnan(nt) && !isnan(nh)) { t = nt; h = nh; } // hatalı ölçümü at / drop failed readings
49 }
50}Schritt 3: 24-Stunden-Diagramm mit Chart.js
Meta refresh ist einfach, lädt aber jedes Mal die ganze Seite und zeigt keinen Verlauf. Machen wir es besser: Die Seite wird einmal geladen, die Werte kommen per JavaScript-fetch() alle 5 Sekunden als JSON von /data, und das Diagramm holt sich seine Daten von /history. Teilt man 24 Stunden in 5-Minuten-Abschnitte, ergibt das 24 × 12 = 288 Messpunkte. Jeder Punkt speichert je einen 4-Byte-Float für Temperatur und Feuchte, also 288 × 2 × 4 = 2.304 Byte, rund 2,3 KB RAM; bei 520 KB im ESP32 ist das fast nichts.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <DHT.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8#define DHT_PIN 4 // DHT22 DATA → GPIO 4
9#define DHT_TYPE DHT22 // DHT11 için DHT11 / DHT11 for a DHT11
10DHT dht(DHT_PIN, DHT_TYPE);
11WebServer server(80);
12
13const unsigned long READ_MS = 10000; // 10 sn'de bir ölç / read every 10 s
14const unsigned long STEP_MS = 300000; // 5 dk'da bir kaydet / store every 5 min
15const int N = 288; // 24 sa × 12 = 288 kayıt / 24 h × 12 = 288 samples
16
17float temps[N], hums[N]; // halka tampon / ring buffer
18int count = 0, head = 0; // dolu kayıt, sıradaki yer / stored samples, next slot
19float lastT = NAN, lastH = NAN; // son geçerli ölçüm / last valid reading
20float sumT = 0, sumH = 0; // 5 dk ortalaması için / for the 5-min average
21int sumN = 0;
22unsigned long lastRead = 0, lastStep = 0;
23
24const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html>
25<html><head><meta charset="utf-8">
26<meta name="viewport" content="width=device-width,initial-scale=1">
27<title>ESP32 DHT22</title>
28<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
29<style>
30body{font-family:sans-serif;margin:16px;background:#f2f4f7;color:#222}
31.box{display:inline-block;background:#fff;border-radius:12px;padding:10px 18px;margin:4px;font-size:30px}
32small{display:block;font-size:13px;color:#666}
33</style></head><body>
34<h2>ESP32 + DHT22</h2>
35<div class="box"><small>Sıcaklık / Temperature</small><span id="t">--</span> °C</div>
36<div class="box"><small>Nem / Humidity</small><span id="h">--</span> %</div>
37<canvas id="c" height="240"></canvas>
38<script>
39const $ = id => document.getElementById(id);
40const fmt = v => v === null ? '--' : v.toFixed(1);
41const chart = new Chart($('c'), {
42 type: 'line',
43 data: { labels: [], datasets: [
44 { label: '°C', data: [], borderColor: '#e4572e', yAxisID: 'y' },
45 { label: '%', data: [], borderColor: '#2e86de', yAxisID: 'y1' } ] },
46 options: { animation: false, elements: { point: { radius: 0 } },
47 scales: { y: { position: 'left' }, y1: { position: 'right', grid: { drawOnChartArea: false } } } }
48});
49function live() {
50 fetch('/data').then(r => r.json()).then(d => { $('t').textContent = fmt(d.t); $('h').textContent = fmt(d.h); });
51}
52function loadHistory() {
53 fetch('/history').then(r => r.json()).then(d => {
54 const n = d.t.length, end = Date.now() - d.age * 1000;
55 chart.data.labels = d.t.map((_, i) => new Date(end - (n - 1 - i) * d.step * 1000).toTimeString().slice(0, 5));
56 chart.data.datasets[0].data = d.t;
57 chart.data.datasets[1].data = d.h;
58 chart.update();
59 });
60}
61live(); loadHistory();
62setInterval(live, 5000);
63setInterval(loadHistory, 60000);
64</script></body></html>)HTML";
65
66// NaN JSON'da geçersizdir, null gönder / NaN is invalid JSON, send null
67String num(float v) { return isnan(v) ? String("null") : String(v, 1); }
68
69bool readDHT(float &t, float &h) { // 3 denemeli okuma / read with 3 attempts
70 for (int i = 0; i < 3; i++) {
71 h = dht.readHumidity();
72 t = dht.readTemperature();
73 if (!isnan(t) && !isnan(h)) return true;
74 delay(2100);
75 }
76 return false;
77}
78
79void handleRoot() { server.send(200, "text/html", PAGE); }
80
81void handleData() {
82 server.send(200, "application/json", "{\"t\":" + num(lastT) + ",\"h\":" + num(lastH) + "}");
83}
84
85void handleHistory() {
86 String t, h;
87 t.reserve(2048);
88 h.reserve(2048);
89 for (int i = 0; i < count; i++) {
90 int k = (head - count + i + N) % N; // en eskiden en yeniye / oldest to newest
91 if (i) { t += ','; h += ','; }
92 t += num(temps[k]);
93 h += num(hums[k]);
94 }
95 String json = "{\"step\":" + String(STEP_MS / 1000) + ",\"age\":" + String((millis() - lastStep) / 1000) +
96 ",\"t\":[" + t + "],\"h\":[" + h + "]}";
97 server.send(200, "application/json", json);
98}
99
100void setup() {
101 Serial.begin(115200);
102 dht.begin();
103 WiFi.mode(WIFI_STA);
104 WiFi.begin(ssid, password);
105 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
106 Serial.print("\nIP: ");
107 Serial.println(WiFi.localIP());
108 server.on("/", handleRoot);
109 server.on("/data", handleData);
110 server.on("/history", handleHistory);
111 server.begin();
112}
113
114void loop() {
115 server.handleClient();
116 unsigned long now = millis();
117 if (lastRead == 0 || now - lastRead >= READ_MS) {
118 lastRead = now;
119 float t, h;
120 if (readDHT(t, h)) { lastT = t; lastH = h; sumT += t; sumH += h; sumN++; }
121 }
122 // ilk kayıt hemen, sonra 5 dk'da bir ortalama / first sample at once, then a 5-min average
123 if ((count == 0 && sumN > 0) || (count > 0 && now - lastStep >= STEP_MS)) {
124 temps[head] = sumN ? sumT / sumN : NAN; // ölçüm yoksa boşluk / gap if no reading
125 hums[head] = sumN ? sumH / sumN : NAN;
126 head = (head + 1) % N;
127 if (count < N) count++;
128 sumT = sumH = 0;
129 sumN = 0;
130 lastStep = now;
131 }
132}| Codeteil | Was er macht |
|---|---|
| READ_MS = 10000 | Liest den Sensor alle 10 Sekunden (Minimum beim DHT22: 2 Sekunden) |
| STEP_MS = 300000 | Speichert den Mittelwert aller Messungen aus 5 Minuten als einen Punkt |
| temps[N], hums[N] | Ringpuffer mit 288 Plätzen; wenn er voll ist, wird der älteste Punkt überschrieben |
| num() | Macht aus NaN ein null, das in JSON gültig ist |
| /history: step und age | Abstand der Punkte und Alter des neuesten Punkts; daraus berechnet der Browser die Uhrzeiten |
| setInterval(live, 5000) | Aktualisiert die großen Zahlen alle 5 Sekunden |
Zwei Details sind wichtig. Erstens kennt JSON keinen Wert NaN: Schreibst du bei einem Sensorfehler "nan" in die Antwort, wirft der JSON-Parser im Browser einen Fehler und die Seite wirkt eingefroren. Deshalb schickt num() stattdessen null, und Chart.js zeichnet null-Werte als Lücke. Zweitens muss der ESP32 die Uhrzeit nicht aus dem Internet holen: Der Browser nimmt seine eigene Uhr und setzt jeden Punkt „so viele Schritte vor jetzt“. Willst du echte Zeitstempel, ergänze die Methode aus ESP32 NTP-Uhrzeit.
Chart.js wird beim Öffnen der Seite vom CDN jsDelivr geladen; das Handy braucht also Internetzugang, um das Diagramm anzuzeigen. Läuft der ESP32 nur als eigener Access Point (AP-Modus) oder gibt es zu Hause kein Internet, legst du chart.umd.min.js (etwa 200 KB) ins LittleFS und lieferst die Datei direkt vom ESP32 aus. Wie das mit LittleFS geht, steht in ESP32 Async Webserver und WebSocket.
Derselbe Server mit AsyncWebServer
Die Standardbibliothek WebServer arbeitet synchron: Solange server.handleClient() in loop() nicht aufgerufen wird, beantwortet sie keine Anfrage. Wartet readDHT() bei Wiederholungen ein paar Sekunden, reagiert auch die Seite so lange nicht. ESPAsyncWebServer bearbeitet Anfragen dagegen im Hintergrund in einem eigenen Task; die Seite öffnet sich sofort, egal was loop() gerade tut, und mehrere Handys können gleichzeitig zugreifen. Der folgende Code liefert denselben /data-Endpunkt mit der Async-Bibliothek:
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4#include <DHT.h>
5
6const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9DHT dht(4, DHT22); // DATA → GPIO 4
10AsyncWebServer server(80);
11float lastT = NAN, lastH = NAN; // loop() yazar, sunucu okur / loop() writes, server reads
12
13const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
14<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 DHT22</title></head>
15<body style="font-family:sans-serif;text-align:center"><h2>ESP32 + DHT22 (Async)</h2>
16<p style="font-size:44px"><span id="t">--</span> °C</p>
17<p style="font-size:44px"><span id="h">--</span> %</p>
18<script>
19const fmt = v => v === null ? '--' : v.toFixed(1);
20function live() {
21 fetch('/data').then(r => r.json()).then(d => {
22 document.getElementById('t').textContent = fmt(d.t);
23 document.getElementById('h').textContent = fmt(d.h);
24 });
25}
26live(); setInterval(live, 5000);
27</script></body></html>)HTML";
28
29String num(float v) { return isnan(v) ? String("null") : String(v, 1); }
30
31void setup() {
32 Serial.begin(115200);
33 dht.begin();
34 WiFi.mode(WIFI_STA);
35 WiFi.begin(ssid, password);
36 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
37 Serial.print("\nIP: ");
38 Serial.println(WiFi.localIP());
39
40 server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
41 request->send(200, "text/html", PAGE);
42 });
43 server.on("/data", HTTP_GET, [](AsyncWebServerRequest *request) { // burada sensör okunmaz / no sensor read here
44 request->send(200, "application/json", "{\"t\":" + num(lastT) + ",\"h\":" + num(lastH) + "}");
45 });
46 server.begin(); // istekler arka planda karşılanır / requests are handled in the background
47}
48
49void loop() {
50 static unsigned long lastRead = 0;
51 if (millis() - lastRead >= 10000) { // 10 sn'de bir oku / read every 10 s
52 lastRead = millis();
53 float t = dht.readTemperature();
54 float h = dht.readHumidity();
55 if (!isnan(t) && !isnan(h)) { lastT = t; lastH = h; }
56 }
57}| Eigenschaft | WebServer | ESPAsyncWebServer |
|---|---|---|
| Installation | Im ESP32-Paket enthalten | ESP Async WebServer + Async TCP nötig |
| Anfragen bearbeiten | handleClient() in loop() | Im Hintergrund, im eigenen Task |
| delay() in loop() | Hält auch den Server an | Stört den Server nicht |
| Mehrere Clients gleichzeitig | Nacheinander | Mehrere Clients problemlos |
| WebSocket und SSE | Nein | Ja |
| Wann nehmen? | Erstes Projekt, einfache Seite | Diagramme, mehrere Nutzer, Live-Daten |
In der Async-Version gilt eine Regel: Lies den Sensor in loop(), nicht beim Eintreffen einer Anfrage, und halte das Ergebnis in einer globalen Variablen. Rufst du delay() oder eine langsame Sensormessung im Request-Handler auf, blockierst du den Task der Async-Bibliothek und Verbindungen brechen ab. Die Diagrammseite und den /history-Handler aus Schritt 3 überträgst du genauso; du ersetzt nur server.send() durch request->send().
Leseintervall: Wie oft sollte man den DHT22 auslesen?
Laut Datenblatt braucht der DHT22 mindestens 2 Sekunden zwischen zwei Messungen; liest du öfter, überspringt die Adafruit-Bibliothek die neue Messung und gibt den alten Wert zurück, oder der Sensor meldet einen Fehler. Die Raumtemperatur ändert sich ohnehin nicht im Sekundentakt, deshalb sind 10–60 Sekunden in der Praxis ideal. Sehr häufiges Abfragen kann den Sensor leicht erwärmen und die Feuchte zu niedrig erscheinen lassen. Für das Diagramm 5-Minuten-Mittelwerte statt Einzelwerte zu speichern, glättet das Rauschen und spart Speicher. Bei einer Station mit Akku schickst du den ESP32 zwischen den Messungen schlafen, wie in ESP32 Deep Sleep beschrieben.
Mit DHT11 verwenden: Was muss sich ändern?
Hast du einen DHT11, funktioniert der gesamte Code; ändere nur die Zeile #define DHT_TYPE DHT11, die Verdrahtung bleibt gleich. Der Unterschied liegt in der Messqualität: Der DHT11 misst 0–50 °C mit ±2 °C Genauigkeit in ganzen Graden und die Luftfeuchte nur zwischen 20 und 90 %. Dein Diagramm sieht dann treppenförmig aus und zeigt nie Minusgrade; für Balkon, Kühlschrank oder Gewächshaus nimm deshalb den DHT22. Typische DHT11-Probleme behandelt DHT11 Temperatur- und Feuchtigkeitssensor.
Projektideen mit dem ESP32 DHT22 Webserver
- Babyzimmer-Monitor: Zeig über 26 °C eine rote Warnung auf der Seite und schick dir eine Nachricht mit einem Telegram-Bot.
- Raumthermostat: Schalte mit einem Relaismodul Heizlüfter oder Ventilator bei einem Grenzwert, den du auf der Webseite einstellst.
- Langzeit-Logger: Schick die 5-Minuten-Mittelwerte in eine Google-Sheets-Tabelle und sammle Daten über Monate.
- Smart Home: Übertrage die Werte per MQTT an Home Assistant und nutze sie in Automationen.
- Station mit Display: Zeig dieselben Werte zusätzlich auf einem OLED-Display, damit du sie ohne Browser ablesen kannst.
- Messung in mehreren Räumen: Stell in jeden Raum einen ESP32 und sammle die Daten per ESP-NOW auf einem Hauptboard.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Seite zeigt immer -- oder nan | Falscher DATA-Pin, kein Pull-up, falscher DHT_TYPE | Anschlusstabelle prüfen, 10 kΩ ergänzen, DHT22 im Code eintragen |
| Gelegentlich nan | WLAN-Interrupts stören das Timing | Mit readDHT() dreimal versuchen, letzten gültigen Wert behalten |
| Temperatur 1–3 °C zu hoch | Abwärme des ESP32 erreicht den Sensor | Sensor 5–10 cm entfernt am Kabel montieren |
| Seite lässt sich nicht öffnen | Handy in anderem Netz oder IP geändert | Ins selbe WLAN wechseln, neue IP aus dem seriellen Monitor nehmen |
| Zahlen da, Diagramm leer | Chart.js konnte nicht geladen werden (kein Internet) | Internet am Handy prüfen oder Datei aus dem LittleFS liefern |
| Diagramm nach Neustart leer | Verlauf liegt im RAM | Messpunkte ins LittleFS schreiben oder in die Cloud schicken |
| Board startet zufällig neu | Schwache USB-Versorgung (Brownout) | Gutes Kabel und 5-V-Netzteil mit mindestens 1 A verwenden |
Der kleine Webserver aus ESP32 und DHT22 ist die Grundlage für größere Projekte wie Thermostat, Gewächshaus oder Wetterstation: Tausch den Sensor, und dieselbe Seitenstruktur zeigt Bodenfeuchte, Luftqualität oder Luftdruck. Wenn du die Schaltung Schritt für Schritt aufbauen möchtest, findest du in der BlueGrays-App bei den Projekten ESP32 DHT22 Temperatur und Feuchte, Async Web Server und Temperatur-Logger die Schaltpläne und fertigen Code.
Häufige Fragen
Warum zeigt der DHT22 am ESP32 nan an?
Die Adafruit-Bibliothek gibt NaN zurück, sobald eine Messung fehlschlägt. Häufige Ursachen sind ein falscher DATA-Pin, ein fehlender 10-kΩ-Pull-up, ein im Code vergessener DHT_TYPE oder Abfragen öfter als alle 2 Sekunden. Prüfe die Verdrahtung, verwirf Fehlmessungen mit isnan() und versuche es 2 Sekunden später erneut.
Funktioniert der DHT22 mit 3,3 V?
Ja, der DHT22 arbeitet zwischen 3,3 und 6 V und sollte am ESP32 aus dem 3V3-Pin versorgt werden, damit auch die Datenleitung bei 3,3 V bleibt. An 5 V zieht der Pull-up die Datenleitung auf 5 V, und das kann einen ESP32-Pin beschädigen, weil der ESP32 nicht 5-V-tolerant ist.
Wie erreiche ich den ESP32-Webserver von unterwegs?
Der Server aus dieser Anleitung funktioniert nur im Heimnetz. Eine Portfreigabe im Router macht das Gerät aus dem Internet erreichbar und ist ein Sicherheitsrisiko. Sicherer ist es, die Werte an einen Dienst wie MQTT, Telegram oder Google Sheets zu schicken oder sich per VPN ins Heimnetz einzuwählen.
DHT22 oder DHT11: Welcher Sensor ist besser?
Für eine einfache Anzeige im Wohnzimmer reicht ein DHT11, aber sein Fehler von ±2 °C und die ganzzahligen Stufen fallen im Diagramm deutlich auf. Für draußen, Minusgrade oder einen glatten Verlauf nimm den DHT22 mit ±0,5 °C; der Preisunterschied ist gering.
Kann ich ESP32 und DHT22 über ein Hutschienennetzteil versorgen?
Ja. Ein 5-V-Hutschienennetzteil kommt an den 5V- bzw. VIN-Pin des ESP32, der DHT22 hängt am 3V3-Pin des Boards. Bei einem 12- oder 24-V-Netzteil brauchst du zusätzlich einen Step-down-Wandler auf 5 V, etwa ein LM2596-Modul; die Masse muss gemeinsam sein.
Bleibt der 24-Stunden-Verlauf nach einem Stromausfall erhalten?
In diesem Beispiel nicht: Die Messpunkte liegen im RAM und sind nach einem Stromausfall oder Neustart weg. Wenn sie bleiben sollen, schreib sie regelmäßig ins LittleFS, speichere sie auf einer SD-Karte oder schick sie an einen Cloud-Dienst wie Google Sheets.
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 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

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.

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

ESP32: Echtzeit aus dem Internet per NTP
Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.
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

