Introducción

¿Cómo podemos saber qué tan húmedo está el ambiente y a qué temperatura se encuentra utilizando un solo sensor?

En esta práctica utilizaremos el sensor de humedad y temperatura AMT1001 junto con un Arduino UNO.

Este módulo entrega la humedad relativa como una señal analógica de voltaje y la temperatura mediante un termistor NTC de 10 kΩ, por lo que no necesita librerías ni protocolos de comunicación: basta con dos entradas analógicas del Arduino.

Su rango de medición de humedad es de aproximadamente 20 a 90 % HR, lo que lo hace útil para proyectos de monitoreo ambiental, invernaderos, humidificadores y control de clima.

Durante esta práctica aprenderemos a identificar sus cables, conectarlo correctamente al Arduino UNO, leer sus dos señales y convertirlas en humedad relativa (%) y temperatura (°C).

¿Qué es el AMT1001?

El AMT1001 es un módulo que integra un sensor de humedad de tipo resistivo y un sensor de temperatura. Internamente incluye un circuito que procesa la señal del elemento de humedad, la compensa por temperatura y la entrega como un voltaje proporcional a la humedad relativa.

La temperatura se obtiene por separado: el módulo incorpora un termistor NTC, una resistencia cuyo valor disminuye cuando la temperatura aumenta.

A diferencia de sensores digitales como el DHT11, el AMT1001 no envía datos en forma de bits. En cambio, entrega señales analógicas que Arduino lee directamente con su convertidor analógico-digital.

Características principales

Característica	Valor
Modelo	AMT1001
Tipo de sensor de humedad	Resistivo, con compensación de temperatura
Salida de humedad	Analógica (voltaje)
Rango de humedad	20 – 90 % HR
Voltaje de salida aproximado	Entre 0.6 y 2.7 V (según la humedad)
Precisión de humedad	± 5 % HR (a 25 °C)
Sensor de temperatura	Termistor NTC de 10 kΩ (a 25 °C)
Rango de temperatura	0 – 50 °C
Precisión de temperatura	± 1 °C
Tiempo de respuesta	Aproximadamente 10 segundos
Alimentación	5 V (admite de 4 a 5.5 V)
Tamaño (sin cables)	60 x 26 x 14 mm
Longitud del cable	200 mm

¿Cómo funciona?

El funcionamiento puede dividirse en varios pasos:

1. El elemento sensor cambia su resistencia eléctrica según la humedad del aire.
2. El circuito interno del módulo mide ese cambio y lo compensa por temperatura.
3. El módulo genera un voltaje proporcional a la humedad relativa.
4. Arduino lee ese voltaje mediante una entrada analógica y lo convierte a porcentaje.
5. Al mismo tiempo, el termistor NTC cambia su resistencia según la temperatura.
6. Con una resistencia fija de 10 kΩ formamos un divisor de voltaje que Arduino lee en otra entrada analógica.
7. El programa calcula la resistencia del termistor y, a partir de ella, la temperatura.

La relación entre voltaje y humedad es lineal: cada 0.03 V equivalen aproximadamente a 1 % de humedad relativa. Por ejemplo, 0.6 V corresponden a 20 % HR y 2.7 V a 90 % HR.

Material necesario

• Arduino UNO.
• Sensor de humedad y temperatura AMT1001.
• Resistencia de 10 kΩ.
• Protoboard.
• Cables Dupont.
• Cable USB para Arduino UNO.
• Opcional: un higrómetro o termómetro de referencia para comparar las mediciones.

Tabla de conexiones

AMT1001	Arduino UNO	Función
Rojo (VCC)	5V	Alimentación
Negro (GND)	GND	Tierra
Amarillo (humedad)	A0	Salida analógica de humedad
Blanco (temperatura)	A1 (con resistencia de 10 kΩ a 5V)	Termistor NTC de 10 kΩ

