Failed to read from DHT sensor: cause e soluzioni (DHT11/DHT22)
Failed to read from DHT sensor o nan? Pin o tipo sbagliato, pull-up mancante, intervallo di lettura, ESP32 e cavi lunghi: cause, soluzioni e uno sketch di test.
Vedere Failed to read from DHT sensor! ripetuto nel Monitor seriale, o nan al posto di temperatura e umidità, è il problema più comune con i sensori DHT11 e DHT22. La buona notizia: il sensore non è quasi mai guasto. La causa di solito è una di queste sei: il numero di pin nel codice non corrisponde al collegamento, il tipo di sensore è sbagliato (DHT22 invece di DHT11 o viceversa), al sensore nudo manca la resistenza di pull-up, il sensore viene letto troppo spesso o appena acceso, l'ESP32 ha problemi di alimentazione o di temporizzazione, oppure il cavo è troppo lungo.
In questa guida vedrai prima che cosa significa esattamente il messaggio di errore, poi il collegamento corretto e una tabella sintomo-causa-soluzione. Dopo esamineremo una per una le cause e scriveremo uno sketch di diagnosi che riconosce da solo il tipo di sensore e misura la percentuale di successo, uno sketch di lettura che sopporta gli errori e uno script MicroPython per il Raspberry Pi Pico che distingue i tipi di errore. Infine vedremo quando conviene abbandonare il DHT per un sensore I2C come l'AHT20 o l'SHT31.

