Guide · 9 min di lettura

ESP32 DHT22 web server: temperatura, umidità e grafico di 24 ore

Web server con ESP32 e DHT22: collegamenti, codice WebServer e AsyncWebServer, pagina che si aggiorna da sola, grafico 24 ore con Chart.js e stop ai valori nan.

Un web server con ESP32 e DHT22 è il modo più rapido per portare un sensore di temperatura e umidità sul Wi-Fi e leggere i valori nel browser del telefono. L'ESP32 misura e nello stesso tempo fa girare un piccolo web server: non servono un altro computer, un'app o un servizio cloud. Qualsiasi telefono, tablet o PC sulla stessa rete vede le letture aggiornate appena apre l'indirizzo IP dell'ESP32.

Procediamo passo dopo passo: prima colleghiamo bene il DHT22 e lo leggiamo senza errori, poi creiamo una pagina semplice che si ricarica da sola e infine disegniamo con Chart.js il grafico di temperatura e umidità delle ultime 24 ore. Scriverai lo stesso server sia con la libreria standard WebServer sia con ESPAsyncWebServer, e vedremo da dove arriva il famigerato valore "nan" e cosa cambia se usi un DHT11.

Sensore di temperatura e umidità DHT22
DHT22 (AM2302): misura da −40 a 80 °C con precisione di ±0,5 °C e da 0 a 100% di umidità relativa, e comunica su un'unica linea dati.

Come funziona un web server ESP32 con DHT22?

Il sistema ha tre parti. L'ESP32 si collega alla rete di casa come client (modalità station) e riceve un indirizzo IP dal router. In background legge il DHT22 a intervalli fissi e tiene in memoria l'ultimo valore valido. Quando il browser del telefono apre quell'IP, l'ESP32 invia una pagina HTML; poche righe di JavaScript nella pagina chiedono poi ogni pochi secondi solo i numeri (JSON) e aggiornano la schermata senza ricaricare tutto. Per il grafico l'ESP32 scrive ogni 5 minuti un valore medio in un buffer circolare (ring buffer); il browser richiede questo elenco e lo disegna con Chart.js.

IndirizzoCosa restituisceChi lo chiede e quando
/La pagina HTML (aspetto e JavaScript)Il browser, alla prima apertura
/dataUltima lettura, es. {"t":23.4,"h":51.2}Il JavaScript, ogni 5 secondi
/historyMedie di 5 minuti delle ultime 24 oreIl JavaScript, una volta al minuto

Materiale e caratteristiche del DHT22

Ti servono una scheda di sviluppo ESP32 (DevKit V1, NodeMCU-32S o simile), un sensore DHT22 o un modulo DHT22 a 3 pin, una resistenza da 10 kΩ se usi il sensore nudo, una breadboard, cavetti jumper e una rete Wi-Fi a 2,4 GHz. Il DHT22 si trova anche come AM2302; la versione con cavo ha già la resistenza di pull-up integrata. La tabella lo confronta con il fratello più economico, il DHT11:

CaratteristicaDHT22 (AM2302)DHT11
Intervallo di temperatura−40 … 80 °C0 … 50 °C
Precisione in temperatura±0,5 °C±2 °C
Intervallo di umidità0 … 100% UR20 … 90% UR
Precisione in umidità±2 … 5% UR±5% UR
Risoluzione0,1 °C / 0,1%1 °C / 1%
Intervallo minimo di lettura2 secondi1 secondo
Alimentazione3,3 … 6 V3,3 … 5,5 V
Assorbimento (misura / riposo)1–1,5 mA / 40–50 µA0,5–2,5 mA / 100–150 µA

Collegamento del DHT22 all'ESP32

Pin del DHT22Pin dell'ESP32Nota
VCC (+, pin 1)3V3Non usare i 5 V: la linea dati viene portata a questa tensione
DATA (OUT, pin 2)GPIO 4Sul sensore nudo, 10 kΩ tra DATA e VCC
NC (pin 3)Non collegatoSolo sul sensore nudo a 4 piedini
GND (−, pin 4)GNDMassa comune con l'ESP32
Per DATA non usare i GPIO 6–11 (collegati alla memoria flash) né i GPIO 34–39 (solo ingresso): il DHT22 riceve il segnale di avvio e invia i dati sullo stesso filo, quindi gli serve un pin bidirezionale. Anche i GPIO 0, 2, 12 e 15 possono influire sull'avvio della scheda. GPIO 4, 13, 16–19, 21–23, 25–27, 32 e 33 sono scelte sicure; puoi vedere il pinout della tua scheda con lo strumento Pinout.

