Componentes · 12 min de lectura

AHT10 Arduino: guía del sensor de temperatura y humedad AHT20

Conecta el AHT10 y AHT20 a Arduino: I2C 0x38, librería AHTX0, comparación con DHT11/DHT22, medidor de humedad con OLED y código para ESP32 y Pico.

El AHT10 es uno de los sensores más elegidos en los últimos años para medir temperatura y humedad a la vez en proyectos con Arduino. El AHT10 de Aosong (ASAIR) y su versión mejorada, el AHT20, se conectan con solo cuatro cables por I2C, miden la temperatura con una precisión de unos ±0,3 °C y la humedad relativa con ±2 %, y entregan valores digitales calibrados de fábrica. En resumen: es mucho más preciso que el DHT11 y más barato y rápido que el DHT22.

En este artículo verás paso a paso las diferencias entre el AHT10 y el AHT20, cómo conectarlos a Arduino Uno, ESP32 y Raspberry Pi Pico, la primera medición con la librería Adafruit AHTX0 y cómo se calculan la temperatura y la humedad a partir de los datos en bruto del sensor. Después descubrirás por qué baja la humedad de casa en invierno con la calefacción encendida, cuál es el rango ideal y cómo calcular el punto de rocío para saber si se empañarán los cristales. Con todo ello montarás un medidor de humedad con una pequeña pantalla OLED.

¿Qué es el AHT10/AHT20 y cómo funciona?

Dentro de ambos sensores hay dos elementos de medición distintos. La humedad se mide con un elemento capacitivo: entre dos electrodos hay una fina capa de polímero que absorbe el vapor de agua del aire. Cuanto más sube la humedad, más agua retiene el polímero, cambia su constante dieléctrica y la capacidad del elemento aumenta de forma medible. La temperatura se mide con un sensor semiconductor situado en el chip. Un procesador especial (ASIC) en la misma cápsula convierte estas dos señales analógicas en números con un ADC de 20 bits y las corrige con coeficientes de calibración definidos en fábrica. Así, a tu microcontrolador le llegan números en bruto ya calibrados; tú solo tienes que convertirlos a grados Celsius y porcentaje con una fórmula sencilla.

El AHT10 y el AHT20 son casi idénticos por fuera, y también coinciden sus rangos de medición y su precisión. La diferencia está en los detalles: el AHT20 tiene un rango de alimentación más amplio (2,0–5,5 V), mejor estabilidad a largo plazo, envía un byte de CRC para comprobar si los datos leídos se han corrompido y usa otro comando de inicialización (0xE1 en el AHT10, 0xBE en el AHT20). En el AHT10 puedes usar 0x38 o 0x39 gracias al pin de selección de dirección, mientras que la dirección del AHT20 es fija: 0x38. Además, se sabe que algunos módulos AHT10 dan problemas al compartir el bus I2C con otros dispositivos; para un proyecto nuevo suele ser más sensato comprar un AHT20.

CaracterísticaAHT10AHT20
FabricanteAosong (ASAIR)Aosong (ASAIR)
Interfaz y direcciónI2C, 0x38 (0x39 con el pin ADR)I2C, 0x38 fija
Tensión de alimentación del chip1,8–3,6 V2,0–5,5 V
Rango de temperatura / precisión-40…+85 °C / ±0,3 °C-40…+85 °C / ±0,3 °C
Rango de humedad / precisión0–100 % RH / ±2 % RH0–100 % RH / ±2 % RH
Resolución0,01 °C / 0,024 % RH0,01 °C / 0,024 % RH
Tiempo de mediciónUnos 75 msUnos 80 ms
Corriente en reposoMenos de 1 µAMenos de 1 µA
Comando de inicialización0xE1 0x08 0x000xBE 0x08 0x00
Comprobación CRCNoSí (byte 7)

Comparación entre AHT20, DHT11 y DHT22

