Guías · 9 min de lectura

ESP32 DHT22 servidor web: temperatura, humedad y gráfica de 24 h

Servidor web con ESP32 y DHT22: conexión, código WebServer y AsyncWebServer, página que se actualiza sola, gráfica de 24 h con Chart.js y solución al error nan.

Un servidor web con ESP32 y DHT22 es la forma más rápida de conectar un sensor de temperatura y humedad al Wi-Fi y ver los valores en el navegador de tu celular. El ESP32 mide y, al mismo tiempo, ejecuta un pequeño servidor web; no necesitas otra computadora, ni una app, ni un servicio en la nube. Cualquier celular, tablet o PC conectado a la misma red ve las lecturas actuales en cuanto abre la dirección IP del ESP32.

Iremos paso a paso: primero conectamos bien el DHT22 y lo leemos sin errores, después armamos una página sencilla que se recarga sola y al final dibujamos la gráfica de temperatura y humedad de las últimas 24 horas con Chart.js. Escribirás el mismo servidor con la librería estándar WebServer y con ESPAsyncWebServer, y veremos por qué aparece el famoso valor "nan" y qué cambia si usas un DHT11.

Sensor de temperatura y humedad DHT22
DHT22 (AM2302): mide de −40 a 80 °C con ±0,5 °C de precisión y de 0 a 100 % de humedad relativa, y se comunica por una sola línea de datos.

¿Cómo funciona un servidor web con ESP32 y DHT22?

El sistema tiene tres partes. El ESP32 se conecta a la red de tu casa como cliente (modo estación) y el router le asigna una IP. En segundo plano lee el DHT22 cada cierto tiempo y guarda en memoria el último valor válido. Cuando el navegador del celular abre esa IP, el ESP32 envía una página HTML; unas pocas líneas de JavaScript dentro de la página piden cada pocos segundos solo los números (JSON) y actualizan la pantalla sin recargar todo. Para la gráfica, el ESP32 guarda cada 5 minutos un promedio en un búfer circular (ring buffer); el navegador pide esa lista y la dibuja con Chart.js.

DirecciónQué devuelveQuién la pide y cuándo
/La página HTML (diseño y JavaScript)El navegador, al abrir la página
/dataÚltima lectura, p. ej. {"t":23.4,"h":51.2}JavaScript, cada 5 segundos
/historyPromedios de 5 minutos de las últimas 24 horasJavaScript, cada minuto

Materiales y características del DHT22

Necesitas una placa de desarrollo ESP32 (DevKit V1, NodeMCU-32S o similar), un sensor DHT22 o un módulo DHT22 de 3 pines, una resistencia de 10 kΩ si usas el sensor suelto, una protoboard, cables jumper (dupont) y una red Wi-Fi de 2,4 GHz. El DHT22 también se vende como AM2302; la versión con cable ya trae la resistencia pull-up integrada. En la tabla lo comparamos con su hermano más barato, el DHT11:

CaracterísticaDHT22 (AM2302)DHT11
Rango de temperatura−40 … 80 °C0 … 50 °C
Precisión de temperatura±0,5 °C±2 °C
Rango de humedad0 … 100 % HR20 … 90 % HR
Precisión de humedad±2 … 5 % HR±5 % HR
Resolución0,1 °C / 0,1 %1 °C / 1 %
Intervalo mínimo de lectura2 segundos1 segundo
Alimentación3,3 … 6 V3,3 … 5,5 V
Consumo (midiendo / en reposo)1–1,5 mA / 40–50 µA0,5–2,5 mA / 100–150 µA

Conexión del DHT22 al ESP32

Pin del DHT22Pin del ESP32Nota
VCC (+, pin 1)3V3No lo conectes a 5 V; la línea de datos sube a esta tensión
DATA (OUT, pin 2)GPIO 4En el sensor suelto, 10 kΩ entre DATA y VCC
NC (pin 3)Sin conectarSolo en el sensor suelto de 4 patas
GND (−, pin 4)GNDTierra común con el ESP32
No uses GPIO 6–11 (conectados a la memoria flash) ni GPIO 34–39 (solo entrada) para DATA: el DHT22 recibe la señal de inicio y envía sus datos por el mismo cable, así que necesita un pin bidireccional. GPIO 0, 2, 12 y 15 también pueden alterar el arranque de la placa. GPIO 4, 13, 16–19, 21–23, 25–27, 32 y 33 son opciones seguras; puedes ver el mapa de tu placa en la herramienta Pinout.

