Controla el Entorno de tu Hogar: Sistema de Monitorización y Control de Temperatura/Humedad con Raspberry Pi

🏡 Controla el Clima de tu Hogar con Raspberry Pi

¿Alguna vez has deseado tener un control preciso sobre la temperatura y la humedad de tu casa u oficina? Con una Raspberry Pi y unos pocos componentes, puedes construir tu propio sistema inteligente para monitorizar y regular el ambiente. Este tutorial te llevará de la mano para crear un proyecto práctico que no solo recopilará datos ambientales, sino que también podrá actuar sobre ellos, activando o desactivando dispositivos de climatización como ventiladores o deshumidificadores.

¿Por qué construir tu propio sistema?

La Raspberry Pi es una plataforma versátil y económica que te permite ir más allá de los dispositivos comerciales. Al construir tu propio sistema, obtienes:

• Personalización: Adapta la lógica de control a tus necesidades específicas.
• Aprendizaje: Una excelente oportunidad para familiarizarte con la electrónica, la programación y la automatización.
• Flexibilidad: Integra el sistema con otras plataformas o proyectos futuros.
• Costo: A menudo, es más económico que soluciones comerciales con funcionalidades similares.

🛠️ Materiales Necesarios

Antes de empezar, asegúrate de tener todos los componentes a mano. La mayoría de ellos son fáciles de conseguir y relativamente económicos.

🔌 Diagrama de Conexión: Montaje del Hardware

El primer paso es conectar físicamente los componentes a tu Raspberry Pi. Prestaremos especial atención a la seguridad y a la correcta polaridad. Si utilizas un módulo DHT22/DHT11 con 3 pines (VCC, GND, DATA), no necesitarás la resistencia pull-up externa, ya que el módulo suele incluirla. Si tu sensor es de 4 pines, la resistencia de 10kΩ va entre VCC y DATA.

1. Conexión del Sensor DHT22

El sensor DHT22 tiene 3 o 4 pines, dependiendo del módulo. Los pines suelen ser VCC (+), GND (-) y DATA (señal). Si es de 4 pines, el segundo pin (de izquierda a derecha) a menudo no se usa.

• VCC (Pin 1): Conéctalo a un pin de 5V de la Raspberry Pi (por ejemplo, el pin 2 o 4 de la cabecera GPIO).
• DATA (Pin 2 o 3): Conéctalo a un pin GPIO de la Raspberry Pi (por ejemplo, GPIO 4 - Pin 7).
• GND (Pin 4): Conéctalo a un pin de GND de la Raspberry Pi (por ejemplo, el pin 6 o 9 de la cabecera GPIO).

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

Los módulos de relé suelen requerir una alimentación separada o pueden compartir la de la Raspberry Pi, dependiendo del modelo. Aquí asumiremos un módulo de 2 canales que se alimenta directamente de la RPi y se activa con pines GPIO.

• VCC: Conéctalo a un pin de 5V de la Raspberry Pi (si el relé necesita 5V) o a 3.3V (si es un relé de 3.3V). Revisa la especificación de tu relé. La mayoría de los relés comunes de 5V funcionan bien con los 5V de la RPi.
• GND: Conéctalo a un pin de GND de la Raspberry Pi.
• IN1 (Entrada de Control 1): Conéctalo a un pin GPIO de la Raspberry Pi (por ejemplo, GPIO 17 - Pin 11).
• IN2 (Entrada de Control 2): Conéctalo a otro pin GPIO de la Raspberry Pi (por ejemplo, GPIO 27 - Pin 13).

Los terminales de salida del relé (NO, NC, COM) son para el dispositivo de corriente alterna (AC). ¡MUCHO CUIDADO AQUÍ!

• COM (Común): Conéctalo a una de las patas del dispositivo que quieres controlar (por ejemplo, una pata del cable de alimentación de un ventilador).
• NO (Normalmente Abierto): Conéctalo a la otra pata del cable de alimentación que va a la red eléctrica. Cuando el relé se activa, el circuito se cierra entre COM y NO.
• NC (Normalmente Cerrado): (Opcional) Si quieres que el dispositivo esté encendido por defecto y se apague al activar el relé, usa NC en lugar de NO.

💻 Preparación del Software en la Raspberry Pi

Una vez que el hardware está conectado, es hora de configurar el software para que la Raspberry Pi pueda leer los sensores y controlar los relés.

1. Actualizar el Sistema Operativo

Es fundamental que tu Raspberry Pi esté actualizada para asegurar compatibilidad y seguridad.

sudo apt update
sudo apt upgrade -y

2. Instalar Librerías para el Sensor DHT22

Necesitaremos una librería de Python para interactuar con el sensor DHT22. La librería Adafruit_DHT es una opción excelente y ampliamente utilizada.

