Cómo crear un Watchdog para dispositivos en red.

Después de haber sufrido una pequeña inundación en el sótano de casa, decidí crear un sistema de alerta y corte de suministro de agua.

Para que mi instalación pueda ponerse en contacto conmigo, necesito la ayuda de sensores online que vigilen constantemente si se produce alguna avería por agua.

El ecosistema Tapo de TP-Link es excelente por su relación calidad-precio, especialmente sus sensores de inundación T300. Sin embargo, tiene un «talón de Aquiles» crítico: la falta de notificaciones por desconexión. Si el Hub H100 o el enchufe P100 se apagan, tu sistema de seguridad muere en silencio.

Aquí te explico cómo convertir tu Raspberry Pi en un vigilante activo que te avisará en segundos si algo falla.

El problema: El silencio de los dispositivos offline

Tanto si la centralita H100 (Hub) como el enchufe P100 que controla el cierre de agua, se avería, sufre un pico de tensión o alguien los desenchufa accidentalmente, el sistema se queda «ciego». El sensor de agua T300 no tiene a quién avisar y la orden de corte nunca se ejecuta.

Lo más preocupante es que la App de Tapo no envía notificaciones si un dispositivo se queda fuera de línea. Para darte cuenta del fallo, tendrías que entrar manualmente en la aplicación y revisar el estado de los iconos uno por uno. En una emergencia o durante unas vacaciones, esta falta de aviso proactivo es un fallo de seguridad inaceptable.

La solución: Un «Watchdog» con Raspberry Pi

Para eliminar este punto ciego, utilizaremos una Raspberry Pi como Watchdog (Perro Guardián). En lugar de esperar a que la App nos avise, la Pi interrogará constantemente a los dispositivos en la red local, si estos no responden, la Pi asume que el sistema está comprometido y dispara una alerta externa.

1. Prepara tu Telegram.

Aprovechando que tenemos telegram (si no lo tienes, ya estás tardando en instalarlo) vamos a utilizarlo para que nos lleguen los avisos de alerta de nuestro script. Para ello crearemos un bot, que será el encargado de gestionar los avisos provenientes de nuestra raspberry.

Crear tu Bot en Telegram (El Emisor)

Primero necesitamos crear la «entidad» que enviará los mensajes desde tu Raspberry Pi.

Abre Telegram y busca al usuario @BotFather.
Escribe /newbot y dale a enviar.
Te pedirá un Nombre para el bot (ejemplo: Vigilante Sótano).
Te pedirá un Username (debe terminar en _bot, ejemplo: mi_sotano_seguro_bot).
BotFather te responderá con un mensaje largo que contiene el API Token (algo parecido a 74839201:AAH-u7...). Copia y guarda este código, es la clave de acceso.

Obtener tu Chat ID (El Receptor)

Ahora necesitamos saber a qué cuenta de Telegram (la tuya) debe escribirle el bot.

Busca en Telegram el bot @userinfobot.
Escríbele un mensaje cualquiera (ej. «Hola»).
Te responderá con tu ID (un número de 9 o 10 dígitos). Guárdalo también.

2. Crea tu script

Abre tu terminal para crear el archivo con:

nano TapoGuard.py

Pega este código (asegúrate de poner tu Token, tu ID, la IP del H100 y la IP del P100):

import os
import time
import requests

# --- CONFIGURACIÓN ---
TOKEN = "Tu_TOKEN"
CHAT_ID = "TU_ID"

# Diccionario de dispositivos: "Nombre": "IP"
DISPOSITIVOS = {
    "Hub H100": "192.168.1.16",
    "Enchufe Válvula P110": "192.168.1.15"
}

REINTENTOS = 3
SEGUNDOS_ENTRE_CHEQUEOS = 60

# Diccionario para recordar el estado de cada uno (Todos empiezan como Online)
estados_caidos = {nombre: False for nombre in DISPOSITIVOS}

