9 Potentes Scripts en Python para Automatizar tu Raspberry Pi

Si eres como yo, tu Raspberry Pi siempre está ejecutando algo: puede ser una copia de seguridad, un monitor de red o un simple script. Pero hacer las mismas tareas todos los días se vuelve aburrido rápidamente. Ahí es donde Python ayuda. Con unos pocos scripts sencillos, tu Pi puede encargarse automáticamente de las tareas rutinarias. He probado un montón y he seleccionado los más útiles.

Los scripts de Python se pueden usar en una Raspberry Pi para automatizar tareas funcionales como copias de seguridad, monitorización, alertas y control de dispositivos con solo unas líneas de código. Son más fáciles de escribir, leer y ampliar que los scripts de Bash, especialmente cuando se usan bibliotecas o API web.

En este artículo, comparto algunos de los scripts de Python más útiles que he usado para hacer que mi Raspberry Pi sea más inteligente y requiera menos intervención manual. Encontrarás ideas, fragmentos de código y consejos que puedes aplicar de inmediato; no se necesitan conocimientos avanzados.

Script de actualización automática del sistema

Mantener tu sistema actualizado es esencial, ya que las actualizaciones suelen incluir parches de seguridad críticos y correcciones de errores. También es buena práctica actualizar el sistema antes de instalar software nuevo.

A diferencia de la mayoría de los sistemas operativos modernos, Raspberry Pi OS no tiene una función de actualización automática o programada. Normalmente, cuando necesitamos actualizar nuestro sistema, lo hacemos manualmente a través del gestor de paquetes usando el siguiente comando:
sudo apt update && sudo apt full-upgrade -y

Este proceso se puede automatizar mediante un script de Python que utilice la biblioteca subprocess. El siguiente fragmento de código de Python actualiza la Raspberry Pi automáticamente:

import subprocess

# Update and upgrade the system
def run_update():
    subprocess.run(["sudo", "apt", "update"])
    subprocess.run(["sudo", "apt", "upgrade", "-y"])

run_update()

Lo que puedes hacer es convertir este script de Python en un archivo ejecutable mediante el siguiente comando:
chmod +x /home/pat/path/to/script.py

Y añadirlo al final de tu archivo ~/.bashrc. De esta forma, al iniciar sesión en tu Raspberry Pi se iniciará automáticamente una actualización del sistema en segundo plano.

Para evitar actualizaciones repetidas, puedes añadir un archivo de registro para guardar la hora de la última actualización y luego añadir una línea en tu script para comprobar que ha pasado un tiempo mínimo (por ejemplo, 7 días) antes de iniciar la actualización:

from pathlib import Path
from datetime import datetime, timedelta

#Define Log Path and the number of days required to start a new update
UPDATE_LOG = Path("/home/pi/.last_update")
UPDATE_THRESHOLD_DAYS = 7

#Check if Update is required
def needs_update():
    if not UPDATE_LOG.exists():
        return True
    last_update = datetime.fromisoformat(UPDATE_LOG.read_text())
    return datetime.now() - last_update > timedelta(days=UPDATE_THRESHOLD_DAYS)

#Only run update if update is required
if needs_update():
    run_update()

Si estás usando tu Raspberry Pi en modo gráfico (GUI), puedes añadir notificaciones que te avisen cuándo una actualización ha empezado y cuándo ha finalizado correctamente (o no). Podemos hacer esto usando la biblioteca plyer.

Puedes instalar esta biblioteca usando el comando:
pip install plyer

Nota: Raspberry Pi OS no tiene preinstalado su demonio de notificaciones. Por lo tanto, debes instalar dunst desde el repositorio oficial para ver las notificaciones. Puedes instalar dunst usando el comando:
sudo apt install dunst

Después, podemos usar esto en nuestro script de Python para mostrar notificaciones cada vez que empieza y termina correctamente una actualización, usando el código:

from plyer import notification

def show_notification(title, message):
    notification.notify(
        title=title,
        message=message,
        timeout=5
    )

show_notification("System Update", "Starting update...")

Una vez configurado, te mostrará una notificación en pantalla cada vez que empiece y complete una actualización del sistema, como se muestra a continuación:

Script de copia de seguridad en la nube

Hacer copias de seguridad de tus archivos es una de esas cosas en las que solo piensas cuando ya es demasiado tarde. Ya sean fotos, proyectos o registros, perderlos por un fallo en la tarjeta SD puede ser muy frustrante. Así que vamos a solucionar eso.

