Controla el Acceso a tu Hogar con Raspberry Pi: Cerradura Inteligente y Sensor de Apertura

🔒 Control de Acceso Inteligente con Raspberry Pi: Tu Hogar Más Seguro

¿Alguna vez has deseado tener una cerradura que puedas controlar desde tu teléfono, o recibir notificaciones cada vez que una puerta se abre? Con una Raspberry Pi, ¡es posible! En este tutorial, te embarcarás en un proyecto emocionante para transformar una cerradura tradicional en una cerradura inteligente y añadir un sistema de monitoreo de acceso con un sensor de puerta/ventana.

Este proyecto no solo te proporcionará una capa extra de seguridad y conveniencia, sino que también te ayudará a profundizar en el mundo de la electrónica y la programación con Raspberry Pi. ¡Prepárate para llevar la seguridad de tu hogar al siguiente nivel!

🎯 Objetivos del Proyecto

Al finalizar este tutorial, habrás logrado:

• Conectar un servomotor a tu Raspberry Pi para controlar el mecanismo de una cerradura.
• Integrar un sensor magnético de puerta/ventana para detectar su estado (abierta/cerrada).
• Programar en Python la lógica para abrir/cerrar la cerradura y monitorear el sensor.
• Configurar notificaciones básicas (por ejemplo, a través de la consola o un archivo de registro) para los eventos de apertura/cierre.

🛠️ Materiales Necesarios

Para llevar a cabo este proyecto, necesitarás los siguientes componentes:

⚙️ Preparación del Entorno Raspberry Pi

Asegúrate de que tu Raspberry Pi esté configurada y lista para trabajar. Si ya tienes Raspberry Pi OS instalado y acceso SSH o de escritorio, puedes saltarte los primeros pasos.

1. Instalación de Raspberry Pi OS

Si aún no lo has hecho, instala la última versión de Raspberry Pi OS en tu tarjeta MicroSD. Puedes usar la herramienta Raspberry Pi Imager.

2. Actualización del Sistema

Conéctate a tu Raspberry Pi (vía SSH o directamente con teclado/monitor) y actualiza los paquetes del sistema:

sudo apt update
sudo apt upgrade -y

3. Habilitar la Interfaz I2C y SPI (Opcional, pero buena práctica)

Aunque para este proyecto solo usaremos GPIOs simples y PWM de software, es buena práctica tener estas interfaces habilitadas para futuros proyectos.

sudo raspi-config

Navega a 3 Interface Options > P3 I2C > Yes y P4 SPI > Yes.

4. Instalación de Librerías Python

Necesitaremos la librería RPi.GPIO para controlar los pines GPIO y gpiozero para una interacción más sencilla con el servomotor y el sensor.

sudo apt install python3-rpi.gpio -y
pip3 install gpiozero

🔌 Diagrama de Conexiones (Hardware)

Es crucial realizar las conexiones correctamente para evitar daños a los componentes. A continuación, se detalla cómo conectar el servomotor y el sensor magnético a la Raspberry Pi.

📌 Servomotor

Los servomotores suelen tener tres cables:

• Marrón/Negro: GND (Tierra)
• Rojo: VCC (Alimentación, 5V)
• Naranja/Amarillo/Blanco: Señal (GPIO)

Conexiones:

• Servomotor GND -> Raspberry Pi GND (Pin 6, 9, 14, 20, 25, 30, 34, 39)
• Servomotor VCC (Rojo) -> Raspberry Pi 5V (Pin 2 o Pin 4)
• Servomotor Señal -> Raspberry Pi GPIO 17 (Pin 11)

📌 Sensor Magnético Reed

Un sensor magnético reed básico tiene dos cables. Funcionan como un interruptor: se cierran cuando el imán está cerca y se abren cuando se aleja.

Vamos a configurarlo como un pull-up interno en la Raspberry Pi para simplificar las conexiones y evitar el rebote (bouncing) o lecturas erróneas.

Conexiones:

• Un cable del sensor -> Raspberry Pi GND (Pin 6, 9, 14, 20, 25, 30, 34, 39)
• El otro cable del sensor -> Raspberry Pi GPIO 27 (Pin 13)

✍️ Escribiendo el Código Python

Crearemos un script Python que maneje tanto el servomotor como el sensor magnético. Este script controlará la cerradura y registrará los eventos de apertura/cierre.

