Failed to Read from DHT Sensor: causas e soluções para DHT11/DHT22
Failed to read from DHT sensor ou nan? Corrija pino ou tipo errado, falta de pull-up, intervalo de leitura, problemas no ESP32 e cabos longos, com um sketch de diagnóstico.
Failed to read from DHT sensor! se repetindo no Monitor Serial, ou nan no lugar da temperatura e da umidade, é o problema mais comum dos sensores DHT11 e DHT22. A boa notícia: o sensor quase nunca está morto. A causa costuma ser uma de seis coisas: o número do pino no código não bate com a ligação, o tipo do sensor está errado (DHT22 no lugar de DHT11 ou o contrário), um sensor avulso está sem resistor de pull-up, o sensor é lido com frequência demais ou logo depois de ligar, o ESP32 tem problemas de alimentação ou de tempo, ou o cabo é longo demais.
Neste guia você vai ver primeiro o que a mensagem de erro significa exatamente, depois a ligação correta e uma tabela sintoma-causa-solução. Em seguida vamos passar por cada causa, uma a uma, e escrever um sketch de diagnóstico que detecta sozinho o tipo do sensor e mede a taxa de sucesso, um sketch de leitura que resiste a erros e um script MicroPython para o Raspberry Pi Pico que diferencia os tipos de erro. Por fim, vamos ver quando largar o DHT e passar para um sensor I2C como o AHT20 ou o SHT31.

