Guias · 12 min de leitura

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.

Sensor de temperatura e umidade DHT11
DHT11: um sensor azul de temperatura e umidade que funciona por um único fio de dados. O branco é o DHT22, que exige outro tipo no código.

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 leituraDHT11DHT22 (AM2302)
Cor do corpoAzulBranco
Alimentação3–5,5 V3,3–6 V
Pulso de início da biblioteca20 ms LOW1,1 ms LOW
Menor intervalo de leitura1 segundo2 segundos
Espera depois de ligarNo mínimo 1 segundoNo mínimo 1 segundo, 2 por segurança
Tipo no códigoDHT11DHT22

Ligação correta: Arduino Uno, ESP32 e Pico

Pino do DHTArduino UnoESP32Raspberry Pi Pico
VCC (+)5V3V33V3 (OUT)
DATA (OUT, S)D2GPIO 4GP15
GND (−)GNDGNDGND
Pull-up (só no sensor avulso)10 kΩ entre DATA e 5V10 kΩ entre DATA e 3V310 kΩ entre DATA e 3V3
Alimentar o sensor por um pino (sketch de leitura confiável)D7GPIO 25Não usado
A ordem dos pinos dos módulos DHT de 3 pinos depende do fabricante: alguns são + OUT −, outros − + OUT. Leia as marcações da placa antes de ligar. No sensor avulso de 4 pinos, com a grade virada para você, a ordem da esquerda para a direita é VCC, DATA, sem conexão, GND. Inverter a alimentação pode superaquecer e matar o sensor em segundos.

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:

SintomaCausa provávelSolução
Toda leitura é nan, nenhum valorOutro pino no código, fio de dados no lugar errado ou sensor sem alimentaçãoCompare o número do pino com a ligação, meça entre VCC e GND com um multímetro
O sensor é DHT11, sempre nanDHT22 definido no código; o pulso de início de 1,1 ms é curto demais para um DHT11Escreva 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ódigoEscreva DHT22 no código
Às vezes funciona, às vezes dá nanSensor avulso sem pull-up, protoboard ou jumper frouxoColoque um resistor de 4,7–10 kΩ entre DATA e VCC, firme os fios
Só a primeira leitura é nanO sensor é lido logo depois de ligarEspere 2 segundos depois do begin()
Depois de um erro, nan por 2 segundosLeitura frequente demais; a biblioteca repete o último resultado para chamadas dentro de 2 sDeixe no mínimo 2 segundos entre leituras
nan ocasional no ESP32Wi-Fi e tarefas atrapalhando o tempo, cabo longo em 3,3 VTente 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 VUse 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 caiAlimente com 5 V, use pull-up de 4,7 kΩ, escolha cabo de par trançado
nan depois de horas, resolvido com um resetO sensor travouAlimente 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.

Se não tiver certeza do tipo do sensor, rode o sketch de diagnóstico abaixo: ele tenta ler primeiro como DHT22, depois como DHT11, e escolhe o tipo que dá valores fisicamente possíveis. Para ver o mapa de pinos da sua placa, use a ferramenta Pinout.

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.

Sensor de temperatura e umidade DHT22
DHT22 (AM2302): o modelo branco, mais preciso e com faixa maior. Um sensor avulso precisa de um pull-up de 4,7–10 kΩ entre DATA e VCC.

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:

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

C++ (Arduino IDE)
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}
Enquanto o sensor está desligado, o pino de dados também é colocado em LOW. Senão o pull-up interno do microcontrolador continua alimentando o sensor pela linha de dados, mesmo que fraco, e o sensor nunca desliga por completo. Se o módulo tiver um LED de alimentação, a corrente total sobe alguns mA, o que ainda não é problema para um GPIO.

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:

MicroPython
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 DHT22

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

SensorInterfacePrecisão de temperaturaPrecisão de umidadeQuando escolher
DHT11Fio ú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
AHT20I2C (0x38)±0,3 °C±2 %Um substituto barato e estável para o DHT
SHT31I2C (0x44 ou 0x45)±0,3 °C±2 %Leituras precisas, ambiente externo, condensação com o aquecedor embutido
BME280I2C 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.

Se a compilação der Adafruit_Sensor.h: No such file or directory, o problema não é o sensor, e sim uma biblioteca: a Adafruit Unified Sensor, da qual a DHT sensor library depende, não está instalada. Instale-a pelo Gerenciador de Bibliotecas ou veja como instalar bibliotecas no Arduino. Misturar exemplos de bibliotecas DHT diferentes também causa erros de compilação; os sketches deste artigo são para a DHT sensor library da Adafruit.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
AR-85Intermediário
Premium

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.

5.0(50)
66
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

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…

4.5(33)
44
ESP32 HTTPClient + API de clima (com display LCD)
ES-31Avançado
Premium

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.

4.7(13)
20