Guías · 12 min de lectura

Failed to read from DHT sensor en Arduino: causas y soluciones

¿Failed to read from DHT sensor o nan en Arduino? Pin o tipo incorrecto, sin pull-up, intervalo de lectura, ESP32 y cables largos, con código de diagnóstico.

Ver Failed to read from DHT sensor! una y otra vez en el Monitor Serie, o nan donde deberían salir la temperatura y la humedad, es el problema más común con los sensores DHT11 y DHT22 en Arduino. La buena noticia: el sensor casi nunca está dañado. La causa suele ser una de estas seis: el número de pin del código no coincide con la conexión, el tipo de sensor está mal definido (DHT22 en lugar de DHT11 o al revés), al sensor sin módulo le falta la resistencia pull-up, se lee demasiado seguido o justo al encenderlo, el ESP32 tiene problemas de alimentación o de tiempos, o el cable es demasiado largo.

En esta guía primero verás qué significa exactamente el mensaje de error, luego la conexión correcta y una tabla de síntoma, causa y solución. Después revisaremos cada causa una por una y escribiremos un código de diagnóstico que detecta solo el tipo de sensor y mide el porcentaje de éxito, un código de lectura que aguanta los errores y un script de MicroPython para la Raspberry Pi Pico que distingue los tipos de error. Al final veremos cuándo conviene dejar el DHT y pasar a un sensor I2C como el AHT20 o el SHT31.

Sensor de temperatura y humedad DHT11
DHT11: sensor de temperatura y humedad de color azul que funciona con un solo cable de datos. El blanco es el DHT22, que se declara distinto en el código.

¿Qué significa "Failed to read from DHT sensor"?

Este mensaje no lo genera la librería, sino el ejemplo DHTtester que viene con la librería DHT de Adafruit. El ejemplo lo imprime cuando readTemperature() o readHumidity() devuelven NaN (Not a Number, «no es un número») en lugar de un valor. La librería devuelve NaN en dos casos: cuando el sensor no responde a la señal de inicio (tiempo de espera agotado) o cuando la suma de verificación de los 40 bits recibidos no coincide (datos corruptos). Lo primero suele apuntar a la conexión, el pin, el tipo o la alimentación; lo segundo, a los tiempos, el ruido y los cables largos.

Para entender por qué pasa tan seguido, basta con mirar el protocolo. El Arduino despierta al sensor manteniendo la línea de datos en LOW un momento; el sensor responde con 80 µs en LOW y 80 µs en HIGH y luego envía 40 bits: 16 de humedad, 16 de temperatura y 8 de suma de verificación. Cada bit empieza con 50 µs en LOW; si el HIGH que sigue dura unos 26–28 µs, el bit es 0, y si dura unos 70 µs, es 1. O sea, el microcontrolador tiene que medir diferencias de unas decenas de microsegundos sin perder ninguna; un cable flojo, un pull-up débil o una interrupción que se cruza rompen ese equilibrio con facilidad.

Característica que afecta la lecturaDHT11DHT22 (AM2302)
ColorAzulBlanco
Alimentación3–5,5 V3,3–6 V
Pulso de inicio de la librería20 ms en LOW1,1 ms en LOW
Intervalo mínimo de lectura1 segundo2 segundos
Espera tras encenderAl menos 1 segundoAl menos 1 segundo, mejor 2
Tipo en el códigoDHT11DHT22

Conexión correcta: Arduino Uno, ESP32 y Pico

Pin del DHTArduino UnoESP32Raspberry Pi Pico
VCC (+)5V3V33V3 (OUT)
DATA (OUT, S)D2GPIO 4GP15
GND (−)GNDGNDGND
Pull-up (solo sensor sin módulo)10 kΩ entre DATA y 5V10 kΩ entre DATA y 3V310 kΩ entre DATA y 3V3
Alimentar el sensor desde un pin (código de lectura confiable)D7GPIO 25No se usa
El orden de pines de los módulos DHT de 3 pines cambia según el fabricante: algunos son + OUT − y otros − + OUT. Lee las marcas de la placa antes de conectar. En el sensor sin módulo de 4 patas, con la rejilla hacia ti, el orden de izquierda a derecha es VCC, DATA, sin conexión, GND. Invertir la alimentación puede calentar y dañar el sensor en segundos.