Si usas el módulo de 3 pines, la resistencia pull-up (y casi siempre un pequeño capacitor) ya viene en la placa, así que lo conectas directo. Con el sensor suelto de 4 patas necesitas una resistencia de 4,7 a 10 kΩ entre DATA y VCC; sin ella la línea queda flotando y la mayoría de las lecturas fallan. A 3,3 V, mantén el cable por debajo de 1 metro; para distancias mayores usa 4,7 kΩ y cable trenzado. Tampoco pongas el sensor pegado al ESP32: el chip Wi-Fi y el regulador calientan la placa y el sensor marcaría 1–2 °C más que la habitación.

Instalar las librerías

  1. Instala el paquete de placas ESP32 en el Arduino IDE (detalles en ¿Qué es el ESP32?) y elige ESP32 Dev Module en Herramientas > Placa.
  2. En el Gestor de librerías busca DHT sensor library (Adafruit) e instálala; acepta también la dependencia Adafruit Unified Sensor.
  3. La librería WebServer viene con el paquete ESP32; no hay que instalar nada más.
  4. Para la versión asíncrona instala ESP Async WebServer y Async TCP (de ESP32Async). Las versiones viejas de me-no-dev, ya sin mantenimiento, suelen dar errores de compilación con los paquetes ESP32 recientes.

Paso 1: leer el DHT22 y evitar el "nan"

Antes de pasar a la parte web, prueba el sensor solo. Cuando una lectura falla, la librería de Adafruit devuelve NaN (not a number) en lugar de un número y el Monitor Serie muestra "nan". Por eso hay que revisar cada valor con isnan(), descartar la lectura fallida y volver a intentar 2 segundos después. La función readDHT() del siguiente código hace tres intentos; si los tres fallan devuelve false y tú sigues usando el ú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}

Abre el Monitor Serie a 115200 baudios. Cada 5 segundos deberías ver una línea con temperatura, humedad y sensación térmica (heat index). Si aparece una y otra vez "DHT read failed", el problema casi siempre es de hardware: el cable DATA está en otro pin, falta la pull-up, el sensor está alimentado con 5 V o el DHT_TYPE es incorrecto. Un fallo aislado de vez en cuando, en cambio, es normal: las interrupciones del Wi-Fi pueden alterar la temporización de microsegundos del sensor y el reintento lo resuelve.

Paso 2: página web sencilla que se recarga sola (WebServer)

Nuestro primer servidor es lo más simple posible: el ESP32 se conecta al Wi-Fi y, cuando se pide la dirección raíz (/), envía una página HTML con la última lectura en números grandes. La etiqueta meta refresh del encabezado le indica al navegador que recargue la página cada 10 segundos, así tienes un indicador casi en vivo sin escribir una sola línea de JavaScript. Cambia el nombre de la red y la contraseña, sube el código y abre en el celular la IP que aparece en el Monitor Serie.

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}
El celular debe estar en la misma red Wi-Fi que el ESP32; con datos móviles no llegas a una dirección 192.168.x.x. El ESP32 solo ve redes de 2,4 GHz. Para que la IP no cambie en cada reinicio, reserva una dirección fija para el ESP32 en tu router (reserva DHCP). Si no logra conectarse, revisa la lista de El ESP32 no se conecta al Wi-Fi.

Paso 3: gráfica de 24 horas con Chart.js

El meta refresh es simple, pero descarga la página completa cada vez y no muestra historial. Hagámoslo mejor: la página se carga una sola vez, los valores llegan como JSON desde /data cada 5 segundos mediante fetch() de JavaScript y la gráfica se trae desde /history. Si dividimos 24 horas en tramos de 5 minutos salen 24 × 12 = 288 muestras. Cada muestra guarda un float de 4 bytes para temperatura y otro para humedad, o sea 288 × 2 × 4 = 2.304 bytes, unos 2,3 KB de RAM; nada para los 520 KB del 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}
Parte del códigoQué hace
READ_MS = 10000Lee el sensor cada 10 segundos (el mínimo del DHT22 es 2 segundos)
STEP_MS = 300000Guarda el promedio de cada 5 minutos de lecturas como una sola muestra
temps[N], hums[N]Búfer circular de 288 posiciones; al llenarse sobrescribe la muestra más antigua
num()Convierte NaN en null, que sí es válido en JSON
/history: step y ageIntervalo entre muestras y antigüedad de la última; con eso el navegador calcula las horas
setInterval(live, 5000)Actualiza los números grandes cada 5 segundos

