Servidor web ESP32 com DHT22: temperatura, umidade e gráfico de 24 horas
Monte um servidor web ESP32 com DHT22: tabela de ligações, código com WebServer e AsyncWebServer, página que se atualiza sozinha, gráfico de 24 horas com Chart.js e solução para leituras nan.
Um servidor web ESP32 com DHT22 é o caminho mais rápido para colocar um sensor de temperatura e umidade no seu Wi-Fi e ler os valores no navegador do celular. O ESP32 faz as medições e, ao mesmo tempo, roda um pequeno servidor web, então você não precisa de um computador separado, de um app ou de um serviço na nuvem. Qualquer celular, tablet ou notebook na mesma rede vê as leituras mais recentes assim que abre o endereço IP do ESP32.
Vamos montar tudo passo a passo: primeiro ligamos o DHT22 corretamente e fazemos leituras confiáveis, depois criamos uma página simples que se atualiza sozinha e, por fim, desenhamos as últimas 24 horas de temperatura e umidade com o Chart.js. Você vai escrever o mesmo servidor com a biblioteca padrão WebServer e com a ESPAsyncWebServer, e vamos ver o que causa a temida leitura “nan” e o que muda se você usar um DHT11.

Como funciona um servidor web ESP32 com DHT22?
O sistema tem três partes. O ESP32 entra na rede da sua casa como cliente (modo estação) e recebe um endereço IP do roteador. Em segundo plano, ele lê o DHT22 em intervalos fixos e guarda na memória o último valor válido. Quando o navegador do celular abre esse endereço IP, o ESP32 envia uma página HTML; algumas linhas de JavaScript dentro da página pedem só os números (JSON) a cada poucos segundos e atualizam a tela sem recarregar a página inteira. Para o gráfico, o ESP32 grava um valor médio num buffer circular (ring buffer) a cada 5 minutos, e o navegador busca essa lista e a desenha com o Chart.js.
| URL | O que retorna | Quem pede e quando |
|---|---|---|
| / | A página HTML (layout e JavaScript) | O navegador, quando a página abre pela primeira vez |
| /data | Última leitura, por ex. {"t":23.4,"h":51.2} | O JavaScript, a cada 5 segundos |
| /history | Médias de 5 minutos das últimas 24 horas | O JavaScript, uma vez por minuto |
Lista de componentes e especificações do DHT22
Você vai precisar de uma placa de desenvolvimento ESP32 (DevKit V1, NodeMCU-32S ou similar), um sensor DHT22 ou um módulo DHT22 de 3 pinos, um resistor de 10 kΩ se usar o sensor avulso, uma protoboard, jumpers e uma rede Wi-Fi de 2,4 GHz. O DHT22 também é vendido como AM2302; a versão AM2302 com fios já tem o resistor de pull-up embutido. A tabela abaixo compara o DHT22 com o irmão mais barato, o DHT11:
| Característica | DHT22 (AM2302) | DHT11 |
|---|---|---|
| Faixa de temperatura | −40 … 80 °C | 0 … 50 °C |
| Precisão de temperatura | ±0,5 °C | ±2 °C |
| Faixa de umidade | 0 … 100% UR | 20 … 90% UR |
| Precisão de umidade | ±2 … 5% UR | ±5% UR |
| Resolução | 0,1 °C / 0,1% | 1 °C / 1% |
| Intervalo mínimo de leitura | 2 segundos | 1 segundo |
| Tensão de alimentação | 3,3 … 6 V | 3,3 … 5,5 V |
| Corrente (medindo / em repouso) | 1–1,5 mA / 40–50 µA | 0,5–2,5 mA / 100–150 µA |
Ligação do DHT22 ao ESP32
| Pino do DHT22 | Pino do ESP32 | Observação |
|---|---|---|
| VCC (+, pino 1) | 3V3 | Não use 5 V; a linha de dados é puxada para essa tensão |
| DATA (OUT, pino 2) | GPIO 4 | No sensor avulso, 10 kΩ entre DATA e VCC |
| NC (pino 3) | Não conectado | Só existe no sensor avulso de 4 pinos |
| GND (−, pino 4) | GND | GND comum com o ESP32 |
Se você tem o módulo de 3 pinos, o resistor de pull-up (e normalmente um pequeno capacitor) já está na placa, então pode ligá-lo direto. Com o sensor avulso de 4 pinos, você precisa de um resistor de 4,7–10 kΩ entre DATA e VCC; sem ele a linha fica flutuando e a maioria das leituras falha. Em 3,3 V, mantenha o cabo com menos de 1 metro; para distâncias maiores, use um pull-up de 4,7 kΩ e cabo de par trançado. Mantenha também o sensor longe do próprio ESP32: o chip de Wi-Fi e o regulador aquecem a placa, e um sensor colado nela mede 1–2 °C acima da temperatura do ambiente.
Instalando as bibliotecas
- Instale o pacote de placas ESP32 na Arduino IDE (veja os detalhes em O que é ESP32?) e escolha ESP32 Dev Module em Ferramentas > Placa.
- No Gerenciador de Bibliotecas, busque DHT sensor library (Adafruit) e instale; aceite a dependência Adafruit Unified Sensor quando for perguntado.
- A biblioteca WebServer já vem com o pacote ESP32, então não há nada extra para instalar.
- Para a versão assíncrona, instale ESP Async WebServer e Async TCP (da ESP32Async). As versões antigas da me-no-dev, sem manutenção, muitas vezes não compilam com os cores ESP32 recentes.
Passo 1: lendo o DHT22 e evitando o “nan”
Teste o sensor sozinho antes de adicionar a parte web. Quando uma leitura falha, a biblioteca da Adafruit retorna NaN (not a number) em vez de um valor, e o Monitor Serial mostra “nan”. Por isso, confira cada valor com isnan(), descarte a leitura que falhou e tente de novo 2 segundos depois. A função readDHT() no código abaixo faz três tentativas; se as três falharem, ela retorna false e você simplesmente continua usando o último valor válido.
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}Abra o Monitor Serial em 115200 baud. A cada 5 segundos você deve ver uma linha com temperatura, umidade e o índice de calor (sensação térmica). Se aparecer sempre “DHT read failed”, o problema quase sempre é de hardware: o fio DATA está no pino errado, falta o pull-up, o sensor está alimentado com 5 V ou o DHT_TYPE está errado. Uma falha isolada de vez em quando é normal: as interrupções do Wi-Fi podem atrapalhar a temporização em microssegundos do sensor, e uma nova tentativa resolve.
Passo 2: uma página web simples que se atualiza sozinha (WebServer)
Nosso primeiro servidor é o mais simples possível: o ESP32 se conecta ao Wi-Fi e, quando a URL raiz (/) é pedida, envia uma página HTML com a última leitura em números grandes. A tag meta refresh no topo manda o navegador recarregar a página a cada 10 segundos, então você tem uma tela quase ao vivo sem escrever uma única linha de JavaScript. Troque o nome da rede e a senha, carregue o sketch e abra no celular o endereço IP que aparece no Monitor Serial.
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: gráfico de 24 horas com Chart.js
O meta refresh é simples, mas baixa a página inteira toda vez e não mostra histórico. Vamos melhorar: a página carrega uma vez, os valores chegam como JSON de /data a cada 5 segundos pelo fetch() do JavaScript, e o gráfico vem de /history. Dividir 24 horas em intervalos de 5 minutos dá 24 × 12 = 288 amostras. Cada amostra guarda um float de 4 bytes para a temperatura e outro para a umidade, então 288 × 2 × 4 = 2.304 bytes, cerca de 2,3 KB de RAM; isso é muito pouco perto dos 520 KB do 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}| Código | O que faz |
|---|---|
| READ_MS = 10000 (intervalo de leitura) | Lê o sensor a cada 10 segundos (o mínimo do DHT22 é 2 segundos) |
| STEP_MS = 300000 (intervalo das amostras) | Guarda a média de cada 5 minutos de leituras como uma amostra |
| temps[N], hums[N] (buffers) | Buffer circular de 288 posições; quando enche, sobrescreve a amostra mais antiga |
| num() (conversão) | Transforma NaN em null, que é JSON válido |
| /history: step e age | Intervalo entre amostras e idade da amostra mais nova; o navegador calcula os rótulos de horário a partir deles |
| setInterval(live, 5000) (atualização) | Atualiza os números grandes da página a cada 5 segundos |
Dois pequenos detalhes importam aqui. Primeiro, o JSON não tem valor NaN: se você escrever “nan” na resposta quando o sensor falha, o parser de JSON do navegador dá erro e a página parece travada. Por isso a num() envia null, e o Chart.js desenha os valores null como falhas na linha. Segundo, o ESP32 não precisa buscar a hora na internet: o navegador usa o próprio relógio e posiciona cada ponto “tantos passos antes de agora”. Se quiser data e hora reais, acrescente o método de Hora NTP no ESP32.
O Chart.js é baixado do CDN jsDelivr quando a página abre, então o celular precisa de acesso à internet para mostrar o gráfico. Se o ESP32 funciona só como ponto de acesso próprio (modo AP), ou se não há internet em casa, coloque o chart.umd.min.js (cerca de 200 KB) no LittleFS e sirva o arquivo direto do ESP32. Explicamos como servir arquivos do LittleFS em Servidor web assíncrono e WebSocket no ESP32.
O mesmo servidor com AsyncWebServer
A biblioteca padrão WebServer é síncrona: nenhuma requisição é respondida se server.handleClient() não for chamada no loop(). Se a readDHT() passar alguns segundos tentando de novo, a página também fica sem responder durante esse tempo. A ESPAsyncWebServer atende as requisições em segundo plano, numa tarefa própria; a página abre na hora, não importa o que o loop() esteja fazendo, e vários celulares podem se conectar ao mesmo tempo. O código abaixo serve o mesmo endpoint /data com a biblioteca assíncrona:
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}| Característica | WebServer | ESPAsyncWebServer |
|---|---|---|
| Instalação | Vem com o pacote ESP32 | Precisa de ESP Async WebServer + Async TCP |
| Atendimento das requisições | handleClient() dentro do loop() | Em segundo plano, numa tarefa própria |
| delay() no loop() | Trava o servidor também | Não afeta o servidor |
| Vários clientes ao mesmo tempo | Um depois do outro | Vários clientes tranquilamente |
| WebSocket e SSE | Não | Sim |
| Quando escolher | Primeiro projeto, página simples | Gráficos, vários usuários, dados ao vivo |
Na versão assíncrona há uma regra a seguir: leia o sensor no loop(), não quando chega uma requisição, e guarde o resultado numa variável global. Se você chamar delay() ou uma leitura lenta do sensor dentro de um handler de requisição, bloqueia a tarefa da biblioteca assíncrona e as conexões caem. Você pode levar a página do gráfico e o handler de /history do Passo 3 para o código assíncrono do mesmo jeito; a única mudança é usar request->send() em vez de server.send().
Intervalo de leitura: com que frequência ler o DHT22?
O datasheet do DHT22 pede pelo menos 2 segundos entre medições; se você ler com mais frequência, a biblioteca da Adafruit pula a nova medição e devolve o valor anterior, ou o sensor retorna erro. A temperatura de um ambiente não muda em segundos mesmo, então na prática 10–60 segundos é o ideal. Ler com muita frequência também pode aquecer levemente o sensor e fazer a umidade aparecer mais baixa. Guardar médias de 5 minutos para o gráfico, em vez de leituras isoladas, reduz o ruído e usa a memória de forma eficiente. Para uma estação alimentada por bateria, você deve colocar o ESP32 para dormir entre as leituras, como explicado em Deep sleep no ESP32.
Usando um DHT11: o que precisa mudar?
Se você tem um DHT11, todo o código funciona; basta mudar a linha #define DHT_TYPE DHT11, e a ligação continua a mesma. A diferença está na qualidade da medição: o DHT11 mede de 0–50 °C com precisão de ±2 °C em passos de grau inteiro e só lê umidade entre 20 e 90%. Seu gráfico vai parecer uma escada e nunca vai descer abaixo de 0 °C, então escolha o DHT22 para varanda, geladeira ou estufa. Para problemas específicos do DHT11, veja Sensor de temperatura e umidade DHT11.
Ideias de projetos com servidor web ESP32 e DHT22
- Monitor do quarto do bebê: mostre um aviso vermelho na página quando passar de 26 °C e mande uma mensagem para o seu celular com um bot do Telegram.
- Termostato de ambiente: ligue um aquecedor ou ventilador com um módulo relé num limite que você define pela página web.
- Registro de longo prazo: envie as médias de 5 minutos para uma planilha do Google Sheets e guarde meses de dados.
- Casa inteligente: envie os valores para o Home Assistant via MQTT e use-os em automações.
- Estação com display: mostre os mesmos valores num display OLED de 0,96 polegada para ler de relance sem abrir a página.
- Medição em vários cômodos: coloque um ESP32 em cada cômodo e reúna os dados numa placa principal com ESP-NOW.
Problemas comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| A página sempre mostra -- ou nan | Pino DATA errado, sem pull-up, DHT_TYPE errado | Confira a tabela de ligações, adicione 10 kΩ, garanta que o código diz DHT22 |
| nan de vez em quando | As interrupções do Wi-Fi atrapalham a temporização | Tente 3 vezes com readDHT() e mantenha o último valor válido |
| Temperatura 1–3 °C acima do real | O calor do ESP32 chega ao sensor | Afaste o sensor 5–10 cm, na ponta de um cabo |
| A página não abre | Celular em outra rede, ou o IP mudou | Entre no mesmo Wi-Fi e use o novo IP do Monitor Serial |
| Os números aparecem, mas o gráfico fica vazio | Não foi possível baixar o Chart.js (sem internet) | Verifique se o celular tem internet, ou sirva o arquivo pelo LittleFS |
| O gráfico zera depois de reiniciar | O histórico fica na RAM | Grave as amostras no LittleFS ou envie-as para a nuvem |
| A placa reinicia aleatoriamente | Alimentação USB fraca (brownout) | Use um cabo bom e uma fonte de 5 V de pelo menos 1 A |
O pequeno servidor web que você montou com um ESP32 e um DHT22 é a base para projetos maiores, como termostatos, estufas e estações meteorológicas: troque o sensor e a mesma estrutura de página pode mostrar umidade do solo, qualidade do ar ou pressão. Se quiser montar o circuito passo a passo, os projetos de temperatura e umidade com ESP32 e DHT22, Async Web Server e registrador de temperatura do app BlueGrays trazem os esquemas de ligação e o código pronto para carregar.
Perguntas frequentes
Por que meu DHT22 retorna nan no ESP32?
A biblioteca da Adafruit retorna NaN sempre que uma leitura falha. As causas mais comuns são o pino DATA errado, a falta do resistor de pull-up de 10 kΩ, o DHT_TYPE deixado como DHT11 no código ou ler o sensor com intervalo menor que 2 segundos. Confira a ligação, descarte as leituras com falha usando isnan() e tente de novo 2 segundos depois.
O DHT22 funciona com 3,3 V?
Sim. O DHT22 funciona de 3,3 a 6 V, e no ESP32 o melhor é alimentá-lo pelo pino 3V3, para a linha de dados também ficar em 3,3 V. Se você alimentar com 5 V, o resistor de pull-up puxa a linha de dados para 5 V, o que pode danificar um pino do ESP32, porque o ESP32 não tolera 5 V.
Como acessar o servidor web do ESP32 de fora da rede de casa?
O servidor deste guia só funciona na sua rede local. Fazer redirecionamento de portas no roteador expõe o dispositivo à internet e é um risco de segurança. Opções mais seguras são enviar as leituras para um serviço como MQTT, Telegram ou Google Sheets, ou se conectar à rede de casa por uma VPN.
DHT22 ou DHT11: qual comprar?
Um DHT11 serve para um display simples em ambiente interno, mas o erro de ±2 °C e os passos de número inteiro ficam evidentes num gráfico. Se você precisa de leituras externas, temperaturas abaixo de 0 °C ou um gráfico mais suave, escolha o DHT22, com precisão de ±0,5 °C; a diferença de preço é pequena.
Posso ligar vários DHT22 num único ESP32?
Sim. Cada sensor vai num GPIO próprio e ganha um objeto próprio no código, por exemplo DHT dht1(4, DHT22) e DHT dht2(16, DHT22). Os DHT22 não podem compartilhar a mesma linha de dados; se você quer muitos sensores num só fio, veja o DS18B20 ou um sensor I2C como o BME280.
O ESP32 mantém o histórico de 24 horas depois de uma queda de energia?
Neste exemplo, não: as amostras ficam na RAM, então se perdem quando a energia cai ou a placa reinicia. Para mantê-las, grave as amostras no LittleFS em intervalos regulares, salve-as num cartão SD ou envie-as para um serviço na nuvem como o Google Sheets.
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.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

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.

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

Hora exata pela internet com ESP32 e NTP
O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.
Mais artigos
- Sensor de temperatura e umidade DHT11: guia para Arduino, ESP32 e Pico
- Servidor web assíncrono no ESP32 com WebSocket: painel de controle em tempo real
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- ESP32 não conecta ao Wi-Fi? Códigos do WiFi.status() e soluções reais
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