O que significa "Failed to read from DHT sensor"?
Essa mensagem não vem da biblioteca em si, e sim do exemplo DHTtester que acompanha a biblioteca DHT da Adafruit. O exemplo a imprime quando readTemperature() ou readHumidity() devolve NaN (Not a Number) em vez de um valor. A biblioteca devolve NaN em dois casos: quando o sensor nem responde ao sinal de início (tempo esgotado) ou quando o checksum dos 40 bits recebidos não confere (dados corrompidos). O primeiro costuma apontar para a ligação, o pino, o tipo ou a alimentação; o segundo, para tempo, ruído e cabos longos.
Para entender por que isso acontece tanto, olhe o protocolo. O Arduino acorda o sensor segurando a linha de dados em LOW por um tempo; o sensor responde com 80 µs em LOW e 80 µs em HIGH e depois envia 40 bits: 16 bits de umidade, 16 bits de temperatura e um checksum de 8 bits. Cada bit começa com 50 µs em LOW; se o HIGH seguinte dura cerca de 26–28 µs, o bit é 0, e se dura cerca de 70 µs, é 1. Ou seja, o microcontrolador precisa medir diferenças de algumas dezenas de microssegundos sem perder nenhuma; um fio frouxo, um pull-up fraco ou uma interrupção no caminho desequilibram isso fácil.
| Característica que afeta a leitura | DHT11 | DHT22 (AM2302) |
|---|---|---|
| Cor do corpo | Azul | Branco |
| Alimentação | 3–5,5 V | 3,3–6 V |
| Pulso de início da biblioteca | 20 ms LOW | 1,1 ms LOW |
| Menor intervalo de leitura | 1 segundo | 2 segundos |
| Espera depois de ligar | No mínimo 1 segundo | No mínimo 1 segundo, 2 por segurança |
| Tipo no código | DHT11 | DHT22 |
Ligação correta: Arduino Uno, ESP32 e Pico
| Pino do 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 (só no sensor avulso) | 10 kΩ entre DATA e 5V | 10 kΩ entre DATA e 3V3 | 10 kΩ entre DATA e 3V3 |
| Alimentar o sensor por um pino (sketch de leitura confiável) | D7 | GPIO 25 | Não usado |
Tabela de sintoma, causa e solução
A tabela abaixo associa os sintomas mais comuns às suas causas. Encontre o seu sintoma e tente primeiro a solução daquela linha; os detalhes estão nas seções depois da tabela:
| Sintoma | Causa provável | Solução |
|---|---|---|
| Toda leitura é nan, nenhum valor | Outro pino no código, fio de dados no lugar errado ou sensor sem alimentação | Compare o número do pino com a ligação, meça entre VCC e GND com um multímetro |
| O sensor é DHT11, sempre nan | DHT22 definido no código; o pulso de início de 1,1 ms é curto demais para um DHT11 | Escreva DHT11 no código |
| Sem erro, mas os valores são absurdos (ex.: 0,1 °C e 16 %) | O sensor é DHT22, DHT11 definido no código | Escreva DHT22 no código |
| Às vezes funciona, às vezes dá nan | Sensor avulso sem pull-up, protoboard ou jumper frouxo | Coloque um resistor de 4,7–10 kΩ entre DATA e VCC, firme os fios |
| Só a primeira leitura é nan | O sensor é lido logo depois de ligar | Espere 2 segundos depois do begin() |
| Depois de um erro, nan por 2 segundos | Leitura frequente demais; a biblioteca repete o último resultado para chamadas dentro de 2 s | Deixe no mínimo 2 segundos entre leituras |
| nan ocasional no ESP32 | Wi-Fi e tarefas atrapalhando o tempo, cabo longo em 3,3 V | Tente de novo, guarde o último valor bom, encurte o cabo |
| O ESP32 nunca lê | GPIO 34–39 escolhido, ou um módulo de 5 V puxando a linha de dados para 5 V | Use um pino bidirecional como o GPIO 4 e alimente o módulo pelo 3V3 |
| Erros com cabo longo (3 m ou mais) | A capacitância do cabo deixa as bordas do sinal lentas e a tensão cai | Alimente com 5 V, use pull-up de 4,7 kΩ, escolha cabo de par trançado |
| nan depois de horas, resolvido com um reset | O sensor travou | Alimente o sensor por um GPIO e desligue-o e ligue-o de novo após uma sequência de erros |
1. Pino errado ou tipo de sensor errado
No Arduino Uno, #define DHTPIN 2 significa o pino digital 2, ou seja, D2; não o A2, nem o segundo terminal da placa. No ESP32 os números são números de GPIO e geralmente batem com as marcações da placa de desenvolvimento. As placas ESP8266 (NodeMCU, Wemos D1 mini) têm uma armadilha: o pino marcado D4 na verdade é o GPIO 2; no código você precisa escrever D4 ou 2, e se escrever 4 a biblioteca fala com outro pino. No ESP32, os GPIO 34–39 são só de entrada e, por isso, não servem para um DHT, cuja linha de dados é usada como saída e como entrada. Os GPIO 6–11 são reservados à memória flash e travam a placa se você usá-los.
O tipo é tão importante quanto o pino. Se você escreve DHT11, a biblioteca acorda o sensor com um pulso LOW de 20 ms; se escreve DHT22, com um pulso de 1,1 ms. Um DHT11 precisa de pelo menos 18 ms, então ler um DHT11 como DHT22 normalmente não recebe resposta nenhuma e o resultado é nan. O contrário é mais traiçoeiro: o DHT22 também responde ao pulso longo, mas a biblioteca decodifica os bytes no formato do DHT11. Não aparece mensagem de erro, só valores absurdos: em um cômodo a 23,5 °C e 65 % de umidade você vai ver 0,1 °C e 16 %. Corpo azul significa DHT11, branco significa DHT22; o AM2302 branco com cabo também é um DHT22.
2. Resistor de pull-up: módulo ou sensor avulso?
A linha de dados do DHT é dreno aberto: o sensor só puxa a linha para LOW, e um resistor de pull-up fornece o nível HIGH. Nos módulos de 3 pinos soldados em uma plaquinha, esse resistor (normalmente 10 kΩ, às vezes 4,7 kΩ) já está lá. No sensor avulso de 4 pinos você precisa colocá-lo entre DATA e VCC; o datasheet sugere cerca de 5 kΩ, e na prática qualquer valor de 4,7 a 10 kΩ funciona bem. A biblioteca coloca o pino em INPUT_PULLUP durante a leitura, mas o pull-up interno do microcontrolador fica por volta de 20–50 kΩ e é fraco demais. Com fio curto às vezes basta, e é exatamente por isso que "às vezes funciona, às vezes dá nan" quase sempre significa falta de pull-up. A ideia está explicada em resistores de pull-up e pull-down, e como ler o valor de um resistor pelas cores na ferramenta Código de Cores de Resistores.