Crea un nuevo archivo llamado smart_lock.py en tu Raspberry Pi:

nano smart_lock.py

Inserta el siguiente código:

import time
from gpiozero import Servo, Button
from signal import pause

# --- Configuración de Pines --- 

# GPIO del servomotor. Aquí usamos el pin GPIO 17 (físico pin 11)
# Ajusta los valores min_pulse_width y max_pulse_width según tu servomotor.
# Estos valores definen los límites del movimiento del servomotor.
# Experimenta para encontrar los valores correctos para 'abierto' y 'cerrado'.
# servo = Servo(17, min_pulse_width=0.5/1000, max_pulse_width=2.5/1000) # Ejemplo de configuración avanzada
servo = Servo(17) # Configuración básica, usa valores por defecto que suelen funcionar bien

# GPIO del sensor magnético. Usamos el pin GPIO 27 (físico pin 13)
# pull_up=True significa que el pin está HIGH por defecto y LOW cuando el sensor se activa (cierra el circuito a GND).
# Cuando la puerta está cerrada (imán cerca), el sensor cierra el circuito y el pin se lee como LOW (activo).
# Cuando la puerta está abierta (imán lejos), el sensor abre el circuito y el pin se lee como HIGH (inactivo).
button_sensor = Button(27, pull_up=True)

# --- Estados de la Cerradura y el Sensor ---

# Define los valores de 'ángulo' para el servomotor para abrir y cerrar.
# 1 es la posición 'extrema' en un sentido, -1 en el otro.
# 0 es la posición central.
# Necesitarás calibrar estos valores para tu cerradura específica.
LOCK_POSITION = 0.5   # Posición para 'cerrar' la cerradura
UNLOCK_POSITION = -0.5 # Posición para 'abrir' la cerradura

# Estado inicial de la cerradura
is_locked = True

# --- Funciones de Control ---