def enviar_telegram(mensaje):
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    params = {"chat_id": CHAT_ID, "text": mensaje}
    try:
        requests.post(url, params=params, timeout=10)
    except Exception as e:
        print(f"Error de red: {e}")

def chequeo_ip(ip):
    # Lanza un ping. Devuelve True si responde.
    salida = os.system(f"ping -c 1 -W 1 {ip} > /dev/null 2>&1")
    return salida == 0

print("--- Vigilante Tapo Iniciado ---")

while True:
    for nombre, ip in DISPOSITIVOS.items():
        exito = False

        # Intentos de ping para evitar falsas alarmas
        for i in range(REINTENTOS):
            if chequeo_ip(ip):
                exito = True
                break
            time.sleep(1)

        # Lógica de notificaciones individualizada
        if not exito and not estados_caidos[nombre]:
            print(f"[{time.strftime('%H:%M:%S')}] ❌ {nombre} CAÍDO")
            enviar_telegram(f"⚠️ ALERTA: El dispositivo '{nombre}' ({ip}) se ha caído de la red.")
            estados_caidos[nombre] = True

        elif exito and estados_caidos[nombre]:
            print(f"[{time.strftime('%H:%M:%S')}] ✅ {nombre} RECUPERADO")
            enviar_telegram(f"✅ OK: El dispositivo '{nombre}' ha vuelto a conectar.")
            estados_caidos[nombre] = False

    time.sleep(SEGUNDOS_ENTRE_CHEQUEOS)

Te aconsejo que pongas una IP fija a tus dispositivos, ya que si esta cambia, el script no funcionará.

Guarda los cambios con Ctrl + o y sal con Ctrl + x

Haz que tu archivo tenga permisos de ejecución.

chmod +x TapoGuard.py

Y pruébalo con:

python3 TapoGuard.py

Desconecta tu Hub del enchufe y observa que ocurre. ¿Te llegaron los mensajes? Ahora conéctalo y vuelve a mirar.

Si todo ha salido bien, tenemos al «cerebro» de la supervisión funcionando.

3. Crea un servicio del sistema (systemd)

Ahora, para que sea un sistema de seguridad permanente, necesitamos que se convierta en un servicio del sistema (un daemon).

De esta forma, si hay un apagón y la Pi se reinicia, el script se levantará solo sin que tengas que teclear nada.

Usa el editor de texto para crear un archivo de configuración en la carpeta del sistema:

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

Copia y pega este contenido dentro del archivo (ajustando la ruta a tu usuario):

[Unit]
Description=Vigilante del Hub Tapo H100
After=network.target

[Service]
# Asegúrate de que la ruta /home/tu_usuario/TapoGuard.py es la correcta
ExecStart=/usr/bin/python3 /home/tu_usuario/TapoGuard.py
Restart=always
RestartSec=10
User=raspberry

[Install]
WantedBy=multi-user.target

No olvides cambiar tu_usuario por el tuyo propio.

Para guardar Ctrl + o y salir con Ctrl + x

Activa el Servicio

Ahora dale las órdenes a la Raspberry Pi para que lo ponga en marcha:

Recarga el sistema para que reconozca el nuevo archivo: sudo systemctl daemon-reload
Activa el inicio automático al arrancar: sudo systemctl enable TapoGuard.service
Inicia el servicio ahora mismo: sudo systemctl start TapoGuard.service

¿Cómo compruebo que está «vivo»?

Puedes ver el estado de tu vigilante con este comando: sudo systemctl status TapoGuard.service

Si sale en verde «active (running)», es que está patrullando la IP de tu Hub.
Ya puedes cerrar la terminal, apagar tu ordenador e irte tranquilo: la Pi se encargará de avisar a tu Telegram si el Tapo H100 deja de responder.

Y si quieres ver los «logs» (lo que el script va imprimiendo):

journalctl -u TapoGuard.service -f