Creando un Termostato Inteligente con Arduino y Sensor DHT11: ¡Control de Temperatura Preciso!

¡Bienvenido a este emocionante tutorial donde construiremos un Termostato Inteligente con Arduino! 🌡️✨

En la actualidad, el control automático de la temperatura en nuestros hogares u oficinas se ha vuelto fundamental para el confort y la eficiencia energética. Con Arduino, podemos crear sistemas personalizados que se ajusten perfectamente a nuestras necesidades. En este tutorial, no solo aprenderás a medir la temperatura y humedad, sino también a usar estos datos para activar o desactivar un sistema de calefacción o refrigeración.

🎯 ¿Qué Aprenderás en Este Tutorial?

Al finalizar este tutorial, serás capaz de:

• Conectar y leer datos de un sensor de temperatura y humedad DHT11.
• Utilizar un módulo de relé para controlar un dispositivo de climatización (por ejemplo, un ventilador o una resistencia calefactora).
• Programar Arduino para establecer un umbral de temperatura y activar/desactivar el relé automáticamente.
• Mostrar la temperatura, humedad y el estado del sistema en una pantalla LCD 16x2.
• Entender los principios básicos de un sistema de control de bucle cerrado.

🛠️ Materiales Necesarios

Para llevar a cabo este proyecto, necesitarás los siguientes componentes. Puedes encontrar la mayoría de ellos en kits de inicio de Arduino o tiendas de electrónica.

🔌 Conexiones Eléctricas: Montando Nuestro Circuito

El primer paso es conectar todos los componentes a nuestra placa Arduino. Sigue cuidadosamente los siguientes diagramas y descripciones.

1. Conexión del Sensor DHT11

El DHT11 tiene 3 o 4 pines, dependiendo de si viene en un módulo o solo el sensor. Los pines suelen ser VCC, GND y Data. Si tiene un cuarto pin, a menudo es NC (No Conectado) o un pin de resistencia pull-up que ya está cubierto si usas un módulo.

• VCC (o +): Conéctalo a 5V en Arduino.
• GND (o -): Conéctalo a GND en Arduino.
• Data (o OUT): Conéctalo a un pin digital de Arduino (usaremos el pin 2).

Si tu DHT11 no viene en un módulo, necesitarás añadir una resistencia pull-up de 10k Ohm entre el pin Data y VCC. El pin Data debe tener esta resistencia para asegurar una lectura estable.

2. Conexión de la Pantalla LCD 16x2 con I2C

El módulo I2C para LCD simplifica enormemente el cableado, usando solo 4 pines.

• VCC: Conéctalo a 5V en Arduino.
• GND: Conéctalo a GND en Arduino.
• SDA: Conéctalo al pin analógico A4 en Arduino Uno.
• SCL: Conéctalo al pin analógico A5 en Arduino Uno.

3. Conexión del Módulo de Relé

El módulo de relé actúa como un interruptor controlado electrónicamente. Tiene pines para alimentación, tierra y señal de control.

• VCC: Conéctalo a 5V en Arduino.
• GND: Conéctalo a GND en Arduino.
• IN (o SIG): Conéctalo a un pin digital de Arduino (usaremos el pin 7).

Para el dispositivo que vas a controlar (por ejemplo, un ventilador o una lámpara pequeña), lo conectarás a los terminales del relé. Un relé de un canal suele tener tres terminales para la carga: Normalmente Abierto (NO), Normalmente Cerrado (NC) y Común (COM).

• Para encender un dispositivo cuando el relé se activa, conecta una de las líneas de alimentación del dispositivo a COM y la otra línea a NO.
• Para apagar un dispositivo cuando el relé se activa, conecta una de las líneas de alimentación del dispositivo a COM y la otra línea a NC.

4. Resumen del Cableado Completo

Aquí tienes una tabla resumen de todas las conexiones:

💻 Programando el Arduino: El Cerebro de Nuestro Termostato

Ahora que tenemos el hardware montado, es hora de escribir el código que dará vida a nuestro termostato inteligente. Necesitaremos instalar algunas librerías.

1. Instalación de Librerías

Abra tu IDE de Arduino y ve a Sketch > Incluir Librería > Administrar Librerías... y busca e instala las siguientes:

• DHT sensor library de Adafruit (para el sensor DHT11)
• LiquidCrystal I2C de Frank de Brabandere o Marc F. Desgroseilliers (para la pantalla LCD con I2C)

2. El Código Fuente (Esqueleto)

Aquí tienes el código completo. Lo explicaremos en detalle después.

#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Definiciones de pines
#define DHTPIN 2          // Pin donde está conectado el pin DATA del DHT11
#define DHTTYPE DHT11     // Tipo de sensor DHT (DHT11 o DHT22)
#define RELAY_PIN 7       // Pin donde está conectado el pin IN del relé