La resistencia de 10 kΩ se coloca entre 5V y el pin A1, en el mismo punto donde llega el cable blanco. De esta forma, la resistencia fija y el termistor forman un divisor de voltaje.

Nota: los colores habituales son rojo = VCC, amarillo = humedad, blanco = temperatura y negro = GND, pero pueden variar según el proveedor. Antes de conectar, puedes comprobarlo con un multímetro: entre el cable de temperatura y GND debes medir cerca de 10 kΩ a 25 °C (unos 12 kΩ a 20 °C y 8.3 kΩ a 30 °C, según la hoja de datos). Invertir la alimentación puede dañar el sensor.

⚠️ Recomendación para la alimentación

El sensor requiere una alimentación estable de 5 V. Como el programa calcula la humedad a partir del voltaje, cualquier variación en la alimentación del Arduino se refleja en la lectura.

Para una primera prueba basta con alimentar el Arduino por USB. En un montaje definitivo conviene usar una fuente estable y mantener los cables del sensor lo más cortos posible para reducir el ruido eléctrico.

¿Por qué dos entradas analógicas y una resistencia de 10 kΩ?

Las dos señales del AMT1001 son analógicas, por lo que usamos dos entradas analógicas del Arduino: A0 para la humedad y A1 para la temperatura. Arduino convierte cada voltaje en una lectura entre 0 y 1023 mediante su convertidor analógico-digital.

La salida de humedad ya es un voltaje, así que se conecta directamente. El termistor, en cambio, no genera voltaje por sí mismo: solo cambia su resistencia. Para que Arduino pueda medirlo, lo combinamos con una resistencia fija de 10 kΩ conectada a 5V.

Así se forma un divisor de voltaje. Cuando la temperatura sube, la resistencia del termistor baja y el voltaje en A1 disminuye; cuando la temperatura baja, el voltaje aumenta. A 25 °C ambas resistencias valen 10 kΩ y el voltaje en A1 es de aproximadamente 2.5 V.

El código

Ahora podemos utilizar un programa sencillo para leer el sensor y mostrar la humedad y la temperatura en el Monitor Serial.

// ==========================================
// SENSOR DE HUMEDAD Y TEMPERATURA AMT1001
// ARDUINO UNO
// HUMEDAD: 20 - 90 % HR
// ==========================================

const int pinHumedad = A0;      // Cable amarillo
const int pinTemperatura = A1;  // Cable blanco

// Datos del divisor y del termistor
const float R_FIJA = 10000.0;     // Resistencia de 10 k a 5V
const float R_NOMINAL = 10000.0;  // NTC: 10 k a 25 C
const float T_NOMINAL = 25.0;     // Temperatura nominal
const float BETA = 3435.0;        // Coeficiente B del NTC

void setup() {

  Serial.begin(9600);

  Serial.println("================================");
  Serial.println(" SENSOR AMT1001");
  Serial.println(" HUMEDAD Y TEMPERATURA");
  Serial.println("================================");
}

void loop() {

  // ---------- HUMEDAD ----------
  int lecturaH = analogRead(pinHumedad);

  // Convertir la lectura ADC a voltaje
  float voltajeH = lecturaH * (5.0 / 1023.0);

  // 0.03 V equivalen a 1 % de humedad relativa
  float humedad = voltajeH / 0.03;

  // ---------- TEMPERATURA ----------
  int lecturaT = analogRead(pinTemperatura);

  float temperatura = 0;
  bool temperaturaValida = false;

  // Evitar divisiones entre cero si el cable esta suelto
  if (lecturaT > 0 && lecturaT < 1023) {

    // Resistencia del termistor a partir del divisor
    float resistencia = R_FIJA * lecturaT / (1023.0 - lecturaT);

    // Ecuacion Beta para obtener la temperatura
    float kelvin = 1.0 / (1.0 / (T_NOMINAL + 273.15)
                   + log(resistencia / R_NOMINAL) / BETA);

    temperatura = kelvin - 273.15;
    temperaturaValida = true;
  }

  // ---------- MOSTRAR RESULTADOS ----------
  Serial.print("Voltaje: ");
  Serial.print(voltajeH, 2);
  Serial.print(" V");

  if (humedad < 20 || humedad > 90) {
    Serial.print(" | Humedad: fuera de rango");
  } else {
    Serial.print(" | Humedad: ");
    Serial.print(humedad, 1);
    Serial.print(" %");
  }

  if (temperaturaValida) {
    Serial.print(" | Temperatura: ");
    Serial.print(temperatura, 1);
    Serial.println(" C");
  } else {
    Serial.println(" | Temperatura: revisar conexion");
  }

  delay(1000);
}