Se usi il modulo a 3 pin, la resistenza di pull-up (e spesso un piccolo condensatore) è già sulla scheda e puoi collegarlo direttamente. Con il sensore nudo a 4 piedini serve una resistenza da 4,7–10 kΩ tra DATA e VCC; senza, la linea resta flottante e la maggior parte delle letture fallisce. A 3,3 V tieni il cavo sotto il metro; per distanze maggiori usa 4,7 kΩ e un cavo intrecciato. Non mettere nemmeno il sensore attaccato all'ESP32: il chip Wi-Fi e il regolatore scaldano la scheda e il sensore segnerebbe 1–2 °C più della stanza.

Installare le librerie

  1. Installa il pacchetto delle schede ESP32 nell'Arduino IDE (dettagli in Cos'è l'ESP32?) e scegli ESP32 Dev Module in Strumenti > Scheda.
  2. Nel Gestore librerie cerca DHT sensor library (Adafruit) e installala; accetta anche la dipendenza Adafruit Unified Sensor.
  3. La libreria WebServer è inclusa nel pacchetto ESP32, non va installata a parte.
  4. Per la versione asincrona installa ESP Async WebServer e Async TCP (di ESP32Async). Le vecchie versioni me-no-dev, non più mantenute, spesso non compilano con i pacchetti ESP32 recenti.

Passo 1: leggere il DHT22 ed evitare i "nan"

Prima di passare alla parte web, prova il sensore da solo. Quando una lettura fallisce, la libreria Adafruit restituisce NaN (not a number) invece di un numero e il Monitor seriale mostra "nan". Per questo devi controllare ogni valore con isnan(), scartare la lettura sbagliata e riprovare dopo 2 secondi. La funzione readDHT() del codice qui sotto fa tre tentativi; se falliscono tutti e tre restituisce false e tu continui a usare l'ultimo valore valido.

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}

Apri il Monitor seriale a 115200 baud. Ogni 5 secondi dovresti vedere una riga con temperatura, umidità e temperatura percepita (heat index). Se compare di continuo "DHT read failed", il problema è quasi sempre hardware: filo DATA sul pin sbagliato, pull-up mancante, sensore alimentato a 5 V o DHT_TYPE errato. Un errore isolato ogni tanto è invece normale: gli interrupt del Wi-Fi possono disturbare la temporizzazione al microsecondo del sensore e un nuovo tentativo risolve.

Passo 2: pagina web semplice che si aggiorna da sola (WebServer)

Il primo server è il più semplice possibile: l'ESP32 si collega al Wi-Fi e, quando viene richiesto l'indirizzo principale (/), invia una pagina HTML con l'ultima lettura in cifre grandi. Il tag meta refresh in testa dice al browser di ricaricare la pagina ogni 10 secondi, così ottieni un display quasi in tempo reale senza scrivere una riga di JavaScript. Cambia nome della rete e password, carica lo sketch e apri sul telefono l'IP che compare nel Monitor seriale.

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}
Il telefono deve essere sulla stessa rete Wi-Fi dell'ESP32: con i dati mobili non raggiungi un indirizzo 192.168.x.x. L'ESP32 vede solo le reti a 2,4 GHz. Per evitare che l'IP cambi a ogni riavvio, riserva un indirizzo fisso all'ESP32 nel router (prenotazione DHCP). Se non si collega proprio, segui la checklist di L'ESP32 non si connette al Wi-Fi.

Passo 3: grafico delle ultime 24 ore con Chart.js

Il meta refresh è semplice, ma scarica ogni volta l'intera pagina e non mostra lo storico. Facciamo di meglio: la pagina si carica una volta sola, i valori arrivano come JSON da /data ogni 5 secondi con la fetch() di JavaScript e il grafico prende i dati da /history. Dividendo 24 ore in intervalli di 5 minuti si ottengono 24 × 12 = 288 campioni. Ogni campione contiene un float da 4 byte per la temperatura e uno per l'umidità, cioè 288 × 2 × 4 = 2.304 byte, circa 2,3 KB di RAM: niente, rispetto ai 520 KB dell'ESP32.

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}
Parte del codiceCosa fa
READ_MS = 10000Legge il sensore ogni 10 secondi (il minimo per il DHT22 è 2 secondi)
STEP_MS = 300000Salva come un solo campione la media delle letture di ogni 5 minuti
temps[N], hums[N]Buffer circolare da 288 posti; quando è pieno sovrascrive il campione più vecchio
num()Trasforma NaN in null, che è valido in JSON
/history: step e ageIntervallo tra i campioni ed età dell'ultimo; da qui il browser calcola gli orari
setInterval(live, 5000)Aggiorna i numeri grandi ogni 5 secondi