Tabla de síntoma, causa y solución

La siguiente tabla relaciona los síntomas más comunes con sus causas. Busca tu síntoma y prueba primero la solución de esa fila; los detalles están en las secciones que siguen:

SíntomaCausa probableSolución
Todas las lecturas dan nan, ningún valorOtro pin en el código, cable de datos en el lugar equivocado o sensor sin alimentaciónCompara el número de pin con la conexión y mide con el multímetro entre VCC y GND
El sensor es un DHT11 y siempre da nanEn el código dice DHT22; el pulso de inicio de 1,1 ms es muy corto para el DHT11Escribe DHT11 en el código
Sin error, pero valores absurdos (p. ej. 0,1 °C y 16 %)El sensor es un DHT22 y en el código dice DHT11Escribe DHT22 en el código
A veces lee y a veces da nanSin pull-up en el sensor sin módulo, protoboard o jumper flojosPon una resistencia de 4,7–10 kΩ entre DATA y VCC y asegura los cables
Solo la primera lectura da nanSe lee el sensor justo después de encenderloEspera 2 segundos después de begin()
Tras un error, nan durante 2 segundosLecturas demasiado seguidas; la librería repite el último resultado durante 2 sDeja al menos 2 segundos entre lecturas
nan de vez en cuando en el ESP32El WiFi y las tareas alteran los tiempos, cable largo a 3,3 VReintenta, guarda el último valor bueno y acorta el cable
El ESP32 nunca leeSe eligió un GPIO 34–39 o un módulo a 5 V lleva la línea de datos a 5 VUsa un pin bidireccional como el GPIO 4 y alimenta el módulo con 3V3
Errores con cable largo (3 m o más)La capacidad del cable suaviza los flancos y cae el voltajeAlimenta con 5 V, usa un pull-up de 4,7 kΩ y cable trenzado
nan después de horas, se arregla con resetEl sensor se colgóAlimenta el sensor desde un GPIO y apágalo y préndelo tras varios errores seguidos

1. Pin equivocado o tipo de sensor incorrecto

En un Arduino Uno, #define DHTPIN 2 significa el pin digital 2, es decir D2; no A2 ni la segunda pata de la placa. En el ESP32 los números son números de GPIO y casi siempre coinciden con las marcas de la placa de desarrollo. Las placas ESP8266 (NodeMCU, Wemos D1 mini) tienen una trampa: el pin marcado D4 en realidad es el GPIO 2; en el código debes escribir D4 o 2, y si escribes 4 la librería usa otro pin. En el ESP32, los GPIO 34–39 son solo de entrada y por eso no sirven para el DHT, cuya línea de datos funciona como salida y como entrada. Los GPIO 6–11 están reservados para la memoria flash y bloquean la placa si los usas.

El tipo es tan importante como el pin. Si escribes DHT11, la librería despierta al sensor con un pulso LOW de 20 ms; si escribes DHT22, con uno de 1,1 ms. El DHT11 necesita al menos 18 ms, así que si lees un DHT11 como DHT22 casi nunca responde y el resultado es nan. Lo contrario es más traicionero: el DHT22 también responde al pulso largo, pero la librería decodifica los bytes con el formato del DHT11. No aparece ningún error, solo valores absurdos: en un cuarto a 23,5 °C y 65 % de humedad verás 0,1 °C y 16 %. Si es azul es un DHT11; si es blanco, un DHT22; el AM2302 blanco con cable también es un DHT22.

Si no estás seguro del tipo de sensor, corre el código de diagnóstico de más abajo: primero intenta leer como DHT22, luego como DHT11, y elige el tipo que da valores físicamente posibles. Para ver el mapa de pines de tu placa usa la herramienta Pinout.