Cosa significa "Failed to read from DHT sensor"?
Questo messaggio non viene dalla libreria, ma dall'esempio DHTtester fornito con la libreria DHT di Adafruit. L'esempio lo stampa quando readTemperature() o readHumidity() restituiscono NaN (Not a Number, «non è un numero») invece di un valore. La libreria restituisce NaN in due casi: quando il sensore non risponde al segnale di avvio (timeout) oppure quando il checksum dei 40 bit ricevuti non torna (dati corrotti). Il primo caso indica di solito collegamenti, pin, tipo o alimentazione; il secondo temporizzazione, disturbi e cavi lunghi.
Per capire perché succede così spesso basta guardare il protocollo. Arduino sveglia il sensore tenendo la linea dati a LOW per un po'; il sensore risponde con 80 µs LOW e 80 µs HIGH e poi invia 40 bit: 16 bit di umidità, 16 bit di temperatura e 8 bit di checksum. Ogni bit inizia con 50 µs LOW; se l'HIGH che segue dura circa 26–28 µs il bit è 0, se dura circa 70 µs è 1. Il microcontrollore deve quindi misurare differenze di poche decine di microsecondi senza perderne nessuna; un filo allentato, un pull-up debole o un interrupt che si mette in mezzo rompono facilmente questo equilibrio.
| Caratteristica che influisce sulla lettura | DHT11 | DHT22 (AM2302) |
|---|---|---|
| Colore | Azzurro | Bianco |
| Alimentazione | 3–5,5 V | 3,3–6 V |
| Impulso di avvio della libreria | 20 ms LOW | 1,1 ms LOW |
| Intervallo minimo di lettura | 1 secondo | 2 secondi |
| Attesa dopo l'accensione | Almeno 1 secondo | Almeno 1 secondo, meglio 2 |
| Tipo nel codice | DHT11 | DHT22 |
Collegamento corretto: Arduino Uno, ESP32 e Pico
| Pin del DHT | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+) | 5V | 3V3 | 3V3 (OUT) |
| DATA (OUT, S) | D2 | GPIO 4 | GP15 |
| GND (−) | GND | GND | GND |
| Pull-up (solo sensore nudo) | 10 kΩ tra DATA e 5V | 10 kΩ tra DATA e 3V3 | 10 kΩ tra DATA e 3V3 |
| Alimentare il sensore da un pin (sketch di lettura affidabile) | D7 | GPIO 25 | Non usato |
Tabella sintomo, causa e soluzione
La tabella qui sotto collega i sintomi più comuni alle loro cause. Trova il tuo sintomo e prova prima la soluzione di quella riga; i dettagli sono nelle sezioni dopo la tabella:
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Ogni lettura è nan, nessun valore | Pin diverso nel codice, filo dati nel posto sbagliato o sensore non alimentato | Confronta il numero di pin con il collegamento, misura tra VCC e GND con il multimetro |
| Il sensore è un DHT11, sempre nan | Nel codice c'è DHT22; l'impulso di avvio di 1,1 ms è troppo corto per il DHT11 | Scrivi DHT11 nel codice |
| Nessun errore ma valori assurdi (es. 0,1 °C e 16 %) | Il sensore è un DHT22, nel codice c'è DHT11 | Scrivi DHT22 nel codice |
| A volte legge, a volte nan | Manca il pull-up sul sensore nudo, breadboard o jumper allentati | Metti 4,7–10 kΩ tra DATA e VCC e fissa bene i fili |
| Solo la prima lettura è nan | Il sensore viene letto subito dopo l'accensione | Aspetta 2 secondi dopo begin() |
| Dopo un errore, nan per 2 secondi | Letture troppo ravvicinate; la libreria ripete l'ultimo risultato per 2 s | Lascia almeno 2 secondi tra una lettura e l'altra |
| nan ogni tanto sull'ESP32 | Wi-Fi e task disturbano la temporizzazione, cavo lungo a 3,3 V | Riprova, tieni l'ultimo valore buono, accorcia il cavo |
| L'ESP32 non legge mai | Scelto un GPIO 34–39 o un modulo a 5 V porta la linea dati a 5 V | Usa un pin bidirezionale come il GPIO 4 e alimenta il modulo a 3V3 |
| Errori con cavo lungo (3 m o più) | La capacità del cavo ammorbidisce i fronti e la tensione cala | Alimenta a 5 V, usa un pull-up da 4,7 kΩ e cavo intrecciato |
| nan dopo ore, si risolve con un reset | Il sensore si è bloccato | Alimenta il sensore da un GPIO e spegnilo e riaccendilo dopo una serie di errori |
1. Pin sbagliato o tipo di sensore sbagliato
Su un Arduino Uno, #define DHTPIN 2 indica il pin digitale 2, cioè D2; non A2 e nemmeno il secondo piedino della scheda. Sull'ESP32 i numeri sono numeri di GPIO e di solito coincidono con le scritte della scheda di sviluppo. Le schede ESP8266 (NodeMCU, Wemos D1 mini) nascondono una trappola: il pin marcato D4 è in realtà il GPIO 2; nel codice devi scrivere D4 oppure 2, e se scrivi 4 la libreria usa un altro pin. Sull'ESP32 i GPIO 34–39 sono solo ingressi e quindi non vanno bene per il DHT, la cui linea dati serve sia da uscita sia da ingresso. I GPIO 6–11 sono riservati alla memoria flash e mandano in crash la scheda se li usi.
Il tipo è importante quanto il pin. Se scrivi DHT11, la libreria sveglia il sensore con un impulso LOW di 20 ms; se scrivi DHT22, con uno di 1,1 ms. Il DHT11 vuole almeno 18 ms, quindi se leggi un DHT11 come DHT22 di solito non ottieni alcuna risposta e il risultato è nan. Il contrario è più subdolo: il DHT22 risponde anche all'impulso lungo, ma la libreria decodifica i byte nel formato del DHT11. Nessun messaggio di errore, solo valori assurdi: in una stanza a 23,5 °C e 65 % di umidità vedrai 0,1 °C e 16 %. Se è azzurro è un DHT11, se è bianco un DHT22; anche l'AM2302 bianco con il cavo è un DHT22.
2. Resistenza di pull-up: modulo o sensore nudo?
La linea dati del DHT è open-drain: il sensore porta la linea solo a LOW e il livello HIGH lo fornisce una resistenza di pull-up. Nei moduli a 3 pin saldati su una piccola scheda questa resistenza (di solito 10 kΩ, a volte 4,7 kΩ) c'è già. Sul sensore nudo a 4 piedini devi metterla tu tra DATA e VCC; il datasheet suggerisce circa 5 kΩ e in pratica qualsiasi valore tra 4,7 e 10 kΩ funziona bene. Durante la lettura la libreria imposta il pin come INPUT_PULLUP, ma il pull-up interno del microcontrollore è di circa 20–50 kΩ, decisamente troppo debole. Con un filo corto a volte basta, ed è proprio per questo che «a volte legge, a volte nan» indica quasi sempre un pull-up mancante. Trovi il principio spiegato in resistenze di pull-up e pull-down, e puoi leggere il valore di una resistenza dai suoi colori con lo strumento Codice colori resistenze.

