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ística | AHT10 | AHT20 |
|---|---|---|
| Fabricante | Aosong (ASAIR) | Aosong (ASAIR) |
| Interfaz y dirección | I2C, 0x38 (0x39 con el pin ADR) | I2C, 0x38 fija |
| Tensión de alimentación del chip | 1,8–3,6 V | 2,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ón | 0–100 % RH / ±2 % RH | 0–100 % RH / ±2 % RH |
| Resolución | 0,01 °C / 0,024 % RH | 0,01 °C / 0,024 % RH |
| Tiempo de medición | Unos 75 ms | Unos 80 ms |
| Corriente en reposo | Menos de 1 µA | Menos de 1 µA |
| Comando de inicialización | 0xE1 0x08 0x00 | 0xBE 0x08 0x00 |
| Comprobación CRC | No | Sí (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ística | AHT10 / AHT20 | DHT11 | DHT22 (AM2302) |
|---|---|---|---|
| Comunicación | I2C (2 hilos) | Protocolo propio de un hilo | Protocolo propio de un hilo |
| Rango de temperatura | -40…+85 °C | 0…50 °C | -40…+80 °C |
| Precisión de temperatura | ±0,3 °C | ±2 °C | ±0,5 °C |
| Rango de humedad | 0–100 % RH | 20–90 % RH | 0–100 % RH |
| Precisión de humedad | ±2 % RH | ±5 % RH | ±2–5 % RH |
| Resolución | 0,01 °C / 0,024 % RH | 1 °C / 1 % RH | 0,1 °C / 0,1 % RH |
| Intervalo de lectura | Unos 80 ms (recomendado 2 s) | 1 s | 2 s |
| Otros dispositivos en el mismo bus | Sí (I2C) | No | No |
| Precio | Bajo | El más bajo | Medio |
¿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 AHT | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN / VCC | 5V (o 3.3V) | 3V3 | 3V3(OUT), pin 36 |
| GND | GND | GND | GND (p. ej. pin 38) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) |
| SDA | A4 | GPIO 21 | GP4 (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.
Paso a paso: primera medición con Arduino
- 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.
- Conecta el sensor según la tabla anterior: VIN a 5V, GND a GND, SCL a A5 y SDA a A4.
- 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.
- Sube el código siguiente y abre el Monitor Serie a 9600 baudios.
- 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.
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.temperature | Temperatura en grados Celsius (float). |
| humidity.relative_humidity | Humedad 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.
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 relativa | Situación | ¿Qué hacer? |
|---|---|---|
| Por debajo del 30 % | Muy seco: sequedad de garganta, ojos y piel, electricidad estática | Usa un humidificador y baja un poco la calefacción |
| 30–40 % | Algo seco, frecuente en invierno | Poner un recipiente con agua o tender la ropa ayuda |
| 40–60 % | Rango ideal | Mantenlo así |
| 60–70 % | Húmedo: empiezan a empañarse los cristales | Ventila poco tiempo pero a menudo |
| Por encima del 70 % | Alto riesgo de moho y ácaros | Ventila 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).

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.
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.
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 secondsIdeas 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íntoma | Causa probable | Solución |
|---|---|---|
| Mensaje "bulunamadi", begin() devuelve false | SDA y SCL invertidos, cable flojo o alimentación incorrecta | Revisa los cables y busca la dirección 0x38 con un escáner I2C |
| El escáner no encuentra ninguna dirección | El módulo no tiene resistencias pull-up o la masa no es común | Añ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 alta | El sensor se ve afectado por el calor del Arduino, el regulador o la pantalla | Aleja 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 cambia | El sensor ha sufrido condensación o su superficie está sucia | Dé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 bus | Espera al menos 2 s entre lecturas, usa cables cortos y comprueba el CRC en el AHT20 |
| Con la OLED el AHT10 se cuelga | Problema de algunos módulos AHT10 al compartir el bus I2C | Pasa al AHT20 o conecta el AHT10 a un bus I2C aparte |
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.
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.

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.

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.

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.

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…

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