2. Resistencia pull-up: ¿módulo o sensor solo?

La línea de datos del DHT es de drenador abierto (open-drain): el sensor solo la lleva a LOW y el nivel HIGH lo pone una resistencia pull-up. En los módulos de 3 pines soldados en una plaquita, esa resistencia (normalmente de 10 kΩ, a veces de 4,7 kΩ) ya viene incluida. En el sensor solo de 4 patas tienes que ponerla tú entre DATA y VCC; la hoja de datos sugiere unos 5 kΩ y en la práctica cualquier valor entre 4,7 y 10 kΩ funciona bien. La librería pone el pin en INPUT_PULLUP al leer, pero el pull-up interno del microcontrolador ronda los 20–50 kΩ y es demasiado débil. Con un cable corto a veces alcanza, y justo por eso el síntoma «a veces lee y a veces da nan» casi siempre significa que falta el pull-up. Explicamos la idea en resistencias pull-up y pull-down, y puedes leer el valor de una resistencia por sus colores con la herramienta Código de colores de resistencias.

Sensor de temperatura y humedad DHT22
DHT22 (AM2302): el modelo blanco, más preciso y con mayor rango. El sensor sin módulo necesita un pull-up de 4,7–10 kΩ entre DATA y VCC.

3. Intervalo de lectura y tiempo de arranque

El DHT11 puede dar como máximo una lectura nueva por segundo, y el DHT22 una cada dos segundos. La librería de Adafruit lo cuida por ti: si no han pasado 2 segundos desde la última lectura, no le pregunta al sensor y devuelve otra vez el último resultado. Aquí está el detalle que casi todos pasan por alto: si ese último resultado fue un error, cada llamada de los siguientes 2 segundos también devuelve nan. Un código que lee cada 100 ms convierte un solo fallo en un bloque de 20 líneas con nan. La solución es sencilla: deja al menos 2 segundos entre lecturas y, en la misma vuelta del loop, lee primero la temperatura y luego la humedad; la segunda llamada usa la misma medición.

El arranque es otra trampa. Según la hoja de datos, el sensor es inestable durante el primer segundo después de recibir alimentación y no acepta órdenes. Si lees justo después de dht.begin() en setup(), el primer valor suele salir nan. Esperar 2 segundos después de begin() elimina el problema por completo. Si quieres saltarte a propósito la caché de 2 segundos de la librería, usa readTemperature(false, true); el segundo parámetro fuerza una lectura nueva.

4. DHT en el ESP32: 3,3 V y tiempos

En el ESP32 aparecen sobre todo dos problemas. El primero es el voltaje: si alimentas un módulo de 3 pines con 5 V, su resistencia pull-up también lleva la línea de datos a 5 V, y los pines del ESP32 solo toleran 3,3 V. Alimenta el módulo desde el pin 3V3; el DHT11 y el DHT22 funcionan con ese voltaje. Si necesitas 5 V por un cable largo, conecta la línea de datos a través de un convertidor de nivel lógico. El segundo son los tiempos: la librería desactiva las interrupciones durante la lectura, pero en el ESP32 eso solo afecta al núcleo donde corre tu código. La pila WiFi del otro núcleo y las esperas de la memoria flash pueden arruinar de vez en cuando una lectura. En un proyecto con WiFi es normal que fallen algunas lecturas de cada 100, así que en el ESP32 siempre conviene reintentar y guardar el último valor bueno.

Si la tasa de error es alta, evita leer el sensor en los momentos de más carga del WiFi, por ejemplo en medio de una petición web, y busca síntomas de brownout: una línea de 3,3 V que cae al arrancar el WiFi también baja la alimentación del sensor. La librería DHTesp, escrita para ESP32 y ESP8266, ajusta los tiempos a estos chips y da resultados más estables en algunas placas.

5. Cables largos e interferencias