sudo apt install build-essential python3-dev python3-pip -y
pip3 install Adafruit_DHT

3. Instalar la Librería RPi.GPIO

Esta librería es la estándar para controlar los pines GPIO de la Raspberry Pi desde Python. Generalmente, ya viene preinstalada con Raspberry Pi OS, pero puedes asegurarte de tener la última versión.

pip3 install RPi.GPIO

📝 Programación del Sistema (Python)

Ahora vamos a escribir el código Python que leerá los datos del sensor y controlará los relés. Crearemos dos scripts principales: uno para la lectura del sensor y otro para la lógica de control del relé. Finalmente, uniremos ambos en un script principal.

1. Script para Leer el Sensor DHT22 (dht_sensor.py)

Este script leerá la temperatura y la humedad y las imprimirá. Lo usaremos para verificar que el sensor está funcionando correctamente.

Crea un nuevo archivo llamado dht_sensor.py:

nano dht_sensor.py

Copia y pega el siguiente código:

import Adafruit_DHT
import time

# Tipo de sensor que estamos usando (DHT11 o DHT22)
sensor = Adafruit_DHT.DHT22

# Pin GPIO al que está conectado el pin DATA del sensor
# Usa la numeración BCM. GPIO 4 es el pin físico 7.
pin_gpio = 4

def read_dht_sensor():
    humidity, temperature = Adafruit_DHT.read_retry(sensor, pin_gpio)
    if humidity is not None and temperature is not None:
        return temperature, humidity
    else:
        return None, None

if __name__ == '__main__':
    print("Iniciando lectura del sensor DHT22...")
    while True:
        temperature, humidity = read_dht_sensor()
        if temperature is not None and humidity is not None:
            print(f"Temperatura: {temperature:.2f}°C, Humedad: {humidity:.2f}%")
        else:
            print("Error al leer el sensor. Reintentando...")
        time.sleep(5) # Leer cada 5 segundos

Guarda el archivo (Ctrl + X, luego Y, Enter) y ejecútalo para probar:

python3 dht_sensor.py

Deberías ver lecturas de temperatura y humedad en la terminal. Si ves errores o lecturas de None, revisa tus conexiones.

2. Script para Controlar los Relés (relay_control.py)

Este script básico te permitirá probar el control de los relés.

Crea un nuevo archivo llamado relay_control.py:

nano relay_control.py

Copia y pega el siguiente código:

import RPi.GPIO as GPIO
import time

# Configuración de los pines GPIO para los relés
# Usamos numeración BCM
RELAY_1_PIN = 17 # GPIO 17 (Pin físico 11)
RELAY_2_PIN = 27 # GPIO 27 (Pin físico 13)

def setup_relays():
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(RELAY_1_PIN, GPIO.OUT)
    GPIO.setup(RELAY_2_PIN, GPIO.OUT)
    # Asegurarse de que los relés estén apagados al inicio
    GPIO.output(RELAY_1_PIN, GPIO.HIGH) # HIGH = Relé apagado (para la mayoría de módulos)
    GPIO.output(RELAY_2_PIN, GPIO.HIGH)
    print("Relés configurados. Apagados.")

def control_relay(relay_pin, state): # state = True (ON), False (OFF)
    if state:
        GPIO.output(relay_pin, GPIO.LOW) # LOW = Relé encendido (para la mayoría de módulos)
        print(f"Relé en GPIO {relay_pin} ENCENDIDO")
    else:
        GPIO.output(relay_pin, GPIO.HIGH) # HIGH = Relé apagado
        print(f"Relé en GPIO {relay_pin} APAGADO")

if __name__ == '__main__':
    try:
        setup_relays()
        print("Probando Relé 1...")
        control_relay(RELAY_1_PIN, True) # Encender Relé 1
        time.sleep(3)
        control_relay(RELAY_1_PIN, False) # Apagar Relé 1
        time.sleep(1)

        print("Probando Relé 2...")
        control_relay(RELAY_2_PIN, True) # Encender Relé 2
        time.sleep(3)
        control_relay(RELAY_2_PIN, False) # Apagar Relé 2
        time.sleep(1)

    except KeyboardInterrupt:
        print("Programa detenido por el usuario.")
    finally:
        GPIO.cleanup()
        print("GPIOs liberados.")

Nota sobre la lógica del relé: Muchos módulos de relé se activan con una señal LOW (0V) y se desactivan con una señal HIGH (3.3V). Esto se debe a que a menudo usan transistores para invertir la señal. Si tu relé funciona al revés, simplemente invierte GPIO.HIGH y GPIO.LOW en las funciones setup_relays y control_relay.

Guarda el archivo y ejecútalo:

python3 relay_control.py

Deberías escuchar los "clics" de los relés al encenderse y apagarse, y ver los mensajes en la terminal.

3. Script Principal de Monitorización y Control (main_controller.py)