Los sensores de temperatura y humedad más conocidos del mundo Arduino son el DHT11 y el DHT22. Se comunican por una sola línea de datos con un protocolo propio muy sensible a los tiempos; la librería desactiva las interrupciones durante unos milisegundos en cada lectura, y el DHT11 se puede leer una vez por segundo y el DHT22 una vez cada dos segundos. El AHT20 usa I2C estándar: en los mismos dos cables puedes conectar también una pantalla OLED, un RTC o un sensor de presión, y no tendrás lecturas perdidas por errores de temporización. RH es la abreviatura de humedad relativa (relative humidity).

CaracterísticaAHT10 / AHT20DHT11DHT22 (AM2302)
ComunicaciónI2C (2 hilos)Protocolo propio de un hiloProtocolo propio de un hilo
Rango de temperatura-40…+85 °C0…50 °C-40…+80 °C
Precisión de temperatura±0,3 °C±2 °C±0,5 °C
Rango de humedad0–100 % RH20–90 % RH0–100 % RH
Precisión de humedad±2 % RH±5 % RH±2–5 % RH
Resolución0,01 °C / 0,024 % RH1 °C / 1 % RH0,1 °C / 0,1 % RH
Intervalo de lecturaUnos 80 ms (recomendado 2 s)1 s2 s
Otros dispositivos en el mismo busSí (I2C)NoNo
PrecioBajoEl más bajoMedio

¿Cuál elegir? Para un proyecto simple que solo comprueba si hace calor o frío, el DHT11 basta. Pero medir la humedad de una habitación con un margen de error de ±5 % significa que no distinguirás entre un 40 % y un 45 %; para controlar la humedad de casa, un invernadero o una incubadora, esa diferencia importa. El DHT22 se acerca al AHT20 en precisión, pero es más caro y más lento. Si además quieres medir presión, el BME280 es una buena alternativa; para una comparación detallada, consulta la comparativa de sensores de temperatura y el artículo sobre BME280 y BMP280.

Conexión del AHT10 / AHT20: Uno, ESP32 y Pico

Pin del módulo AHTArduino UnoESP32Raspberry Pi Pico
VIN / VCC5V (o 3.3V)3V33V3(OUT), pin 36
GNDGNDGNDGND (p. ej. pin 38)
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)

La mayoría de los módulos AHT10 y AHT20 del mercado traen un pequeño regulador de 3,3 V y resistencias pull-up para las líneas I2C, así que se pueden conectar directamente a 5 V en el Uno. En el Uno R3, SDA y SCL también están en los dos pines junto a AREF; internamente son la misma línea que A4 y A5. Otra placa muy común combina el AHT20 con un BMP280: el AHT20 está en 0x38 y el BMP280 normalmente en 0x77, así que con una sola conexión lees temperatura, humedad y presión. Para los fundamentos del bus, el artículo qué es I2C es un buen comienzo.

No alimentes el módulo a 5 V sin asegurarte de que lleva regulador. Si en la placa solo ves el chip del sensor y unas resistencias (sobre todo en algunas placas AHT10 sin regulador), debes alimentarlo a 3,3 V; el límite superior del chip AHT10 es 3,6 V. Además, como la dirección del AHT20 no se puede cambiar, no puedes conectar dos AHT20 al mismo bus I2C; para un segundo sensor usa el segundo bus I2C del ESP32 y de la Pico, o un multiplexor I2C como el TCA9548A.

Paso a paso: primera medición con Arduino

  1. Abre el Gestor de bibliotecas en el IDE de Arduino, busca Adafruit AHTX0 e instálala; cuando pregunte por las dependencias, elige Install all para instalar también Adafruit BusIO y Adafruit Unified Sensor.
  2. Conecta el sensor según la tabla anterior: VIN a 5V, GND a GND, SCL a A5 y SDA a A4.
  3. Si no estás seguro de que el sensor aparece en el bus, ejecuta primero un escáner I2C; en la lista debes ver la dirección 0x38.
  4. Sube el código siguiente y abre el Monitor Serie a 9600 baudios.
  5. Sopla suavemente sobre el sensor: verás que el valor de humedad sube rápido en unos segundos y luego vuelve despacio al valor anterior.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_AHTX0.h>