Cuando llevas el sensor al otro lado del cuarto o al exterior, la tasa de error sube. Hay dos razones: la capacidad de un cable largo hace más lento el flanco de subida y difumina la diferencia entre 26 µs y 70 µs que separa los bits 0 y 1, y en un cable delgado además cae el voltaje. Con cables de más de unos metros, alimenta el sensor con 5 V, baja el pull-up a 4,7 kΩ y lleva la línea de datos trenzada con GND; un par de un cable de red (UTP) es ideal para esto. La hoja de datos sugiere un pull-up de unos 5 kΩ para cables de hasta 20 metros, pero con cables jumper espera problemas a partir de 3–5 metros. Si a mayor distancia solo necesitas la temperatura, el DS18B20 aguanta mucho mejor los cables largos.

Código de diagnóstico para probar el sensor (Uno y ESP32)

El siguiente código usa el pin D2 en el Arduino Uno y el GPIO 4 en el ESP32; reconoce la placa solo. Al arrancar intenta leer el sensor primero como DHT22 y luego como DHT11, y elige el tipo que da valores físicamente posibles (−40 a 80 °C, 0 a 100 %). Después lee cada 2,5 segundos y muestra el porcentaje de éxito. Abre el Monitor Serie a 115200 baudios:

C++ (Arduino IDE)
1// DHT teşhis kodu: tipi bulur, başarı oranını ölçer (Uno ve ESP32) / DHT diagnostic: finds the type, measures the success rate (Uno and ESP32)
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4;                       // ESP32: GPIO 4 (34-39 olmaz / never 34-39)
6#else
7const int DHT_PIN = 2;                       // Uno ve Nano: D2 / Uno and Nano: D2
8#endif
9
10DHT asDht22(DHT_PIN, DHT22);
11DHT asDht11(DHT_PIN, DHT11);
12DHT *sensor = nullptr;                       // bulunan tip / detected type
13unsigned long okCount = 0, failCount = 0;
14
15bool plausible(float t, float h) {           // fiziksel olarak mümkün mü? / physically possible?
16  return !isnan(t) && !isnan(h) && t > -40 && t < 80 && h >= 0 && h <= 100;
17}
18
19bool tryRead(DHT &d) {
20  float t = d.readTemperature(false, true);  // force: 2 sn önbelleğini atla / force: skip the 2 s cache
21  float h = d.readHumidity();                // aynı ölçümü kullanır / reuses the same reading
22  return plausible(t, h);
23}
24
25void detect() {
26  for (int i = 0; i < 2 && !sensor; i++) {   // önce iki kez DHT22 gibi dene / first try twice as DHT22
27    if (tryRead(asDht22)) sensor = &asDht22;
28    delay(2500);
29  }
30  if (!sensor && tryRead(asDht11)) sensor = &asDht11;  // sonra DHT11 gibi / then as DHT11
31  if (sensor == &asDht22) Serial.println(F("DHT22 / AM2302 bulundu / found"));
32  else if (sensor == &asDht11) Serial.println(F("DHT11 bulundu / found"));
33  else Serial.println(F("Yanit yok: pin, kablo, besleme, pull-up / no reply: pin, wiring, power, pull-up"));
34}
35
36void setup() {
37  Serial.begin(115200);
38  asDht22.begin();
39  asDht11.begin();
40  delay(2000);                               // açılıştan sonra bekle / wait after power-up
41  detect();
42}
43
44void loop() {
45  delay(2500);                               // DHT22 için en az 2 sn / at least 2 s for the DHT22
46  if (!sensor) {
47    detect();                                // bulunana kadar yeniden dene / retry until found
48    return;
49  }
50  float t = sensor->readTemperature(false, true);
51  float h = sensor->readHumidity();
52  if (isnan(t) || isnan(h)) failCount++;
53  else okCount++;
54  Serial.print(F("T: "));
55  Serial.print(t, 1);
56  Serial.print(F(" C  H: %"));
57  Serial.print(h, 1);
58  Serial.print(F("  Basari / success: %"));
59  Serial.println(100.0 * okCount / (okCount + failCount), 0);
60}