Puedes escribir un script en Python para hacer copias de seguridad automáticamente de cualquier carpeta de tu Raspberry Pi a Google Drive. Puedes programarlo para que se ejecute periódicamente (diario, semanal, etc.) mediante una tarea de cron. Usaremos rclone, una herramienta potente que conecta tu Pi con los servicios de almacenamiento en la nube más populares.

Para usar rclone (en inglés), primero necesitas instalarlo usando el comando:
sudo apt install rclone

Nota: Asegúrate de configurar rclone para vincularlo con tu Google Drive usando el comando:
rclone config

Una vez instalado y configurado, puedes usar un código Python sencillo, como el que se muestra a continuación, para hacer copias de seguridad, automáticamente, de la carpeta seleccionada en tu Google Drive:

import subprocess
from datetime import datetime

# Folder to back up
source_folder = "/home/pi/projects"

# Destination folder in Google Drive
backup_name = f"backup_{datetime.now().strftime('%Y-%m-%d')}"
remote_folder = f"gdrive:PiBackups/{backup_name}"

# Run the backup
subprocess.run(["rclone", "copy", source_folder, remote_folder])

Puedes mejorar esto aún más configurando un crontab para automatizar y ejecutar el script en intervalos programados (por ejemplo, cada noche). Esto asegura que tus datos importantes se clonen automáticamente en tu Google Drive.

Puedes usar un método de notificación similar al que vimos en el script de actualización automática, para avisarte cuando se haya creado una copia de seguridad.

También puedes usar la función sync de rclone para actualizar las copias de seguridad existentes en lugar de crear una nueva cada vez. Otra ventaja de usar rclone es que puedes configurarlo para trabajar con Dropbox, OneDrive u otros servicios de alojamiento de archivos similares, y no estás limitado únicamente a Google Drive.

Si quieres conocer otros métodos para hacer copias de seguridad de tu Raspberry Pi, los explicamos aquí, en La guía definitiva para hacer copias de seguridad y restaurar tu Raspberry Pi, como usar rsnapshot para copias de seguridad incrementales (en inglés).

Registro de uso de recursos

¿Te has preguntado alguna vez si tu Raspberry Pi se está calentando demasiado o está usando demasiada memoria? Si tu Pi de repente se ralentiza, tener un registro de rendimiento puede ayudarte a averiguar por qué.

Aunque hay varias herramientas disponibles para monitorizar el estado de tu Raspberry Pi (en inglés), la mayoría requieren que estés presente físicamente. Puedes desarrollar un script de Python usando la biblioteca psutil para llevar un registro del uso de CPU, memoria y disco, y avisarte si algo supera un límite establecido.

Puedes instalar la biblioteca psutil usando el comando:
pip install psutil

Después puedes usar las funciones integradas de psutil para obtener el uso de CPU, RAM y disco, como se muestra a continuación:

import psutil 

cpu = psutil.cpu_percent()
ram = psutil.virtual_memory().percent
disk = psutil.disk_usage('/').percent

Otra estadística importante a monitorizar es la temperatura de la CPU de la Raspberry Pi. La temperatura de la CPU también se puede obtener leyendo el valor del archivo /sys/class/thermal/thermal_zone0/temp. También puedes convertir esto en código Python:

# Function to get CPU temperature
def get_cpu_temp():
    try:
        with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
            temp_str = f.readline()
            return round(int(temp_str) / 1000, 1)
    except FileNotFoundError:
        return None

Después puedes guardar todos estos datos en un archivo CSV con una marca de fecha y hora para crear un registro que puedas revisar más tarde y analizar el rendimiento del sistema.

También puedes mejorar este script usando Pushbullet para enviar notificaciones si algo se vuelve excesivo (por ejemplo, si la temperatura de la CPU es demasiado alta) mientras estás fuera.

Nota: Asegúrate de tener Pushbullet instalado y configurado en tu PC o móvil para recibir las notificaciones.

Puedes usar un script de Python, como el que se muestra a continuación, para enviar notificaciones de Pushbullet a todos los dispositivos conectados:

import requests

PUSHBULLET_TOKEN = "your_token_here"

def send_alert(msg):
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": PUSHBULLET_TOKEN},
        json={"type": "note", "title": "Raspberry Pi Alert", "body": msg}
    )