3
4Adafruit_AHTX0 aht;   // AHT10 ve AHT20 için ortak nesne / shared object for AHT10 and AHT20
5
6void setup() {
7  Serial.begin(9600);
8  if (!aht.begin()) {                       // 0x38 adresinde sensörü ara / look for the sensor at 0x38
9    Serial.println(F("AHT sensor bulunamadi / not found"));
10    while (1) delay(10);
11  }
12  Serial.println(F("AHT sensor hazir / ready"));
13}
14
15void loop() {
16  sensors_event_t humidity, temp;
17  aht.getEvent(&humidity, &temp);           // ölçümü başlat ve oku / trigger and read a measurement
18
19  Serial.print(F("Sicaklik / Temp: "));
20  Serial.print(temp.temperature, 1);
21  Serial.print(F(" C   Nem / Humidity: %"));
22  Serial.println(humidity.relative_humidity, 1);
23  delay(2000);                              // kendi kendine ısınmayı önle / avoid self-heating
24}
Línea¿Qué hace?
aht.begin()Busca el sensor en la dirección 0x38, lo reinicia y comprueba el estado de calibración. Devuelve false si no lo encuentra.
aht.getEvent(&humidity, &temp)Envía el comando de medición (0xAC), espera a que termine y lee los dos valores a la vez.
temp.temperatureTemperatura en grados Celsius (float).
humidity.relative_humidityHumedad relativa en porcentaje (float).
delay(2000)Espera 2 segundos entre mediciones; evita que el chip se caliente por sí mismo.

De los datos en bruto a temperatura y humedad: fórmulas

Leer el sensor sin librería también es fácil, porque el protocolo consta de pocos comandos. Para iniciar una medición se escriben en el sensor los bytes 0xAC 0x33 0x00; unos 80 ms después, el primero de los seis bytes leídos es el byte de estado. Si su bit más alto (bit 7, 0x80) vale 1, el sensor aún está midiendo; si el bit 3 (0x08) vale 1, el sensor está calibrado. En los cinco bytes siguientes están, uno junto a otro, el valor de humedad de 20 bits (S_RH) y el de temperatura de 20 bits (S_T). Las fórmulas de conversión son: RH = S_RH / 2^20 × 100 y T = S_T / 2^20 × 200 − 50. Por ejemplo, si el valor bruto de humedad es 471.859, la humedad es 471.859 / 1.048.576 × 100 ≈ 45,0 %; si el valor bruto de temperatura es 372.244, la temperatura resulta 372.244 / 1.048.576 × 200 − 50 ≈ 21,0 °C. El código MicroPython de la sección de la Pico aplica exactamente estos pasos.

Puede resultar tentador leer el sensor varias veces por segundo, pero cada medición calienta el chip, aunque sea muy poco. El fabricante recomienda limitar las mediciones a una cada 2 segundos para que el autocalentamiento sea despreciable. Para magnitudes que cambian despacio, como la humedad de casa, leer cada 5–10 segundos es más que suficiente.

Control de la humedad de casa en invierno: por qué importa

En invierno, detrás de la garganta seca, las descargas de electricidad estática o los labios agrietados suele haber humedad baja. La causa es una regla física simple: la cantidad de vapor de agua que puede contener el aire aumenta rápidamente con la temperatura. A 0 °C, un metro cúbico de aire puede contener como máximo unos 4,8 gramos de vapor de agua; a 21 °C, ese límite sube a unos 18,3 gramos. El aire exterior a 0 °C y 80 % de humedad contiene unos 3,9 g/m³ de agua. Cuando ese aire entra y la calefacción lo calienta a 21 °C, la cantidad de agua no cambia, pero la que puede contener se multiplica casi por cuatro; la humedad relativa baja a 3,9 / 18,3 ≈ 21 %. La precisión de ±2 % del AHT20 te permite ver fácilmente este tipo de cambios y comprobar si el humidificador realmente funciona.

Humedad relativaSituación¿Qué hacer?
Por debajo del 30 %Muy seco: sequedad de garganta, ojos y piel, electricidad estáticaUsa un humidificador y baja un poco la calefacción
30–40 %Algo seco, frecuente en inviernoPoner un recipiente con agua o tender la ropa ayuda
40–60 %Rango idealMantenlo así
60–70 %Húmedo: empiezan a empañarse los cristalesVentila poco tiempo pero a menudo
Por encima del 70 %Alto riesgo de moho y ácarosVentila y, si hace falta, usa un deshumidificador

