Guias · 9 min de leitura

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.

Sensor de temperatura e umidade DHT22
DHT22 (AM2302): mede de −40 a 80 °C com precisão de ±0,5 °C e umidade relativa de 0–100%, e se comunica por uma única linha de dados.

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.

URLO que retornaQuem 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
/historyMédias de 5 minutos das últimas 24 horasO 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ísticaDHT22 (AM2302)DHT11
Faixa de temperatura−40 … 80 °C0 … 50 °C
Precisão de temperatura±0,5 °C±2 °C
Faixa de umidade0 … 100% UR20 … 90% UR
Precisão de umidade±2 … 5% UR±5% UR
Resolução0,1 °C / 0,1%1 °C / 1%
Intervalo mínimo de leitura2 segundos1 segundo
Tensão de alimentação3,3 … 6 V3,3 … 5,5 V
Corrente (medindo / em repouso)1–1,5 mA / 40–50 µA0,5–2,5 mA / 100–150 µA

Ligação do DHT22 ao ESP32

Pino do DHT22Pino do ESP32Observação
VCC (+, pino 1)3V3Não use 5 V; a linha de dados é puxada para essa tensão
DATA (OUT, pino 2)GPIO 4No sensor avulso, 10 kΩ entre DATA e VCC
NC (pino 3)Não conectadoSó existe no sensor avulso de 4 pinos
GND (−, pino 4)GNDGND comum com o ESP32
Não use os GPIO 6–11 (ligados ao chip de memória flash) nem os GPIO 34–39 (só entrada) para o DATA: o DHT22 recebe o sinal de início e envia os dados pelo mesmo fio, então precisa de um pino bidirecional. Os GPIO 0, 2, 12 e 15 também podem alterar a forma como a placa inicializa. Os GPIO 4, 13, 16–19, 21–23, 25–27, 32 e 33 são escolhas seguras; você pode conferir o mapa da sua placa na ferramenta Pinagem.

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

  1. Instale o pacote de placas ESP32 na Arduino IDE (veja os detalhes em O que é ESP32?) e escolha ESP32 Dev Module em Ferramentas > Placa.
  2. No Gerenciador de Bibliotecas, busque DHT sensor library (Adafruit) e instale; aceite a dependência Adafruit Unified Sensor quando for perguntado.
  3. A biblioteca WebServer já vem com o pacote ESP32, então não há nada extra para instalar.
  4. 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.

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

C++ (Arduino IDE)
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) + " &deg;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}
Seu celular precisa estar na mesma rede Wi-Fi que o ESP32; não dá para acessar um endereço 192.168.x.x pelos dados móveis. O ESP32 só enxerga redes de 2,4 GHz. Para o IP não mudar a cada reinicialização, reserve um endereço fixo para o ESP32 no roteador (reserva de DHCP). Se ele não conectar de jeito nenhum, siga o checklist em ESP32 não conecta ao Wi-Fi.

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.

C++ (Arduino IDE)
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ódigoO 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 ageIntervalo 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:

C++ (Arduino IDE)
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> &deg;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ísticaWebServerESPAsyncWebServer
InstalaçãoVem com o pacote ESP32Precisa de ESP Async WebServer + Async TCP
Atendimento das requisiçõeshandleClient() dentro do loop()Em segundo plano, numa tarefa própria
delay() no loop()Trava o servidor tambémNão afeta o servidor
Vários clientes ao mesmo tempoUm depois do outroVários clientes tranquilamente
WebSocket e SSENãoSim
Quando escolherPrimeiro projeto, página simplesGrá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

SintomaCausa provávelSolução
A página sempre mostra -- ou nanPino DATA errado, sem pull-up, DHT_TYPE erradoConfira a tabela de ligações, adicione 10 kΩ, garanta que o código diz DHT22
nan de vez em quandoAs interrupções do Wi-Fi atrapalham a temporizaçãoTente 3 vezes com readDHT() e mantenha o último valor válido
Temperatura 1–3 °C acima do realO calor do ESP32 chega ao sensorAfaste o sensor 5–10 cm, na ponta de um cabo
A página não abreCelular em outra rede, ou o IP mudouEntre no mesmo Wi-Fi e use o novo IP do Monitor Serial
Os números aparecem, mas o gráfico fica vazioNã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 reiniciarO histórico fica na RAMGrave as amostras no LittleFS ou envie-as para a nuvem
A placa reinicia aleatoriamenteAlimentaçã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.

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
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
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
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

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

4.5(14)
23
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
ES-29Avançado
Premium

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

4.8(14)
23
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

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.

4.5(13)
22