Este es el corazón de nuestro sistema. Combinará la lectura del sensor con la lógica de control del relé.

Crea un nuevo archivo llamado main_controller.py:

nano main_controller.py

Copia y pega el siguiente código. Ajusta los umbrales de temperatura y humedad según tus preferencias.

import Adafruit_DHT
import RPi.GPIO as GPIO
import time
import datetime

# --- Configuración de Hardware ---
SENSOR_TYPE = Adafruit_DHT.DHT22
SENSOR_GPIO_PIN = 4  # Pin DATA del DHT22 (BCM numbering)

FAN_RELAY_PIN = 17   # Relé para el ventilador (GPIO 17 / Pin 11 físico)
DEHUMIDIFIER_RELAY_PIN = 27 # Relé para el deshumidificador (GPIO 27 / Pin 13 físico)

# --- Umbrales de Control ---
# Si la temperatura supera este valor, el ventilador se enciende.
TEMP_HIGH_THRESHOLD = 26.0 # °C
# Si la temperatura baja de este valor, el ventilador se apaga.
TEMP_LOW_THRESHOLD = 24.0  # °C

# Si la humedad supera este valor, el deshumidificador se enciende.
HUM_HIGH_THRESHOLD = 65.0 # %
# Si la humedad baja de este valor, el deshumidificador se apaga.
HUM_LOW_THRESHOLD = 55.0  # %

# --- Variables de Estado ---
fan_state = False # False = OFF, True = ON
dehumidifier_state = False

# --- Configuración GPIO ---
def setup_gpio():
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(FAN_RELAY_PIN, GPIO.OUT)
    GPIO.setup(DEHUMIDIFIER_RELAY_PIN, GPIO.OUT)
    # Asegurarse de que los relés estén apagados al inicio
    GPIO.output(FAN_RELAY_PIN, GPIO.HIGH)   # HIGH = Relé apagado (comúnmente)
    GPIO.output(DEHUMIDIFIER_RELAY_PIN, GPIO.HIGH)
    print("GPIOs configurados y relés inicializados en estado apagado.")

def control_relay(pin, state_on):
    global fan_state, dehumidifier_state
    
    current_state = GPIO.input(pin) == GPIO.LOW # True si está encendido (LOW)
    
    if state_on and not current_state:
        GPIO.output(pin, GPIO.LOW) # Encender relé
        print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Relé en GPIO {pin} ENCENDIDO.")
        if pin == FAN_RELAY_PIN:
            fan_state = True
        elif pin == DEHUMIDIFIER_RELAY_PIN:
            dehumidifier_state = True
    elif not state_on and current_state:
        GPIO.output(pin, GPIO.HIGH) # Apagar relé
        print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Relé en GPIO {pin} APAGADO.")
        if pin == FAN_RELAY_PIN:
            fan_state = False
        elif pin == DEHUMIDIFIER_RELAY_PIN:
            dehumidifier_state = False

# --- Función de lectura del sensor ---
def read_dht_data():
    humidity, temperature = Adafruit_DHT.read_retry(SENSOR_TYPE, SENSOR_GPIO_PIN)
    return temperature, humidity

# --- Lógica de Control Principal ---
def main_loop():
    global fan_state, dehumidifier_state

    while True:
        temperature, humidity = read_dht_data()

        if temperature is not None and humidity is not None:
            print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Temp: {temperature:.2f}°C, Hum: {humidity:.2f}% | Fan: {'ON' if fan_state else 'OFF'}, Dehumidifier: {'ON' if dehumidifier_state else 'OFF'}")

            # Lógica para el ventilador (temperatura)
            if temperature > TEMP_HIGH_THRESHOLD and not fan_state:
                control_relay(FAN_RELAY_PIN, True)  # Encender ventilador
            elif temperature < TEMP_LOW_THRESHOLD and fan_state:
                control_relay(FAN_RELAY_PIN, False) # Apagar ventilador

            # Lógica para el deshumidificador (humedad)
            if humidity > HUM_HIGH_THRESHOLD and not dehumidifier_state:
                control_relay(DEHUMIDIFIER_RELAY_PIN, True) # Encender deshumidificador
            elif humidity < HUM_LOW_THRESHOLD and dehumidifier_state:
                control_relay(DEHUMIDIFIER_RELAY_PIN, False) # Apagar deshumidificador

        else:
            print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Error al leer el sensor.")

        time.sleep(10) # Leer y actuar cada 10 segundos

if __name__ == '__main__':
    try:
        setup_gpio()
        main_loop()
    except KeyboardInterrupt:
        print("\nPrograma detenido por el usuario.")
    except Exception as e:
        print(f"Se ha producido un error inesperado: {e}")
    finally:
        GPIO.cleanup() # Siempre liberar los recursos GPIO al finalizar
        print("GPIOs liberados. Saliendo.")