Otra ventaja de medir la humedad es poder calcular el punto de rocío, la temperatura a la que el vapor de agua del aire empieza a condensarse. Si el cristal de una ventana o la superficie interior de un muro exterior baja de esa temperatura, se forman gotas de agua y con el tiempo aparece moho. Se calcula con la fórmula de Magnus: γ = ln(RH/100) + 17,62·T / (243,12 + T) y Td = 243,12·γ / (17,62 − γ). Por ejemplo, si la habitación está a 21 °C y 60 % de humedad, el punto de rocío es de unos 12,9 °C; como en invierno la cara interior del cristal puede bajar fácilmente de 10 °C, el cristal se empaña. Si en la misma habitación la humedad baja al 45 %, el punto de rocío cae a 8,6 °C y el riesgo de condensación disminuye claramente. En el código del ESP32 mostraremos este cálculo directamente en la pantalla.

Medidor de humedad con pantalla OLED (Arduino Uno)

Juntemos ahora lo aprendido: con un Arduino Uno, un AHT20 y una pantalla OLED SSD1306 de 0,96 pulgadas harás un medidor de humedad para tu mesa. Como ambos módulos usan I2C, se conectan en paralelo a los mismos pines A4 (SDA) y A5 (SCL); no hay conflicto porque la OLED está en 0x3C y el AHT20 en 0x38. Para la instalación de la librería de la pantalla y otros detalles, echa un vistazo al artículo cómo usar una pantalla OLED (SSD1306).

Pantalla OLED I2C de 0,96 pulgadas SSD1306
La pantalla OLED SSD1306 de 0,96 pulgadas comparte el mismo bus I2C que el AHT20: la pantalla está en 0x3C y el sensor en 0x38.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Adafruit_AHTX0.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1);   // 128x64 OLED, reset pini yok / no reset pin
7Adafruit_AHTX0 aht;
8
9void setup() {
10  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {   // OLED adresi / OLED address
11    for (;;);                                         // ekran yok / no display
12  }
13  display.setTextColor(SSD1306_WHITE);
14  if (!aht.begin()) {                                 // AHT20 adresi 0x38 / AHT20 address 0x38
15    display.clearDisplay();
16    display.setCursor(0, 0);
17    display.print(F("AHT sensor yok!"));
18    display.display();
19    for (;;);
20  }
21}
22
23void loop() {
24  sensors_event_t humidity, temp;
25  aht.getEvent(&humidity, &temp);
26  float t = temp.temperature;
27  float h = humidity.relative_humidity;
28
29  display.clearDisplay();
30  display.setTextSize(1);
31  display.setCursor(0, 0);
32  display.print(F("Sicaklik: "));
33  display.print(t, 1);
34  display.print(F(" C"));
35
36  display.setTextSize(3);                   // nem büyük puntoyla / humidity in large font
37  display.setCursor(0, 16);
38  display.print(F("%"));
39  display.print(h, 0);
40
41  display.setTextSize(1);
42  display.setCursor(0, 46);
43  if (h < 30)       display.print(F("Hava cok kuru"));      // %30 alti / below 30 %
44  else if (h < 40)  display.print(F("Biraz kuru"));
45  else if (h <= 60) display.print(F("Ideal nem"));
46  else              display.print(F("Nemli: kuf riski"));  // %60 ustu / above 60 %
47
48  display.drawRect(0, 56, 128, 8, SSD1306_WHITE);                    // çubuk çerçevesi / bar frame
49  display.fillRect(2, 58, (int)(h / 100.0 * 124), 4, SSD1306_WHITE);  // nem kadar dolu / filled by humidity
50  display.display();                                                  // tamponu gönder / push the buffer
51  delay(2000);
52}