¿Qué hace el programa?

Primero definimos los pines donde están conectadas las dos señales del sensor:

const int pinHumedad = A0;
const int pinTemperatura = A1;

Después iniciamos la comunicación con el Monitor Serial:

Serial.begin(9600);

En el loop() Arduino lee primero la salida de humedad:

int lecturaH = analogRead(pinHumedad);

Esta lectura tiene un valor entre 0 y 1023. La convertimos a voltaje:

float voltajeH = lecturaH * (5.0 / 1023.0);

Y como cada 0.03 V equivalen a 1 % de humedad relativa, dividimos el voltaje entre 0.03:

float humedad = voltajeH / 0.03;

Para la temperatura, primero calculamos la resistencia del termistor a partir del divisor de voltaje:

float resistencia = R_FIJA * lecturaT / (1023.0 - lecturaT);

Después aplicamos la ecuación Beta, que relaciona la resistencia de un termistor NTC con su temperatura:

float kelvin = 1.0 / (1.0 / (T_NOMINAL + 273.15)
               + log(resistencia / R_NOMINAL) / BETA);

temperatura = kelvin - 273.15;

El if evita realizar el cálculo cuando la lectura es 0 o 1023 (por ejemplo, si el cable blanco está desconectado), ya que en esos casos la fórmula no tiene sentido.

El valor BETA = 3435 es el coeficiente que indica la hoja de datos para el termistor del AMT1001 (10 kΩ a 25 °C). La ecuación Beta es una aproximación, por lo que para mayor precisión conviene comparar la lectura con un termómetro de referencia.

Prueba en el Monitor Serial

Después de cargar el programa en el Arduino UNO, abrimos el Monitor Serial y seleccionamos:

9600 baudios

Deberías ver una línea nueva cada segundo, similar a esta:

Voltaje: 1.52 V | Humedad: 50.7 % | Temperatura: 24.8 C

Los valores reales dependerán de las condiciones del lugar donde realices la prueba.

Realizando la prueba

Para comprobar el funcionamiento podemos acercar el aliento al sensor: la humedad debe subir en unos segundos y regresar lentamente a su valor original. Si sujetamos el sensor con los dedos, la temperatura debe aumentar poco a poco.

Esta tabla muestra la relación teórica entre el voltaje de salida y la humedad relativa:

Voltaje de salida	Humedad relativa
0.60 V	20 %
1.20 V	40 %
1.50 V	50 %
1.80 V	60 %
2.40 V	80 %
2.70 V	90 %

Puedes verificar estos valores midiendo con un multímetro el voltaje entre el cable amarillo y GND.

¿Por qué la medición puede variar?

Es importante entender que el sensor no es un instrumento de laboratorio.

La medición puede verse afectada por diferentes factores:

• Variaciones en la alimentación de 5 V.
• Ruido eléctrico y cables largos.
• Corrientes de aire o fuentes de calor cercanas.
• Condensación de agua sobre el sensor.
• Tolerancia de la resistencia de 10 kΩ.
• Tolerancia del termistor y de su coeficiente Beta.
• Tiempo de respuesta: el sensor tarda alrededor de 10 segundos en estabilizarse después de un cambio.