3. Intervallo di lettura e tempo di avvio
Il DHT11 può fornire al massimo una nuova misura al secondo, il DHT22 una ogni due secondi. La libreria Adafruit lo garantisce per te: se dall'ultima lettura non sono passati 2 secondi, non interroga il sensore e restituisce di nuovo l'ultimo risultato. Ecco il dettaglio che molti non notano: se quell'ultimo risultato era un errore, anche ogni chiamata nei 2 secondi successivi restituisce nan. Uno sketch che legge ogni 100 ms trasforma così un solo errore in un blocco di 20 righe di nan. La soluzione è semplice: lascia almeno 2 secondi tra una lettura e l'altra e, nello stesso giro del loop, leggi prima la temperatura e poi l'umidità; la seconda chiamata usa la stessa misura.
Anche l'avvio è una trappola. Secondo il datasheet il sensore è instabile nel primo secondo dopo l'accensione e non accetta comandi. Se leggi subito dopo dht.begin() in setup(), il primo valore spesso è nan. Aspettare 2 secondi dopo begin() elimina del tutto il problema. Se vuoi saltare di proposito la cache di 2 secondi della libreria, usa readTemperature(false, true); il secondo parametro forza una nuova lettura.
4. DHT sull'ESP32: 3,3 V e temporizzazione
Sull'ESP32 i problemi più frequenti sono due. Il primo è la tensione: se alimenti un modulo a 3 pin a 5 V, la sua resistenza di pull-up porta anche la linea dati a 5 V, mentre i pin dell'ESP32 sopportano solo 3,3 V. Alimenta il modulo dal pin 3V3; DHT11 e DHT22 funzionano a questa tensione. Se per un cavo lungo ti servono 5 V, collega la linea dati tramite un convertitore di livello logico. Il secondo è la temporizzazione: la libreria disabilita gli interrupt durante la lettura, ma sull'ESP32 questo riguarda solo il core su cui gira il tuo codice. Lo stack Wi-Fi sull'altro core e le attese della memoria flash possono comunque rovinare ogni tanto una lettura. In un progetto con Wi-Fi è normale che qualche lettura su 100 fallisca, quindi sull'ESP32 conviene sempre riprovare e conservare l'ultimo valore buono.
Se la percentuale di errori è alta, evita di leggere il sensore nei momenti di maggior carico del Wi-Fi, per esempio nel mezzo di una richiesta web, e cerca i segni di un brownout: una linea a 3,3 V che crolla all'avvio del Wi-Fi abbassa anche l'alimentazione del sensore. La libreria DHTesp, scritta per ESP32 ed ESP8266, adatta la temporizzazione a questi chip e su alcune schede dà risultati più stabili.
5. Cavi lunghi e disturbi
Quando sposti il sensore dall'altra parte della stanza o all'esterno, la percentuale di errori sale. I motivi sono due: la capacità di un cavo lungo rallenta il fronte di salita del segnale e confonde la differenza tra 26 µs e 70 µs che separa i bit 0 e 1, e in un filo sottile cala anche la tensione. Con cavi più lunghi di qualche metro, alimenta il sensore a 5 V, abbassa il pull-up a 4,7 kΩ e porta la linea dati intrecciata con GND; una coppia di un cavo di rete è perfetta per questo. Il datasheet suggerisce un pull-up di circa 5 kΩ per cavi fino a 20 metri, ma con i cavetti jumper aspettati problemi già oltre 3–5 metri. Se a distanze maggiori ti serve solo la temperatura, il DS18B20 sopporta molto meglio i cavi lunghi.
Sketch di diagnosi per testare il sensore (Uno ed ESP32)
Lo sketch qui sotto usa il pin D2 su Arduino Uno e il GPIO 4 sull'ESP32; riconosce la scheda da solo. All'avvio prova a leggere il sensore prima come DHT22 e poi come DHT11, e sceglie il tipo che dà valori fisicamente possibili (da −40 a 80 °C, da 0 a 100 %). Poi legge ogni 2,5 secondi e stampa la percentuale di successo. Apri il Monitor seriale a 115200 baud:
1// DHT teşhis kodu: tipi bulur, başarı oranını ölçer (Uno ve ESP32) / DHT diagnostic: finds the type, measures the success rate (Uno and ESP32)
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4; // ESP32: GPIO 4 (34-39 olmaz / never 34-39)
6#else
7const int DHT_PIN = 2; // Uno ve Nano: D2 / Uno and Nano: D2
8#endif
9
10DHT asDht22(DHT_PIN, DHT22);
11DHT asDht11(DHT_PIN, DHT11);
12DHT *sensor = nullptr; // bulunan tip / detected type
13unsigned long okCount = 0, failCount = 0;
14
15bool plausible(float t, float h) { // fiziksel olarak mümkün mü? / physically possible?
16 return !isnan(t) && !isnan(h) && t > -40 && t < 80 && h >= 0 && h <= 100;
17}
18
19bool tryRead(DHT &d) {
20 float t = d.readTemperature(false, true); // force: 2 sn önbelleğini atla / force: skip the 2 s cache
21 float h = d.readHumidity(); // aynı ölçümü kullanır / reuses the same reading
22 return plausible(t, h);
23}
24
25void detect() {
26 for (int i = 0; i < 2 && !sensor; i++) { // önce iki kez DHT22 gibi dene / first try twice as DHT22
27 if (tryRead(asDht22)) sensor = &asDht22;
28 delay(2500);
29 }
30 if (!sensor && tryRead(asDht11)) sensor = &asDht11; // sonra DHT11 gibi / then as DHT11
31 if (sensor == &asDht22) Serial.println(F("DHT22 / AM2302 bulundu / found"));
32 else if (sensor == &asDht11) Serial.println(F("DHT11 bulundu / found"));
33 else Serial.println(F("Yanit yok: pin, kablo, besleme, pull-up / no reply: pin, wiring, power, pull-up"));
34}
35
36void setup() {
37 Serial.begin(115200);
38 asDht22.begin();
39 asDht11.begin();
40 delay(2000); // açılıştan sonra bekle / wait after power-up
41 detect();
42}
43
44void loop() {
45 delay(2500); // DHT22 için en az 2 sn / at least 2 s for the DHT22
46 if (!sensor) {
47 detect(); // bulunana kadar yeniden dene / retry until found
48 return;
49 }
50 float t = sensor->readTemperature(false, true);
51 float h = sensor->readHumidity();
52 if (isnan(t) || isnan(h)) failCount++;
53 else okCount++;
54 Serial.print(F("T: "));
55 Serial.print(t, 1);
56 Serial.print(F(" C H: %"));
57 Serial.print(h, 1);
58 Serial.print(F(" Basari / success: %"));
59 Serial.println(100.0 * okCount / (okCount + failCount), 0);
60}Ecco come interpretare il risultato: se compare Yanit yok / no reply, il sensore non risponde con nessuno dei due tipi; controlla pin, alimentazione e pull-up nell'ordine visto sopra. Se ha trovato un tipo, guarda la percentuale di successo. Su un Arduino Uno con cavo corto dovrebbe essere del 100 %. Su un ESP32 che usa il Wi-Fi, sopra il 95 % va bene. Sotto il 90 % il problema è molto probabilmente il pull-up, un falso contatto o un cavo lungo. Se cambi sensore e vedi la stessa percentuale, il problema non è il sensore ma il circuito.
Lettura a prova di errore: nuovi tentativi e riavvio del sensore
In un progetto reale un singolo nan non deve mai arrivare al display, a un database o alla decisione di attivare un relè. Lo sketch qui sotto legge ogni 3 secondi, continua a usare l'ultimo valore valido dopo una lettura fallita e, dopo cinque errori di fila, spegne e riaccende il sensore. Per farlo, il VCC del sensore va a un GPIO (D7 sull'Uno, GPIO 25 sull'ESP32) invece che a 5V o 3V3. Un DHT assorbe al massimo 2,5 mA, quindi un pin lo alimenta senza problemi, e i sensori che si bloccano dopo ore di funzionamento si riprendono così senza reset. Lo sketch usa delay() solo durante il riavvio del sensore; per il resto del tempo il loop resta libero per altri compiti.
1// Güvenilir DHT okuma: son iyi değer, hata sayacı, sensörü kapatıp açma / reliable DHT reading: last good value, error counter, sensor power cycle
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4;
6const int DHT_POWER_PIN = 25; // sensörün VCC'si bu pinden / the sensor's VCC comes from this pin
7#else
8const int DHT_PIN = 2;
9const int DHT_POWER_PIN = 7;
10#endif
11#define DHT_TYPE DHT22 // DHT11 kullanıyorsan DHT11 yaz / write DHT11 for a DHT11
12
13DHT dht(DHT_PIN, DHT_TYPE);
14const unsigned long READ_EVERY_MS = 3000; // 3 sn'de bir oku / read every 3 s
15const int MAX_FAILS = 5; // 5 hata = 15 sn / 5 errors = 15 s
16unsigned long lastRead = 0;
17float lastTemp = NAN, lastHum = NAN; // son geçerli değerler / last valid values
18int failStreak = 0;
19
20void powerCycleSensor() {
21 pinMode(DHT_PIN, OUTPUT);
22 digitalWrite(DHT_PIN, LOW); // veri hattından beslenmesin / no power through the data line
23 digitalWrite(DHT_POWER_PIN, LOW); // sensörü kapat / switch the sensor off
24 delay(1000);
25 digitalWrite(DHT_POWER_PIN, HIGH); // yeniden aç / switch it back on
26 dht.begin(); // veri pinini yeniden hazırlar / sets the data pin up again
27 delay(2000); // açılış süresi / start-up time
28}
29
30void setup() {
31 Serial.begin(115200);
32 pinMode(DHT_POWER_PIN, OUTPUT);
33 digitalWrite(DHT_POWER_PIN, HIGH);
34 dht.begin();
35 delay(2000);
36}
37
38void loop() {
39 if (millis() - lastRead >= READ_EVERY_MS) {
40 lastRead = millis();
41 float t = dht.readTemperature();
42 float h = dht.readHumidity();
43 if (isnan(t) || isnan(h)) {
44 failStreak++;
45 Serial.print(F("Okuma hatasi / read error #"));
46 Serial.println(failStreak);
47 if (failStreak >= MAX_FAILS) {
48 Serial.println(F("Sensor yeniden baslatiliyor / power-cycling the sensor"));
49 powerCycleSensor();
50 failStreak = 0;
51 }
52 } else {
53 failStreak = 0;
54 lastTemp = t;
55 lastHum = h;
56 }
57 if (!isnan(lastTemp)) { // ekranda hep son iyi değer / always show the last good value
58 Serial.print(F("T: "));
59 Serial.print(lastTemp, 1);
60 Serial.print(F(" C H: %"));
61 Serial.println(lastHum, 1);
62 }
63 }
64 // diğer işler burada bekletilmeden çalışır / other tasks run here without waiting
65}Test con il Raspberry Pi Pico (MicroPython)
Il firmware MicroPython del Pico include un modulo dht pronto per DHT11 e DHT22, quindi non devi installare nessuna libreria. Il suo pregio è che distingue i due tipi di errore: se il sensore non risponde affatto ottieni OSError: [Errno 110] ETIMEDOUT, se i dati arrivano ma il checksum non torna ottieni checksum error. Il primo indica collegamenti, pin e alimentazione; il secondo disturbi, un pull-up debole e cavi lunghi. Collega il sensore a 3V3, GND e GP15 ed esegui lo script in Thonny:
1# DHT testi (Raspberry Pi Pico, MicroPython): hata türlerini ayırır / DHT test: tells the error types apart
2import dht
3import time
4from machine import Pin
5
6sensor = dht.DHT22(Pin(15)) # GP15; DHT11 için dht.DHT11 / dht.DHT11 for a DHT11
7time.sleep(2) # açılış süresi / start-up time
8ok = 0
9fail = 0
10
11while True:
12 try:
13 sensor.measure()
14 t = sensor.temperature()
15 h = sensor.humidity()
16 ok += 1
17 print("T: {:.1f} C H: {:.1f} %".format(t, h))
18 except OSError as e: # ETIMEDOUT: sensör cevap vermedi / the sensor did not answer
19 fail += 1
20 print("Cevap yok / no reply:", e)
21 except Exception as e: # checksum error: veri bozuk geldi / the data arrived corrupted
22 fail += 1
23 print("Bozuk veri / corrupted data:", e)
24 print("Basari / success: {}%".format(100 * ok // (ok + fail)))
25 time.sleep(2.5) # DHT22 için en az 2 sn / at least 2 s for the DHT22Quando passare a un AHT20 o a un SHT31?
Se dopo tutti questi controlli la percentuale di errori resta alta, o ti servono misure più precise, forse è il momento di lasciare il DHT. Sensori come AHT20, SHT31 e BME280 comunicano via I2C: è il sensore stesso a gestire la temporizzazione e il microcontrollore legge solo il risultato pronto. Per questo restano stabili sull'ESP32 anche con il Wi-Fi acceso e possono condividere gli stessi due fili con un display OLED. L'unico vantaggio rimasto al DHT è che si può portare a qualche metro di distanza con un solo filo; l'I2C è pensato per cavi corti.
| Sensore | Interfaccia | Precisione temperatura | Precisione umidità | Quando sceglierlo |
|---|---|---|---|---|
| DHT11 | Filo singolo | ±2 °C | ±5 % | Esperimenti scolastici, controllo approssimativo di una stanza |
| DHT22 (AM2302) | Filo singolo | ±0,5 °C | ±2–5 % | Dove serve un cavo di qualche metro |
| AHT20 | I2C (0x38) | ±0,3 °C | ±2 % | Sostituto economico e stabile del DHT |
| SHT31 | I2C (0x44 o 0x45) | ±0,3 °C | ±2 % | Misure precise, esterno, condensa grazie al riscaldatore integrato |
| BME280 | I2C o SPI | ±1 °C | ±3 % | Quando ti serve anche la pressione |
In breve: per progetti al chiuso con il sensore vicino alla scheda, l'AHT20 è il passaggio più semplice; i dettagli sono in AHT10 e AHT20. In serra, in bagno o all'esterno, dove l'umidità supera il 90 %, l'SHT31 dura di più perché il suo riscaldatore elimina la condensa. Se vuoi anche la pressione, il BME280 ti dà tutte e tre le misure in un solo sensore. Per vedere tutti i sensori di temperatura uno accanto all'altro, guarda il confronto tra sensori di temperatura.
In sintesi, dietro «failed to read from DHT sensor» ci sono quasi sempre pin, tipo, pull-up, intervallo di lettura, alimentazione o cavo, e lo sketch di diagnosi ti mostra quale in pochi minuti. Le basi del sensore sono in sensore di temperatura e umidità DHT11. Quando il sensore legge senza errori, puoi proseguire nell'app BlueGrays con i progetti di temperatura e umidità con DHT11, di ESP32 con DHT22 e display LCD e di data logger di temperatura con ESP32, ognuno con schema e codice pronto.
Domande frequenti
Perché il mio DHT11 restituisce nan?
nan significa che la libreria non ha ricevuto una risposta valida dal sensore. Le cause più comuni sono un numero di pin che non corrisponde al collegamento, il tipo dichiarato come DHT22, il pull-up mancante sul sensore nudo e letture a meno di 2 secondi l'una dall'altra. Lo sketch di diagnosi individua la causa in pochi minuti.
Come risolvo "Failed to read from DHT sensor!" con il DHT22?
Controlla che nel codice ci sia DHT22, che il pin sia giusto e che tra due letture passino almeno 2 secondi. Il sensore nudo ha bisogno di una resistenza da 4,7–10 kΩ tra DATA e VCC. Sull'ESP32 alimentalo a 3V3 e non usare i GPIO 34–39.
Serve una resistenza di pull-up per il DHT22?
Sul sensore nudo a 4 piedini sì: metti da 4,7 a 10 kΩ tra DATA e VCC. I moduli a 3 pin l'hanno già sulla scheda. Il pull-up interno del microcontrollore è troppo debole e affidarsi solo a quello causa errori intermittenti.
Il DHT11 funziona a 3,3 V?
Sì, il DHT11 funziona da 3 a 5,5 V e il DHT22 da 3,3 a 6 V; su ESP32 e Pico è consigliato alimentarli a 3V3. A 3,3 V tieni il cavo corto, perché la caduta di tensione su un cavo lungo rovina le letture. Per cavi di diversi metri è più sicuro usare 5 V con un convertitore di livello logico.
Ogni quanto si può leggere un DHT22?
Il DHT22 al massimo ogni due secondi e il DHT11 una volta al secondo. Con chiamate più ravvicinate la libreria Adafruit restituisce l'ultimo risultato senza interrogare il sensore, e se era un errore si ripete anche il nan. Per controllare una stanza basta una lettura ogni 5–60 secondi.
Quale sensore usare al posto del DHT22?
Per misure più stabili e precise sono ottime scelte l'AHT20 o l'SHT31 su I2C; gestiscono da soli la temporizzazione e funzionano bene sull'ESP32 anche con il Wi-Fi acceso. In ambienti molto umidi è preferibile l'SHT31 con riscaldatore, e il BME280 se ti serve anche la pressione. Se ti serve solo la temperatura con un cavo lungo, usa un DS18B20.
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.

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.

Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)
Un pannello a scritte scorrevoli per la scrivania o la parete che mostra a turno l'ora, la data e il clima della stanza.

Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

ESP32 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.
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