El código toma una medición cada dos segundos; arriba escribe la temperatura en letra pequeña y en el centro la humedad en letra tres veces mayor. La línea de debajo indica, según los rangos de la tabla anterior, si el aire está seco, ideal o húmedo, y la barra inferior muestra la humedad de forma visual. Como el búfer de imagen de la OLED ocupa aproximadamente 1 KB de los 2 KB de RAM del Uno, escribimos los textos fijos con la macro F(). Si colocas el sensor a unos centímetros, al final de un cable, en lugar de pegarlo a la pantalla y al Arduino, el calor que emiten las placas no afectará a la medición.

AHT20 con ESP32: punto de rocío y humedad mínima/máxima

En el ESP32 las mismas librerías de Adafruit funcionan sin cambios; la única diferencia son los pines I2C. En las placas ESP32 DevKit el pin SDA por defecto es el GPIO 21 y el SCL el GPIO 22, y puedes indicarlos explícitamente con Wire.begin(21, 22). El código siguiente muestra la humedad y la temperatura en la OLED, calcula el punto de rocío con la fórmula de Magnus y guarda la humedad mínima y máxima desde que se encendió el dispositivo. Como usamos millis() en lugar de delay(), loop() queda libre; si más adelante quieres enviar los datos al móvil por Wi-Fi o mostrarlos en una página web, no tendrás que reescribir el código desde cero. Para la parte de Wi-Fi puedes empezar con el artículo qué es el ESP32.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <math.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5#include <Adafruit_AHTX0.h>
6
7#define SDA_PIN 21   // ESP32 I2C SDA
8#define SCL_PIN 22   // ESP32 I2C SCL
9
10Adafruit_SSD1306 display(128, 64, &Wire, -1);
11Adafruit_AHTX0 aht;
12
13float minH = 100.0;
14float maxH = 0.0;
15unsigned long lastRead = 0;
16
17// Magnus formülü ile çiy noktası / dew point with the Magnus formula
18float dewPoint(float t, float h) {
19  const float b = 17.62;
20  const float c = 243.12;
21  if (h < 1.0) h = 1.0;                      // ln(0) hatasını önle / avoid ln(0)
22  float g = log(h / 100.0) + (b * t) / (c + t);
23  return (c * g) / (b - g);
24}
25
26void setup() {
27  Serial.begin(115200);
28  Wire.begin(SDA_PIN, SCL_PIN);              // I2C pinlerini seç / select I2C pins
29  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
30    Serial.println("OLED bulunamadi / OLED not found");
31    for (;;) delay(10);
32  }
33  if (!aht.begin(&Wire)) {
34    Serial.println("AHT bulunamadi / AHT not found");
35    for (;;) delay(10);
36  }
37  display.setTextColor(SSD1306_WHITE);
38}
39
40void loop() {
41  if (millis() - lastRead < 2000) return;    // 2 saniyede bir ölç / measure every 2 s
42  lastRead = millis();
43
44  sensors_event_t humidity, temp;
45  aht.getEvent(&humidity, &temp);
46  float t = temp.temperature;
47  float h = humidity.relative_humidity;
48  if (h < minH) minH = h;
49  if (h > maxH) maxH = h;
50  float td = dewPoint(t, h);
51
52  Serial.printf("T=%.1f C  RH=%.1f %%  Td=%.1f C\n", t, h, td);
53
54  display.clearDisplay();
55  display.setTextSize(1);
56  display.setCursor(0, 0);
57  display.print("Sicaklik: ");
58  display.print(t, 1);
59  display.print(" C");
60
61  display.setTextSize(3);
62  display.setCursor(0, 12);
63  display.print("%");
64  display.print(h, 1);
65
66  display.setTextSize(1);
67  display.setCursor(0, 42);
68  display.print("Ciy noktasi: ");
69  display.print(td, 1);
70  display.print(" C");
71  display.setCursor(0, 54);
72  display.print("Min %");
73  display.print(minH, 0);
74  display.print("  Maks %");
75  display.print(maxH, 0);
76  display.display();
77}

Raspberry Pi Pico y MicroPython con AHT20