if temp and temp > TEMP_LIMIT:
    send_alert(f"CPU temperature is high: {temp}°C")

Ahora, cada vez que tu Raspberry Pi se caliente demasiado, te avisará automáticamente, incluso cuando estés fuera:

Las notificaciones de Pushbullet también se pueden recibir en tu móvil.

Si tu Raspberry Pi se sobrecalienta con frecuencia, sigue esta guía completa sobre Temperatura de Raspberry Pi: Límites y Soluciones.

Apagado de pantalla por inactividad / ahorro de energía

¿Dejas tu Raspberry Pi funcionando con una pantalla conectada? Si es así, esa pantalla puede permanecer encendida incluso cuando nadie la está usando. Con el tiempo, esto puede desperdiciar electricidad y reducir la vida útil de tu pantalla.

Raspberry Pi OS incluye una función básica de apagado de pantalla, que la pone en negro tras 10 o 15 minutos de inactividad. Sin embargo, esta función solo pone la pantalla en negro, y la salida HDMI no se desactiva.

Con un sencillo script de Python, puedes monitorizar la actividad del ratón y el teclado y apagar automáticamente la pantalla tras un tiempo determinado. También podemos usar vgencmd para desactivar la alimentación de la salida HDMI, lo que supone un ahorro de energía mucho más significativo que el apagado de pantalla predeterminado.

Para monitorizar la actividad del teclado y el ratón, necesitarás la biblioteca pynput. Puedes instalarla usando el comando:
pip install pynput

Después puedes usar un script de Python para monitorizar el uso del teclado y el ratón:

import time
from pynput import mouse, keyboard

def reset_timer(x=None):
    global last_input_time
    last_input_time = time.time()

# Set up listeners for keyboard and mouse
keyboard_listener = keyboard.Listener(on_press=reset_timer)
mouse_listener = mouse.Listener(on_move=reset_timer, on_click=reset_timer, on_scroll=reset_timer)

keyboard_listener.start()
mouse_listener.start()

A continuación, puedes seguir monitorizando el tiempo de inactividad. Si el tiempo supera un cierto umbral, puedes usar vgencmd para desactivar la salida HDMI.

while True:
    idle_duration = time.time() - last_input_time

    if idle_duration > IDLE_TIME and not screen_off:
        subprocess.run(["/usr/bin/vcgencmd", "display_power", "0"])
        screen_off = True
        print("Screen turned OFF due to inactivity.")
        
    elif idle_duration <= IDLE_TIME and screen_off:
        subprocess.run(["/usr/bin/vcgencmd", "display_power", "1"])
        screen_off = False
        print("Activity detected. Screen turned ON.")

    time.sleep(5)

Puedes automatizar y ejecutar este script en segundo plano usando ~/.bashrc, rc.local o un servicio systemd. Este script puede suponer un ahorro de energía considerable, ya que tu monitor suele ser lo que más electricidad consume.

Script para detectar inserción de USB

Transferir archivos desde una Raspberry Pi normalmente implica conectarse por SSH, SCP o sincronización en la nube. Pero a veces, la forma más fácil sigue siendo la más antigua: conectar una unidad USB.

Sin embargo, si estás usando tu Raspberry Pi como servidor sin monitor y quieres descargar algunos registros de ella, ¿no sería genial que simplemente conectaras un USB y tu Raspberry Pi descargara automáticamente todos los registros relevantes en tu USB y lo expulsara de forma segura?

Suena como algo de una película de James Bond, pero puedes hacerlo con un sencillo script de Python.

Puedes encontrar la ruta de montaje de tu USB usando el código Python que se muestra a continuación:

import os

MOUNT_ROOT = "/media/pi"
USB_LABEL = "LOGDUMP"  # Optional: use a specific USB label

def find_usb_mount():
    for mount in os.listdir(MOUNT_ROOT):
        mount_path = os.path.join(MOUNT_ROOT, mount)
        if os.path.ismount(mount_path):
            if USB_LABEL and USB_LABEL.lower() not in mount.lower():
                continue
            return mount_path
    return None

Y luego usar eso para copiar datos a tu USB usando la biblioteca shutil:

import os
import shutil
import time

SOURCE_DIR = "/var/log/mylogs"
DESTINATION_NAME = f"logs_{time.strftime('%Y%m%d_%H%M%S')}"