Aquí importan dos detalles. Primero, JSON no tiene un valor NaN: si escribes "nan" en la respuesta cuando el sensor falla, el analizador JSON del navegador da error y la página parece congelada. Por eso num() envía null, y Chart.js dibuja los null como huecos en la línea. Segundo, el ESP32 no necesita sacar la hora de internet: el navegador usa su propio reloj y ubica cada punto "tantos pasos antes de ahora". Si quieres fecha y hora reales, agrega el método de Hora NTP con ESP32.

Chart.js se descarga del CDN jsDelivr al abrir la página, así que el celular necesita acceso a internet para mostrar la gráfica. Si el ESP32 funciona solo como punto de acceso propio (modo AP) o no hay internet en casa, guarda chart.umd.min.js (unos 200 KB) en LittleFS y sírvelo directamente desde el ESP32. Cómo servir archivos desde LittleFS lo explicamos en Servidor web asíncrono ESP32 y WebSocket.

El mismo servidor con AsyncWebServer

La librería estándar WebServer es síncrona: no responde ninguna petición mientras no se llame a server.handleClient() dentro de loop(). Si readDHT() tarda unos segundos reintentando, la página tampoco responde durante ese tiempo. ESPAsyncWebServer, en cambio, atiende las peticiones en segundo plano, en su propia tarea; la página abre al instante haga lo que haga loop() y pueden conectarse varios celulares a la vez. Este código sirve el mismo endpoint /data con la librería así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
InstalaciónViene con el paquete ESP32Requiere ESP Async WebServer + Async TCP
Atención de peticioneshandleClient() dentro de loop()En segundo plano, en su propia tarea
delay() en loop()También frena el servidorNo afecta al servidor
Varios clientes a la vezUno tras otroVarios clientes sin problema
WebSocket y SSENoSí
¿Cuándo elegirlo?Primer proyecto, página simpleGráficas, varios usuarios, datos en vivo

En la versión asíncrona hay una sola regla: lee el sensor en loop(), no cuando llega una petición, y guarda el resultado en una variable global. Si pones un delay() o una lectura lenta dentro del manejador de la petición, bloqueas la tarea de la librería y se cortan las conexiones. La página con la gráfica y el manejador /history del paso 3 se pasan igual al código asíncrono; lo único que cambia es usar request->send() en lugar de server.send().

Intervalo de lectura: ¿cada cuánto leer el DHT22?

La hoja de datos del DHT22 pide al menos 2 segundos entre mediciones; si lees más seguido, la librería de Adafruit no hace una medición nueva y te devuelve el valor anterior, o el sensor responde con error. La temperatura de una habitación no cambia en segundos, así que en la práctica un intervalo de 10 a 60 segundos es ideal. Leer muy seguido además puede calentar un poco el sensor y hacer que la humedad salga más baja. Guardar promedios de 5 minutos para la gráfica en vez de lecturas sueltas reduce el ruido y aprovecha mejor la memoria. En una estación a batería conviene dormir el ESP32 entre lecturas, como explicamos en ESP32 Deep Sleep.

Usarlo con un DHT11: ¿qué hay que cambiar?

Si tienes un DHT11, todo el código funciona; solo cambia la línea #define DHT_TYPE DHT11 y deja las conexiones igual. La diferencia está en la calidad de la medición: el DHT11 mide de 0 a 50 °C con ±2 °C de precisión en pasos enteros y lee la humedad solo entre 20 y 90 %. La gráfica se verá escalonada y nunca bajará de 0 °C, así que para un balcón, una heladera o un invernadero elige el DHT22. Los problemas típicos del DHT11 están en Sensor de temperatura y humedad DHT11.

Ideas de proyectos con el servidor web ESP32 DHT22

  • Monitor para el cuarto del bebé: Muestra un aviso rojo en la página cuando pase de 26 °C y manda un mensaje al celular con un bot de Telegram.
  • Termostato de habitación: Enciende una estufa o un ventilador con un módulo relé según un umbral que ajustas desde la página.
  • Registro a largo plazo: Envía los promedios de 5 minutos a una hoja de Google Sheets y guarda meses de datos.
  • Casa inteligente: Manda los valores a Home Assistant por MQTT y úsalos en automatizaciones.
  • Estación con pantalla: Muestra los mismos valores en una pantalla OLED para leerlos de un vistazo sin abrir la página.
  • Medición en varias habitaciones: Pon un ESP32 en cada cuarto y junta los datos en una placa principal con ESP-NOW.