Qui contano due dettagli. Primo, in JSON il valore NaN non esiste: se scrivi "nan" nella risposta quando il sensore fallisce, il parser JSON del browser va in errore e la pagina sembra bloccata. Per questo num() invia null, e Chart.js disegna i null come buchi nella linea. Secondo, l'ESP32 non deve prendere l'ora da internet: il browser usa il proprio orologio e colloca ogni punto "tanti passi prima di adesso". Se vuoi data e ora reali, aggiungi il metodo di Ora NTP con ESP32.

Chart.js viene scaricato dal CDN jsDelivr all'apertura della pagina, quindi il telefono deve avere accesso a internet per mostrare il grafico. Se l'ESP32 lavora solo come access point (modalità AP) o in casa manca internet, metti chart.umd.min.js (circa 200 KB) in LittleFS e servilo direttamente dall'ESP32. Come servire file da LittleFS lo spieghiamo in Web server asincrono ESP32 e WebSocket.

Lo stesso server con AsyncWebServer

La libreria standard WebServer è sincrona: nessuna richiesta riceve risposta finché in loop() non viene chiamato server.handleClient(). Se readDHT() passa qualche secondo a riprovare, anche la pagina resta senza risposta per quel tempo. ESPAsyncWebServer invece gestisce le richieste in background, in un task tutto suo: la pagina si apre subito qualunque cosa stia facendo loop() e più telefoni possono collegarsi insieme. Il codice seguente serve lo stesso endpoint /data con la libreria asincrona:

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}
CaratteristicaWebServerESPAsyncWebServer
InstallazioneInclusa nel pacchetto ESP32Servono ESP Async WebServer + Async TCP
Gestione delle richiestehandleClient() dentro loop()In background, nel proprio task
delay() in loop()Ferma anche il serverNon tocca il server
Più client insiemeUno dopo l'altroPiù client senza problemi
WebSocket e SSENoSì
Quando sceglierlo?Primo progetto, pagina sempliceGrafici, più utenti, dati in tempo reale

Nella versione asincrona c'è una sola regola: leggi il sensore in loop(), non all'arrivo di una richiesta, e tieni il risultato in una variabile globale. Se nell'handler della richiesta metti un delay() o una lettura lenta del sensore, blocchi il task della libreria e le connessioni cadono. La pagina con il grafico e l'handler /history del passo 3 si portano nel codice asincrono allo stesso modo; cambia solo l'uso di request->send() al posto di server.send().

Intervallo di lettura: ogni quanto leggere il DHT22?

Il datasheet del DHT22 chiede almeno 2 secondi tra due misure; se leggi più spesso, la libreria Adafruit salta la nuova misura e ti restituisce il valore precedente, oppure il sensore risponde con un errore. La temperatura di una stanza comunque non cambia in pochi secondi, quindi in pratica un intervallo di 10–60 secondi è l'ideale. Interrogarlo troppo spesso può anche scaldare un po' il sensore e far risultare l'umidità più bassa. Salvare per il grafico medie di 5 minuti invece di letture singole riduce il rumore e sfrutta meglio la memoria. In una stazione a batteria conviene mandare in sleep l'ESP32 tra una lettura e l'altra, come spiegato in ESP32 Deep Sleep.

Usarlo con un DHT11: cosa bisogna cambiare?

Se hai un DHT11 tutto il codice funziona: cambia solo la riga #define DHT_TYPE DHT11, i collegamenti restano uguali. La differenza è nella qualità della misura: il DHT11 misura da 0 a 50 °C con ±2 °C di precisione a gradini di un grado e legge l'umidità solo tra 20 e 90%. Il grafico avrà un andamento a scalini e non scenderà mai sotto 0 °C, quindi per balcone, frigorifero o serra scegli il DHT22. I problemi tipici del DHT11 sono trattati in Sensore di temperatura e umidità DHT11.

Idee di progetto con il web server ESP32 DHT22

  • Monitor per la cameretta: Mostra un avviso rosso sopra i 26 °C e invia un messaggio al telefono con un bot Telegram.
  • Termostato ambiente: Accendi una stufetta o un ventilatore con un modulo relè in base a una soglia impostata dalla pagina web.
  • Registrazione a lungo termine: Invia le medie di 5 minuti a un foglio Google Sheets e conserva mesi di dati.
  • Casa smart: Manda i valori a Home Assistant via MQTT e usali nelle automazioni.
  • Stazione con display: Mostra gli stessi valori su un display OLED per leggerli a colpo d'occhio senza aprire la pagina.
  • Misure in più stanze: Metti un ESP32 in ogni stanza e raccogli i dati su una scheda principale con ESP-NOW.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