def copy_logs(usb_path):
    dest = os.path.join(usb_path, DESTINATION_NAME)
    os.makedirs(dest, exist_ok=True)
    shutil.copytree(SOURCE_DIR, dest, dirs_exist_ok=True)
    print(f"✅ Logs copied to: {dest}")

Sin embargo, la verdadera magia ocurre cuando añades este script a tus reglas de udev. Puedes hacerlo siguiendo estos pasos:

• Primero, necesitas hacer que tu script de Python sea ejecutable mediante el siguiente comando:
  sudo chmod +x /path/to/your/script.py
• Luego, puedes crear un script de shell auxiliar que contenga el siguiente script de bash (en inglés):
  python3 /path/to/your/script.py
• Haz que este script de shell también sea ejecutable.
• Finalmente, puedes crear una regla de udev con el comando:
  sudo nano /etc/udev/rules.d/99-usb-log.rules
• Añade las siguientes líneas:
  ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd[a-z][0-9]", RUN+="/path/to/your/shell/script.sh"
• Recarga udev usando el comando:
  sudo udevadm control --reload-rules && sudo udevadm trigger

Ahora, cada vez que insertes un USB, tu Raspberry Pi copiará automáticamente todos tus registros al USB sin necesidad de monitor, teclado ni ratón.

Puedes mejorar aún más este script añadiendo un método de autenticación para reforzar la seguridad de los datos, por ejemplo, un token de autenticación guardado en tu USB, que el script de Python verificará antes de copiar todos los registros al USB.

Relacionado: Los 10 mejores consejos de copia de seguridad para Raspberry Pi para mantener tus datos seguros (en inglés)

Detector de movimiento por cámara con captura de imagen

Convertir tu Raspberry Pi en un sistema de seguridad básico suena complicado, pero es más sencillo de lo que piensas. Usando un módulo de cámara con Raspberry Pi y algo de magia de visión por ordenador, puedes lograrlo fácilmente.

OpenCV es una biblioteca de código abierto compatible con lenguajes como Python y C++ (en inglés). Te permite crear proyectos de visión por ordenador y aprendizaje automático. Con OpenCV puedes lograr tareas como reconocimiento facial, reconocimiento de gestos, etc.

Puedes configurar tu cámara de Raspberry Pi para usarla con Python siguiendo esta guía: Cómo usar la cámara de Raspberry Pi con Python en 2025.

Puedes instalar OpenCV en tu Raspberry Pi usando el comando:
sudo apt install python3-opencv

Después puedes usar OpenCV en un script de Python para crear un algoritmo de detección de movimiento, como se muestra a continuación:

import cv2

# Capture video stream
cam = cv2.VideoCapture(0)

# Read the first frame and preprocess it
_, frame1 = cam.read()
gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
gray1 = cv2.GaussianBlur(gray1, (21, 21), 0)

while True:
    # Read the next frame
    _, frame2 = cam.read()
    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.GaussianBlur(gray2, (21, 21), 0)

    # Compute difference between frames
    delta = cv2.absdiff(gray1, gray2)
    thresh = cv2.threshold(delta, 25, 255, cv2.THRESH_BINARY)[1]
    thresh = cv2.dilate(thresh, None, iterations=2)

    # Find contours (moving areas)
    contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # Check for motion
    motion_detected = any(cv2.contourArea(c) > 1000 for c in contours)

    if motion_detected:
        print("⚠️ Motion detected!")

    # Update the baseline frame
    gray1 = gray2.copy()

    # Exit on 'q'
    if cv2.waitKey(10) == ord('q'):
        break

cam.release()
cv2.destroyAllWindows()

Este script de detección de movimiento puede entonces enviarte un correo electrónico con la imagen adjunta. Esto también se puede hacer con un sencillo código Python:

import smtplib
from email.message import EmailMessage

def send_email(image_path):
    # Set up the email details
    msg = EmailMessage()
    msg['Subject'] = '📸 Motion Detected on Raspberry Pi'
    msg['From'] = '[email protected]'
    msg['To'] = '[email protected]'
    msg.set_content('Motion detected! See attached snapshot.')

    # Attach the image
    with open(image_path, 'rb') as f:
        msg.add_attachment(f.read(), maintype='image', subtype='jpeg', filename='snapshot.jpg')

    # Send via Gmail (or your preferred SMTP)
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
        smtp.login('[email protected]', 'your_app_password')
        smtp.send_message(msg)
        print("📧 Email sent successfully!")