def lock_door():
    global is_locked
    servo.value = LOCK_POSITION
    is_locked = True
    log_event(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Cerradura: CERRADA")
    print("Cerradura: CERRADA")

def unlock_door():
    global is_locked
    servo.value = UNLOCK_POSITION
    is_locked = False
    log_event(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Cerradura: ABIERTA")
    print("Cerradura: ABIERTA")

def toggle_lock():
    if is_locked:
        unlock_door()
    else:
        lock_door()

def door_opened_callback():
    # Esta función se llama cuando el botón del sensor se 'presiona' (circuito cerrado, pin LOW).
    # En nuestro caso, con pull_up=True, LOW significa que el imán está CERRADO (puerta cerrada).
    # Por lo tanto, si el botón está 'presionado' (circuito cerrado), la puerta está cerrada.
    # Si el botón no está 'presionado' (circuito abierto), la puerta está abierta.
    # La lógica de gpiozero Button.when_pressed() es que se activa cuando el botón se presiona (circuito cerrado).
    # Si la puerta está cerrada, el sensor se activa.
    log_event(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Sensor: Puerta CERRADA")
    print("Sensor: Puerta CERRADA")

def door_closed_callback():
    # Esta función se llama cuando el botón del sensor se 'libera' (circuito abierto, pin HIGH).
    # Si el botón está 'liberado', la puerta está ABIERTA.
    log_event(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Sensor: Puerta ABIERTA")
    print("Sensor: Puerta ABIERTA")

def log_event(message):
    with open("smart_lock_events.log", "a") as log_file:
        log_file.write(message + "\n")

# --- Configuración de Eventos del Sensor ---

# Asignar funciones a los eventos del sensor
# cuando el sensor está 'presionado' (imán cerca, puerta cerrada)
button_sensor.when_pressed = door_opened_callback 
# cuando el sensor está 'liberado' (imán lejos, puerta abierta)
button_sensor.when_released = door_closed_callback 

# --- Bucle Principal / Interacción ---

if __name__ == '__main__':
    print("\n--- Sistema de Cerradura Inteligente Iniciado ---")
    print(f"Cerradura inicial: {'CERRADA' if is_locked else 'ABIERTA'}")
    log_event(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Sistema Iniciado")

    # Asegurarse de que la cerradura esté en su posición inicial
    lock_door()
    time.sleep(1) # Pequeña pausa para que el servo se mueva

    print("Introduce 'cerrar' para cerrar, 'abrir' para abrir, 'alternar' para cambiar estado, 'estado' para ver, 'salir' para terminar.")

    try:
        while True:
            command = input("> ").lower()
            if command == 'cerrar':
                if not is_locked:
                    lock_door()
                else:
                    print("La cerradura ya está cerrada.")
            elif command == 'abrir':
                if is_locked:
                    unlock_door()
                else:
                    print("La cerradura ya está abierta.")
            elif command == 'alternar':
                toggle_lock()
            elif command == 'estado':
                print(f"Estado actual de la cerradura: {'CERRADA' if is_locked else 'ABIERTA'}")
                print(f"Estado actual del sensor (puerta): {'CERRADA' if button_sensor.is_pressed else 'ABIERTA'}")
            elif command == 'salir':
                print("Saliendo del sistema.")
                servo.close() # Libera el recurso del servomotor
                button_sensor.close() # Libera el recurso del botón
                break
            else:
                print("Comando no reconocido. Usa 'cerrar', 'abrir', 'alternar', 'estado' o 'salir'.")
            time.sleep(0.1) # Pequeño retardo para evitar uso excesivo de CPU

    except KeyboardInterrupt:
        print("\nPrograma terminado por el usuario.")
    finally:
        servo.close()
        button_sensor.close()
        print("Recursos GPIO liberados.")

📖 Explicación del Código

• Importaciones: gpiozero simplifica el control de GPIOs. time para pausas y signal para manejar interrupciones.
• Servo(17): Inicializa el servomotor en el pin GPIO 17. Puedes ajustar min_pulse_width y max_pulse_width si tu servomotor no se mueve en todo su rango. El valor por defecto suele ser 0.5ms a 2.5ms, que cubre el rango típico de 0° a 180°.
• Button(27, pull_up=True): Configura el pin GPIO 27 como entrada para el sensor. pull_up=True significa que el pin estará en estado HIGH (3.3V) por defecto. Cuando el imán está cerca, el sensor cierra el circuito a GND, llevando el pin a LOW. La lógica del sensor se invierte aquí para que when_pressed se active cuando la puerta está cerrada.
• LOCK_POSITION y UNLOCK_POSITION: Estos valores (entre -1 y 1) controlan la posición del servomotor. -1 es un extremo, 1 es el otro, y 0 es el centro. Debes calibrar estos valores empíricamente para tu cerradura específica. Conecta el servomotor y ejecuta el script, luego ajusta estos valores hasta que la cerradura se abra y cierre correctamente.
• lock_door() / unlock_door() / toggle_lock(): Funciones para controlar el servomotor y actualizar el estado de la cerradura.
• door_opened_callback() / door_closed_callback(): Estas funciones se ejecutan automáticamente cuando el estado del sensor cambia. when_pressed se activa cuando el circuito del sensor se cierra (puerta cerrada), y when_released cuando se abre (puerta abierta).
• log_event(message): Guarda un registro de los eventos en un archivo smart_lock_events.log. Esto es útil para auditar el acceso.
• Bucle principal (if __name__ == '__main__':):
  • Inicializa la cerradura a un estado cerrado.
  • Entra en un bucle infinito que espera comandos del usuario para abrir, cerrar o alternar la cerradura.
  • Muestra el estado actual de la cerradura y el sensor cuando se solicita.
  • Maneja la salida limpia del programa con KeyboardInterrupt.

🧪 Prueba y Calibración

Una vez que tengas todo conectado y el código guardado, es hora de probarlo y calibrar el servomotor.

1. Ejecutar el Script

Desde la terminal de tu Raspberry Pi, ejecuta el script Python:

python3 smart_lock.py

2. Calibración del Servomotor

Cuando el script se inicie, la cerradura intentará ir a la LOCK_POSITION. Observa el movimiento del servomotor. Experimenta con los valores de LOCK_POSITION y UNLOCK_POSITION en el código. Edita el archivo smart_lock.py, guarda y vuelve a ejecutar para probar los cambios.

• Ejemplo de calibración: Si LOCK_POSITION = 0.5 mueve la cerradura a una posición "casi cerrada" pero no del todo, prueba con 0.6 o 0.7. Si UNLOCK_POSITION = -0.5 no la abre lo suficiente, prueba con -0.6 o -0.7.
• El rango del value de gpiozero.Servo va de -1 (un extremo) a 1 (el otro extremo). 0 es el punto central.

3. Prueba del Sensor Magnético

Mientras el script está ejecutándose, acerca y aleja el imán del sensor magnético. Deberías ver mensajes en la consola (Sensor: Puerta CERRADA o Sensor: Puerta ABIERTA) y también se registrarán en el archivo smart_lock_events.log.

cat smart_lock_events.log

Este comando te permitirá ver el contenido del archivo de registro.

🔩 Adaptación Mecánica de la Cerradura

Esta es la parte más creativa y dependiente de la cerradura que elijas. El objetivo es que el servomotor pueda mover el pestillo o el mecanismo de la cerradura.

Ideas para la Adaptación:

• Cerraduras de pestillo simple: Puedes crear una pequeña palanca que se conecte al brazo del servomotor y empuje/tire del pestillo.
• Impresión 3D: Diseñar e imprimir piezas a medida es una excelente opción para integrar el servomotor de forma limpia y efectiva.
• Soportes universales: Existen soportes para servomotores que puedes atornillar a una superficie y luego conectar una varilla o un brazo al mecanismo de la cerradura.

🚀 Ejecución en Segundo Plano y Arranque Automático

Para que tu sistema de cerradura inteligente sea práctico, querrás que el script se ejecute automáticamente al iniciar la Raspberry Pi y en segundo plano.

Ejecutar en Segundo Plano (temporal)

Puedes usar nohup y & para ejecutar el script en segundo plano sin que se detenga al cerrar la terminal:

nohup python3 smart_lock.py &

Para detenerlo, necesitarás encontrar el ID del proceso (ps aux | grep smart_lock.py) y luego matarlo (kill <PID>).

Servicio Systemd (Recomendado para Producción)

Crear un servicio Systemd es la forma más robusta de gestionar scripts que deben ejecutarse al inicio y en segundo plano.

1. Crea el archivo de servicio:

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

2. Pega el siguiente contenido (ajusta la ruta si es necesario):

[Unit]
Description=Servicio de Cerradura Inteligente con Raspberry Pi
After=network.target

[Service]
ExecStart=/usr/bin/python3 /home/pi/smart_lock.py
WorkingDirectory=/home/pi/
StandardOutput=inherit
StandardError=inherit
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

*   `ExecStart`: La ruta completa al intérprete de Python y a tu script.
*   `WorkingDirectory`: El directorio donde se encuentra tu script.
*   `User`: El usuario bajo el cual se ejecutará el script (normalmente `pi`).

3. Habilita y arranca el servicio:

sudo systemctl daemon-reload
sudo systemctl enable smartlock.service
sudo systemctl start smartlock.service

4. Verifica el estado del servicio:

sudo systemctl status smartlock.service

Ahora, tu cerradura inteligente se iniciará automáticamente cada vez que arranques tu Raspberry Pi.

📈 Posibles Mejoras y Expansiones

Este proyecto es una base sólida. Aquí tienes algunas ideas para llevarlo más allá:

• Interfaz de Usuario Web: Crea una página web sencilla con Flask o Node.js para controlar la cerradura desde cualquier dispositivo en tu red local.
• Notificaciones Avanzadas: Integra servicios como Pushbullet, Telegram o Home Assistant para recibir notificaciones en tu teléfono cuando la puerta se abre o cierra.
• Autenticación: Añade métodos de autenticación como lectores RFID, teclados numéricos, o incluso reconocimiento facial con una cámara Raspberry Pi.
• Registro en Base de Datos: Guarda los eventos en una base de datos (SQLite, MySQL) en lugar de un archivo de texto para un análisis más profundo.
• Energía de Respaldo: Un pequeño UPS o una batería de respaldo para asegurar que la cerradura funcione incluso durante cortes de energía.
• Modo "Vacaciones": Un modo que genere una alerta especial si la puerta se abre inesperadamente mientras no estás en casa.

✅ Conclusión

¡Felicidades! Has construido tu propio sistema de cerradura inteligente y monitoreo de acceso con Raspberry Pi. Este proyecto te ha permitido combinar hardware y software para resolver un problema práctico de seguridad y comodidad en el hogar. La Raspberry Pi es una plataforma increíblemente versátil, y este es solo el comienzo de lo que puedes lograr con ella. Sigue experimentando y expandiendo las funcionalidades. ¡El límite es tu imaginación!