Así se interpreta el resultado: si aparece Yanit yok / no reply, el sensor no responde con ninguno de los dos tipos; revisa el pin, la alimentación y el pull-up en el orden de arriba. Si encontró un tipo, mira el porcentaje de éxito. En un Arduino Uno con cable corto debe ser del 100 %. En un ESP32 con WiFi, más del 95 % es aceptable. Por debajo del 90 %, lo más probable es que el problema sea el pull-up, un falso contacto o un cable largo. Si cambias el sensor y ves el mismo porcentaje, el problema no es el sensor sino el circuito.

Lectura a prueba de errores: reintentos y reinicio del sensor

En un proyecto real, un solo nan nunca debe llegar a la pantalla, a una base de datos ni a la decisión de activar un relé. El siguiente código lee cada 3 segundos, sigue usando el último valor válido cuando una lectura falla y, tras cinco errores seguidos, apaga y vuelve a encender el sensor. Para eso, el VCC del sensor va a un GPIO (D7 en el Uno, GPIO 25 en el ESP32) en lugar de a 5V o 3V3. Un DHT consume como máximo 2,5 mA, así que un pin lo alimenta sin problema, y los sensores que se cuelgan después de horas se recuperan así sin necesidad de reset. El código solo usa delay() al reiniciar el sensor; el resto del tiempo el loop queda libre para otras tareas.

C++ (Arduino IDE)
1// Güvenilir DHT okuma: son iyi değer, hata sayacı, sensörü kapatıp açma / reliable DHT reading: last good value, error counter, sensor power cycle
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4;
6const int DHT_POWER_PIN = 25;                // sensörün VCC'si bu pinden / the sensor's VCC comes from this pin
7#else
8const int DHT_PIN = 2;
9const int DHT_POWER_PIN = 7;
10#endif
11#define DHT_TYPE DHT22                       // DHT11 kullanıyorsan DHT11 yaz / write DHT11 for a DHT11
12
13DHT dht(DHT_PIN, DHT_TYPE);
14const unsigned long READ_EVERY_MS = 3000;    // 3 sn'de bir oku / read every 3 s
15const int MAX_FAILS = 5;                     // 5 hata = 15 sn / 5 errors = 15 s
16unsigned long lastRead = 0;
17float lastTemp = NAN, lastHum = NAN;         // son geçerli değerler / last valid values
18int failStreak = 0;
19
20void powerCycleSensor() {
21  pinMode(DHT_PIN, OUTPUT);
22  digitalWrite(DHT_PIN, LOW);                // veri hattından beslenmesin / no power through the data line
23  digitalWrite(DHT_POWER_PIN, LOW);          // sensörü kapat / switch the sensor off
24  delay(1000);
25  digitalWrite(DHT_POWER_PIN, HIGH);         // yeniden aç / switch it back on
26  dht.begin();                               // veri pinini yeniden hazırlar / sets the data pin up again
27  delay(2000);                               // açılış süresi / start-up time
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(DHT_POWER_PIN, OUTPUT);
33  digitalWrite(DHT_POWER_PIN, HIGH);
34  dht.begin();
35  delay(2000);
36}
37
38void loop() {
39  if (millis() - lastRead >= READ_EVERY_MS) {
40    lastRead = millis();
41    float t = dht.readTemperature();
42    float h = dht.readHumidity();
43    if (isnan(t) || isnan(h)) {
44      failStreak++;
45      Serial.print(F("Okuma hatasi / read error #"));
46      Serial.println(failStreak);
47      if (failStreak >= MAX_FAILS) {
48        Serial.println(F("Sensor yeniden baslatiliyor / power-cycling the sensor"));
49        powerCycleSensor();
50        failStreak = 0;
51      }
52    } else {
53      failStreak = 0;
54      lastTemp = t;
55      lastHum = h;
56    }
57    if (!isnan(lastTemp)) {                  // ekranda hep son iyi değer / always show the last good value
58      Serial.print(F("T: "));
59      Serial.print(lastTemp, 1);
60      Serial.print(F(" C  H: %"));
61      Serial.println(lastHum, 1);
62    }
63  }
64  // diğer işler burada bekletilmeden çalışır / other tasks run here without waiting
65}
Mientras el sensor está apagado, el pin de datos también se pone en LOW. Si no, el pull-up interno del microcontrolador lo sigue alimentando por la línea de datos, aunque sea débilmente, y el sensor nunca se apaga del todo. Si el módulo tiene LED de encendido, la corriente total sube unos mA, lo que sigue sin ser problema para un GPIO.