Combinando estos dos scripts, puedes hacer que tu Raspberry Pi actúe como un vigilante del hogar. Cada vez que detecte algún movimiento en su cámara, tomará una foto y te la enviará por correo electrónico.

Puedes mejorar este proyecto añadiendo un sensor de detección de movimiento HC-SR501 para reforzar las capacidades de detección de movimiento de tu sistema.

Comprobador de disponibilidad de dispositivos

Si tienes dispositivos inteligentes para el hogar como impresoras, o incluso otra Raspberry Pi en tu red, es posible que quieras saber cuándo alguno se desconecta. Esto puede ser muy útil para administrar de forma remota tus herramientas.

Un script de Python puede comprobar periódicamente si tus dispositivos de red (rúter, impresoras o controladores de dispositivos inteligentes para el hogar) son accesibles. Haciendo ping a sus direcciones IP a intervalos determinados, el script puede detectar si alguno se desconecta y enviarte una notificación cuando eso ocurra.

Comprobar la disponibilidad de tus dispositivos mediante ping se puede hacer fácilmente con el código siguiente:

import os
import time

# List of devices to monitor (name, IP address)
devices = {
    "Router": "192.168.1.1",
    "Printer": "192.168.1.100",
    "NAS": "192.168.1.50"
}

def is_reachable(ip):
    return os.system(f"ping -c 1 -W 2 {ip} > /dev/null 2>&1") == 0

while True:
    for name, ip in devices.items():
        if not is_reachable(ip):
            print(f"⚠️ {name} ({ip}) is offline!")
            # Add optional alert here
        else:
            print(f"✅ {name} is reachable.")
    time.sleep(300)  # Wait 5 minutes

Puedes dar seguimiento a todos los dispositivos, y si alguno se desconecta, recibir una notificación mediante Pushbullet o enviándote un correo electrónico, tal como se muestra en las secciones anteriores.

A continuación, un ejemplo de función que envía una notificación a través de Pushbullet:

import requests

def send_alert(device_name, ip):
    token = "your_pushbullet_token"
    msg = f"{device_name} ({ip}) is offline!"
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": token},
        json={"type": "note", "title": "Device Alert", "body": msg}
    )

Usando este script, puedes monitorizar el estado de todos tus dispositivos inteligentes en casa mientras estás de vacaciones.

Pero, ¿cómo te asegurarás de que tu propia Raspberry Pi sigue encendida?

Esto también se puede hacer usando una notificación de «latido» (heartbeat); puedes modificar el mismo script de Python para generar notificaciones periódicas de este tipo.

import time
import requests

def send_heartbeat():
    token = "your_pushbullet_token"
    message = {
        "type": "note",
        "title": "Raspberry Pi Heartbeat",
        "body": "I'm still online. Time: " + time.strftime("%Y-%m-%d %H:%M:%S")
    }
    requests.post("https://api.pushbullet.com/v2/pushes", headers={
        "Access-Token": token
    }, json=message)

while True:
    send_heartbeat()
    print("✅ Heartbeat sent.")
    time.sleep(3600)  # Every hour

Puedes combinar estos scripts de Python para detectar el estado de todos los dispositivos inteligentes conectados en tu casa y de la propia Raspberry Pi. De esta forma, puedes estar tranquilo sabiendo que todo funciona correctamente cuando estás fuera.

También puedes añadir monitorización de la velocidad de red (en inglés) para detectar la conectividad general de tu red doméstica con internet y avisarte si la velocidad de conexión cae por debajo de un umbral determinado.

Para una administración de sistemas más avanzada de servidores conectados a través de tu Raspberry Pi, considera usar Nagios (en inglés).

Controlador de luces para dispositivos Philips Hue o Tasmota

La Raspberry Pi se puede usar para varios proyectos de domótica (en inglés). Aunque existen numerosas herramientas de domótica (en inglés) disponibles, algunos scripts sencillos de Python también se pueden usar para automatizar las luces de tu hogar inteligente.

Un script de Python puede controlar bombillas como las Philips Hue o las bombillas con firmware Tasmota (en inglés). Estas luces se pueden encender o apagar en franjas horarias específicas o cuando se detecta movimiento.