En la Raspberry Pi Pico con MicroPython ni siquiera necesitas una librería aparte; el protocolo es tan simple que puedes escribirlo tú mismo en pocas líneas. El código espera primero 40 ms por el tiempo de arranque del sensor, mira el bit de calibración del byte de estado y, si hace falta, envía el comando de inicialización. Después, en cada medición envía el comando 0xAC, espera 80 ms, lee hasta que el bit de ocupado se pone a cero y calcula el resultado con las fórmulas explicadas arriba. Si usas un AHT10, basta con llamar a aht_init(True). El bus I2C0 de la Pico está aquí en los pines GP4 (SDA) y GP5 (SCL); si quieres añadir una OLED, puedes usar el controlador ssd1306.py con el mismo objeto i2c. Para instalar MicroPython, consulta el artículo qué es la Raspberry Pi Pico.

MicroPython
1from machine import Pin, I2C
2import time
3
4ADDR = 0x38                                     # AHT10/AHT20 I2C adresi / I2C address
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
6print("I2C:", [hex(a) for a in i2c.scan()])     # 0x38 görünmeli / 0x38 should appear
7
8def aht_init(aht10=False):
9    time.sleep_ms(40)                           # açılış süresi / power-up time
10    status = i2c.readfrom(ADDR, 1)[0]
11    if not status & 0x08:                       # kalibre değilse / if not calibrated
12        cmd = 0xE1 if aht10 else 0xBE           # AHT10: 0xE1, AHT20: 0xBE
13        i2c.writeto(ADDR, bytes([cmd, 0x08, 0x00]))
14        time.sleep_ms(10)
15
16def aht_read():
17    i2c.writeto(ADDR, bytes([0xAC, 0x33, 0x00])) # ölçümü başlat / trigger measurement
18    time.sleep_ms(80)
19    d = i2c.readfrom(ADDR, 6)
20    while d[0] & 0x80:                          # meşgulse bekle / wait while busy
21        time.sleep_ms(10)
22        d = i2c.readfrom(ADDR, 6)
23    raw_h = (d[1] << 12) | (d[2] << 4) | (d[3] >> 4)
24    raw_t = ((d[3] & 0x0F) << 16) | (d[4] << 8) | d[5]
25    h = raw_h * 100 / 1048576                   # RH = S_RH / 2^20 * 100
26    t = raw_t * 200 / 1048576 - 50              # T = S_T / 2^20 * 200 - 50
27    return t, h
28
29aht_init()                                      # AHT10 için aht_init(True) / use aht_init(True) for AHT10
30while True:
31    t, h = aht_read()
32    print("Sicaklik: {:.1f} C  Nem: %{:.1f}".format(t, h))
33    time.sleep(2)                               # 2 saniyede bir / every 2 seconds

Ideas de proyectos con el AHT20

  • Medidor de humedad por habitación: pon un AHT20 y una pequeña OLED en cada habitación y comprueba cuál es la más seca en invierno.
  • Humidificador automático: cuando la humedad baje del 40 %, enciende el humidificador con un módulo de relé y apágalo al 50 %.
  • Control del extractor del baño: activa el extractor cuando la humedad supere el 70 % después de la ducha; puedes usar el circuito del artículo control de ventilador con Arduino.
  • Mini invernadero e incubadora: controla temperatura y humedad a la vez; el proyecto de invernadero inteligente es un buen punto de partida.
  • Registrador de datos con batería: pon el ESP32 en modo deep sleep y mide cada 10 minutos; el AHT20 consume menos de un microamperio en reposo.
  • Termostato inteligente: mide la temperatura con ±0,3 °C de precisión y enciende y apaga la caldera con un relé; los detalles están en el artículo termostato con Arduino.
  • Alarma de humedad para armarios y trasteros: avisa con un zumbador cuando la humedad supere el 65 % y actúa antes de que aparezca moho.

Errores frecuentes y soluciones