// Umbrales de temperatura
const float TEMP_MIN = 22.0; // Temperatura mínima deseada para activar el calentamiento
const float TEMP_MAX = 24.0; // Temperatura máxima deseada para activar el enfriamiento

// Inicialización de objetos
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2); // Cambia 0x27 por la dirección I2C de tu LCD si es diferente

void setup() {
  Serial.begin(9600);
  Serial.println("Termostato Inteligente Iniciando...");

  // Inicializar sensor DHT
  dht.begin();

  // Inicializar LCD
  lcd.init();
  lcd.backlight(); // Encender la luz de fondo de la LCD
  lcd.print("Termostato ON");
  lcd.setCursor(0, 1);
  lcd.print("Cargando...");

  // Configurar pin del relé como salida
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW); // Asegurarse de que el relé esté apagado al inicio
}

void loop() {
  // Esperar un poco entre lecturas (el DHT11 necesita 2 segundos)
  delay(2000);

  // Leer temperatura y humedad
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // Lee la temperatura en grados Celsius
  // float f = dht.readTemperature(true); // Para leer en Fahrenheit

  // Comprobar si las lecturas fallaron y volver a intentarlo
  if (isnan(h) || isnan(t)) {
    Serial.println("Error: No se pudo leer el sensor DHT!");
    lcd.clear();
    lcd.print("DHT Error!");
    lcd.setCursor(0, 1);
    lcd.print("Revisar sensor");
    return; // Salir del loop para volver a intentar
  }

  // Lógica de control del termostato
  String status_clima = "INACTIVO";

  if (t < TEMP_MIN) {
    // Si la temperatura actual es menor que la mínima deseada, activar calentamiento (o desactivar enfriamiento)
    digitalWrite(RELAY_PIN, HIGH); // ACTIVA el relé (depende de cómo lo conectes, LOW/HIGH para ON/OFF)
    status_clima = "CALENTANDO";
  } else if (t > TEMP_MAX) {
    // Si la temperatura actual es mayor que la máxima deseada, activar enfriamiento (o desactivar calentamiento)
    digitalWrite(RELAY_PIN, HIGH); // ACTIVA el relé (depende de cómo lo conectes, LOW/HIGH para ON/OFF)
    status_clima = "ENFRIANDO";
  } else {
    // La temperatura está dentro del rango deseado, apagar el dispositivo
    digitalWrite(RELAY_PIN, LOW); // DESACTIVA el relé
    status_clima = "NORMAL";
  }

  // Mostrar información en el monitor serial
  Serial.print("Humedad: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.print(" *C");
  Serial.print("\tEstado: ");
  Serial.println(status_clima);

  // Mostrar información en la LCD
  lcd.clear();
  lcd.print("Temp: ");
  lcd.print(t, 1); // Muestra la temperatura con 1 decimal
  lcd.print((char)223); // Carácter de grado (°) en ASCII
  lcd.print("C Hum: ");
  lcd.print(h, 0); // Muestra la humedad sin decimales
  lcd.print("%");

  lcd.setCursor(0, 1); // Ir a la segunda línea
  lcd.print("Status: ");
  lcd.print(status_clima);
}

3. Explicación del Código 📖

Inclusión de Librerías

#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

• DHT.h: Proporciona funciones para interactuar con el sensor DHT11/DHT22.
• Wire.h: Librería necesaria para la comunicación I2C, que usa nuestra LCD.
• LiquidCrystal_I2C.h: Controla la pantalla LCD a través del protocolo I2C.

Definiciones de Pines y Variables Globales

#define DHTPIN 2
#define DHTTYPE DHT11
#define RELAY_PIN 7

const float TEMP_MIN = 22.0;
const float TEMP_MAX = 24.0;

DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2);

• DHTPIN, DHTTYPE, RELAY_PIN: Macros para definir los pines y el tipo de sensor. Esto facilita cambios futuros.
• TEMP_MIN, TEMP_MAX: Variables clave que definen el rango de temperatura deseado. Puedes ajustarlas a tu preferencia.
• DHT dht(DHTPIN, DHTTYPE): Crea una instancia del objeto DHT.
• LiquidCrystal_I2C lcd(0x27, 16, 2): Crea una instancia del objeto LCD. 0x27 es la dirección I2C común, pero podría ser 0x3F para algunos módulos. 16 y 2 son las dimensiones de la pantalla (columnas x filas).

Función setup()

void setup() {
  Serial.begin(9600);
  dht.begin();
  lcd.init();
  lcd.backlight();
  lcd.print("Termostato ON");
  lcd.setCursor(0, 1);
  lcd.print("Cargando...");
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);
}