La pagina mostra sempre -- o nanPin DATA sbagliato, niente pull-up, DHT_TYPE erratoControlla la tabella dei collegamenti, aggiungi 10 kΩ, verifica che nel codice ci sia DHT22
nan ogni tantoGli interrupt del Wi-Fi disturbano la temporizzazioneRiprova 3 volte con readDHT() e tieni l'ultimo valore valido
Temperatura più alta di 1–3 °CIl calore dell'ESP32 arriva al sensoreSposta il sensore a 5–10 cm con un cavo
La pagina non si apreTelefono su un'altra rete o IP cambiatoCollegati allo stesso Wi-Fi e usa il nuovo IP del Monitor seriale
I numeri arrivano ma il grafico è vuotoChart.js non è stato scaricato (niente internet)Controlla che il telefono abbia internet o servi il file da LittleFS
Il grafico si azzera al riavvioLo storico sta in RAMScrivi i campioni in LittleFS o mandali nel cloud
La scheda si riavvia a casoAlimentazione USB debole (brownout)Usa un buon cavo e un alimentatore da 5 V di almeno 1 A

Questo piccolo web server con ESP32 e DHT22 è la base per progetti più grandi come termostati, serre e stazioni meteo: cambia il sensore e la stessa struttura di pagina può mostrare umidità del terreno, qualità dell'aria o pressione. Se vuoi montare il circuito passo dopo passo, nell'app BlueGrays trovi schemi di collegamento e codice pronto nei progetti ESP32 DHT22 temperatura e umidità, Async Web Server e data logger di temperatura.

Domande frequenti

Perché il DHT22 dà nan sull'ESP32?

La libreria Adafruit restituisce NaN ogni volta che una lettura fallisce. Le cause più comuni sono il pin DATA sbagliato, la resistenza di pull-up da 10 kΩ mancante, DHT_TYPE rimasto su DHT11 nel codice o letture più frequenti di una ogni 2 secondi. Controlla i collegamenti, scarta le letture fallite con isnan() e riprova dopo 2 secondi.

Il DHT22 funziona a 3,3 V?

Sì, il DHT22 lavora tra 3,3 e 6 V e con l'ESP32 conviene alimentarlo dal pin 3V3, così anche la linea dati resta a 3,3 V. Se lo alimenti a 5 V, la pull-up porta la linea dati a 5 V e questo può danneggiare un pin dell'ESP32, che non tollera i 5 V.

Come accedo al web server dell'ESP32 da fuori casa?

Il server di questa guida funziona solo nella rete locale. Aprire una porta sul router espone il dispositivo a internet ed è un rischio per la sicurezza. È più sicuro inviare le letture a un servizio come MQTT, Telegram o Google Sheets, oppure collegarti alla rete di casa con una VPN.

Meglio DHT22 o DHT11?

Per un semplice display in casa basta un DHT11, ma il suo errore di ±2 °C e i gradini interi si notano molto su un grafico. Se ti servono misure all'esterno, sotto 0 °C o una curva più regolare, prendi il DHT22 con ±0,5 °C; la differenza di prezzo è piccola.

Si possono collegare più DHT22 a un solo ESP32?

Sì. Ogni sensore va su un proprio GPIO e ha un proprio oggetto nel codice, per esempio DHT dht1(4, DHT22) e DHT dht2(16, DHT22). I DHT22 non possono condividere la linea dati; se vuoi molti sensori su un solo filo, guarda il DS18B20 o un sensore I2C come il BME280.

Lo storico di 24 ore si perde se manca la corrente?

In questo esempio sì: i campioni stanno in RAM e si cancellano con un blackout o un riavvio della scheda. Per conservarli, scrivili periodicamente in LittleFS, salvali su una scheda SD o inviali a un servizio cloud come Google Sheets.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
ES-28Avanzato
Premium

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)

In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

4.5(14)
23
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

Connessione Wi-Fi STA con ESP32 (con display LCD)

In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

4.4(21)
38
ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
ES-29Avanzato
Premium

ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)

Aggiungiamo all'ESP32 un servizio mDNS (Multicast DNS), così lo raggiungi con un nome host leggibile come bluegrays-esp.local invece che con un indirizzo IP. Anche se l'IP assegnato dal DHCP cambia, il dispositivo risponde sempre allo stesso nome. Un piccolo server web sulla scheda ti permette di controllare il LED dal browser all'indirizzo http://bluegrays-esp.local/.

4.8(14)
23
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

ESP32: ora reale da Internet tramite NTP

L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

4.5(13)
22