Ratgeber · 8 Min. Lesezeit

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.

DHT22 Temperatur- und Feuchtigkeitssensor
DHT22 (AM2302): misst −40 bis 80 °C mit ±0,5 °C Genauigkeit und 0–100 % relative Luftfeuchte über eine einzige Datenleitung.

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.

AdresseWas kommt zurück?Wer fragt wann?
/Die HTML-Seite (Layout und JavaScript)Der Browser beim ersten Aufruf
/dataLetzter Messwert, z. B. {"t":23.4,"h":51.2}JavaScript, alle 5 Sekunden
/history5-Minuten-Mittelwerte der letzten 24 StundenJavaScript, 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:

EigenschaftDHT22 (AM2302)DHT11
Temperaturbereich−40 … 80 °C0 … 50 °C
Temperaturgenauigkeit±0,5 °C±2 °C
Feuchtebereich0 … 100 % rF20 … 90 % rF
Feuchtegenauigkeit±2 … 5 % rF±5 % rF
Auflösung0,1 °C / 0,1 %1 °C / 1 %
Kürzestes Leseintervall2 Sekunden1 Sekunde
Versorgungsspannung3,3 … 6 V3,3 … 5,5 V
Stromaufnahme (Messung / Ruhe)1–1,5 mA / 40–50 µA0,5–2,5 mA / 100–150 µA

ESP32 DHT22 Anschluss

DHT22-PinESP32-PinHinweis
VCC (+, Pin 1)3V3Nicht an 5 V; die Datenleitung wird auf diese Spannung hochgezogen
DATA (OUT, Pin 2)GPIO 4Beim nackten Sensor 10 kΩ zwischen DATA und VCC
NC (Pin 3)FreiNur beim 4-poligen nackten Sensor
GND (−, Pin 4)GNDGemeinsame Masse mit dem ESP32
Nimm für DATA weder GPIO 6–11 (am Flash-Speicher) noch GPIO 34–39 (nur Eingang): Der DHT22 empfängt sein Startsignal und sendet seine Daten über dieselbe Leitung und braucht deshalb einen bidirektionalen Pin. Auch GPIO 0, 2, 12 und 15 können das Bootverhalten beeinflussen. GPIO 4, 13, 16–19, 21–23, 25–27, 32 und 33 sind sichere Wahl; die Pinbelegung deines Boards findest du im Tool Pinout.

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

  1. Installiere das ESP32-Boardpaket in der Arduino IDE (Details in Was ist der ESP32?) und wähle unter Werkzeuge > Board ESP32 Dev Module.
  2. Suche im Bibliotheksverwalter nach DHT sensor library (Adafruit) und installiere sie; bestätige die Abhängigkeit Adafruit Unified Sensor.
  3. Die WebServer-Bibliothek ist im ESP32-Paket enthalten und muss nicht extra installiert werden.
  4. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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) + " &deg;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}
Das Handy muss im selben WLAN wie der ESP32 sein; über mobile Daten erreichst du keine 192.168.x.x-Adresse. Der ESP32 sieht nur 2,4-GHz-Netze. Damit sich die IP-Adresse nicht bei jedem Neustart ändert, reservierst du im Router eine feste Adresse für den ESP32 (DHCP-Reservierung, bei der FRITZ!Box „Diesem Netzwerkgerät immer die gleiche IPv4-Adresse zuweisen“). Klappt die Verbindung gar nicht, hilft die Checkliste in ESP32 verbindet sich nicht mit dem WLAN.

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.

C++ (Arduino IDE)
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}
CodeteilWas er macht
READ_MS = 10000Liest den Sensor alle 10 Sekunden (Minimum beim DHT22: 2 Sekunden)
STEP_MS = 300000Speichert 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 ageAbstand 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:

C++ (Arduino IDE)
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> &deg;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}
EigenschaftWebServerESPAsyncWebServer
InstallationIm ESP32-Paket enthaltenESP Async WebServer + Async TCP nötig
Anfragen bearbeitenhandleClient() in loop()Im Hintergrund, im eigenen Task
delay() in loop()Hält auch den Server anStört den Server nicht
Mehrere Clients gleichzeitigNacheinanderMehrere Clients problemlos
WebSocket und SSENeinJa
Wann nehmen?Erstes Projekt, einfache SeiteDiagramme, 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

SymptomWahrscheinliche UrsacheLösung
Seite zeigt immer -- oder nanFalscher DATA-Pin, kein Pull-up, falscher DHT_TYPEAnschlusstabelle prüfen, 10 kΩ ergänzen, DHT22 im Code eintragen
Gelegentlich nanWLAN-Interrupts stören das TimingMit readDHT() dreimal versuchen, letzten gültigen Wert behalten
Temperatur 1–3 °C zu hochAbwärme des ESP32 erreicht den SensorSensor 5–10 cm entfernt am Kabel montieren
Seite lässt sich nicht öffnenHandy in anderem Netz oder IP geändertIns selbe WLAN wechseln, neue IP aus dem seriellen Monitor nehmen
Zahlen da, Diagramm leerChart.js konnte nicht geladen werden (kein Internet)Internet am Handy prüfen oder Datei aus dem LittleFS liefern
Diagramm nach Neustart leerVerlauf liegt im RAMMesspunkte ins LittleFS schreiben oder in die Cloud schicken
Board startet zufällig neuSchwache 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.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

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.

4.8(16)
26
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

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.

4.5(14)
23
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

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.

4.8(14)
23
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

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.

4.5(13)
22