Necesitarás instalar la biblioteca phue para habilitar esta funcionalidad en Python. Puedes hacerlo usando el comando:
pip install phue

Debes conocer la IP de tu Hue Bridge para conectarte. Además, la primera vez que ejecutes el script, deberás pulsar el botón de enlace del puente para autorizar tu Pi. Puedes iniciar una conexión con el siguiente código Python:

from phue import Bridge

bridge_ip = '192.168.1.100'  # Replace with your bridge IP
b = Bridge(bridge_ip)
b.connect()

Una vez conectado, puedes usar esta biblioteca para controlar las luces:

from datetime import datetime

# Turn on a specific light by name
def turn_on_lights():
    b.set_light('Living Room Lamp', 'on', True)

# Turn off all lights at midnight
if datetime.now().hour == 0:
    b.set_light('Living Room Lamp', 'on', False)

Además de encenderlas o apagarlas, puedes controlar el brillo, los colores y las escenas usando esta biblioteca.

Si en lugar de luces Philips Hue estás usando enchufes o bombillas inteligentes con Tasmota, también puedes controlarlos mediante solicitudes HTTP. Por ejemplo, el siguiente código se puede usar para encender y apagar un dispositivo con Tasmota:

import requests
from datetime import datetime

# Replace with your Tasmota device IP
device_ip = "192.168.1.150"

def turn_light_on():
    requests.get(f"http://{device_ip}/cm?cmnd=Power%20On")

def turn_light_off():
    requests.get(f"http://{device_ip}/cm?cmnd=Power%20Off")

Para lograr una automatización aún mayor, combina estos controles con una simple comprobación de fecha y hora o con el script de detección de movimiento que vimos antes. También puedes automatizar estos scripts mediante tareas de cron.

Puedes combinar estos scripts con MQTT (en inglés) para habilitar funciones de control remoto para tus dispositivos inteligentes en casa.

Aunque las herramientas de domótica preconstruidas son excelentes y ofrecen multitud de funciones, desarrollar tu propio script de Python permite una personalización mucho mayor.

Monitor de disponibilidad de sitios web

Si alojas tu propia web, blog o servidor doméstico, es bueno saber cuándo se cae, especialmente si ocurre cuando no estás pendiente. Actualizar el navegador manualmente no es una solución fiable.

Un script de Python puede comprobar regularmente el estado de tu sitio y avisarte si devuelve un código de error o se vuelve demasiado lento para responder. Crear tu propio sistema de monitorización de disponibilidad usando la librería requests solo requiere unas pocas líneas de código.

Puedes instalar la biblioteca requests usando el comando:
pip install requests

Una vez instalada esta biblioteca, se puede usar para desarrollar un script básico de comprobación de disponibilidad, como se muestra a continuación:

import requests
import time

URL = "https://yourwebsite.com"
CHECK_INTERVAL = 300  # 5 minutes

def check_website():
    try:
        response = requests.get(URL, timeout=5)
        if response.status_code != 200:
            print(f"⚠️ Website returned status code {response.status_code}")
        else:
            print(f"✅ Website is online. ({response.status_code})")
    except requests.exceptions.RequestException as e:
        print(f"🚨 Website check failed: {e}")

while True:
    check_website()
    time.sleep(CHECK_INTERVAL)

Después puedes enviarte notificaciones mediante Pushbullet o correo electrónico (en inglés) para que te avisen si la web está caída o si devuelve un error:

import requests

def send_alert(message):
    token = "your_pushbullet_token"
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": token},
        json={"type": "note", "title": "Website Down", "body": message}
    )

Puedes usar esta función dentro de tu función de comprobación de la siguiente manera:

if response.status_code != 200:
    send_alert(f"Website returned {response.status_code}")

Puedes mejorarlo aún más para avisarte si el tiempo de carga de tu web es lento. Los tiempos de carga lentos también pueden indicar un problema subyacente que necesita solucionarse.

response = requests.get(URL, timeout=10)
load_time = response.elapsed.total_seconds()

if load_time > 1.5:
    send_alert(f"⏱️ Website is slow: {load_time:.2f}s")

Puedes combinar este script con tu comprobador de accesibilidad de dispositivos y tu registro de uso de recursos para crear un script todo en uno que te mantenga informado sobre todos tus dispositivos inteligentes, tu web/blog y la salud de la propia Raspberry Pi.