Prueba con la Raspberry Pi Pico (MicroPython)

El firmware de MicroPython de la Pico trae un módulo dht listo para el DHT11 y el DHT22, así que no hay que instalar ninguna librería. Lo bueno es que distingue los dos tipos de error: si el sensor no responde aparece OSError: [Errno 110] ETIMEDOUT, y si llegan datos pero la suma de verificación no coincide aparece checksum error. Lo primero apunta a la conexión, el pin y la alimentación; lo segundo, a interferencias, un pull-up débil y cables largos. Conecta el sensor a 3V3, GND y GP15 y corre el script en Thonny:

MicroPython
1# DHT testi (Raspberry Pi Pico, MicroPython): hata türlerini ayırır / DHT test: tells the error types apart
2import dht
3import time
4from machine import Pin
5
6sensor = dht.DHT22(Pin(15))       # GP15; DHT11 için dht.DHT11 / dht.DHT11 for a DHT11
7time.sleep(2)                     # açılış süresi / start-up time
8ok = 0
9fail = 0
10
11while True:
12    try:
13        sensor.measure()
14        t = sensor.temperature()
15        h = sensor.humidity()
16        ok += 1
17        print("T: {:.1f} C  H: {:.1f} %".format(t, h))
18    except OSError as e:          # ETIMEDOUT: sensör cevap vermedi / the sensor did not answer
19        fail += 1
20        print("Cevap yok / no reply:", e)
21    except Exception as e:        # checksum error: veri bozuk geldi / the data arrived corrupted
22        fail += 1
23        print("Bozuk veri / corrupted data:", e)
24    print("Basari / success: {}%".format(100 * ok // (ok + fail)))
25    time.sleep(2.5)               # DHT22 için en az 2 sn / at least 2 s for the DHT22

¿Cuándo conviene pasar a un AHT20 o SHT31?

Si después de todas estas revisiones la tasa de error sigue alta, o necesitas mediciones más precisas, quizá sea hora de dejar el DHT. Sensores como el AHT20, el SHT31 y el BME280 se comunican por I2C: el propio sensor maneja los tiempos y el microcontrolador solo lee el resultado listo. Por eso funcionan estables en el ESP32 incluso con el WiFi encendido y pueden compartir los mismos dos cables con una pantalla OLED. La única ventaja que le queda al DHT es que se puede llevar a unos metros de distancia con un solo cable; el I2C está pensado para cables cortos.

SensorInterfazPrecisión de temperaturaPrecisión de humedad¿Cuándo elegirlo?
DHT11Un solo cable±2 °C±5 %Prácticas escolares, monitoreo aproximado de un cuarto
DHT22 (AM2302)Un solo cable±0,5 °C±2–5 %Donde necesitas un cable de algunos metros
AHT20I2C (0x38)±0,3 °C±2 %Reemplazo barato y estable del DHT
SHT31I2C (0x44 o 0x45)±0,3 °C±2 %Medición precisa, exteriores, condensación gracias a su calefactor
BME280I2C o SPI±1 °C±3 %Cuando también necesitas la presión del aire

En resumen: para proyectos en interiores con el sensor cerca de la placa, el AHT20 es el cambio más fácil; los detalles están en AHT10 y AHT20. En invernaderos, baños o exteriores donde la humedad pasa del 90 %, el SHT31 dura más porque su calefactor elimina la condensación. Si además quieres la presión, el BME280 te da las tres mediciones en un solo sensor. Para ver todos los sensores de temperatura lado a lado, revisa la comparativa de sensores de temperatura.

Si al compilar te sale Adafruit_Sensor.h: No such file or directory, el problema no es el sensor sino una librería: no está instalada Adafruit Unified Sensor, de la que depende DHT sensor library. Instálala desde el Gestor de Librerías o revisa cómo instalar librerías en Arduino. Mezclar ejemplos de distintas librerías DHT también provoca errores de compilación; los códigos de este artículo son para la DHT sensor library de Adafruit.

En pocas palabras, detrás de «failed to read from DHT sensor» en Arduino casi siempre están el pin, el tipo, el pull-up, el intervalo de lectura, la alimentación o el cable, y el código de diagnóstico te muestra cuál en pocos minutos. Encontrarás lo básico del sensor en sensor de temperatura y humedad DHT11. Cuando tu sensor lea sin fallas, puedes seguir en la app BlueGrays con los proyectos de temperatura y humedad con DHT11, de ESP32 con DHT22 y pantalla LCD y de registrador de temperatura con ESP32, cada uno con su diagrama y código listo.

Preguntas frecuentes

¿Por qué mi DHT11 marca nan?

nan significa que la librería no recibió una respuesta válida del sensor. Las causas más comunes son un número de pin que no coincide con la conexión, el tipo declarado como DHT22, la falta de pull-up en el sensor sin módulo y leerlo cada menos de 2 segundos. El código de diagnóstico te ayuda a encontrar la causa en pocos minutos.

¿Cómo soluciono «Failed to read from DHT sensor!» en el DHT22?

Verifica que en el código diga DHT22, que el pin sea el correcto y que esperes al menos 2 segundos entre lecturas. El sensor sin módulo necesita una resistencia de 4,7–10 kΩ entre DATA y VCC. En el ESP32, aliméntalo con 3V3 y no uses los GPIO 34–39.

¿El DHT11 necesita resistencia pull-up?

El sensor solo de 4 patas sí la necesita: pon de 4,7 a 10 kΩ entre DATA y VCC. Los módulos de 3 pines ya la traen en la placa. El pull-up interno del microcontrolador es muy débil, así que depender solo de él provoca errores intermitentes.

¿El DHT11 funciona con 3,3 V?

Sí, el DHT11 funciona de 3 a 5,5 V y el DHT22 de 3,3 a 6 V; en el ESP32 y la Pico se recomienda alimentarlos con 3V3. A 3,3 V conviene usar un cable corto, porque la caída de voltaje en un cable largo arruina las lecturas. Para cables de varios metros es más seguro usar 5 V con un convertidor de nivel lógico.

¿Cada cuánto se puede leer un DHT22?

El DHT22 como máximo cada dos segundos y el DHT11 una vez por segundo. Si lo llamas más seguido, la librería de Adafruit devuelve el último resultado sin preguntarle al sensor, y si ese resultado fue un error, el nan también se repite. Para monitorear un cuarto basta con leer cada 5 a 60 segundos.

¿Qué sensor es mejor que el DHT11 o el DHT22?

Para mediciones más estables y precisas, el AHT20 o el SHT31 por I2C son buenas opciones; manejan sus propios tiempos y funcionan bien en el ESP32 aunque el WiFi esté encendido. En lugares muy húmedos conviene el SHT31 con calefactor, y el BME280 si también necesitas la presión. Si solo necesitas temperatura con un cable largo, usa un DS18B20.

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
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
Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
AR-85Intermedio
Premium

Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)

Un panel de texto en movimiento para tu mesa o tu pared que muestra por turnos la hora, la fecha y el clima de la habitación.

5.0(50)
66
Estación de riego inteligente
AR-83Avanzado
Premium

Estación de riego inteligente

Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

5.0(42)
57
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla LCD)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

4.7(13)
20