3. Intervalo de leitura e tempo de inicialização
Um DHT11 faz no máximo uma leitura nova por segundo, e um DHT22 uma a cada dois segundos. A biblioteca da Adafruit protege isso para você: se passaram menos de 2 segundos desde a última leitura, ela nem pergunta ao sensor e devolve de novo o último resultado. Eis o detalhe que quase todo mundo perde: se esse último resultado foi um erro, todas as chamadas dos 2 segundos seguintes também devolvem nan. Um sketch que lê a cada 100 ms transforma uma leitura falha em um bloco de 20 linhas de nan. A solução é simples: deixe no mínimo 2 segundos entre leituras e, no mesmo loop, leia primeiro a temperatura e depois a umidade; a segunda chamada reaproveita a mesma medição.
A inicialização é outra armadilha. Segundo o datasheet, o sensor fica instável no primeiro segundo depois de receber alimentação e não aceita comandos. Se você ler logo depois do dht.begin() no setup(), o primeiro valor muitas vezes é nan. Esperar 2 segundos depois do begin() elimina o problema por completo. Se quiser pular de propósito o cache de 2 segundos da biblioteca, use readTemperature(false, true); o segundo parâmetro força uma leitura nova.
4. DHT no ESP32: 3,3 V e tempo
Dois problemas aparecem com mais frequência no ESP32. O primeiro é a tensão: se você alimenta um módulo de 3 pinos com 5 V, o resistor de pull-up do módulo também puxa a linha de dados para 5 V, e os pinos do ESP32 só toleram 3,3 V. Alimente o módulo pelo pino 3V3; o DHT11 e o DHT22 funcionam nessa tensão. Se precisar de 5 V por causa de um cabo longo, ligue a linha de dados por um conversor de nível lógico. O segundo é o tempo: a biblioteca desliga as interrupções durante a leitura, mas no ESP32 isso só afeta o núcleo onde o seu código roda. A pilha Wi-Fi no outro núcleo e as esperas da memória flash ainda podem corromper uma leitura de vez em quando. Em um projeto com Wi-Fi é normal falharem algumas leituras em 100, então no ESP32 você deve sempre tentar de novo e guardar o último valor bom.
Se a taxa de erro for alta, evite ler o sensor nos momentos de maior atividade do Wi-Fi, por exemplo no meio de uma requisição web, e procure sintomas de brownout: um trilho de 3,3 V que cai quando o Wi-Fi liga derruba também a alimentação do sensor. A biblioteca DHTesp, escrita para ESP32 e ESP8266, ajusta o tempo para esses chips e dá resultados mais estáveis em algumas placas.
5. Cabos longos e interferência
Quando você leva o sensor para o outro lado do cômodo ou para fora, a taxa de erro sobe. Há dois motivos: a capacitância de um cabo longo deixa lenta a borda de subida do sinal e borra a diferença entre 26 µs e 70 µs que separa os bits 0 e 1, e um cabo fino também derruba a tensão. Para cabos com mais de alguns metros, alimente o sensor com 5 V, baixe o pull-up para 4,7 kΩ e passe a linha de dados como par trançado com o GND; um par de um cabo de rede é ideal para isso. O datasheet sugere um pull-up de cerca de 5 kΩ para cabos de até 20 metros, mas com jumpers espere problemas acima de 3–5 metros. Se você só precisa de temperatura a uma distância maior, o DS18B20 lida muito melhor com cabos longos.
Sketch de diagnóstico para testar o sensor (Uno e ESP32)
O sketch abaixo usa o pino D2 no Arduino Uno e o GPIO 4 no ESP32; ele detecta a placa sozinho. Ao iniciar, tenta ler o sensor primeiro como DHT22, depois como DHT11, e escolhe o tipo que dá valores fisicamente possíveis (−40 a 80 °C, 0 a 100 %). Depois lê a cada 2,5 segundos e mostra a taxa de sucesso. Abra o Monitor Serial 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}Veja como ler o resultado: se aparecer Yanit yok / no reply, o sensor não responde como nenhum dos tipos; confira o pino, a alimentação e o pull-up na ordem acima. Se um tipo foi encontrado, olhe a taxa de sucesso. Em um Arduino Uno com cabo curto ela deve ser 100 %. Em um ESP32 usando Wi-Fi, qualquer valor acima de 95 % é aceitável. Abaixo de 90 %, o problema provavelmente é o pull-up, um mau contato ou um cabo longo. Se você trocar o sensor e vir a mesma taxa, o problema não é o sensor, e sim o circuito.
Leitura tolerante a erros: novas tentativas e religar o sensor
Em um projeto de verdade, um único nan nunca deve chegar ao display, a um banco de dados ou à decisão de um relé. O sketch abaixo lê a cada 3 segundos, continua usando o último valor válido depois de uma leitura falha e desliga e liga o sensor depois de cinco erros seguidos. Para isso, o VCC do sensor vai a um GPIO (D7 no Uno, GPIO 25 no ESP32) em vez do 5V ou do 3V3. Um DHT consome no máximo 2,5 mA, então um pino o alimenta com folga, e sensores que travam depois de horas de funcionamento se recuperam assim sem reset. O sketch só usa delay() ao reiniciar o sensor; no resto do tempo o loop fica livre para outras tarefas.
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}Testando com o Raspberry Pi Pico (MicroPython)
O firmware MicroPython do Pico tem um módulo dht embutido para o DHT11 e o DHT22, então não há biblioteca para instalar. A vantagem é que ele diferencia os dois tipos de erro: se o sensor nem responde, você recebe OSError: [Errno 110] ETIMEDOUT, e se os dados chegam mas o checksum não confere, recebe checksum error. O primeiro aponta para a ligação, o pino e a alimentação; o segundo, para interferência, pull-up fraco e cabos longos. Ligue o sensor ao 3V3, ao GND e ao GP15 e rode o script no 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 trocar por um AHT20 ou SHT31?
Se a taxa de erro continuar alta depois de todas essas verificações, ou se você precisa de leituras mais precisas, talvez seja hora de largar o DHT. Sensores como AHT20, SHT31 e BME280 conversam por I2C: o próprio sensor cuida do tempo e o microcontrolador só lê o resultado pronto. Por isso eles ficam estáveis no ESP32 mesmo com o Wi-Fi ligado e podem dividir os mesmos dois fios com um display OLED. O único ponto em que o DHT ainda leva vantagem é poder ficar a alguns metros de distância com um único fio; o I2C foi feito para cabos curtos.
| Sensor | Interface | Precisão de temperatura | Precisão de umidade | Quando escolher |
|---|---|---|---|---|
| DHT11 | Fio único | ±2 °C | ±5 % | Experimentos escolares, monitoramento aproximado do cômodo |
| DHT22 (AM2302) | Fio único | ±0,5 °C | ±2–5 % | Quando você precisa de um cabo de alguns metros |
| AHT20 | I2C (0x38) | ±0,3 °C | ±2 % | Um substituto barato e estável para o DHT |
| SHT31 | I2C (0x44 ou 0x45) | ±0,3 °C | ±2 % | Leituras precisas, ambiente externo, condensação com o aquecedor embutido |
| BME280 | I2C ou SPI | ±1 °C | ±3 % | Quando você também precisa de pressão do ar |
Resumindo: em projetos internos com o sensor perto da placa, o AHT20 é a troca mais fácil; os detalhes estão em AHT10 e AHT20. Em estufas, banheiros ou ambientes externos onde a umidade passa de 90 %, o SHT31, cujo aquecedor elimina a condensação, dura mais. Se também quiser pressão, o BME280 entrega as três leituras em um só sensor. Para ver todos os sensores de temperatura lado a lado, dê uma olhada na comparação de sensores de temperatura.
Resumindo, por trás de "failed to read from DHT sensor" quase sempre estão o pino, o tipo, o pull-up, o intervalo de leitura, a alimentação ou o cabo, e o sketch de diagnóstico mostra qual deles em poucos minutos. O básico do uso do sensor está em sensor de temperatura e umidade DHT11. Quando o seu sensor estiver lendo de forma confiável, você pode partir para os projetos Temperatura e Umidade com DHT11, ESP32 DHT22 com LCD e Registrador de Temperatura com ESP32 no app BlueGrays, com esquemas de ligação e código pronto.
Perguntas frequentes
Por que o meu DHT11 devolve nan?
nan significa que a biblioteca não recebeu uma resposta válida do sensor. As causas mais comuns são um número de pino que não bate com a ligação, o tipo definido como DHT22, falta de resistor de pull-up em um sensor avulso e leituras com intervalo menor que 2 segundos. Rodar o sketch de diagnóstico aponta a causa em poucos minutos.
Como corrigir "Failed to read from DHT sensor!" em um DHT22?
Confirme que o tipo no código é DHT22, que o pino está certo e que você espera no mínimo 2 segundos entre leituras. Um sensor avulso precisa de um resistor de 4,7–10 kΩ entre DATA e VCC. No ESP32, alimente o sensor pelo 3V3 e não use os GPIO 34–39.
O DHT22 precisa de resistor de pull-up?
O sensor avulso de 4 pinos precisa; coloque um resistor de 4,7–10 kΩ entre DATA e VCC. Os módulos de 3 pinos já têm um na placa. O pull-up interno do microcontrolador é fraco demais, então depender só dele causa erros intermitentes.
O DHT11 ou o DHT22 funcionam com 3,3 V?
Sim, o DHT11 funciona de 3 a 5,5 V e o DHT22 de 3,3 a 6 V, e no ESP32 e no Pico é recomendado alimentá-los pelo 3V3. Em 3,3 V mantenha o cabo curto, porque a queda de tensão em um cabo longo corrompe as leituras. Para um cabo de vários metros, alimentação de 5 V com conversor de nível lógico é mais segura.
Com que frequência dá para ler um DHT22?
Um DHT11 pode ser lido no máximo uma vez por segundo e um DHT22 uma vez a cada dois segundos. Para chamadas com menos de 2 segundos de intervalo, a biblioteca da Adafruit devolve o último resultado sem perguntar ao sensor; se esse resultado foi um erro, o nan também se repete. Para monitorar um cômodo, ler a cada 5–60 segundos é mais que suficiente.
Qual é uma alternativa melhor ao DHT22?
Para leituras mais estáveis e precisas, o AHT20 ou o SHT31 via I2C são boas escolhas; eles cuidam do próprio tempo, então funcionam bem no ESP32 mesmo com o Wi-Fi ligado. Em lugares muito úmidos, prefira o SHT31 com aquecedor, e o BME280 se também precisar de pressão. Se você só precisa de temperatura por um cabo longo, use um DS18B20.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
Um painel com texto em rolagem para sua mesa ou parede que mostra, em sequência, a hora, a data e as condições do ambiente.

Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Medição de temperatura com NTC e display LCD 2x16
Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

ESP32 HTTPClient + API de clima (com display LCD)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