Este script establece dos umbrales para cada parámetro (temperatura y humedad) para evitar el "ciclo corto" o "chattering" del relé (es decir, que se encienda y apague repetidamente si el valor fluctúa justo en el umbral). Por ejemplo, el ventilador se enciende a 26°C pero no se apaga hasta que baja a 24°C.

Guarda el archivo y ejecútalo:

python3 main_controller.py

Verás las lecturas del sensor y los mensajes de activación/desactivación de los relés en tu terminal.

🚀 Ejecución Automática al Inicio (Servicio Systemd)

Para que tu sistema funcione de manera continua y se inicie automáticamente después de un reinicio de la Raspberry Pi, puedes configurarlo como un servicio Systemd.

1. Crear el Archivo de Servicio

Crea un nuevo archivo de servicio en /etc/systemd/system/:

sudo nano /etc/systemd/system/environment_controller.service

Copia y pega el siguiente contenido, asegurándote de reemplazar /home/pi/main_controller.py con la ruta completa a tu script si lo guardaste en otro lugar:

[Unit]
Description=Servicio de Control de Ambiente con Raspberry Pi
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/main_controller.py
Restart=on-failure
User=pi

[Install]
WantedBy=multi-user.target

Guarda y cierra el archivo.

2. Habilitar y Iniciar el Servicio

sudo systemctl daemon-reload # Recargar los servicios de Systemd
sudo systemctl enable environment_controller.service # Habilitar el servicio para que inicie en el arranque
sudo systemctl start environment_controller.service # Iniciar el servicio ahora

3. Verificar el Estado del Servicio

Para asegurarte de que todo funciona correctamente, puedes comprobar el estado del servicio:

sudo systemctl status environment_controller.service

Deberías ver que el servicio está active (running). Si hay errores, el journalctl te dará más detalles.

sudo journalctl -u environment_controller.service -f

✨ Posibles Mejoras y Expansiones

Este proyecto es una base sólida, pero las posibilidades de expansión son infinitas:

• Interfaz Web: Utiliza frameworks como Flask o Django para crear una interfaz web donde puedas ver los datos en tiempo real y cambiar los umbrales de control de forma remota.
• Base de Datos: Almacena los datos de temperatura y humedad en una base de datos (SQLite, InfluxDB) para análisis históricos y gráficos.
• Notificaciones: Envía notificaciones (email, Telegram, Pushbullet) si los valores superan ciertos límites o si hay un error en el sensor.
• Integración con Hogar Inteligente: Conecta tu sistema a plataformas como Home Assistant o OpenHAB para integrarlo con otros dispositivos inteligentes.
• Sensores Múltiples: Añade más sensores DHT22 en diferentes habitaciones para monitorizar y controlar múltiples zonas.
• Pantalla LCD: Conecta una pequeña pantalla LCD (como una I2C LCD de 16x2 o 20x4) para mostrar la temperatura y humedad actuales directamente en el dispositivo.
• Control Manual: Añade botones físicos para encender/apagar los relés manualmente, o para anular la automatización temporalmente.

Troubleshooting Común

• Sensor DHT22 no lee datos:

  • Verifica todas las conexiones del cableado, especialmente VCC, GND y DATA.
  • Asegúrate de que el pin GPIO configurado en el código coincide con el pin físico en la RPi.
  • Si usas un DHT22 de 4 pines, asegúrate de que estás usando el pin DATA correcto (el segundo desde VCC se suele ignorar).
  • Comprueba si necesitas la resistencia pull-up de 10kΩ entre VCC y DATA. Muchos módulos ya la incluyen internamente.
  • Reinstala la librería Adafruit_DHT o asegúrate de que usas pip3.

• Relé no se activa/desactiva:

  • Revisa las conexiones VCC y GND del módulo de relé.
  • Asegúrate de que el relé recibe suficiente energía (5V es común).
  • Verifica que el pin GPIO configurado en el código coincide con el pin físico de la RPi y el pin IN del relé.
  • Si el relé no hace clic, puede que la lógica de HIGH/LOW esté invertida en tu módulo. Prueba a cambiar GPIO.HIGH por GPIO.LOW y viceversa en el script relay_control.py.
  • Asegúrate de que el modo GPIO (GPIO.BCM o GPIO.BOARD) sea consistente en tu código.

• El servicio Systemd no inicia:

  • Revisa la ruta del script Python en el archivo .service. Debe ser la ruta completa y correcta.
  • Comprueba los permisos del script Python (chmod +x main_controller.py).
  • Usa sudo systemctl status environment_controller.service y sudo journalctl -u environment_controller.service -f para ver los errores.

Este tutorial te proporciona una base sólida para crear tu propio sistema de control ambiental. ¡Diviértete experimentando y personalizando tu hogar inteligente con la Raspberry Pi!