SíntomaCausa probableSolución
Mensaje "bulunamadi", begin() devuelve falseSDA y SCL invertidos, cable flojo o alimentación incorrectaRevisa los cables y busca la dirección 0x38 con un escáner I2C
El escáner no encuentra ninguna direcciónEl módulo no tiene resistencias pull-up o la masa no es comúnAñade pull-ups de 4,7 kΩ de SDA y SCL a 3,3 V y une las masas
La temperatura sale 2–3 °C más altaEl sensor se ve afectado por el calor del Arduino, el regulador o la pantallaAleja el sensor de las placas con un cable y haz orificios de ventilación en la caja
La humedad está siempre cerca del 100 % o no cambiaEl sensor ha sufrido condensación o su superficie está suciaDéjalo varias horas en un ambiente seco y templado y no toques la superficie del sensor
De vez en cuando valores absurdos (p. ej. -50 °C)Lectura antes de terminar la medición, lecturas demasiado frecuentes o ruido en el busEspera al menos 2 s entre lecturas, usa cables cortos y comprueba el CRC en el AHT20
Con la OLED el AHT10 se cuelgaProblema de algunos módulos AHT10 al compartir el bus I2CPasa al AHT20 o conecta el AHT10 a un bus I2C aparte
Para que el sensor mida bien, tiene que estar en contacto con el aire. Si lo metes en una caja cerrada, haz siempre un orificio delante del sensor y colócalo en un compartimento separado del regulador y del microcontrolador, que se calientan. La luz solar directa, la parte superior de un radiador o la esquina de un muro exterior no reflejan el valor real de la habitación; mide a la altura a la que te sientas y cerca del centro de la habitación.

El AHT10 y, sobre todo, el AHT20 ofrecen, a pesar de su bajo precio, una precisión más que suficiente para controlar el clima interior, y gracias al I2C son muy fáciles de conectar y de combinar con otros módulos. Si empezaste antes con el DHT11, puedes pasar el mismo proyecto al AHT20 cambiando unas pocas líneas y comprobar por ti mismo lo estables que se vuelven las mediciones. En la app BlueGrays encontrarás, paso a paso y con esquemas y código, proyectos como la medición de temperatura y humedad con DHT11, un indicador con LCD y ESP32, una pantalla del tiempo con OLED y un registrador de temperatura con tarjeta microSD, y podrás adaptarlos fácilmente al AHT20.

Preguntas frecuentes

¿Cuál es la diferencia entre el AHT10 y el AHT20?

Los dos tienen el mismo rango de medición y una precisión de aproximadamente ±0,3 °C y ±2 % RH. El AHT20 ofrece un rango de alimentación más amplio (2,0–5,5 V), comprobación de datos con CRC y mejor estabilidad a largo plazo; además, los comandos de inicialización son distintos. Para proyectos nuevos conviene elegir el AHT20.

¿Cuál es la dirección I2C del AHT20?

La dirección del AHT20 es 0x38 fija y no se puede cambiar. En el AHT10 se puede elegir 0x38 o 0x39 con el pin ADR. Para usar dos AHT20 hacen falta un segundo bus I2C o un multiplexor I2C como el TCA9548A.

¿Es mejor el AHT20 o el DHT22?

Para la mayoría de los proyectos domésticos es mejor el AHT20: su precisión es igual o mejor que la del DHT22, es más barato, mide más rápido y, gracias al I2C, comparte los mismos dos cables con otros módulos. La ventaja del DHT22 es que puede funcionar con cables largos; el I2C funciona mejor con cables cortos, de menos de 1 metro.

¿Se puede conectar el AHT10 a un Arduino a 5 V?

Los módulos con regulador funcionan con seguridad a 5 V; comprueba si la placa lleva un pequeño regulador de tres patillas y la inscripción VIN. En las placas AHT10 sin regulador, como el límite superior del chip es 3,6 V, debes alimentar el módulo a 3,3 V.

¿Por qué el AHT20 marca una temperatura alta?

La causa más frecuente es que el sensor recibe el calor del Arduino, del regulador de tensión o de la pantalla. Medir con demasiada frecuencia también calienta un poco el chip. Mantén el sensor lejos de las placas, al final de un cable, y mide como mucho una vez cada 2 segundos.

¿Cuál debe ser la humedad ideal en casa?

En interiores se considera ideal una humedad relativa del 40–60 %. En invierno, por la calefacción, la humedad puede bajar del 30 %; entonces aumentan la sequedad de garganta y piel. Por encima del 60 % empiezan a empañarse los cristales y, con el tiempo, aparece el riesgo de moho.

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
ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

4.3(10)
22
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)

El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

4.3(10)
16
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
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