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.

¿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ón | Qué devuelve | Quié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 |
| /history | Promedios de 5 minutos de las últimas 24 horas | JavaScript, 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ística | DHT22 (AM2302) | DHT11 |
|---|---|---|
| Rango de temperatura | −40 … 80 °C | 0 … 50 °C |
| Precisión de temperatura | ±0,5 °C | ±2 °C |
| Rango de humedad | 0 … 100 % HR | 20 … 90 % HR |
| Precisión de humedad | ±2 … 5 % HR | ±5 % HR |
| Resolución | 0,1 °C / 0,1 % | 1 °C / 1 % |
| Intervalo mínimo de lectura | 2 segundos | 1 segundo |
| Alimentación | 3,3 … 6 V | 3,3 … 5,5 V |
| Consumo (midiendo / en reposo) | 1–1,5 mA / 40–50 µA | 0,5–2,5 mA / 100–150 µA |
Conexión del DHT22 al ESP32
| Pin del DHT22 | Pin del ESP32 | Nota |
|---|---|---|
| VCC (+, pin 1) | 3V3 | No lo conectes a 5 V; la línea de datos sube a esta tensión |
| DATA (OUT, pin 2) | GPIO 4 | En el sensor suelto, 10 kΩ entre DATA y VCC |
| NC (pin 3) | Sin conectar | Solo en el sensor suelto de 4 patas |
| GND (−, pin 4) | GND | Tierra común con el ESP32 |
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
- Instala el paquete de placas ESP32 en el Arduino IDE (detalles en ¿Qué es el ESP32?) y elige ESP32 Dev Module en Herramientas > Placa.
- En el Gestor de librerías busca DHT sensor library (Adafruit) e instálala; acepta también la dependencia Adafruit Unified Sensor.
- La librería WebServer viene con el paquete ESP32; no hay que instalar nada más.
- 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.
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.
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}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.
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ódigo | Qué hace |
|---|---|
| READ_MS = 10000 | Lee el sensor cada 10 segundos (el mínimo del DHT22 es 2 segundos) |
| STEP_MS = 300000 | Guarda 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 age | Intervalo 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:
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 |
|---|---|---|
| Instalación | Viene con el paquete ESP32 | Requiere ESP Async WebServer + Async TCP |
| Atención de peticiones | handleClient() dentro de loop() | En segundo plano, en su propia tarea |
| delay() en loop() | También frena el servidor | No afecta al servidor |
| Varios clientes a la vez | Uno tras otro | Varios clientes sin problema |
| WebSocket y SSE | No | Sí |
| ¿Cuándo elegirlo? | Primer proyecto, página simple | Grá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íntoma | Causa probable | Solución |
|---|---|---|
| La página siempre muestra -- o nan | Pin DATA incorrecto, sin pull-up, DHT_TYPE equivocado | Revisa la tabla de conexión, agrega 10 kΩ, verifica que diga DHT22 |
| nan de vez en cuando | Las interrupciones del Wi-Fi alteran la temporización | Reintenta 3 veces con readDHT() y conserva el último valor válido |
| Temperatura 1–3 °C más alta | El calor del ESP32 llega al sensor | Aleja el sensor 5–10 cm con un cable |
| La página no abre | El celular está en otra red o cambió la IP | Conéctate al mismo Wi-Fi y usa la IP nueva del Monitor Serie |
| Hay números pero la gráfica está vacía | No 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 reiniciar | El historial vive en la RAM | Guarda las muestras en LittleFS o envíalas a la nube |
| La placa se reinicia sola | Alimentació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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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

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.

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

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.

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

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