• Serial.begin(9600): Inicializa la comunicación serial para depuración.
• dht.begin(): Inicializa el sensor DHT.
• lcd.init() y lcd.backlight(): Inicializan la pantalla LCD y encienden su retroiluminación.
• lcd.print() y lcd.setCursor(): Muestran mensajes iniciales en la LCD.
• pinMode(RELAY_PIN, OUTPUT): Configura el pin del relé como salida.
• digitalWrite(RELAY_PIN, LOW): Asegura que el relé esté inicialmente apagado.

Función loop()

Esta es la función principal que se ejecuta repetidamente.

void loop() {
  delay(2000);
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    // Manejo de error
  }

  String status_clima = "INACTIVO";

  if (t < TEMP_MIN) {
    digitalWrite(RELAY_PIN, HIGH); // O LOW, según tu relé y conexión
    status_clima = "CALENTANDO";
  } else if (t > TEMP_MAX) {
    digitalWrite(RELAY_PIN, HIGH); // O LOW
    status_clima = "ENFRIANDO";
  } else {
    digitalWrite(RELAY_PIN, LOW); // O HIGH
    status_clima = "NORMAL";
  }
  // ... (impresión en Serial y LCD)
}

• delay(2000): El sensor DHT11 necesita al menos 2 segundos entre lecturas para funcionar correctamente. Este delay es crucial.
• dht.readHumidity() y dht.readTemperature(): Leen los valores del sensor. isnan() verifica si la lectura fue exitosa.
• Lógica de control: Aquí es donde el "termostato inteligente" cobra vida:
  • Si la temperatura (t) es menor que TEMP_MIN, asumimos que necesitamos calentar (o evitar un enfriamiento excesivo). El relé se activa.
  • Si la temperatura (t) es mayor que TEMP_MAX, asumimos que necesitamos enfriar (o evitar un calentamiento excesivo). El relé se activa.
  • Si la temperatura está entre TEMP_MIN y TEMP_MAX, el relé se desactiva, manteniendo la temperatura en el rango deseado.
• Importante: El digitalWrite(RELAY_PIN, HIGH) o LOW para activar/desactivar el relé depende de tu módulo. Algunos módulos de relé se activan con un estado BAJO (LOW) en el pin de control, mientras que otros lo hacen con un estado ALTO (HIGH). ¡Experimenta con esto si no funciona como esperas!
• Las últimas líneas actualizan el Serial Monitor y la LCD con los datos actuales y el estado del termostato.

✅ Puesta en Marcha y Pruebas

Una vez que hayas cargado el código a tu Arduino y verificado las conexiones, es hora de probar tu termostato.

1. Conecta el Arduino al ordenador vía USB.
2. Abre el Monitor Serial en el IDE de Arduino (Herramientas > Monitor Serial) y asegúrate de que la velocidad sea 9600 baudios.
3. Observa la LCD y el Monitor Serial: Deberías ver las lecturas de temperatura y humedad, junto con el estado del sistema.
4. Simula cambios de temperatura: Puedes probar a calentar suavemente el sensor DHT11 (con tu mano o aire caliente a una distancia segura) o enfriarlo (con un poco de aire de un ventilador) para ver cómo reacciona el relé y el estado del sistema.
5. Ajusta los umbrales: Modifica TEMP_MIN y TEMP_MAX en el código y vuelve a cargar para personalizar el comportamiento de tu termostato.

✨ Mejoras y Posibles Extensiones

Este termostato básico es un excelente punto de partida. Aquí hay algunas ideas para llevarlo al siguiente nivel:

• Control de Histéresis: Para evitar que el relé se encienda y apague constantemente cuando la temperatura está cerca del umbral, puedes implementar una histéresis (por ejemplo, encender a 22°C y apagar a 23°C en lugar de ambos en 22°C).
• Interfaz de Usuario Avanzada: Añade botones para ajustar TEMP_MIN y TEMP_MAX directamente desde la LCD, sin necesidad de reprogramar Arduino.
• Conectividad: Integra un módulo WiFi (ESP8266) para controlar el termostato desde tu teléfono o monitorear los datos de forma remota.
• Programación Horaria: Añade un módulo RTC (Real Time Clock) para establecer horarios específicos de encendido/apagado o diferentes rangos de temperatura para el día y la noche.
• Múltiples Sensores: Conecta varios sensores DHT11 en diferentes habitaciones y promedia las lecturas o controla zonas individuales.
• Más Potencia: Si necesitas controlar aparatos de mayor potencia, asegúrate de usar relés adecuados o contactores, siempre con las debidas precauciones de seguridad.

💡 Conclusión

¡Felicidades! 🎉 Has construido tu propio termostato inteligente con Arduino, aprendiendo sobre la lectura de sensores, el control de actuadores (relés) y la visualización de datos en una pantalla LCD. Este proyecto es una base sólida para explorar el mundo de la automatización del hogar y la Internet de las Cosas (IoT) con Arduino.

¡Esperamos que hayas disfrutado de este tutorial y te animes a seguir experimentando y creando! ¡El límite es tu imaginación!