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.

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.
| Indirizzo | Cosa restituisce | Chi lo chiede e quando |
|---|---|---|
| / | La pagina HTML (aspetto e JavaScript) | Il browser, alla prima apertura |
| /data | Ultima lettura, es. {"t":23.4,"h":51.2} | Il JavaScript, ogni 5 secondi |
| /history | Medie di 5 minuti delle ultime 24 ore | Il 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:
| Caratteristica | DHT22 (AM2302) | DHT11 |
|---|---|---|
| Intervallo di temperatura | −40 … 80 °C | 0 … 50 °C |
| Precisione in temperatura | ±0,5 °C | ±2 °C |
| Intervallo di umidità | 0 … 100% UR | 20 … 90% UR |
| Precisione in umidità | ±2 … 5% UR | ±5% UR |
| Risoluzione | 0,1 °C / 0,1% | 1 °C / 1% |
| Intervallo minimo di lettura | 2 secondi | 1 secondo |
| Alimentazione | 3,3 … 6 V | 3,3 … 5,5 V |
| Assorbimento (misura / riposo) | 1–1,5 mA / 40–50 µA | 0,5–2,5 mA / 100–150 µA |
Collegamento del DHT22 all'ESP32
| Pin del DHT22 | Pin dell'ESP32 | Nota |
|---|---|---|
| VCC (+, pin 1) | 3V3 | Non usare i 5 V: la linea dati viene portata a questa tensione |
| DATA (OUT, pin 2) | GPIO 4 | Sul sensore nudo, 10 kΩ tra DATA e VCC |
| NC (pin 3) | Non collegato | Solo sul sensore nudo a 4 piedini |
| GND (−, pin 4) | GND | Massa comune con l'ESP32 |
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
- Installa il pacchetto delle schede ESP32 nell'Arduino IDE (dettagli in Cos'è l'ESP32?) e scegli ESP32 Dev Module in Strumenti > Scheda.
- Nel Gestore librerie cerca DHT sensor library (Adafruit) e installala; accetta anche la dipendenza Adafruit Unified Sensor.
- La libreria WebServer è inclusa nel pacchetto ESP32, non va installata a parte.
- 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.
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.
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}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.
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 codice | Cosa fa |
|---|---|
| READ_MS = 10000 | Legge il sensore ogni 10 secondi (il minimo per il DHT22 è 2 secondi) |
| STEP_MS = 300000 | Salva 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 age | Intervallo 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:
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}| Caratteristica | WebServer | ESPAsyncWebServer |
|---|---|---|
| Installazione | Inclusa nel pacchetto ESP32 | Servono ESP Async WebServer + Async TCP |
| Gestione delle richieste | handleClient() dentro loop() | In background, nel proprio task |
| delay() in loop() | Ferma anche il server | Non tocca il server |
| Più client insieme | Uno dopo l'altro | Più client senza problemi |
| WebSocket e SSE | No | Sì |
| Quando sceglierlo? | Primo progetto, pagina semplice | Grafici, 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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La pagina mostra sempre -- o nan | Pin DATA sbagliato, niente pull-up, DHT_TYPE errato | Controlla la tabella dei collegamenti, aggiungi 10 kΩ, verifica che nel codice ci sia DHT22 |
| nan ogni tanto | Gli interrupt del Wi-Fi disturbano la temporizzazione | Riprova 3 volte con readDHT() e tieni l'ultimo valore valido |
| Temperatura più alta di 1–3 °C | Il calore dell'ESP32 arriva al sensore | Sposta il sensore a 5–10 cm con un cavo |
| La pagina non si apre | Telefono su un'altra rete o IP cambiato | Collegati allo stesso Wi-Fi e usa il nuovo IP del Monitor seriale |
| I numeri arrivano ma il grafico è vuoto | Chart.js non è stato scaricato (niente internet) | Controlla che il telefono abbia internet o servi il file da LittleFS |
| Il grafico si azzera al riavvio | Lo storico sta in RAM | Scrivi i campioni in LittleFS o mandali nel cloud |
| La scheda si riavvia a caso | Alimentazione 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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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.

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).

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.

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().

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.

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/.

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.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