Importante: el sensor está diseñado para ambientes sin condensación. No debe mojarse ni utilizarse donde se formen gotas de agua sobre él, ya que la lectura deja de ser confiable y el elemento sensor puede dañarse.

Mejora: promediar varias lecturas

Las lecturas analógicas suelen fluctuar ligeramente entre una y otra. Una forma sencilla de estabilizar el resultado es tomar varias lecturas seguidas y calcular su promedio.

Para ello, agrega esta función al final del programa:

// Promedio de 10 lecturas para reducir el ruido
int leerPromedio(int pin) {
  long suma = 0;
  for (int i = 0; i < 10; i++) {
    suma += analogRead(pin);
    delay(5);
  }
  return suma / 10;
}

Después reemplaza las dos líneas de lectura del programa original:

int lecturaH = leerPromedio(pinHumedad);
int lecturaT = leerPromedio(pinTemperatura);

El resto del programa permanece igual.

Calibración del sensor

Una de las mejoras que podemos realizar posteriormente es calibrar el sensor.

El procedimiento consiste en comparar las lecturas del AMT1001 con un higrómetro y un termómetro de referencia en diferentes condiciones y registrar la diferencia.

Por ejemplo:

Referencia        AMT1001        Diferencia
-------------------------------------------
45 % HR           47.2 %         +2.2 %
60 % HR           61.8 %         +1.8 %
24.0 C            24.6 C         +0.6 C

Con estos datos podemos restar la diferencia promedio en el programa o ajustar el valor de BETA para obtener mediciones más cercanas a las reales. Los valores de la tabla son solo un ejemplo.

Ventajas del AMT1001

• Salida analógica lineal: la humedad se obtiene con una sola operación, sin librerías.
• Dos mediciones en un módulo: humedad relativa y temperatura.
• Compensación de temperatura: el circuito interno corrige la lectura de humedad.
• Compatible con cualquier microcontrolador: solo requiere entradas analógicas.
• Conexión sencilla: alimentación, tierra, dos señales y una resistencia.

Aplicaciones

Este sensor puede utilizarse en diferentes proyectos electrónicos y de automatización:

• Estaciones de monitoreo ambiental.
• Invernaderos y cultivos.
• Humidificadores y deshumidificadores.
• Sistemas de aire acondicionado y ventilación.
• Incubadoras.
• Control de procesos industriales.
• Instrumentos de medición.
• Proyectos educativos.

AMT1001 vs. DHT11

Característica	AMT1001	DHT11
Tipo de salida	Analógica	Digital (un solo hilo)
Librería	No requiere	Requiere
Pines de Arduino	2 analógicos	1 digital
Rango de humedad	20 – 90 % HR	20 – 90 % HR
Lectura de temperatura	Termistor NTC (requiere cálculo)	Valor digital directo

Conclusión

En esta práctica aprendimos a utilizar el sensor de humedad y temperatura AMT1001 con un Arduino UNO.

Aprendimos que este módulo entrega la humedad relativa como un voltaje analógico lineal y la temperatura mediante un termistor NTC de 10 kΩ, por lo que puede leerse sin librerías usando únicamente dos entradas analógicas.

Finalmente utilizamos Arduino para convertir las lecturas analógicas en humedad relativa y temperatura, y visualizarlas en el Monitor Serial.

Este proyecto representa una base muy útil para desarrollar sistemas más avanzados. Por ejemplo, podemos encender un ventilador o un humidificador mediante un relevador cuando la humedad salga de cierto rango, mostrar los datos en una pantalla LCD o registrar las mediciones a lo largo del día.

El siguiente paso recomendado sería calibrar el sensor con un instrumento de referencia y agregar el promedio de lecturas para obtener mediciones más estables.

Productos relacionados

Estos son los productos utilizados en esta práctica y puedes consultarlos directamente en Tecneu:

Productos utilizados en esta práctica