Errores comunes y soluciones

SíntomaCausa probableSolución
La página siempre muestra -- o nanPin DATA incorrecto, sin pull-up, DHT_TYPE equivocadoRevisa la tabla de conexión, agrega 10 kΩ, verifica que diga DHT22
nan de vez en cuandoLas interrupciones del Wi-Fi alteran la temporizaciónReintenta 3 veces con readDHT() y conserva el último valor válido
Temperatura 1–3 °C más altaEl calor del ESP32 llega al sensorAleja el sensor 5–10 cm con un cable
La página no abreEl celular está en otra red o cambió la IPConéctate al mismo Wi-Fi y usa la IP nueva del Monitor Serie
Hay números pero la gráfica está vacíaNo se pudo descargar Chart.js (sin internet)Verifica que el celular tenga internet o sirve el archivo desde LittleFS
La gráfica se borra al reiniciarEl historial vive en la RAMGuarda las muestras en LittleFS o envíalas a la nube
La placa se reinicia solaAlimentación USB débil (brownout)Usa un buen cable y un cargador de 5 V de al menos 1 A

Este pequeño servidor web con ESP32 y DHT22 es la base de proyectos más grandes como termostatos, invernaderos y estaciones meteorológicas: cambia el sensor y la misma estructura de página puede mostrar humedad del suelo, calidad del aire o presión. Si quieres armar el circuito paso a paso, en la app BlueGrays encontrarás los diagramas de conexión y el código listo en los proyectos ESP32 DHT22 temperatura y humedad, Async Web Server y registrador de temperatura.

Preguntas frecuentes

¿Por qué el DHT22 marca nan en el ESP32?

La librería de Adafruit devuelve NaN cada vez que una lectura falla. Las causas más comunes son el pin DATA equivocado, la falta de la resistencia pull-up de 10 kΩ, haber dejado DHT11 como DHT_TYPE o leer el sensor más seguido que cada 2 segundos. Revisa el cableado, descarta las lecturas fallidas con isnan() y vuelve a intentar a los 2 segundos.

¿El DHT22 funciona con 3,3 V?

Sí. El DHT22 funciona entre 3,3 y 6 V y con un ESP32 conviene alimentarlo desde el pin 3V3 para que la línea de datos también quede en 3,3 V. Si lo alimentas con 5 V, la pull-up lleva la línea de datos a 5 V y eso puede dañar un pin del ESP32, que no tolera 5 V.

¿Cómo veo el servidor web del ESP32 desde fuera de casa?

El servidor de esta guía funciona solo en tu red local. Abrir puertos en el router expone el dispositivo a internet y es un riesgo de seguridad. Es más seguro enviar las lecturas a un servicio como MQTT, Telegram o Google Sheets, o conectarte a tu red de casa con una VPN.

¿DHT22 o DHT11, cuál conviene comprar?

Para un indicador simple dentro de casa alcanza con un DHT11, pero su error de ±2 °C y sus pasos enteros se notan mucho en una gráfica. Si necesitas medir afuera, bajo 0 °C o quieres una curva más suave, compra el DHT22 de ±0,5 °C; la diferencia de precio es poca.

¿Se pueden conectar varios DHT22 a un mismo ESP32?

Sí. Cada sensor va a su propio GPIO y tiene su propio objeto en el código, por ejemplo DHT dht1(4, DHT22) y DHT dht2(16, DHT22). Los DHT22 no pueden compartir la línea de datos; si quieres muchos sensores en un solo cable, mira el DS18B20 o un sensor I2C como el BME280.

¿Se pierde el historial si el ESP32 se reinicia?

En este ejemplo sí: las muestras se guardan en la RAM y se borran con un corte de luz o un reinicio. Para conservarlas, escríbelas cada cierto tiempo en LittleFS, guárdalas en una tarjeta SD o envíalas a un servicio en la nube como Google Sheets.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)

En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

4.5(14)
23
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
ES-29Avanzado
Premium

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)

Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

4.8(14)
23
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

ESP32: hora real desde Internet con NTP

El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

4.5(13)
22