Pero como en mi caso utilizo la placa como un híbrido entre PC y servidor, y aprovechando que la Raspberry Pi 5 va sobrada de potencia, he decidido instalar Xfce4 desde cero para llevar la experiencia de uso a otro nivel.

En este artículo te guiaré paso a paso para instalar Xfce, configurar el sistema completamente en español, instalar un navegador web y personalizar el entorno para conseguir un aspecto moderno y atractivo.

Requisitos previos

• Raspberry Pi 5 (también vale para Pi 3/4/400/500)
• Disco SSD o Nvme (evita las MicroSD) de 120 GB en adelante.
• Raspberry Pi OS Lite instalado en el disco (versión 64-bit)
• Conexión a internet (por cable o WiFi configurada desde raspi-config)
• Paciencia y ganas de aprender

¿Por qué empezar con Raspberry Pi OS Lite?

Si ya tienes la versión completa de Raspberry Pi OS (con el escritorio Pixel), instalar otro entorno encima puede provocar conflictos visuales y duplicación de aplicaciones. Por eso es mejor empezar desde Raspberry Pi OS Lite (sin escritorio) e instalar solo lo que necesitas.

• Descarga Raspberry Pi OS Lite 64 bits, desde la web oficial.
• Grábalo en un un disco SSD o Nvme con Raspberry Pi Imager.
• Usa el asistente para elegir nombre de la máquina, usuario, configurar idioma etc etc etc .

1. Instalación base de Xfce

Una vez instalado, entra a tu sistema de terminal pura, e inicia sesión con tu usuario y ejecuta estos comandos en orden:

1.1 Actualizar el sistema por completo

sudo apt update
sudo apt full-upgrade -y

Nota: full-upgrade es importante porque actualiza el kernel y paquetes con cambios de dependencias, algo que el simple upgrade no hace siempre.

1.2 Instalar Xfce + drivers + gestor de red

sudo apt install xfce4 xfce4-goodies network-manager-gnome gldriver-test -y

¿Qué es cada cosa?

• xfce4: el escritorio base.
• xfce4-goodies: un montón de utilidades extra (visor de imágenes, archivador, editor de texto, etc.).
• network-manager-gnome: interfaz gráfica para conectarte a Internet desde el escritorio.
• gldriver-test: Específico de Raspberry Pi y detecta automáticamente el hardware (Pi 5 con VideoCore VII) para configurar el driver gráfico adecuado.

1.3 Configurar el arranque en modo gráfico

Ve a las opciones de configuración la eeprom con el siguiente comando.

sudo raspi-config

Dentro de la herramienta:

Ve a 1. System Options Configure system settings

Raspberry Pi 5 Model B Rev 1.0, 8GB


┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│       1 System Options       Configure system settings                       │
│       2 Display Options      Configure display settings                      │
│       3 Interface Options    Configure connections to peripherals            │
│       4 Performance Options  Configure performance settings                  │
│       5 Localisation Options Configure language and regional settings        │
│       6 Advanced Options     Configure advanced settings                     │
│       8 Update               Update this tool to the latest version          │
│       9 About raspi-config   Information about this configuration tool       │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Select>                     <Finish>  

Busca la opcion S5 Boot Select boot into desktop or to command line y pulsa Enter

┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│      S1 Wireless LAN    Enter SSID and passphrase                            │
│      S2 Audio           Select audio out through HDMI or 3.5mm jack          │
│      S3 Password        Change password for the 'raspberry' user             │
│      S4 Hostname        Set name for this computer on a network              │
│      S5 Boot            Select boot into desktop or to command line          │
│      S6 Auto Login      Enable auto login to desktop or to command line      │
│      S7 Splash Screen   Choose graphical splash screen or text boot          │
│      S8 Power LED       Set behaviour of power LED                           │
│      S9 Browser         Choose default web browser                           │
│      S10 Admin Password Enable or disable sudo password                      │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Select>                     <Back>         

Baja con las flechas del teclado hasta B2 Desktop Desktop GUI

┌─────────┤ Raspberry Pi Software Configuration Tool (raspi-config) ├──────────┐
│                                                                              │
│                           B1 Console Text console                            │
│                           B2 Desktop Desktop GUI                             │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                                                                              │
│                     <Aceptar>                    <Cancelar>                  │
│                                                               

Pulsa Tab, para Aceptar, luego Enter, y al salir te preguntará si quieres reiniciar. Di que Sí.

1.4 Al reiniciar, ¡magia!

Aparecerá la pantalla de inicio de sesión de Xfce (LightDM por defecto). Inicia sesión con tu usuario y contraseña.

¡Felicidades! Ya tienes Xfce funcionando, con el driver gráfico correcto y el gestor de red listo para conectar por ETHERNET o WiFi.

2. Poniendo a punto el sistema.

2.2 Instala los paquetes de idioma de Xfce4.

Xfce recién instalado está en inglés. Vamos a arreglarlo.

sudo apt install task-spanish-desktop -y

2.3 Configura el idioma del sistema.

sudo dpkg-reconfigure locales

• Usa las flechas y la barra espaciadora para seleccionar es_ES.UTF-8
• También marca en_US.UTF-8 UTF-8 (por si acaso, no está de más).
• En la pantalla siguiente, elige es_ES.UTF-8 como idioma por defecto.

2.4 Hacer visibles equipos en red.

Por algún motivo que desconozco, xfce viene de fábrica mas ciego que un topo, no ve ningún equipo en la red.

Y para arreglare esto, instala los paquete sugeridos:

sudo apt install thunar-archive-plugin thunar-media-tags-plugin gvfs-backends

2.5 Reinicia para que todo se aplique.

sudo reboot

Al volver, todos los menús de Xfce, la configuración y las aplicaciones estarán en español de España (incluido Firefox cuando lo abras).

3. Personaliza Xfce para que se vea BONITO

Xfce por defecto es funcional pero feo. Con estos pasos lo convertirás en un escritorio moderno, similar a macOS o Windows 11.

3.1 Instala temas, iconos y un dock

sudo apt install arc-theme papirus-icon-theme

• Arc-theme: tema limpio y moderno (versión oscura y clara).
• Papirus-icon-theme: los mejores iconos para Linux, actualizados y vistosos.

3.1.a Aplicar el tema y los iconos (desde el escritorio)

Ve al menú de aplicaciones > Settings > Appearance:

• En la pestaña Style, selecciona Arc-Darker (o Arc-Dark si te gusta muy oscuro).
• En la pestaña Icons, selecciona Papirus-Dark (o Papirus para la versión clara).

Luego ve a Settings > Window Manager y en la pestaña Style, elige también Arc-Darker para que las ventanas combinen.

3.1.b Cambiar el fondo de pantalla (opcional)

Haz clic derecho en el escritorio > Desktop Settings > Background. Elige una imagen bonita. Puedes descargar fondos con:

sudo apt install variety  # gestor de fondos de pantalla (luego lo encuentras en el menú)

3.1.c Extra: instalar un tema para LightDM (pantalla de inicio de sesión)

sudo apt install lightdm-settings

Luego ve a Settings > LightDM GTK+ Greeter Settings para elegir un tema que combine con tu escritorio.

4 Trucos adicionales para un escritorio perfecto

4.2 Hacer que el sistema sea más rápido

En una Raspberry Pi 5 va muy fluido, así que no deshabilitaré ningún efecto, pero si tu placa es mas limitada puedes hacerlo así.

# Deshabilitar efectos visuales pesados
xfconf-query -c xfwm4 -p /general/use_compositing -s false

5 Instalar Software.

5.1 Instalar un navegador web (Firefox en español)

Lo primero que haremos será instalar un navegador, ya que lo vas a necesitar para seguir este tutorial.

En una terminal reglamentaria y homologada, escribe:

sudo apt install firefox-esr firefox-esr-l10n-es-es -y

Ahora lo encontrarás en el menú de aplicaciones > Internet > Firefox ESR.

5.2 Instalar Flatpak

Con Flatpak tendremos acceso a una gran cantidad de software y lo instalaremos mediante el siguiente proceso.

# 1. Instalar Flatpak
sudo apt install flatpak -y

# 2. Añadir el repositorio Flathub
sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

5.3 Instalar Telegram desde Flatpak

Telegram no puede faltar en mis equipos, así, que una vez instalado Flatpak, nada nos impide empezar a instalar cualquier software que necesitemos, en este caso empezamos por Telegram.

# 3. Instalar Telegram
sudo flatpak install flathub org.telegram.desktop -y

# 4. Ejecutar Telegram
flatpak run org.telegram.desktop

5.4 Instalar software básico

# Reproductor de música
sudo apt install quodlibet

# Reproductor de vídeo
sudo apt install vlc

# Editor de imágenes
sudo apt install gimp

# Oficina (opcional, algo pesado para Pi 5 pero funciona)
sudo apt install libreoffice

6. Resumen de comandos útiles (chuleta)

7. Conclusión

Con este tutorial hemos conseguido:

Instalar Xfce en Raspberry Pi 5 sin pantalla negra (usando gldriver-test y raspi-config).
Tener el sistema completo en español de España (interfaz, teclado y Firefox).
Un escritorio bonito y moderno con temas Arc, iconos Papirus.
Un navegador web, gestor de red WiFi y aplicaciones básicas listas para usar.

Ahora tu Raspberry Pi 5 tiene un escritorio ligero, atractivo y totalmente funcional, perfecto para trabajar, navegar o incluso como pequeño PC de escritorio.

¿Te ha funcionado? ¿Tienes alguna duda? Déjame un comentario en el blog y te ayudaré.

Este tutorial está basado en mi experiencia real y en el vídeo «How to Install XFCE Desktop on Raspberry Pi OS Lite (Trixie)» de Amine Tech. Todos los comandos han sido probados en Raspberry Pi 5 con Debian 13 Trixie,

Estas instrucciones no te funcionarán si instalaste aMule desde repositorios.

La plantilla web por defecto es bastante espartana, con un diseño que recuerda a principios de los 2000. Por suerte, aMule permite cambiarla fácilmente, y existen creaciones de la comunidad mucho más atractivas y modernas.

En este artículo te mostraré cómo instalar AmuleWebUI-Reloaded, una plantilla que utiliza Bootstrap, jQuery e iconos para ofrecer una interfaz responsive, limpia y agradable a la vista, tanto en ordenador como en móvil.

¿Qué mejora esta plantilla?

• Diseño actualizado con Bootstrap y animaciones CSS.
• Interfaz responsive que se adapta a pantallas pequeñas (perfecta para usar desde el móvil).
• Iconos y botones más claros que facilitan la navegación.
• Transiciones suaves y logo animado en el inicio de sesión.
• Mismas funcionalidades que la plantilla original, solo mejora la apariencia.

Requisitos previos

Antes de empezar, asegúrate de que tienes:

• aMule funcionando en tu Raspberry Pi (siguiendo mi guía de compilación).
• Acceso por SSH a la Raspberry Pi.
• El servicio amule.service activo.

Instalación paso a paso

1. Detener el servicio aMule

Siempre es recomendable detener el demonio antes de modificar sus archivos:

sudo systemctl stop amule.service

2. Clonar la plantilla en el directorio correcto

Como compilamos aMule desde código fuente y lo instalamos en /usr/local, el directorio de plantillas web está en:

cd /usr/local/share/amule/webserver

Ahora clonamos el repositorio de la plantilla:

sudo git clone https://github.com/MatteoRagni/AmuleWebUI-Reloaded.git

Nota: Usamos sudo porque el directorio pertenece al sistema.

3. Configurar aMule para usar la nueva plantilla

Editamos el archivo de configuración del demonio, que se encuentra en tu carpeta personal:

nano ~/.aMule/amule.conf

Buscamos la sección [Webserver] y añadimos o modificamos la línea Template:

[Webserver]
Enabled=1
Password=tu_hash_md5
Port=4711
Template=AmuleWebUI-Reloaded

Importante: El nombre Template debe coincidir exactamente con el nombre de la carpeta que clonaste. Respeta mayúsculas y minúsculas.

Guarda los cambios con Ctrl+O, presiona Enter y sal con Ctrl+X.

4. Reiniciar el servicio

sudo systemctl restart amule.service

5. ¡Disfrutar de la nueva interfaz!

Abre tu navegador y accede a http://la-ip-de-tu-raspberry:4711 (o http://localhost:4711 si estás en la propia Raspberry).

Verás que la pantalla de login tiene un logo animado y un aspecto mucho más cuidado. Introduce tu contraseña y ¡listo!

Verificación de que todo funciona

Si algo no va bien, puedes comprobar los logs del servicio:

journalctl -u amule.service -f

Abre la interfaz web mientras observas los logs. Si la plantilla no se carga, puede que el nombre no coincida o que la carpeta no esté en la ruta correcta.

También puedes listar las plantillas disponibles para confirmar que está instalada:

ls -la /usr/local/share/amule/webserver/

Deberías ver la carpeta AmuleWebUI-Reloaded junto con otras (como default o php-default).

Comparativa visual

Para que te hagas una idea, así se ve la interfaz antes (plantilla clásica):

Y así se ve después con AmuleWebUI-Reloaded:

La diferencia es notable, sobre todo si accedes desde el móvil.

Posibles problemas y soluciones

Conclusión

Cambiar la plantilla web de aMule es un proceso sencillo que mejora enormemente la experiencia de uso. En pocos minutos, tu interfaz web pasará de ser funcional pero austera a algo mucho más agradable y moderno.

Ahora ya puedes gestionar tus descargas desde cualquier dispositivo con un diseño responsive y cuidado. Si te ha gustado este artículo, compártelo o déjame un comentario con tus impresiones.

¡Felices descargas!

Enlaces de interés

• Repositorio de la plantilla AmuleWebUI-Reloaded
• Guía de compilación de aMule en Raspberry Pi 5
• Web oficial de aMule

Compilar aMule desde GitHub no solo sirve para tener nuevas funciones, sino para asegurar que el programa sea totalmente compatible con hardware y software moderno. En esta guía usaremos el sistema de compilación oficial del proyecto: CMake, que sustituye al antiguo autotools.

Objetivo: Obtener amuled (demonio), amulegui (interfaz remota), amulecmd (consola) y amuleweb (interfaz web) funcionando en Raspberry Pi 5 con Debian 13 / Raspberry Pi OS.

Tabla de versiones y ramas

Tipo	Qué es	¿Cuándo elegirla?
Master (rama principal)	El tronco principal, con los últimos parches	Nuestra elección. Es la más compatible con sistemas modernos.
Tags (etiquetas)	Versiones congeladas (ej. v2.3.3)	Solo si usas un sistema operativo muy antiguo.
Branches de desarrollo	Ramas experimentales	Solo para desarrolladores.

Configuración previa: Wayland vs X11

La Raspberry Pi 5 con Debian 13 usa Wayland por defecto. Sin embargo, aMule funciona mejor con X11.

Para saber si estás utilizando Wayland o X11 (Xorg) en tu sistema Linux, el método más rápido y universal es consultarlo en tu terminal.

echo $XDG_SESSION_TYPE

Si la respuesta es wayland, estás usando Wayland.
Si la respuesta es x11 (o xorg), estás usando el sistema X11

Para cambiarlo:

sudo raspi-config

• Ve a Advanced Options → Wayland
• Selecciona X11
• Reinicia

1. Limpieza de instalaciones previas

Si no tenías amule instalado, pasa al punto 2.

Si ya tenías aMule instalado de los repositorios o de una compilación anterior, ejecuta los siguientes comandos:

sudo systemctl stop amule.service 2>/dev/null
sudo apt purge amule amule-daemon amule-utils-gui amule-utils amule-common -y
sudo apt autoremove --purge -y

2. Instalación de dependencias

sudo apt update
sudo apt install -y build-essential cmake git \
    libboost-all-dev libwxgtk3.2-dev libcryptsetup-dev \
    libcurl4-openssl-dev libgd-dev libgeoip-dev \
    libupnp-dev libcrypto++-dev libreadline-dev \
    libglib2.0-dev pkg-config gettext zlib1g-dev

3. Obtención del código (rama master)

cd ~

git clone https://github.com/amule-project/amule.git

cd amule

git checkout master

4. Configuración de la compilación con CMake

Creamos un directorio separado para compilar (buena práctica):

mkdir -p build

cd build

Ahora configuramos la compilación optimizada para Raspberry Pi 5 (Cortex-A76):

cmake .. \
    -DCMAKE_CXX_FLAGS="-O3 -march=armv8.2-a+crypto -mtune=cortex-a76 -pipe" \
    -DBUILD_DAEMON=ON \
    -DBUILD_REMOTEGUI=ON \
    -DBUILD_AMULECMD=ON \
    -DBUILD_WEBSERVER=ON \
    -DBUILD_MONOLITHIC=OFF \
    -DENABLE_MMAP=ON \
    -DENABLE_UPNP=ON \
    -DCMAKE_INSTALL_PREFIX=/usr/local

4.1 Explicación de las opciones:

5. Compilación e instalación

# Comienza la compilación con este comando
make -j$(nproc)

# Instalamos con la siguiente instruccion
sudo make install

# Actualiza los enlaces y la caché de las librerías compartidas.
sudo ldconfig

La compilación tarda unos minutos. -j$(nproc) usa los 4 núcleos de la Raspberry Pi 5.

6. Configuración del demonio

A. Primer arranque (crea la carpeta .aMule)

/usr/local/bin/amuled

(Se cerrará solo. Es normal)

B. Generar contraseña encriptada (hash MD5)

echo -n "TuContraseñaSegura" | md5sum

Crea un par de contraseñas, las usaremos mas adelante.
Copia el resultado (varios caracteres hexadecimales).

C. Editar la configuración

Es aquí donde utilizaremos las dos contraseñas creadas, mas la activación de las conexiones externas.

nano ~/.aMule/amule.conf

Modifica estas líneas:

AcceptExternalConnections=1
ECPassword=pega_uno_de los_hash_que_copiaste

En la sección [WebServer]:

[WebServer]
Enabled=1
Password=pega_el_otro_hash_que_creaste
Port=4711

Guarda con Ctrl+O, Enter, y sal con Ctrl+X.

7. Crear servicio systemd (arranque automático)

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

Pega esto (cambia TU_USUARIO):

[Unit]
Description=aMule Master Daemon
After=network.target

[Service]
Type=simple
User=tu_usuario
Group=tu_grupo
ExecStart=/usr/local/bin/amuled
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Activa el servicio:

sudo systemctl daemon-reload
sudo systemctl enable amule.service
sudo systemctl start amule.service
sudo systemctl status amule.service

Si ves active (running), el demonio está funcionando.

Acceso desde el navegador

Abre http://localhost:4711

9. Comprobación final

# Ver ejecutables instalados
ls -la /usr/local/bin/amule*

# Ver puertos abiertos
sudo netstat -tlnp | grep -E "4711|4712"

Deberías ver:

• Puerto 4712 → amuled (conexión interna con amuleweb/amulegui)
• Puerto 4711 → amuleweb (servidor web)

10. Posibles errores y soluciones

10.1 El problema crónico de aMuleWeb: cuando la interfaz remota desaparece

Lamentablemente, aMule arrastra un problema conocido desde hace años: aMuleWeb se cierra sin previo aviso, dejándonos sin acceso remoto a nuestras descargas desde fuera de la red local.

Se trata de un fallo intermitente del propio programa que lleva presente mucho tiempo. No es un caso aislado, sino una anomalía bien documentada.

10.1.1 Diagnóstico rápido

Si notas que aMuleWeb deja de funcionar, comprueba su estado de esta manera:

# Ver si hay proceso de amuleweb
ps aux | grep amuleweb | grep -v grep

# Ver qué puertos están escuchando
sudo netstat -tlnp | grep 4711

Si no ves nada en el puerto 4711, el problema es que amuleweb no se ha iniciado.

Revisando los informes de la comunidad y el propio GitHub del proyecto y este error es un clásico:

• Se cierra sin avisar (crashea): Hay informes de que amuleweb falla inesperadamente, sobre todo cuando la lista de descargas se hace larga o hay muchos elementos para mostrar en la interfaz web .
• El demonio (amuled) sigue vivo: Lo crucial es que amuleweb puede morir, pero amuled (el núcleo que realmente descarga los archivos) sigue funcionando perfectamente en segundo plano .

Entonces, ¿cómo solucionarlo?

10.1.2 Solución práctica para tu Raspberry

Dado que amuleweb es inestable y se cierra solo de vez en cuando , la solución más robusta para un sistema 24/7 es, un script «vigilante» (watchdog) que lo reactive automáticamente cuando muera.

Aquí tienes la forma más sencilla de hacerlo.

Paso 1: Crear el script vigilante

Ve a tu terminal, si estas en el equipo, si no, conéctate por SSH y crea el script:

sudo nano /usr/local/bin/amuleweb-watchdog.sh

Paso 2: Copiar el contenido (más simple y efectivo)

Este script es más simple: solo comprueba si el proceso amuleweb existe y, si no, lo arranca.

#!/bin/bash

# Script para vigilar y reiniciar amuleweb si se cierra

if pgrep -x "amuleweb" > /dev/null
then
    # Si está corriendo, no hace nada
    :
else
    # Si no se encuentra, lo registra en el sistema y lo reinicia
    logger "amuleweb-watchdog: amuleweb no encontrado, reiniciando..."
    # Asegúrate de cambiar 'tu_usuario' por el tuyo, ej. 'raspberry'
    sudo -u tu_usuario /usr/local/bin/amuleweb --amule-config-file=/home/tu_usuario/.aMule/amule.conf &
fi

Paso 3: Dar permisos y probar

sudo chmod +x /usr/local/bin/amuleweb-watchdog.sh

Paso 4: Programarlo cada minuto

Edita el crontab del usuario root para que vigile todo el tiempo:

sudo crontab -e

Añade esta línea al final del archivo:

* * * * * /usr/local/bin/amuleweb-watchdog.sh

Con esto, el sistema comprobará cada minuto si amuleweb está vivo y lo levantará automáticamente si se ha cerrado.

10.2 Volver a recompilar

Si por algún motivo algo sale mal a la hora de compilar y debes de volver a recompilar, puedes seguir estos pasos

# Detener el servicio antes de recompilar
sudo systemctl stop amule.service

Ve siguiendo los pasos siguientes uno a uno

# muevete a la carpeta que se creó a traves de github
cd ~/amule

# Borra la carpeta build
rm -rf build

#Crea la carpeta build
mkdir build

# muévete a la carpeta build
cd build

# Configurar con todas las opciones explícitas
cmake .. \
    -DCMAKE_CXX_FLAGS="-O3 -march=armv8.2-a+crypto -mtune=cortex-a76 -pipe" \
    -DBUILD_DAEMON=ON \
    -DBUILD_REMOTEGUI=ON \
    -DBUILD_AMULECMD=ON \
    -DBUILD_WEBSERVER=ON \
    -DBUILD_MONOLITHIC=OFF \
    -DENABLE_MMAP=ON \
    -DENABLE_UPNP=ON \
    -DCMAKE_INSTALL_PREFIX=/usr/local \
    -DBoost_NO_BOOST_CMAKE=ON \
    -DBoost_USE_STATIC_LIBS=OFF

Cuando termine ejecuta en orden cuando finalice cada uno de los siguientes comandos

# Compila el programa (traduce el código fuente a lenguaje máquina).
make -j$(nproc)

# Copia los ejecutables y archivos a las carpetas definitivas del sistema.
sudo make install

# Actualiza la caché de librerías compartidas del sistema.
sudo ldconfig

Una vez terminado arrancamos el servicio de nuevo.

# Volver a arrancar el servicio con la nueva versión
sudo systemctl start amule.service

11. Desinstala aMule

Si no te convence como va tu aMule compilado, siempre lo podrás eliminar de la forma siguiente:

Dirigente a la carpeta «builld»

cd ~/amule/build

Una vez dentro, mira que archivos hay contenidos en ella. Deberas ver «install_manifest.txt»

# Revisa el manifest de instalación (si existe)
cat install_manifest.txt

Si ese archivo existe, puedes usarlo para desinstalar automáticamente:

sudo xargs rm -f < install_manifest.txt

Un vez ejecutado el comando anterior, la desistalación será instantanea, ni si quiera te enviará un mensaje de que todo está ok

Busca posibles restos con:

find /usr/local -name "*amule*" -type f 2>/dev/null

No deberá de salir nada a la orden del comando anterior.

Notas importantes

• Usamos CMake porque es el sistema oficial de compilación del proyecto aMule desde 2024.
• La compilación con -DBUILD_MONOLITHIC=OFF es necesaria para que amuled funcione correctamente como servicio.
• Los puertos 4712 (EC) y 4711 (Web) son distintos. No los confundas.

WireGuard es una VPN moderna, ultrarrápida y muy segura. A diferencia de OpenVPN, es nativa del kernel de Linux (va como parte del sistema, no como un programa aparte), consume muy pocos recursos y se configura en minutos.

¿Para qué querrás una VPN en tu Raspberry Pi?

• Acceder a tu red local desde cualquier lugar (archivos, impresoras, otros equipos)
• Navegar con la IP de tu casa cuando estés fuera (evitar bloqueos geográficos)
• Sincronizar contraseñas de forma segura con KeePass + Syncthing (el siguiente tutorial)
• Usar WiFi públicas sin miedo a que espíen tu tráfico

Ventajas de montarla en una Raspberry Pi:

• Consumo eléctrico ridículo (puede estar 24/7 encendida)
• Control total de tus datos (no dependes de servicios de terceros)
• Aprendizaje enorme

Requisitos

• Una Raspberry Pi (cualquier modelo desde la 3B funciona, pero mejor una Pi 4 o 5)
• Raspberry Pi OS instalado y actualizado (puede ser la versión Lite sin escritorio)
• DuckDNS (gratuito) o cualquier servicio de DNS dinámico ( no lo configuramos aquí)
• Un puerto abierto en tu router (el 51820 UDP)
• Un teléfono Android (para probar el cliente)

1. Instalación de WireGuard

Conéctate a tu Raspberry Pi por SSH o directamente con teclado y pantalla.

sudo apt update && sudo apt upgrade -y
sudo apt install wireguard wireguard-tools qrencode iptables nftables -y

Verifica que el módulo del kernel se ha cargado correctamente:

sudo modprobe wireguard
lsmod | grep wireguard

Si ves algo como wireguard 131072 0, está todo bien.

2. Generar las claves del servidor

Cada VPN necesita un par de claves (pública y privada) para el servidor y otro par para cada cliente. Empezamos con las del servidor.

sudo mkdir -p /etc/wireguard
cd /etc/wireguard
sudo umask 077
sudo wg genkey | sudo tee private.key
sudo cat private.key | sudo wg pubkey | sudo tee public.key

Comprueba que se han creado los archivos:

sudo ls -la /etc/wireguard/

Debes ver private.key y public.key, ambos con permisos -rw------- (600).

3. Crear la configuración del servidor

Ahora creamos el archivo de configuración que arrancará la VPN.

sudo nano /etc/wireguard/wg0.conf

Pega este contenido (cambiando la PrivateKey por la tuya):

[Interface]
PrivateKey = PEGA_AQUÍ_TU_CLAVE_PRIVADA
Address = 10.0.0.1/24
ListenPort = 51820
SaveConfig = false

PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

¿Cómo obtener tu clave privada?

sudo cat /etc/wireguard/private.key

Copia el resultado y pégalo donde pone PrivateKey = ...

Importante sobre la interfaz de red:

• Si tu Raspberry Pi usa cable Ethernet, deja eth0
• Si usa WiFi, cambia eth0 por wlan0
• Si no estás seguro, ejecuta ip route | grep default y mira qué interfaz aparece

Las líneas PostUp y PostDown son las que permiten que tu móvil tenga acceso a internet a través de la VPN (enmascaramiento NAT). Sin ellas, la VPN conectará pero no habrá internet.

Guarda el archivo (Ctrl+O, Enter, Ctrl+X).

4. Configurar el sistema para enrutar tráfico

La VPN necesita que el sistema operativo permita reenviar paquetes de una interfaz a otra.

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Debes ver net.ipv4.ip_forward = 1 en la salida.

5. Arrancar WireGuard

sudo chmod 600 /etc/wireguard/*
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

Verifica que funciona:

sudo wg show

Deberías ver algo como:

interface: wg0
  public key: TU_CLAVE_PUBLICA
  private key: (hidden)
  listening port: 51820

Y comprueba que el puerto está escuchando:

sudo ss -tuln | grep 51820

Debe aparecer 0.0.0.0:51820.

6. Crear la configuración para el móvil (cliente)

Cada dispositivo que se conecte a la VPN necesita su propio par de claves. Vamos a generar las del móvil.

sudo mkdir -p /etc/wireguard/clients
cd /etc/wireguard/clients
sudo umask 077
sudo wg genkey | sudo tee mobile_private.key
sudo cat mobile_private.key | sudo wg pubkey | sudo tee mobile_public.key

Ahora creamos el archivo de configuración que importaremos en el móvil.

sudo nano mobile.conf

Pega este contenido (cambia solo los campos entre [ ... ]):

[Interface]
PrivateKey = [CLAVE_PRIVADA_DEL_MOVIL]
Address = 10.0.0.2/32
DNS = 8.8.8.8

[Peer]
PublicKey = [CLAVE_PUBLICA_DEL_SERVIDOR]
Endpoint = [TU_DOMINIO_O_IP_PUBLICA]:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

Rellena cada campo:

• [CLAVE_PRIVADA_DEL_MOVIL] → El contenido de sudo cat /etc/wireguard/clients/mobile_private.key
• [CLAVE_PUBLICA_DEL_SERVIDOR] → El contenido de sudo cat /etc/wireguard/public.key
• [TU_DOMINIO_O_IP_PUBLICA] → Tu dominio DuckDNS (ej: tublog.duckdns.org) o tu IP pública si no tienes DNS dinámico

Guarda el archivo.

7. Añadir el móvil como cliente permitido en el servidor

MOBILE_PUBKEY=$(sudo cat /etc/wireguard/clients/mobile_public.key)
sudo wg set wg0 peer $MOBILE_PUBKEY allowed-ips 10.0.0.2/32
sudo wg-quick save wg0

Verifica que aparece el peer:

sudo wg show

Ahora deberías ver una sección peer: adicional con la clave pública del móvil.

8. Preparar el código QR para el móvil

sudo cat /etc/wireguard/clients/mobile.conf | qrencode -t ansiutf8

Esto mostrará un código QR en la terminal.

En tu Android:

1. Instala la app WireGuard desde Play Store
2. Abre la app → Botón + → Escanear desde código QR
3. Escanea el código QR de la terminal

La app importará automáticamente la configuración. Solo tendrás que pulsar el interruptor para conectarte.

9. Abrir el puerto en el router (imprescindible para acceso remoto)

Este es el único paso que depende de tu router, pero es sencillo.

Primero, averigua la IP local de tu Raspberry Pi:

hostname -I

Anota la primera IP (ej: 192.168.1.150).

Accede a la web de tu router (normalmente 192.168.1.1 o 192.168.0.1).

Busca la sección «Reenvío de puertos» o «Port Forwarding» y añade una regla:

Guarda los cambios. Si tu router tiene la opción, reinícialo para aplicar la regla.

Si usas DuckDNS: Asegúrate de que el cliente de actualización está corriendo en tu Raspberry Pi o en el router, para que tu dominio siempre apunte a tu IP pública.

10. Comprobación final

Prueba dentro de casa (WiFi local)

1. En el móvil, activa WireGuard
2. Abre el navegador y busca «cuál es mi IP»
3. Debe mostrar la IP pública de tu casa (la de tu router)

Prueba desde fuera (con datos móviles)

1. Desactiva el WiFi del móvil
2. Activa WireGuard
3. Repite la búsqueda de IP
4. Sigue debiendo mostrar la IP de tu casa

Si ves la IP de tu casa, la VPN funciona perfectamente.

11. Posibles errores y soluciones (basados en errores reales)

12. Mantenimiento y buenas prácticas

• Actualiza regularmente: sudo apt update && sudo apt upgrade -y
• Monitorea el servicio: sudo systemctl status wg-quick@wg0
• Revoca el acceso a un dispositivo: Elimina su peer del servidor con sudo wg set wg0 peer [su_clave_publica] remove
• Copia de seguridad de las claves: Guarda en un lugar seguro (/etc/wireguard/ entero)
• Puerto seguro: El 51820 UDP es el estándar, pero puedes cambiarlo por cualquier otro si quieres algo menos predecible

13. ¿Qué viene después?

Con la VPN funcionando, ya puedes:

• Sincronizar contraseñas entre tu PC con Linux y tu Android usando KeePassXC + Syncthing (próximo tutorial)
• Acceder a tu red doméstica desde cualquier lugar (NAS, servidor multimedia, impresora)
• Usar Pi-hole para bloquear anuncios también en tu móvil cuando estás fuera de casa

Conclusión

Has montado tu propia VPN en una Raspberry Pi sin depender de servicios externos, sin Docker y con software libre. WireGuard es ligero, seguro y una vez configurado, olvidas que está ahí.

¿Te ha servido? ¿Tienes dudas? Puedes dejar un comentario y te ayudaré (porque yo ya pasé por todos los errores posibles mientras escribía este tutorial).

Este tutorial está basado en una instalación real en Raspberry Pi 5 con Raspberry Pi OS, sin Docker, y probado con Android 13.

De repente, cada vez que reiniciaba el sistema, la Pi arrancaba pero con la pantalla más negra que el porvenir de un zombi. Al principio, el pánico: pensé que el sistema se colgaba y no arrancaba. Cambié el HAT, probé otro disco NVMe, compré cables HDMI nuevos e incluso reinstalé el sistema operativo varias veces. ¿El resultado? El mismo vacío oscuro.

Sin embargo, al entrar por SSH desde mi teléfono, descubrí la verdad: la Pi estaba vivita y coleando, con el sistema totalmente cargado y funcionando de fondo. El problema no era que la Pi no arrancara, ¡era que no quería hablar con mi monitor!

Nota: Para que el sistema arranque de forma normal quita el cable de alimentación y tras 5 segundos vuelve a conectar.

¿Por qué el NVMe «rompe» el vídeo al reiniciar?

Si te está pasando lo mismo, no te vuelvas loco cambiando hardware. La explicación de por qué con una tarjeta SD o un SSD lento todo iba bien y con el NVMe oficial falla, se resume en estos tres factores:

• Tu Raspberry Pi ahora es «demasiado rápida»: Imagina que el arranque es una conversación. Con la SD, la Pi tardaba 30 segundos; al monitor le daba tiempo a despertarse y tomarse un café. Con el NVMe, el sistema carga en 5 segundos. La Pi lanza la señal de vídeo tan rápido que el monitor aún está «desperezándose» del reinicio. Cuando el monitor quiere mirar, la Pi ya ha dejado de llamar a la puerta y ambos se quedan esperando en silencio.
• Interferencias y «ruido» eléctrico: El bus PCIe donde va tu NVMe funciona a frecuencias altísimas que generan ondas electromagnéticas. Como los puertos micro-HDMI están pegados al conector PCIe en la Pi 5, ese «ruido» puede ensuciar la señal. Si el cable no es de excelente calidad, la Pi no recibe los datos del monitor (EDID) y, por seguridad, apaga la salida.
• El reinicio «suave» vs «fuerte»: Al reiniciar desde el escritorio, el driver de vídeo a veces no se cierra correctamente antes de que el rapidísimo NVMe vuelva a cargar todo. Esto deja a la gráfica en un estado de confusión total.

En resumen: Es como si tu Raspberry Pi fuera ahora un coche de carreras. Arranca tan rápido que sale del garaje antes de que la puerta (tu monitor) termine de abrirse.

A continuación, te explico los pasos exactos para decirle a tu Pi: «Espera un segundo antes de salir y, aunque veas la puerta cerrada, empuja, que se abrirá».

El cambio imprescindible (De Wayland a X11)

Por defecto, la Raspberry Pi 5 utiliza Wayland. Sin embargo, Wayland todavía tiene problemas para gestionar el «Screen Blanking» (que la pantalla se apague sola tras un tiempo sin uso).

Si quieres que tu monitor descanse y que los comandos que vamos a usar funcionen, debemos volver al servidor gráfico X11.

¿Cómo cambiar a X11?

1. Abre una terminal y escribe: sudo raspi-config
2. Ve a 6 Advanced Options.
3. Busca A6 Wayland.
4. Selecciona W1 X11 (o el que indique que desactiva Wayland).
5. Dale a Finish y acepta el Reboot (reiniciar).

Ahora que estamos en X11, todos los comandos de ahorro de energía y gestión de pantalla funcionarán como un reloj.

Parte 1: El «Seguro de Vida» (Configurar SSH)

Antes de meterle mano a la configuración interna, necesitamos una forma de hablar con la Raspberry Pi cuando la pantalla está en negro. Para eso usamos el SSH (Secure Shell). Si puedes entrar por SSH desde tu móvil o tu PC mientras la pantalla está oscura, ¡felicidades!, tu Pi no está muerta, solo está «tímida» con el monitor.

1. ¿Cómo saber si el SSH está activo?

Si tienes la suerte de que la pantalla ha encendido o estás configurándola por primera vez, abre una terminal y comprueba el estado del servicio:

sudo systemctl status ssh

Caso A: El servicio funciona correctamente

Si ves un mensaje en verde que dice active (running), todo está perfecto. Ya puedes acceder remotamente.

Ojo: En mi caso veréis que uso el puerto 22299, pero por defecto en vuestra Pi será el 22.

● ssh.service - OpenBSD Secure Shell server
     Active: active (running) since Sat 2026-03-14 15:15:56 CET; 3h 28min ago
     ...
     mar 14 15:15:56 pi5-2 sshd[1006]: Server listening on 0.0.0.0 port 22299.

Caso B: El servicio está apagado o muerto

Si por el contrario ves que dice inactive (dead), significa que estás «ciego» si la pantalla falla. Tienes que activarlo obligatoriamente.

○ ssh.service - OpenBSD Secure Shell server
     Loaded: loaded (...; disabled; ...)
     Active: inactive (dead)

2. Cómo activar e iniciar el SSH

Para que el SSH se encienda solo cada vez que arranques la Pi (muy importante para nuestro problema), ejecuta estos dos comandos:

Primero: Habilitar el inicio automático

sudo systemctl enable ssh

Verás que el sistema crea unos «symlinks» (accesos directos internos), eso indica que ahora arrancará siempre con el sistema.

Segundo: Arrancar el servicio ahora mismo

sudo systemctl start ssh

Parte 2: El diagnóstico definitivo (¿Monitor o Sistema?)

Una vez que tengas SSH, la próxima vez que reinicies y la pantalla se quede «más negra que el porvenir de un zombi», no entres en pánico. Conéctate desde tu móvil y lanza este comando:

kmsprint

• Si ves HDMI-A-1 (connected) nos confirma que la Raspberry Pi sí detecta el monitor, pero la señal de vídeo no se está «dibujando»
• Si quieres forzar el encendido desde el móvil, pega esto en la terminal de tu móvil:

export DISPLAY=:0
xset dpms force on

Si esto no enciende tu monitor, ejecuta:

sudo systemctl restart lightdm

(Esto cerrará tus apps abiertas, pero debería forzar al monitor a recibir señal).

En mi caso, reiniciar lightdm encendió mi monitor.

El hecho de que al reiniciar lightdm la pantalla se encienda es la prueba definitiva: el sistema operativo arranca bien, el hardware funciona y el disco NVMe está perfecto.

Parte 3: La Solución Definitiva (La «D» Mágica)

Si has confirmado que por SSH todo funciona pero el HDMI se queda frito, vamos a aplicar la medicina. Editamos el archivo de configuración del arranque:

sudo nano /boot/firmware/cmdline.txt

Ve al final de la única línea que hay, añade un espacio y escribe:

video=HDMI-A-1:1920x1080@60D

¿Por qué la D? Porque le dice a la Pi: «Envía señal Digital sí o sí, no preguntes al monitor si está listo, ¡dispara!».

Un último ajuste en la EEPROM

Para que el disco NVMe y el vídeo se lleven bien eléctricamente en la Raspberry Pi 5, te recomiendo este cambio final:

sudo rpi-eeprom-config --edit

Dentro te encontrarás tres líneas como estas.

BOOT_UART=1
BOOT_ORDER=0xf146
NET_INSTALL_AT_POWER_ON=1

Añade estas líneas al final de las existentes:

• POWER_OFF_ON_HALT=1
• HDMI_DELAY=1

Cuando lo tengas, guarda los cambios con Ctrl + o y cierra para salir con Crtl + x

Entonces se generará la nueva configuración.

raspberry@pi5:~ $ sudo rpi-eeprom-config --edit
Updating bootloader EEPROM
 image: /usr/lib/firmware/raspberrypi/bootloader-2712/default/pieeprom-2026-05-26.bin
config_src: blconfig device
config: /tmp/tmp_3tpo_c8/boot.conf
################################################################################
[all]
BOOT_UART=1
BOOT_ORDER=0xf146
NET_INSTALL_AT_POWER_ON=1
POWER_OFF_ON_HALT=1
HDMI_DELAY=1

################################################################################
*** CREATED UPDATE /tmp/tmp_3tpo_c8/pieeprom.upd  ***

Checking flashrom probe
   CURRENT: vie 06 feb 2026 14:31:40 UTC (1770388300)
    UPDATE: mar 26 may 2026 15:01:25 UTC (1779807685)
    BOOTFS: /boot/firmware
'/tmp/tmp.1fcqwNnARo' -> '/boot/firmware/pieeprom.upd'

UPDATING bootloader. This could take up to a minute. Please wait

*** Do not disconnect the power until the update is complete ***

If a problem occurs then the Raspberry Pi Imager may be used to create
a bootloader rescue SD card image which restores the default bootloader image.

flashrom -p linux_spi:dev=/dev/spidev10.0,spispeed=16000 -w /boot/firmware/pieeprom.upd
Verifying update
VERIFY: SUCCESS
UPDATE SUCCESSFUL
raspberry@pi5:~ $ 

Ahora tan solo reinicia el sistema con

sudo reboot

Este paso es como ajustar el «reloj interno» y la gestión eléctrica de la placa base de tu Raspberry Pi 5. Es el ajuste que soluciona el conflicto físico entre el disco NVMe y el puerto HDMI.

• POWER_OFF_ON_HALT=1: Fuerza un reinicio eléctrico completo. Evita que el disco «atonté» a la salida de vídeo.
• HDMI_DELAY=1: Le da un segundo de ventaja al monitor para que esté listo antes de que la Pi empiece a enviar imágenes.

¡Y listo! Con esto habrás pasado de tener un pisapapeles caro a una Raspberry Pi 5 con NVMe que vuela y que no se achica ante ningún reinicio.

Todo empezó curioseando en webs de segunda mano. Ya sabéis cómo va: vendedores que aseguran que el disco está en perfectas condiciones e incluso adjuntan capturas de pantalla de tests de salud. Pero, ¿os fiáis? Yo prefiero hacer las pruebas por mi cuenta y salir de dudas. En Wallapop, por ejemplo, tienes 48 horas para revisar el producto, así que hay tiempo de sobra para comprobar la verdad.

En esta ocasión, voy a testear un SSD Kingston A400 de 240GB conectado por USB 3.0 a mi Raspberry Pi 5. Mi objetivo: saber si está sano, si es rápido y si está bien configurado.

Hoy os cuento el proceso paso a paso: desde identificar el adaptador USB-SATA hasta medir la velocidad real y consultar la salud interna con SMART. Estos comandos son oro puro si usas el SSD para boot, un NAS casero o backups, y quieres exprimir tu Pi sin sorpresas.

¿Por qué molestarse en hacer esto?

• Saber si tu SSD (o HDD) está sano: Evitas perder datos por fallos silenciosos (bad blocks, sectores reasignados, desgaste excesivo).
• Medir rendimiento real: Muchos enclosures USB baratos limitan a 30-50 MB/s o caen a USB 2.0. Con UASP bien configurado, un SSD SATA puede volar a 300-400 MB/s en Pi 5.
• Detectar problemas de hardware: Chipset malo (Realtek vs ASMedia), alimentación inestable, cables defectuosos o quirks del kernel.
• Beneficios prácticos: Boot mucho más rápido que microSD, menos corrupción de filesystem, alertas tempranas si la vida del SSD baja, y tranquilidad total (sobre todo si usas el Pi 24/7).

1. Lista todos los dispositivos USB conectados.

En mi caso:

vigilante@raspberrypi:~ $ lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 05e3:0610 Genesys Logic, Inc. Hub
Bus 001 Device 003: ID 04d9:0006 Holtek Semiconductor, Inc. Wired Keyboard (78/79 key) [RPI Wired Keyboard 5]
Bus 001 Device 004: ID 093a:2510 Pixart Imaging, Inc. Optical Mouse
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 004 Device 002: ID 14b0:0206 StarTech.com Ltd.  SA400S37240G

→ Identifica el VID:PID del adaptador (14b0:0206 es StarTech con chipset ASMedia ASM105x, de los mejores). Si ves Realtek (0bda:xxxx), ojo, pueden ser más problemáticos.

2. Muestra el árbol USB con drivers y velocidades.

vigilante@raspberrypi:~ $ lsusb -t
/:  Bus 001.Port 001: Dev 001, Class=root_hub, Driver=xhci-hcd/2p, 480M
    |__ Port 002: Dev 002, If 0, Class=Hub, Driver=hub/4p, 480M
        |__ Port 001: Dev 003, If 0, Class=Human Interface Device, Driver=usbhid, 1.5M
        |__ Port 001: Dev 003, If 1, Class=Human Interface Device, Driver=usbhid, 1.5M
        |__ Port 002: Dev 004, If 0, Class=Human Interface Device, Driver=usbhid, 1.5M
/:  Bus 002.Port 001: Dev 001, Class=root_hub, Driver=xhci-hcd/1p, 5000M
/:  Bus 003.Port 001: Dev 001, Class=root_hub, Driver=xhci-hcd/2p, 480M
/:  Bus 004.Port 001: Dev 001, Class=root_hub, Driver=xhci-hcd/1p, 5000M
    |__ Port 001: Dev 002, If 0, Class=Mass Storage, Driver=uas, 5000M

Velocidades de transferencia: Al final de cada línea verás algo como 5000M (5 Gbps/USB 3.0), 480M (480 Mbps/USB 2.0) o incluso 10G (USB 3.1 Gen 2).
Drivers (Controladores): Te indica qué driver está gestionando el dispositivo (por ejemplo, usb-storage o el deseado uas para mayor velocidad en SSDs).

¡UASP activo! Esto es lo que queremos: bajo uso CPU, mejor rendimiento secuencial. Si ves «usb-storage» en vez de «uas», es más lento y usa más CPU.

3. Identifica el disco.

«Antes de tocar nada, necesitamos saber quién es quién. Usamos lsblk para ver de forma clara el modelo y tamaño de nuestros discos, y fdisk para confirmar los detalles técnicos y sectores del sistema. Es el primer paso para no equivocarnos de unidad al formatear o testear.»

lsblk -o NAME,SIZE,TYPE,MODEL (El DNI del disco)

lsblk significa List Block Devices. Es la forma más limpia y moderna de ver qué tienes conectado.

• ¿Para qué sirve? Para identificar rápidamente qué letra tiene tu disco (sda, sdb, etc.) y qué particiones hay dentro.
• ¿Qué significan las opciones? Con -o le pedimos que solo nos muestre lo que nos interesa:
  • NAME: El nombre técnico (ej. sda).
  • SIZE: Cuánto espacio tiene.
  • TYPE: Si es un disco entero (disk) o una partición (part).
  • MODEL: La marca y modelo real (aquí es donde verás si tu SSD es un Kingston, un Samsung, etc.).
• Ventaja: No necesita permisos de superusuario (sudo) y la salida es muy fácil de leer.

vigilante@raspberrypi:~ $ lsblk -o NAME,SIZE,TYPE,MODEL
NAME     SIZE TYPE MODEL
loop0      2G loop 
sda    223,6G disk KINGSTON SA400S37240G
├─sda1   512M part 
└─sda2 223,1G part 
zram0      2G disk 

sudo fdisk -l | grep -i disk (La Radiografía técnica)

fdisk es una herramienta clásica y potente para manejar tablas de particiones.

• ¿Para qué sirve? Muestra detalles mucho más técnicos que lsblk, como el número exacto de sectores, el identificador del disco y el tamaño en bytes exactos.
• ¿Por qué usamos el grep -i disk? Si lanzas sudo fdisk -l a secas, te saldrá una lista larguísima de todas las particiones, sectores de inicio, fin, etc. Al filtrar con grep, le decimos: «Solo enséñame las líneas que resuman la información de los discos físicos».
• Ventaja: Te da el tamaño exacto en bytes (útil para clonar discos) y te confirma si el disco tiene un esquema de particiones válido (GPT o DOS).

vigilante@raspberrypi:~ $ sudo fdisk -l | grep -i disk
Disk /dev/ram0: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram1: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram2: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram3: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram4: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram5: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram6: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram7: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram8: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram9: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram10: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram11: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram12: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram13: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram14: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/ram15: 4 MiB, 4194304 bytes, 8192 sectors
Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
Disk /dev/sda: 223,57 GiB, 240057409536 bytes, 468862128 sectors
Disk model:  SA400S37240G   
Disklabel type: dos
Disk identifier: 0xc7a2c28e
Disk /dev/zram0: 2 GiB, 2147483648 bytes, 524288 sectors

Esto confirma que /dev/sda es mi SSD (no la SD de boot ni zram).

4. Instalar herramientas.

   sudo apt update
   sudo apt install hdparm smartmontools

Las herramientas necesarias para la monitorio son:
- hdparm para tests de velocidad
- smartmontools para SMART (salud del disco).

5. El Autodiagnóstico: Obligando al SSD a decir la verdad

A veces, un vendedor de segunda mano puede haber «reseteado» los contadores SMART o simplemente el disco aún no ha registrado un fallo que acaba de ocurrir. Para eso usamos el Short Self-Test.

Ejecuta este comando para iniciar un chequeo instantáneo:

sudo smartctl -t short -d sat /dev/sda

Nota: Este comando no te dará el resultado al instante. Solo le da la orden al disco y te devuelve el control de la terminal. Es como pedir cita en el médico: la orden está dada, pero el examen lleva su tiempo (normalmente 1 o 2 minutos).

Este comando es una buena opción para mirar los atributos, porque obliga al disco a trabajar en ese momento. Si hay un fallo físico inminente, el test se detendrá y te avisará. Es la forma más rápida de saber si el SSD que tienes en las manos es fiable.

¿Cómo sé si ha terminado? Tienes que consultar el log después de que pase ese tiempo usando el comando:

sudo smartctl -l selftest -d sat /dev/sda

Este comando arroja sobre mi disco la siguiente información:

vigilante@raspberrypi:~ $ sudo smartctl -l selftest -d sat /dev/sda
smartctl 7.4 2023-08-01 r5530 [aarch64-linux-6.12.62+rpt-rpi-2712] (local build)
Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF READ SMART DATA SECTION ===
SMART Self-test log structure revision number 1
Num  Test_Description    Status                  Remaining  LifeTime(hours)  LBA_of_first_error
# 1  Short offline       Completed without error       00%      9098         -

¿Cómo leer el log de autodiagnóstico? (Self-test)

Esto es lo que debes mirar:

• Status: «Completed without error». Esta es la clave. Significa que el disco ha analizado sus componentes internos, la electrónica y la superficie de las celdas de memoria y no ha encontrado fallos físicos.
• Remaining: «00%». Indica que el test ha terminado por completo, si hay otro valor, espera y lanza el comando otra vez para ver si terminó.
• LifeTime(hours): «9098». Es el momento exacto en la vida del disco en el que se hizo el test.
• LBA_of_first_error: «-«. Si aquí aparece un número, es la dirección del sector donde el disco ha fallado. Al aparecer un guion, confirmamos que el disco está limpio.

Ese comando tiene dos variantes de test:
- short: Tarda 1-2 minutos y revisa lo más crítico.
- long: Puede tardar 1 hora o más porque lee cada una de las celdas del disco. Para una compra de Wallapop, con el short suele ser suficiente, pero si el disco es muy grande y tienes tiempo, el long es la seguridad total.

5.1 Test de velocidad de escritura. (Test de Estrés)

hdparm mide lectura, pero los SSD fallan al escribir. Crea un archivo de prueba de 1GB para ver si la velocidad se mantiene estable:

dd if=/dev/zero of=./testfile bs=1G count=1 oflag=dsync

• Resultado OK: Velocidad constante (ej. 200-350 MB/s para SATA).
• Resultado sospechoso: Si empieza rápido y cae de golpe a 15-20 MB/s, las celdas están muy castigadas.

Para mi caso:

vigilante@raspberrypi:~ $ dd if=/dev/zero of=./testfile bs=1G count=1 oflag=dsync
1+0 records in
1+0 records out
1073741824 bytes (1,1 GB, 1,0 GiB) copied, 4,03518 s, 266 MB/s

Resultado es excelente! , esos 266 MB/s de escritura real (y con el flag dsync, que fuerza a que el dato se escriba físicamente antes de terminar) confirman que tu SSD y tu adaptador USB están trabajando a un nivel de rendimiento altísimo para una Raspberry Pi.

Para un SSD SATA conectado por USB en una Raspberry Pi, es prácticamente el límite de lo que el hardware puede dar. Tienes un conjunto de disco y controladora muy sólido.

5.2 Test de velocidad de lectura real (sin caché)

Mi resultado:

   vigilante@raspberrypi:~ $ sudo hdparm -t /dev/sda

/dev/sda:
 Timing buffered disk reads: 1026 MB in  3.02 seconds = 339.63 MB/sec

¡Brutal! para un SSD SATA en USB 3.0 en Pi 5. El Kingston A400 nativo hace ~500 MB/s, pero con overhead USB + enclosure, 340 MB/s es top. Si sale <100 MB/s → problema (cable, chipset, alimentación, o sin UASP).

6. ¿Soporta TRIM?

Si compras un pack de SSD + Carcasa USB, necesitas saber si el conjunto permite el comando TRIM.

El soporte de TRIM depende tanto del disco como del adaptador usb-to-sata. Si uno de ellos no es compatible, el otro tampoco lo será.

Compruébalo así:

vigilante@raspberrypi:~ $ lsblk --discard
NAME   DISC-ALN DISC-GRAN DISC-MAX DISC-ZERO
loop0         0        4K       4G         0
sda           0        0B       0B         0
├─sda1        0        0B       0B         0
└─sda2        0        0B       0B         0
zram0         0       16K       2T         0

Fíjate en las columnas DISC-ALN y DISC-MAX. Si aparecen ceros, el adaptador USB no es compatible con TRIM o el SSD es muy antiguo. En una Pi, esto es clave para que el sistema no se degrade.

Sin TRIM, la Raspberry Pi no podrá decirle al SSD qué bloques están libres, y con el tiempo el disco se volverá lento como una tortuga.

7. Muestra TODA la info SMART.

A veces compras un disco en Aliexpress o en tiendas de segunda mano, te venden un «Samsung 870» metido en una carcasa genérica, pero dentro hay un disco chino de marca blanca.

Existe un comando con dos variantes que nos dará una rápida o extensa información del disco

sudo smartctl -i -d sat /dev/sda (Información de identidad)

La -i viene de Info.

• Qué hace: Solo te dice qué es el disco.
• Qué verás: Marca, modelo, número de serie, versión del firmware y si el SMART está activado o no.
• Cuándo usarlo: Cuando solo quieres confirmar que el disco que te han vendido es el modelo real y no un «cambiazo» (lo que hablábamos de Wallapop).

sudo smartctl -a -d sat /dev/sda (Análisis total)

La -a viene de All (Todo).

• Qué hace: Muestra todo lo que el disco sabe de sí mismo. Incluye la información de la -i, pero añade lo más importante:
  • Atributos SMART: Los contadores de vida, horas de encendido, errores de lectura y los famosos sectores reasignados (ID 05/196).
  • Resumen de Salud: El veredicto «PASSED» o «FAILED».
  • Estadísticas de temperatura: Mínimas y máximas históricas.
• Cuándo usarlo: Siempre que quieras diagnosticar o saber si el disco está sano.

Este comando nos dará un rápido resumen de la identidad real del disco:

vigilante@raspberrypi:~ $ sudo smartctl -i -d sat /dev/sda
smartctl 7.4 2023-08-01 r5530 [aarch64-linux-6.12.62+rpt-rpi-2712] (local build)
Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Phison Driven SSDs
Device Model:     KINGSTON SA400S37240G
Serial Number:    60026B7785211E3B
LU WWN Device Id: 5 0026b7 785211e3b
Firmware Version: SBFKB1H5
User Capacity:    240.057.409.536 bytes [240 GB]
Sector Size:      512 bytes logical/physical
Rotation Rate:    Solid State Device
TRIM Command:     Available
Device is:        In smartctl database 7.3/5528
ATA Version is:   ACS-3 T13/2161-D revision 4
SATA Version is:  SATA 3.2, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is:    Fri Mar 13 18:05:54 2026 CET
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

Mira donde pone Device Model. Si el vendedor dice que es un Kingston y el comando dice «Netac» o «KingSpec», te están intentando engañar.

Si vas a quedar con alguien de Wallapop, llévate tu Raspberry Pi, un PowerBank y estos comandos anotados. En 5 minutos sabrás si el SSD es una ganga o una estafa.

Veamos la información completa del disco (salud interna):

vigilante@raspberrypi:~ $ sudo smartctl -a -d sat /dev/sda
smartctl 7.4 2023-08-01 r5530 [aarch64-linux-6.12.62+rpt-rpi-2712] (local build)
Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Phison Driven SSDs
Device Model:     KINGSTON SA400S37240G
Serial Number:    60026B7785211E3B
LU WWN Device Id: 5 0026b7 785211e3b
Firmware Version: SBFKB1H5
User Capacity:    240.057.409.536 bytes [240 GB]
Sector Size:      512 bytes logical/physical
Rotation Rate:    Solid State Device
TRIM Command:     Available
Device is:        In smartctl database 7.3/5528
ATA Version is:   ACS-3 T13/2161-D revision 4
SATA Version is:  SATA 3.2, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is:    Mon Mar  9 19:15:15 2026 CET
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED

General SMART Values:
Offline data collection status:  (0x00)	Offline data collection activity
					was never started.
					Auto Offline Data Collection: Disabled.
Self-test execution status:      (   0)	The previous self-test routine completed
					without error or no self-test has ever 
					been run.
Total time to complete Offline 
data collection: 		(65535) seconds.
Offline data collection
capabilities: 			 (0x11) SMART execute Offline immediate.
					No Auto Offline data collection support.
					Suspend Offline collection upon new
					command.
					No Offline surface scan supported.
					Self-test supported.
					No Conveyance Self-test supported.
					No Selective Self-test supported.
SMART capabilities:            (0x0003)	Saves SMART data before entering
					power-saving mode.
					Supports SMART auto save timer.
Error logging capability:        (0x01)	Error logging supported.
					General Purpose Logging supported.
Short self-test routine 
recommended polling time: 	 (   1) minutes.
Extended self-test routine
recommended polling time: 	 (   2) minutes.

SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME          FLAG     VALUE WORST THRESH TYPE      UPDATED  WHEN_FAILED RAW_VALUE
  1 Raw_Read_Error_Rate     0x0032   100   100   000    Old_age   Always       -       0
  9 Power_On_Hours          0x0032   100   100   000    Old_age   Always       -       9090
 12 Power_Cycle_Count       0x0032   100   100   000    Old_age   Always       -       154
148 Unknown_Attribute       0x0000   100   100   000    Old_age   Offline      -       0
149 Unknown_Attribute       0x0000   100   100   000    Old_age   Offline      -       0
167 Write_Protect_Mode      0x0000   100   100   000    Old_age   Offline      -       0
168 SATA_Phy_Error_Count    0x0012   100   100   000    Old_age   Always       -       0
169 Bad_Block_Rate          0x0000   100   100   000    Old_age   Offline      -       17
170 Bad_Blk_Ct_Lat/Erl      0x0000   100   100   010    Old_age   Offline      -       0/12
172 Erase_Fail_Count        0x0032   100   100   000    Old_age   Always       -       0
173 MaxAvgErase_Ct          0x0000   100   100   000    Old_age   Offline      -       67 (Average 51)
181 Program_Fail_Count      0x0032   100   100   000    Old_age   Always       -       0
182 Erase_Fail_Count        0x0000   100   100   000    Old_age   Offline      -       0
187 Reported_Uncorrect      0x0032   100   100   000    Old_age   Always       -       0
192 Unsafe_Shutdown_Count   0x0012   100   100   000    Old_age   Always       -       149
194 Temperature_Celsius     0x0022   024   048   000    Old_age   Always       -       24 (Min/Max 17/48)
196 Reallocated_Event_Count 0x0032   100   100   000    Old_age   Always       -       0
199 SATA_CRC_Error_Count    0x0032   100   100   000    Old_age   Always       -       0
218 CRC_Error_Count         0x0032   100   100   000    Old_age   Always       -       0
231 SSD_Life_Left           0x0000   094   094   000    Old_age   Offline      -       94
233 Flash_Writes_GiB        0x0032   100   100   000    Old_age   Always       -       7476
241 Lifetime_Writes_GiB     0x0032   100   100   000    Old_age   Always       -       4094
242 Lifetime_Reads_GiB      0x0032   100   100   000    Old_age   Always       -       11006
244 Average_Erase_Count     0x0000   100   100   000    Old_age   Offline      -       51
245 Max_Erase_Count         0x0000   100   100   000    Old_age   Offline      -       67
246 Total_Erase_Count       0x0000   100   100   000    Old_age   Offline      -       392144

SMART Error Log Version: 1
No Errors Logged

SMART Self-test log structure revision number 1
No self-tests have been logged.  [To run self-tests, use: smartctl -t]

Selective Self-tests/Logging not supported

The above only provides legacy SMART information - try 'smartctl -x' for more

Lo más interesante de mi disco

• Overall-health self-assessment test result: PASSED → Perfecto.
• 9 – Power_On_Hours: 9090 (~1 año encendido).
• 192 – Unsafe_Shutdown_Count: 149 → Apagados bruscos (lo solucioné con el SAI + NUT del post anterior).
• 196 – Reallocated_Event_Count: 0 → Ningún sector malo reasignado.
• 231 – SSD_Life_Left: 94% → Aún le queda 94% de vida (TBW ~80 TB, yo ~4 TB escritos).
• 194 – Temperature_Celsius: 24 (Max 48) → Fresco.
• 169 – Bad_Block_Rate : 17 → indica el porcentaje de bloques que salieron defectuosos de fábrica o se han marcado como malos.
• 241 – Lifetime_Writes_GiB: 4094 (~4.1 TB escritos). El bridge USB (StarTech) pasa SMART completo → gran ventaja vs enclosures baratos que lo truncan.

¿Qué aprendí y recomendaciones?

• Mi combo Kingston A400 240GB + enclosure StarTech (ASMedia UAS) es ganador: rápido, estable, SMART full y salud excelente.
• Si usas SSD USB en Pi → prioriza chipsets ASMedia (ASM1153/1053), evita Realtek baratos si puedes.
• Alimentación: Usa powered hub o fuente externa para HDD/SSD grandes.
• Monitorea periódicamente: Pon un cron mensual con smartctl -a y alerta por Telegram si vida <80% o temp >55°C.
• Beneficio final: Boot Pi en 10-15s vs 30-60s en microSD, apps más fluidas, menos corrupción, y sabes exactamente cómo está tu hardware.
• El aviso de «Sectores Reasignados»
  Dependiendo de la marca de tu SSD, este valor puede llamarse de varias formas. Es el contador de sectores que han muerto y que el disco ha tenido que sustituir por otros de «reserva»:
  En la mayoría (Samsung, Crucial, etc): Busca el ID 05 (Reallocated Sector Count).
  En discos como el mío (Kingston/Phison): Busca el ID 196 (Reallocated Event Count).
  Lo importante: En la columna RAW_VALUE, el número debe ser 0. Si ves un 10, un 50 o un 100, ese disco está empezando a morir físicamente. ¡No lo compres!
• El ID 169 (Bad_Block_Rate). Este es otro chivato muy bueno, Mi valor es 17. En muchos SSD de gama media/baja, esto indica el porcentaje de bloques que salieron defectuosos de fábrica o se han marcado como malos. Mientras el ID 196 esté en 0, el disco ha gestionado bien esos fallos, pero si ese número sube de repente, mala señal.

Si estás montando un NAS, media center o server casero con Raspberry Pi, haz estos tests YA. Te ahorras disgustos y descubres si tu setup vuela o cojea.

¿Has probado boot desde SSD USB? ¿Qué velocidades te salen? ¡Cuéntame en comentarios!

Próximo post: script para alertas automáticas de SMART por Telegram.

¡Un saludo, linuxetes!

La verdadera magia de NUT (Network UPS Tools) reside en su arquitectura Maestro-Esclavo. En esta guía, vamos a configurar nuestra infraestructura para que la Raspberry Pi Zero actúe como el «cerebro» central (Master). Ella será la encargada de monitorizar el USB del SAI y, en caso de batería baja, enviará una orden de apagado por red a todos los demás equipos (Slaves) de tu hogar.

Al finalizar esta configuración, habrás creado una red de seguridad inteligente donde:

• La comunicación es total: Tus PCs con Windows y Linux «escucharán» a la pequeña Pi Zero.
• El apagado es elegante: Cada equipo cerrará sus procesos y protegerá sus discos antes de que el SAI corte la energía.
• Tú mantienes el control: Seguirás recibiendo los reportes detallados en Telegram mientras tus equipos se ponen a salvo automáticamente.

Prepárate para convertir tu modesta Raspberry Pi Zero en el guardián de toda la electrónica de tu despacho. ¡Vamos a ello!

1. Configuración en la Raspberry Pi Zero (El Maestro)

Para expandir tu red de protección y que tu Raspberry Pi 5 y tus otros PCs (i7, i5) se apaguen de forma coordinada, vamos a configurar una arquitectura Maestro-Esclavo (o Primario-Secundario).

Tu Pi Zero seguirá siendo el «Cerebro» (Master) porque tiene el cable USB, y los demás serán «Clientes» (Slaves) que escuchan por red.

Primero debemos autorizar a la Pi Zero a hablar con el resto de la casa.

A. Abrir la escucha de red

Edita el archivo de configuración del servidor:

sudo nano /etc/nut/upsd.conf

Sustituye tus líneas LISTEN por esta (es la más compatible):

LISTEN 0.0.0.0 3493

Esto permite que la Pi Zero responda tanto a su propio script de Telegram como a los PCs externos.

B. Crear el usuario para los esclavos

Edita el archivo de usuarios:

sudo nano /etc/nut/upsd.users

Añade este perfil al final (usa una contraseña distinta a la de admin):

[remotemon]
    password = clave_red_segura
    upsmon slave

Reinicia los servicios para aplicar los cambios:

sudo systemctl restart nut-server nut-monitor

Recuerda poner una IP fija a tu Raspberry pi zero

2. Configuración de NUT Cliente en Debian 13

Con nuestro servidor NUT funcionando, el siguiente paso es conectar tus PCs «esclavos» para que se apaguen de forma segura cuando la batería del SAI se agote.

En Debian 13, la instalación estándar de nut-client suele fallar por cambios en el sistema de permisos y rutas de archivos. En esta guía vamos a limpiar los conflictos y aplicar un «parche maestro» para que funcione a la primera.

Antes de empezar, debemos asegurarnos de que no existan servicios antiguos o duplicados que bloqueen a nut-monitor. En instalaciones de Debian, a veces aparece un archivo llamado upsmon.service que genera conflictos de prioridad.

Limpieza de conflictos previos

Ejecuta estos comandos para limpiar el terreno:

# Detenemos y deshabilitamos el servicio antiguo si existe
sudo systemctl stop upsmon.service 2>/dev/null
sudo systemctl disable upsmon.service 2>/dev/null

# Borramos el archivo duplicado para que systemd no se confunda
sudo rm -f /etc/systemd/system/upsmon.service

# Refrescamos la base de datos de servicios
sudo systemctl daemon-reload

Un par de aclaraciones.

1. nut-monitor.service es el nombre oficial y moderno en Debian 13.
2. upsmon.service es un alias o un residuo de versiones anteriores. Si ambos existen como archivos físicos en /etc/systemd/system/, systemd puede intentar arrancar los dos, chocando al intentar escribir en el mismo archivo de bloqueo (PID), lo que hace que el servicio se apague en milisegundos (el error que te pasaba a ti).

El siguiente paso es configurar tus otros PCs (esclavos) para que se apaguen de forma segura. En Debian 13, el proceso tiene sus «trucos». Aquí tienes cómo hacerlo funcionar a la primera.

Instalación del Cliente

Lo primero es instalar las herramientas necesarias en el PC que queremos proteger:

sudo apt update
sudo apt install nut-client -y

Configuración del Modo

Debemos decirle a NUT que este equipo no tiene un SAI conectado por USB, sino que va a escuchar a través de la red.

Edita el archivo: sudo nano /etc/nut/nut.conf

Modifica la línea del modo para que quede exactamente así:

MODE=netclient

Configuración del Monitor (upsmon.conf)

Este es el archivo donde ocurre la «magia». Aquí le decimos a qué servidor mirar.

Edita el archivo: sudo nano /etc/nut/upsmon.conf

Añade (o modifica) la línea MONITOR con los datos de tu servidor:

MONITOR salicru@192.168.1.14 1 remotemon clave_red_segura slave

Nota: Sustituye la IP por la de tu servidor NUT y asegúrate de que el usuario (remotemon) y la contraseña coincidan con los del archivo upsd.users del servidor.

El «Parche Maestro» para Debian 13

En Debian 13, el servicio estándar suele fallar debido a un script intermedio (wrapper) y a restricciones de permisos en la carpeta temporal /run/nut. Para solucionarlo, usaremos un Override de Systemd.

Paso A: Crear la carpeta de personalización

sudo mkdir -p /etc/systemd/system/nut-monitor.service.d

Paso B: Crear el archivo de corrección

sudo nano /etc/systemd/system/nut-monitor.service.d/override.conf

Paso C: Pegar el siguiente contenido (esto anula los errores de fábrica y apunta al binario real):

[Service]
ExecStartPre=
ExecStart=
ExecStart=/lib/nut/upsmon -F
RuntimeDirectory=nut
RuntimeDirectoryMode=0755
User=root
Group=nut

Aplicar cambios y Arrancar

Ahora solo queda refrescar el sistema y poner en marcha el monitor:

sudo systemctl daemon-reload
sudo systemctl enable nut-monitor
sudo systemctl restart nut-monitor

Verificación final

Para estar seguros de que todo funciona, ejecutamos:

sudo systemctl status nut-monitor

Si ves un texto en verde (active/running), ¡lo has logrado!

También puedes probar la conexión directa con este comando:

upsc salicru@192.168.1.14 ups.status

Si responde OL, tu PC está oficialmente bajo la protección del SAI.

«Saber más»

• El Binario Real: En Debian 13, /usr/sbin/upsmon es solo un script. Al usar /lib/nut/upsmon, evitamos fallos silenciosos.
• RuntimeDirectory: Es la forma moderna de gestionar la carpeta /run/nut sin pelearse con permisos de archivos manuales.
• Seguridad: El uso de override.conf permite que, si actualizas el sistema, tus cambios no se borren.

3. Configuración en PCs con Windows (i7 / i5)

Si alguno de tus PCs usa Windows, no necesitas scripts complejos:

1. Descarga e instala WinNUT-Client.
2. Configura la conexión:
   • UPS Name: salicru
   • UPS Host: 192.168.1.14 (IP de la Pi Zero)
   • Port: 3493
   • Username: esclavo
   • Password: clave_red_segura
3. Calibración: En la pestaña «Shutdown», elige cuánto tiempo quieres que pase desde que se corta la luz hasta que el PC se apague.

¿Cómo funcionará el apagado en cadena?

Es importante entender la jerarquía para que nadie pierda datos:

1. Corte de luz: La Pi Zero avisa por Telegram al instante.
2. Batería Baja: Cuando la Pi Zero detecta que queda poca energía, envía la señal de «Pánico» por red a los demás equipos
3. Apagado de Esclavos: El resto de equipos reciben la orden y se apagan de inmediato para proteger sus discos.
4. Apagado del Maestro: La Pi Zero espera a que los esclavos se desconecten. Una vez sola, inicia su propio apagado.
5. Corte Total: En el último segundo, la Pi Zero le dice al Salicru: «Apágate en 30 segundos».

Ahora tus equipos están protegidos y más seguros ante la pérdida de datos.

En este artículo, vamos a configurar un sistema de alertas avanzado utilizando una Raspberry Pi y el software NUT (Network UPS Tools) para convertir un SAI Salicru convencional en un dispositivo inteligente y conectado.

El objetivo es automatizar el control total de nuestra energía mediante un Bot de Telegram que nos mantendrá informados con mensajes detallados y visuales. Al finalizar este tutorial, tu sistema será capaz de:

• Notificar cortes y restablecimientos de corriente de forma instantánea.
• Enviar reportes detallados con voltajes de entrada, salida y estado de la batería.
• Gestionar estados críticos como el nivel de batería bajo o la necesidad de sustitución de celdas (REPLBATT).
• Proteger tu hardware, avisándote justo antes de que la Raspberry Pi realice un apagado controlado para evitar daños en la tarjeta SD.

Todo esto mediante un script optimizado que garantiza que la información que recibes en tu móvil es veraz y estable, permitiéndote tomar decisiones informadas estés donde estés.

Sistema

Como sistema operativo voy utilizar Rasbperry Pi OS lite 64bits, basado en Debian 13. El usuario del sistema será nut y el host será zero.

Materiales necesarios

• RASPBERRY PI ZERO 2W – 2WH (Versión: W (WiFi))
• Un SAI Salicru con puerto USB (Serie SOHO+ o similar).
• CABLE OTG MICROUSB/M USB-A/H NEGRO
• ALIMENTADOR OFICIAL RASPBERRY PI MICRO-USB 5,1V 2,5A 12,75W
• CAJA OFICIAL RASPBERRY PI ZERO
• CABLE USB-A A USB-B M/M AZUL 30CM

Instalación de NUT

Actualizamos la lista de repositorios e instalamos los paquetes oportunos.

sudo apt update && sudo apt install nut nut-client nut-server curl bc -y

Configuración del hardware.

Según el modelo de SAI, nut puede manejar distintos tipos de driver. Antes de configurar el archivo ups.conf conecta el cable USB de la PI al SAI y ejecuta este comando:

sudo nut-scanner -U

Este comando escaneará los buses USB y te dirá exactamente qué driver recomienda NUT para tu dispositivo específico.

nut@zero:~ $ sudo nut-scanner -U
Cannot load SNMP library (libnetsnmp.so.40) : file not found. SNMP search disabled.
Cannot load XML library (libneon.so.27) : file not found. XML search disabled.
Cannot load AVAHI library (libavahi-client.so.3) : file not found. AVAHI search disabled.
Cannot load IPMI library (libfreeipmi.so.17) : file not found. IPMI search disabled.
Scanning USB bus.
[nutdev1]
	driver = "nutdrv_qx"
	port = "auto"
	vendorid = "0665"
	productid = "5161"
	product = "USB to Serial"
	vendor = "Cypress Semiconductor"
	bus = "001"
	device = "002"
	busport = "001"
	###NOTMATCHED-YET###bcdDevice = "0002"

Observa que el driver recomendado es «nutdrv_qx«.

Archivos de configuración de NUT

Define el driver, editando el siguiente archivo.

sudo nano /etc/nut/ups.conf

Al comienzo del archivo, pega lo siguiente.

[salicru]
    driver = nutdrv_qx
    port = auto
    vendorid = 0665
    productid = 5161
    vendor = "Cypress Semiconductor"
    product = "USB to Serial"
    desc = "Salicru SOHO 2000"

En ese mismo archivo busca la línea maxretry = 3 comentala y déjala así.

#maxretry = 3

Guarda con Crtl + o y cierra con Crtl + x

Configura el modo editando el siguiente archivo.

sudo nano /etc/nut/nut.conf 

Busca la línea MODE, cambia la línea a standalone.

MODE=standalone

Configurar el acceso (upsd.conf)

Una vez que el driver está leyendo los datos del USB, necesitamos que el «servidor de NUT» (upsd) recoja esa información y la deje disponible para resto de equipos y otros programas (como nuestro script de Telegram o el comando upsc) puedan consultarla.

Para ello, editamos el archivo de configuración del demonio:

sudo nano /etc/nut/upsd.conf

Este archivo suele tener lineas que apuntan al localhost como las que vemos a continuación.

LISTEN 127.0.0.1 3493
LISTEN ::1 3493

Si las tienes, borralas y deja solo una línea LISTEN tal y como queda en la siguiente instrucción.

LISTEN 0.0.0.0 3493

El 0.0.0.0 sirve para que los demás equipos vean a la Pi Zero.

«Por seguridad, NUT viene configurado para ser ‘tímido’ (127.0.0.1) y solo hablar consigo mismo. Al cambiarlo a 0.0.0.0, convertimos a nuestra Raspberry Pi Zero en un Faro de Energía: ahora cualquier equipo de nuestra red local puede ver el estado del SAI y saber cuándo debe ponerse a salvo.»

¿Qué hace exactamente LISTEN 0.0.0.0?

Cuando configuras LISTEN 0.0.0.0 en el archivo upsd.conf de la Pi Zero, le estás diciendo al servidor NUT: «No te escondas; acepta preguntas de cualquier dirección IP que llegue a esta Raspberry».

• Sin el 0.0.0.0 (solo con 127.0.0.1): La Pi Zero está «sorda» a lo que venga de fuera. Tus equipos intentarán llamarla por red, pero ella no responderá porque solo escucha sus propios pensamientos internos (localhost).
• Con el 0.0.0.0: La Pi Zero abre sus «oídos» a toda la red local. Ahora, cuando el i7 pregunte: «¿Cómo va la batería?», la Pi Zero podrá escucharlo y responderle con los datos del Salicru.

¿Cómo «ve» la Pi Zero a los demás?

Curiosamente, la Pi Zero no necesita «ver» activamente a los demás equipos para protegerlos. Funciona al revés:

1. La Pi Zero (Maestro) simplemente publica la información del SAI en la red.
2. Los demás equipos (Esclavos como la Pi 5 o el i7) se conectan a ella constantemente para «leer» esa información.
3. En el momento en que la Pi Zero detecta batería baja, cambia su estado a FSD (Forced Shutdown).
4. Los esclavos, que están vigilando ese estado cada pocos segundos, ven el cambio y deciden apagarse por su cuenta.

Configurar 0.0.0.0 es como abrir la ventanilla de información de la Pi Zero al resto de la casa. Permite que tus PCs potentes se conviertan en «clientes» que consultan el estado del SAI a través de la red WiFi o Ethernet.

¿127.0.0.1 vs 0.0.0.0? Entendiendo la «Escucha» de Red

Para que tu estrategia de apagado coordinado funcione, es vital entender qué dirección IP debe usar el servidor NUT. Aquí tienes la comparativa de lo que sucede en tu Raspberry Pi Zero:

Configuración (LISTEN)	Alcance	Seguridad	¿Cuándo usarla?
127.0.0.1 (Localhost)	Solo Interno. La Pi Zero solo se habla a sí misma.	Máxima. Nadie fuera de la Pi puede ver los datos.	Cuando solo quieres recibir avisos por Telegram desde esa Raspberry.
0.0.0.0 (Todas las IPs)	Toda la Red. La Pi Zero se vuelve visible para el i7, la Pi 5 y el resto de PCs.	Media. Requiere usar contraseñas en upsd.users.	Obligatorio para apagar otros equipos de casa por red.

Crear la regla de permisos (udev)

La regla de udev es la forma que tiene Linux (en este caso tu Raspberry Pi con Debian) de gestionar los dispositivos que conectas físicamente a los puertos.

Para crear la regla, abre el editor nano con el siguiente comando.

sudo nano /etc/udev/rules.d/99-nut-ups.rules

Pega dentro esta línea exactamente:

SUBSYSTEM=="usb", ATTR{idVendor}=="0665", ATTR{idProduct}=="5161", MODE="0660", GROUP="nut"

(Guarda con Ctrl+O, Enter y sal con Ctrl+X).

Los valores de la regla, los vimos cuando ejecutamos el comando nut-scanner -U de donde extraemos los valores idVendor y idProduct.

Aplicamos la regla con:

sudo udevadm control --reload-rules && sudo udevadm trigger

Como Linux es un sistema multiusuario y seguro, por defecto no permite que cualquier programa (como el software de NUT) «hable» directamente con un hardware USB a menos que seas el administrador (root). La regla de udev que creamos sirve para decirle al sistema: «Cuando veas este SAI de Salicru, dáselo al grupo ‘nut’ para que pueda leer sus datos».

Anatomía de la regla

La línea que pusimos en /etc/udev/rules.d/99-nut-ups.rules se desglosa así:

SUBSYSTEM=="usb", ATTR{idVendor}=="0665", ATTR{idProduct}=="5161", MODE="0660", GROUP="nut"

• SUBSYSTEM=="usb": Le dice a Linux que solo mire en los puertos USB.
• ATTR{idVendor}=="0665": «Busca al fabricante 0665».
• ATTR{idProduct}=="5161": «Y que el producto sea el 5161».
• MODE="0660": Esto define los permisos de archivos de Linux. 0660 significa que el dueño y el grupo pueden leer y escribir, pero el resto del mundo no puede hacer nada.
• GROUP="nut": Aquí está la magia. Le asigna la propiedad del puerto al grupo nut. Como el software de monitorización corre bajo el usuario nut, ahora ya tiene «llave» para entrar al puerto USB.

¿Por qué es necesaria en la Raspberry Pi?

Sin esta regla, cuando el driver nutdrv_qx intenta preguntar al SAI «¿cuánta batería te queda?», el sistema operativo le responde: «Acceso denegado».

Si esta regla no está o está mal aplicada, te saldrá el error insufficient permissions. Al añadir la regla, el permiso se vuelve automático: cada vez que arranques la Raspberry o reconectes el USB, Linux aplicará estas instrucciones al instante.

Sincronizar los servicios

Ejecuta esto para limpiar y arrancar de forma oficial:

sudo systemctl stop nut-monitor nut-server
sudo rm -f /run/nut/*.pid
sudo systemctl start nut-server
sudo systemctl start nut-monitor

Comprobar la comunicación

Ahora, espera unos 5 segundos y lanza:

upsc salicru@localhost

El comando nos muestra en tiempo real la información detallada, el estado y las variables del Sistema de Alimentación Ininterrumpida (SAI/UPS)que está gestionado localmente mediante la herramienta NUT (Network UPS Tools)

nut@zero:~ $ upsc salicru@localhost
Init SSL without certificate database
battery.voltage: 27.4
device.type: ups
driver.debug: 0
driver.flag.allow_killpower: 0
driver.name: nutdrv_qx
driver.parameter.pollfreq: 30
driver.parameter.pollinterval: 2
driver.parameter.port: auto
driver.parameter.product: USB to Serial
driver.parameter.productid: 5161
driver.parameter.synchronous: auto
driver.parameter.vendor: Cypress Semiconductor
driver.parameter.vendorid: 0665
driver.state: updateinfo
driver.version: 2.8.1
driver.version.data: Q1 0.08
driver.version.internal: 0.36
driver.version.usb: libusb-1.0.28 (API: 0x100010a)
input.frequency: 49.8
input.voltage: 235.2
input.voltage.fault: 235.2
output.voltage: 231.3
ups.beeper.status: enabled
ups.delay.shutdown: 30
ups.delay.start: 180
ups.load: 0
ups.productid: 5161
ups.status: OL
ups.temperature: 25.0
ups.type: offline / line interactive
ups.vendorid: 0665
nut@zero:~ $

Puerto de escucha

Como dato interesante, comprueba si el puerto 3493 que configuramos anteriormente, está a la escucha

nut@zero:~ $ ss -ltn | grep 3493
LISTEN 0      16           0.0.0.0:3493      0.0.0.0:*  

Las líneas LISTEN, indican que la Raspberry ya tiene la oreja puesta y está lista para informar sobre el estado del Salicru.

Procesos

Puedes escribir upsutil salicru@localhost o simplemente ver el estado del servicio:

Para verificar si el monitor (upsmon) está funcionando correctamente en tu Raspberry Pi, usa estos comandos:

nut@zero:~ $ ps aux | grep upsmon
root        6906  0.0  0.6   7304  2688 ?        Ss   10:05   0:00 /lib/nut/upsmon -F
nut         6907  0.0  1.2  10236  5120 ?        S    10:05   0:03 /lib/nut/upsmon -F
nut         9598  0.0  0.4   8804  2064 pts/0    S+   21:39   0:00 grep --color=auto upsmon
nut@zero:~ $ 

Deberías ver 3 procesos: uno que corre como root (el que tiene permiso para apagar la Pi) el otro como el usuario nut y el otro es simplemente el comando que acabamos de escribir.

Comprobar el estado del servicio.

Ejecuta el comando sudo systemctl status nut-monitor

nut@zero:~ $ sudo systemctl status nut-monitor
● nut-monitor.service - Network UPS Tools - power device monitor and shutdown controller
     Loaded: loaded (/usr/lib/systemd/system/nut-monitor.service; enabled; preset: enabled)
     Active: active (running) since Sat 2026-03-07 22:12:57 CET; 12h ago
 Invocation: 95d0260bee1c4eca9ad4a618365a8a2c
    Process: 1091 ExecStartPre=/usr/bin/systemd-tmpfiles --create /usr/lib/tmpfiles.d/nut-common-tmpfiles.conf (code=exited, status=0/SUCCESS)
   Main PID: 1093 (upsmon)
      Tasks: 2 (limit: 176)
        CPU: 3.333s
     CGroup: /system.slice/nut-monitor.service
             ├─1093 /lib/nut/upsmon -F
             └─1098 /lib/nut/upsmon -F

mar 07 22:12:57 zero systemd[1]: Starting nut-monitor.service - Network UPS Tools - power device monitor and shutdown controller...
mar 07 22:12:57 zero systemd[1]: Started nut-monitor.service - Network UPS Tools - power device monitor and shutdown controller.
mar 07 22:12:57 zero nut-monitor[1093]: fopen /run/nut/upsmon.pid: No such file or directory
mar 07 22:12:57 zero nut-monitor[1093]: Could not find PID file to see if previous upsmon instance is already running!
mar 07 22:12:57 zero nut-monitor[1093]: UPS: salicru@localhost (primary) (power value 1)
mar 07 22:12:57 zero nut-monitor[1093]: Using power down flag file /etc/killpower
mar 07 22:12:57 zero nut-monitor[1098]: Init SSL without certificate database
mar 07 22:12:57 zero nut-monitor[1098]: upsnotify: notify about state 2 with libsystemd: was requested, but not running as a service unit now, will not spam more about it
mar 07 22:12:57 zero nut-monitor[1098]: upsnotify: failed to notify about state 2: no notification tech defined, will not spam more about it
mar 07 22:12:57 zero nut-monitor[1098]: upsnotify: logged the systemd watchdog situation once, will not spam more about it
nut@zero:~ $ 

Si aparece en verde (active (running)), el vigilante está despierto.

Configurando los avisos por terminal.

sudo nano /etc/nut/upsmon.conf

Pega el siguiente texto debajo

# Banderas para ejecutar el comando (EXEC)
NOTIFYFLAG ONLINE   SYSLOG+WALL+EXEC
NOTIFYFLAG ONBATT   SYSLOG+WALL+EXEC
NOTIFYFLAG LOWBATT  SYSLOG+WALL+EXEC
NOTIFYFLAG SHUTDOWN SYSLOG+WALL+EXEC
NOTIFYFLAG REPLBATT SYSLOG+WALL+EXEC

Reinicia el servicio con:

sudo systemctl stop nut-monitor nut-server

Esto dará avisos en la terminal de tu raspberry, pero no lo hará si estas accediendo por ssh.

Cómo configurar el apagado automático (upsmon)

Como nuestra Raspberry Pi Zero 2W está conectada al Salicru, vamos a configurar el sistema para que se apague de forma segura.

Configurar el usuario

Debemos de tener un par de usuarios configurados para la gestión del SAI, que será el usurario administrador [monuser] y el usuario de los equipos remotos que será [remotemon]

Edita el archivo de usuarios de NUT:

sudo nano /etc/nut/upsd.users

Añade esto al final:

[monuser]
    password = mi_password_segura
    upsmon master

Si quieres, puedes dar a [monuser] privilegios de administrador así:

[monuser]
    password = mi_password_segura
    upsmon master
    actions = SET
    instcmds = ALL

Para dar privilegios de administrador a un usuario, tan solo agrégale las directrices actions e instcmds

Para el usuario remoto, añade este perfil al final (usa una contraseña distinta a la de admin):

[remotemon]
    password = clave_red_segura
    upsmon slave

Configurar el monitor

Edita el archivo del monitor:

sudo nano /etc/nut/upsmon.conf

Busca la sección MONITOR y asegúrate de que quede así:

MONITOR salicru@localhost 1 monuser mi_password_segura master
SHUTDOWNCMD "/sbin/shutdown -h now"
POWERDOWNFLAG /etc/killpower

Activar el servicio

Reinicia todo para que los cambios tengan efecto:

sudo systemctl restart nut-monitor

¿Qué pasará ahora cuando se corte la luz?

Si el SAI se apaga antes de que la Raspberry complete su apagado, podrías tener el mismo problema que con un corte normal de luz, archivos corruptos en la MicroSD. Este sistema está diseñado con una secuencia de retardo muy específica para evitar esto, El Retardo (Delay). Cuando la Raspberry envía la orden de «Kill Power», no le está diciendo al SAI «Apágate ya», sino «Apágate dentro de X segundos».

Si te fijas en los datos de tu upsc salicru@localhost, hay una línea clave:

ups.delay.shutdown: 30

Esto significa que cuando la Raspberry envía la orden final, el SAI Salicru inicia una cuenta atrás interna de 30 segundos.

La Secuencia Cronológica

Para que veas que es seguro, este es el orden real de los eventos:

1. Raspberry detecta Batería Baja: Inicia su propio proceso de apagado (SHUTDOWNCMD).
2. Cierre de Servicios: Debian detiene bases de datos, logs y procesos. La tarjeta SD deja de escribir datos.
3. Script Final de NUT: Justo en el último segundo del apagado (cuando el sistema ya está en modo «solo lectura»), se ejecuta la orden de «Kill Power» hacia el SAI.
4. SAI recibe la orden: El Salicru empieza su cuenta atrás de 30 segundos.
5. Raspberry muere: La Pi termina de apagarse por completo en 2 o 3 segundos más.
6. El SAI se apaga: 27 segundos después de que la Pi ya esté totalmente «muerta», el SAI corta la energía.

¿Por qué es necesario que el SAI se apague?

Imagina que no enviamos el «Kill Power»:

• La Raspberry se apaga y se queda esperando.
• El SAI se queda encendido con batería hasta que se agote al 0%.
• Vuelve la luz de la calle.
• Problema: Como el SAI nunca llegó a cortarle la corriente a la Raspberry (porque se quedó en un estado de «espera» con la batería agotada pero sin apagar el circuito), la Raspberry no detectará que ha vuelto la energía y no arrancará sola. Se quedará apagada hasta que alguien vaya físicamente a desenchufarla y enchufarla.

Resumen de seguridad

Con el valor de 30 segundos que tiene tu Salicru de fábrica:

• La Raspberry tiene tiempo de sobra (le sobran unos 25 segundos) para terminar de cerrarlo todo antes de que el SAI corte el flujo eléctrico.
• Es un método estándar y muy seguro.

Un detalle importante: En las Raspberry Pi, para que el ciclo de «vuelva la luz y se encienda sola» funcione perfecto, asegúrate de que el SAI esté configurado para rearmarse automáticamente (cosa que los Salicru SOHO+ hacen por defecto).

Para estar seguro de que la Raspberry sabe que es la jefa del apagado (modo master), ejecuta:

upsc salicru@localhost ups.delay.shutdown

Si te responde 30, significa que todo está listo para que, en caso de emergencia, la Pi le ordene al Salicru esperar 30 segundos antes de cortar la energía, dándole tiempo a la MicroSD para cerrarse a salvo.

¿Cómo saber si realmente se apagará? (Simulación segura)

Si quieres estar 100% seguro de que la configuración es correcta sin apagar la Raspberry de golpe, puedes mirar el log del sistema:

sudo journalctl -f -u nut-monitor -u nut-server

Si ahora mismo desenchufas el SAI de la pared, Verás en el log UPS salicru@localhost on battery.

nut@zero:~ $ sudo journalctl -f -u nut-monitor -u nut-server
mar 07 18:05:06 zero nut-server[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 18:05:06 zero upsd[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 19:24:09 zero nut-server[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 19:24:09 zero upsd[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 19:27:08 zero nut-server[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 19:27:08 zero upsd[7408]: Instant command: upsmon@::1 did test.battery.start.quick on salicru (tracking ID: disabled)
mar 07 20:05:29 zero nut-monitor[6907]: UPS salicru@localhost on battery
mar 07 20:05:45 zero nut-monitor[9348]: Network UPS Tools upsmon 2.8.1

Si miras en upsc salicru@localhost verás que cambia a status: OB.

nut@zero:~ $ upsc salicru@localhost
Init SSL without certificate database
battery.voltage: 26.9
device.type: ups
driver.debug: 0
driver.flag.allow_killpower: 0
driver.name: nutdrv_qx
driver.parameter.pollfreq: 30
driver.parameter.pollinterval: 2
driver.parameter.port: auto
driver.parameter.product: USB to Serial
driver.parameter.productid: 5161
driver.parameter.synchronous: auto
driver.parameter.vendor: Cypress Semiconductor
driver.parameter.vendorid: 0665
driver.state: quiet
driver.version: 2.8.1
driver.version.data: Q1 0.08
driver.version.internal: 0.36
driver.version.usb: libusb-1.0.28 (API: 0x100010a)
input.frequency: 50.0
input.voltage: 9.6
input.voltage.fault: 9.6
output.voltage: 227.4
ups.beeper.status: enabled
ups.delay.shutdown: 30
ups.delay.start: 180
ups.load: 0
ups.productid: 5161
ups.status: OB
ups.temperature: 25.0
ups.type: offline / line interactive
ups.vendorid: 0665

Lo más importante:

Como el modelo SOHO+ 2000, tiene mucha autonomía para una Raspberry Pi Zero 2W (que consume casi nada). No esperes a que llegue a Low Battery (batería baja) de forma real porque podría tardar horas.

Si en algún momento quieres probar que el apagado funciona de verdad, el comando es:

sudo upsmon -c fsd

(Esto significa «Forced Shutdown» y simula que la batería se ha agotado, iniciando el proceso de apagado de seguridad inmediatamente).

¡Ya está todo listo y protegido! Tu Raspberry Pi ahora sobrevivirá a los cortes de luz sin corromper la tarjeta SD.

El script de alertas para Telegram

Creamos el script que enviará los mensajes:

sudo nano /usr/local/bin/nut-telegram.sh

Copia y pega el siguiente script. No olvides reemplazar «tu_token» y «tu_id» por los tuyos propios

#!/bin/bash

# Configuración del Bot de Telegram
TOKEN="tu_token"
CHAT_ID="tu_id"
export LC_ALL=C

# Función interna para leer los sensores (Lógica estable)
capturar() {
    BATERIA_V=$(upsc salicru@localhost battery.voltage 2>/dev/null || echo "0.0")
    VOLTAJE_IN=$(upsc salicru@localhost input.voltage 2>/dev/null || echo "0.0")
    VOLTAJE_OUT=$(upsc salicru@localhost output.voltage 2>/dev/null || echo "0.0")
    CARGA_SAI=$(upsc salicru@localhost ups.load 2>/dev/null || echo "0")
    ESTADO_SAI=$(upsc salicru@localhost ups.status 2>/dev/null || echo "N/A")
}

case "$1" in
    *"on battery"*)
        ICONO="🚨"
        TITULO="CORTE DE SUMINISTRO"
        
        # BUCLE DE ESPERA: No envía hasta que la entrada sea < 50V real
        intentos=0
        capturar
        while [[ "${VOLTAJE_IN%.*}" -gt 50 ]] && [[ $intentos -lt 12 ]]; do
            sleep 5
            capturar
            ((intentos++))
        done

        # --- DIAGNÓSTICO DE SALUD AL CORTE ---
        V_INT=${BATERIA_V%.*}
        if [ "$V_INT" -lt 24 ]; then
            DETALLE="¡OJO! Las baterías están muy bajas ($BATERIA_V V). Salud crítica, considera cambiarlas."
        else
            DETALLE="El SAI está operando con baterías. Salud química OK ($BATERIA_V V)."
        fi
        ;;

    *"on line power"*)
        ICONO="✅"
        TITULO="CORRIENTE RESTABLECIDA"
        DETALLE="El sistema vuelve a la red eléctrica."

        # BUCLE DE ESPERA: No envía hasta que la entrada sea > 200V real
        intentos=0
        capturar
        while [[ "${VOLTAJE_IN%.*}" -lt 200 ]] && [[ $intentos -lt 12 ]]; do
            sleep 5
            capturar
            ((intentos++))
        done
        ;;

    *"low battery"*)
        ICONO="⚠"
        TITULO="BATERIA CRITICA"
        DETALLE="Nivel muy bajo. El apagado es inminente."
        capturar
        ;;

    *"SHUTDOWN"*)
        ICONO="💀"
        TITULO="APAGADO DE EMERGENCIA"
        DETALLE="La Raspberry se apaga para proteger la SD."
        capturar
        ;;

    *"REPLBATT"*)
        ICONO="🛠"
        TITULO="FALLO DE BATERIA"
        DETALLE="Es necesario sustituir las baterías del Salicru."
        capturar
        ;;

    *)
        ICONO="ℹ"
        TITULO="NOTIFICACION SAI"
        DETALLE="$1"
        capturar
        ;;
esac

# Mensaje final con los iconos: 🔌 y ⚡
CUERPO="$ICONO *$TITULO* $ICONO
------------------------------------
📝 $DETALLE

🔋 *Bateria:* $BATERIA_V V
🔌 *Entrada:* $VOLTAJE_IN V
⚡ *Salida:* $VOLTAJE_OUT V
📊 *Carga SAI:* $CARGA_SAI%
📈 *Estado:* $ESTADO_SAI"

# Envío a Telegram
curl -s -X POST "https://api.telegram.org/bot$TOKEN/sendMessage" \
     --data-urlencode "chat_id=$CHAT_ID" \
     --data-urlencode "text=$CUERPO" \
     --data-urlencode "parse_mode=Markdown" > /dev/null 2>&1

Importante: Dale permisos de ejecución con:

sudo chmod 755 /usr/local/bin/nut-telegram.sh

y haz que el dueño sea el usuario de nut:

sudo chown nut:nut /usr/local/bin/nut-telegram.sh

Configurando los avisos por telegram

Volvemos a configurar las flags para los avisos por telegram, por lo que volvemos a entrar al archivo upsmon.conf

 sudo nano /etc/nut/upsmon.conf

Copia encima o debajo de las anteriores notificaciones

# Comando externo para notificaciones
NOTIFYCMD "/usr/local/bin/nut-telegram.sh"

# Definición de mensajes que activan el script
NOTIFYMSG ONLINE    "UPS salicru@localhost on line power"
NOTIFYMSG ONBATT    "UPS salicru@localhost on battery"
NOTIFYMSG LOWBATT   "UPS salicru@localhost low battery"
NOTIFYMSG SHUTDOWN  "SHUTDOWN"
NOTIFYMSG REPLBATT  "REPLBATT"

Reinicia el servicio

sudo systemctl restart nut-monitor

Haz una prueba manual con:

sudo -u nut /usr/local/bin/nut-telegram.sh "Prueba manual"

Test

Podemos listar los comandos que puede realizar nuestro salicru.

nut@zero:~ $ upscmd -l salicru
Instant commands supported on UPS [salicru]:

beeper.toggle - Toggle the UPS beeper
driver.killpower - Tell the driver daemon to initiate UPS shutdown; should be unlocked with driver.flag.allow_killpower option or variable setting
driver.reload - Reload running driver configuration from the file system (only works for changes in some options)
driver.reload-or-error - Reload running driver configuration from the file system (only works for changes in some options); return an error if something changed and could not be applied live (so the caller can restart it with new options)
driver.reload-or-exit - Reload running driver configuration from the file system (only works for changes in some options); exit the running driver if something changed and could not be applied live (so service management framework can restart it with new options)
load.off - Turn off the load immediately
load.on - Turn on the load immediately
shutdown.return - Turn off the load and return when power is back
shutdown.stayoff - Turn off the load and remain off
shutdown.stop - Stop a shutdown in progress
test.battery.start - Start a battery test
test.battery.start.deep - Start a deep battery test
test.battery.start.quick - Start a quick battery test
test.battery.stop - Stop the battery test

De la lista podemos ejecutar test.battery.start.quick que lo único que hace es pasar al estado OL CAL y hacer un test del sistema para el chequeo interno del SAI pero no hará como su nombre indica, ningún test de las baterías.

nut@zero:~ $ upscmd -u upsmon -p tu_contresña_segura salicru test.battery.start.quick
OK

Mientras se realiza el test, puedes comprobar el voltage de la batería en tiempo real con este comando, que se mantendrá inmutable ya que el el sistema se mantiene todo el tiempo OnLine.

while true; do upsc salicru@localhost battery.voltage; sleep 1; done

Mantenimiento Preventivo Mensual

«Investigando a fondo con la consola de NUT, descubrimos que el Salicru SOHO+ protege sus baterías. Aunque veas comandos como test.battery.start.deep, el SAI los ignora para evitar descargas innecesarias. El único comando que acepta es el quick, que activa el modo OL CAL (Calibración Online). Este modo es genial para verificar que los relés y el inversor funcionan, pero no estresa la batería.

Conclusión: Para saber la salud real de tus baterías en este modelo, el ‘Test del Tirón’ (desenchufar 10 segundos) sigue siendo el único modo. Mi script de Telegram te avisará al instante de cuánto cae el voltaje en ese momento y en que estado se encuentran las baterías.»

Si el driver nutdrv_qx solo nos permite el OL CAL, vamos a convertir ese «estiramiento» en nuestro test mensual. Aunque no descargue la batería, es vital porque obliga a los relés físicos a moverse. Un SAI que nunca hace un test puede acabar con los relés «pegados» por el calor y el desuso, y el día que se vaya la luz de verdad, no conmutará.

Script de «Mantenimiento Preventivo de Relés e Inversor».

Abre una terminal y ejecuta el siguiente comando para crear nuestro archivo de mantenimiento

sudo nano /usr/local/bin/mantenimiento-sai.sh

Pega el siguente texto, no olvides de introducir «tu_token_de_telegram» «tu_id_de_chat» y «tu_contraseña_segura»

#!/bin/bash

# --- CONFIGURACIÓN ---
TOKEN="TU_TOKEN_DE_TELEGRAM"
ID="TU_ID_DE_CHAT"
UPS="salicru"
USUARIO="upsmon"
CLAVE="tu_contraseña_segura"

# 1. Inicio del mantenimiento
curl -s -X POST "https://api.telegram.org/bot$TOKEN/sendMessage" -d "chat_id=$ID&text=⚙ *Mantenimiento Mensual:* Iniciando test de relés en $UPS..."

# 2. Lanzar el Quick Test (Modo CAL)
upscmd -u $USUARIO -p $CLAVE $UPS test.battery.start.quick > /dev/null
sleep 2

# 3. Verificamos si el SAI ha entrado en modo calibración
STATUS=$(upsc $UPS ups.status)

if [[ "$STATUS" == *"CAL"* ]]; then
    # Esperamos a que termine (vimos que dura unos 9-10 seg)
    sleep 10
    FINAL_STATUS=$(upsc $UPS ups.status)
    if [[ "$FINAL_STATUS" == "OL" ]]; then
        MSG="✅ *TEST OK*: Los relés han conmutado y el inversor ha arrancado correctamente. El sistema de emergencia está operativo."
    else
        MSG="⚠ *AVISO*: El test ha terminado pero el estado es $FINAL_STATUS. Revisar manualmente."
    fi
else
    MSG="❌ *ERROR*: El SAI ha ignorado la orden de test. Es posible que necesite un reinicio del servicio NUT."
fi

# 4. Enviar resultado
curl -s -X POST "https://api.telegram.org/bot$TOKEN/sendMessage" -d "chat_id=$ID&parse_mode=Markdown&text=$MSG"

Este script hará el test aceptado por el Salicru, verificará que el estado pase por OL CAL y te informará de que la electrónica de conmutación sigue viva.

La automatización (Cron)

Para que se haga solo una vez al mes (por ejemplo, el día 1 a las 10:00), añade esto a tu sudo crontab -e:

00 10 1 * * /usr/local/bin/mantenimiento-sai.sh

«¿Por qué automatizar un test que no descarga la batería?»

Muchos usuarios cometen el error de no tocar su SAI hasta que se va la luz. El problema es que los relés son piezas mecánicas que pueden fallar por falta de uso. Mi script mensual fuerza al Salicru a entrar en modo OL CAL. Aunque no descargue la batería, este proceso hace que los relés ‘hagan ejercicio’ y que el inversor se autochequee. Es la garantía de que, cuando llegue el apagón real, la parte mecánica del SAI no estará agarrotada.

Tabla de Salud de la Batería (Sistema de 24V)

«Una vez que recibas la notificación en tu móvil, ¿cómo saber si esos voltios son buenos o malos? He preparado esta tabla de referencia para que sepas cuándo es el momento de sacar la cartera y comprar repuestos:»

Voltaje en Batería	Estado de Salud	Significado Técnico	Acción
> 27.0 V	Excelente	Carga completa en flotación.	Ninguna.
24.5 V – 26.5 V	Normal	Funcionamiento correcto bajo carga.	Uso habitual.
23.5 V – 24.4 V	Aviso / Débil	La batería empieza a perder capacidad química.	Planificar cambio a medio plazo.
< 23.5 V	Crítico	Agotamiento inminente o celdas dañadas.	Cambio urgente. Riesgo de apagón repentino.

Existe una nueva versión de este documento, mas moderna y actualizada aqui

«Instalar aMule desde GitHub no solo sirve para tener nuevas funciones, si no, para asegurar que el programa sea totalmente compatible con el hardware y software moderno. Obtenemos un binario que aprovecha los 64 bits de la Raspberry Pi, ya que desde 2021, el código está «congelado».

Ramas de desarrollo.

A la hora de compilar debes saber que existen varias ramas de desarrollo. Para entenderlo fácil, imagina que el desarrollo de un programa en GitHub es como un árbol del cual parten distintas ramas, y de nosotros depende elegir la rama que se ajuste a nuestras necesidades.

De las ramas disponibles, la rama master (o a veces llamada main) es la que ocupa nuestra atención, es donde los desarrolladores van subiendo todos los parches modernos para hacerlo compatible con el compilador actual (gcc) y las nuevas librerías (wxWidgets 3.2).

Otras ramas son las Tags y los Branches de desarollo.

En esta tabla a modo de resumen, te muestro los tres tipos de «versiones» disponibles:

«Usamos la rama Master porque es la versión ‘viva’ del código. Mientras que las versiones descargables (estables) se quedan congeladas en el tiempo, la rama Master recibe actualizaciones constantes que permiten que aMule se compile sin errores en sistemas de vanguardia como Debian 13.»

Desactiva Wayland

Tu Raspberry Pi 5 con Debian 13 usa por defecto Wayland como servidor gráfico. Sin embargo, aMule utiliza la librería wxWidgets (wxGTK).

Aunque wxWidgets ha mejorado mucho, su implementación para Wayland todavía tiene problemas graves con los menús contextuales y las barras de herramientas en aplicaciones que no han sido actualizadas internamente. Al forzar X11, el sistema utiliza una capa de compatibilidad (XWayland) que dibuja las ventanas de la forma «clásica», permitiendo que los menús aparezcan donde deben.

Sigue estos pasos en tu Raspberry Pi OS

Si usas la imagen oficial de Raspberry Pi, hay una herramienta integrada que gestiona esto sin tocar código:

1. Abre la terminal y escribe: sudo raspi-config
2. Ve a Advanced Options (Opciones avanzadas).
3. Busca la opción Wayland.
4. Selecciona X11 (o «Disable Wayland»).
5. Finaliza y reinicia.

1. Limpieza de Instalaciones Previas

Utiliza este punto, si ya tenías aMule instalado y por ende, un servicio systemd de control. Si no es así, pasa al punto 2.

Si ya usabas aMule o bien tenías algún servicio de systemd corriendo para su gestion, debemos eliminar todo rastro para evitar conflictos con versiones antiguas de los repositorios.

Comprueba si ya tienes un servicio activo con systemctl list-units --all | grep -i amule

systemctl list-units --all | grep -i amule
  amule.service                                                                                                                                                                        loaded    active   running   aMule Master Daemon

Esto arroja que tengo un servicio llamado amule.service y debo detenerlo con este comando:

sudo systemctl stop amule.service

Una vez detenido el servicio, desinstalamos todo lo relacionado con aMule

sudo apt purge amule amule-daemon amule-utils-gui amule-utils amule-common

Y por último eliminamos todos los restos que dependen de la mula.

sudo apt autoremove --purge

2. Instalación de Dependencias de Compilación

Necesitamos el conjunto de herramientas de desarrollo y las librerías necesarias para el GUI remoto y el demonio:

sudo apt update

Instala el compilador y demás librerías. Copia y pega todo ese bloque en la terminal y dale a Enter.

sudo apt install -y libboost-all-dev git build-essential autoconf automake libtool \
libwxgtk3.2-dev libcryptsetup-dev libcurl4-openssl-dev libgd-dev \
libgeoip-dev libupnp-dev libboost-dev binutils-dev zlib1g-dev \
libcrypto++-dev libreadline-dev gettext autopoint

3. Obtención y Preparación del Código (Master)

Clonamos directamente la rama de desarrollo para asegurar que los parches estén aplicados:

Nos situamos en el directorio principal con:

cd ~

Descargamos el directorio completo desde GitHub

git clone https://github.com/amule-project/amule.git

El código anterior nos genera un directorio llamado amule, en el cual nos debemos situar con el comando:

 cd amule

Elegimos la rama principal de desarrollo (main)

git checkout master

Con git checkout master, le decimos a nuestra Raspberry: «No me des lo que se publicó hace años, dame lo que los desarrolladores tienen en su mesa de trabajo hoy mismo».

Preparamos el código fuente antes de la compilacion para permitir al software compilarse específicamente en tu máquina

./autogen.sh

El siguiente comando no es necesario usarlo, sirve para «volver al estado de fábrica» cuando ya has intentado compilar antes y la carpeta se ha llenado de archivos basura (objetos .o, ejecutables a medio hacer, scripts generados por ./autogen.sh). Se debería usar antes de ./autogen.sh para así una vez ejecutado, se vuelvan a crear los nuevos archivos de compilación.

git clean -fxd       # Limpieza total del árbol de archivos

4. Configuración del Demonio y Utilidades

A continuación te presento dos tipos de configuraciones, ya sea para Raspberry Pi 4 o Raspberry Pi 5 y así obtener la configuración del demonio (amuled), la interfaz gráfica remota (amule-gui) y las herramientas de consola:

«El comando ./configure es el cerebro del proceso. Se encarga de comprobar que tu Raspberry Pi tiene todas las librerías instaladas y utiliza nuestras instrucciones personalizadas para crear un plan de construcción (Makefile) optimizado para nuestro SSD y procesador.»

Copia esto tal cual y lo pegas en tu terminal.

Para Raspberry Pi 4 (Cortex-A72)

CXXFLAGS="-O3 -march=armv8-a+crc+simd -mtune=cortex-a72" ./configure \
    --enable-amule-daemon \
    --enable-amule-gui \
    --enable-amulecmd \
    --enable-webserver \
    --enable-cas \
    --enable-alcc \
    --disable-monolithic \
    --with-denoise-level=0 \
    --enable-optimize \
    --enable-mmap \
    --disable-debug
    --with-boost

Para Raspberry Pi 5 (Cortex-A76)

CXXFLAGS="-O3 -march=armv8.2-a+crypto -mtune=cortex-a76" \
./configure \
    --enable-amule-daemon \
    --enable-amule-gui \
    --enable-amulecmd \
    --enable-webserver \
    --enable-cas \
    --enable-alcc \
    --disable-monolithic \
    --with-denoise-level=0 \
    --enable-optimize \
    --enable-mmap \
    --disable-debug \
    --with-boost

Si ./configure falla con «Boost not found», prueba:

--with-boost=/usr --with-boost-libdir=/usr/lib/aarch64-linux-gnu --with-boost-includedir=/usr/include

Se ha incluido --enable-optimize para que la Raspberry Pi exprima su procesador y --disable-monolithic para separar el demonio de la interfaz.

5. Compilación Potente e Instalación

Aprovechamos los 4 núcleos de la Pi 4. Al estar en SSD, este proceso es significativamente más rápido:

make -j$(nproc)

make -j$(nproc) (La Construcción)

Este es el comando que hace el trabajo pesado.

• ¿Qué hace?: Lee un archivo llamado Makefile (que se generó al ejecutar el ./configure) y empieza a llamar al compilador para transformar cada archivo de código .cpp en archivos binarios de lenguaje máquina.
• El parámetro --j$(nproc): Es vital en la Raspberry Pi 4. Le dice al sistema: «Usamos $(nproc) para que el sistema detecte automáticamente los 4 núcleos de la Pi 4 o Pi 5 «. Sin el -j$(nproc), solo usaría uno y la compilación de aMule tardaría 4 veces más.
• Resultado: Al terminar, tendrás el programa «construido» dentro de la carpeta donde estás, pero aún no está instalado en el sistema.

sudo make install

sudo make install (La Mudanza)

Una vez que el programa está construido, hay que poner cada pieza en su sitio definitivo.

• ¿Qué hace?: Copia los ejecutables (como amuled, amulegui) y los archivos de ayuda/traducciones a las carpetas protegidas del sistema operativo.
• ¿A dónde van?: En tu caso, los mueve a /usr/local/bin/.
• ¿Por qué sudo?: Porque para escribir archivos en las carpetas del sistema (/usr/local/) necesitas permisos de administrador (SuperUser DO).

sudo ldconfig

sudo ldconfig (El Registro)

Este es el paso que mucha gente olvida y que causa errores de «librería no encontrada».

• ¿Qué hace?: Actualiza los enlaces y la caché de las librerías compartidas.
• ¿Por qué es necesario?: aMule utiliza muchas piezas externas (como wxWidgets o Crypto++). Al instalar versiones nuevas, el sistema necesita «indexarlas» en una base de datos interna (/etc/ld.so.cache).
• En resumen: Le dice al sistema operativo: «¡Oye! Acabamos de instalar programas y librerías nuevas en /usr/local/lib. Asegúrate de que todos los procesos sepan dónde encontrarlas ahora mismo».

6. Configuración de Acceso y Directorios

A. Primer arranque

Para que todo funcione, tienes que «despertar» al demonio.

En una terminal escribe:

amuled

Esto creará la carpeta ~/.aMule.

Es muy posible que en la primera vez que el programa se ejecute, este se cierre automáticamente, ¡Tranquilo! es totalmente normal. La primera vez que ejecutas aMule, crea la carpeta de configuración, pero se cierra inmediatamente porque un demonio sin «mando a distancia» no sirve para nada.

El error te está diciendo literalmente: «Si no puedo conectarme con el exterior, no tengo forma de que me des órdenes».

B. Generar una contraseña segura

Las contraseñas del archivo amule.conf son encriptadas y no se pueden escribir directamente. Por ejemplo para usar la contraseña <BurritoSabanero> habrá que encriptarla para que sea válida y se pueda usar.

Primero, genera el código (hash) de tu contraseña. Cambia tu_contraseña_aquí por la que quieras:

echo -n "tu_contraseña_aquí" | md5sum

Por ejemplo:

echo -n "BurritoSabanero" | md5sum

No olvides entrecomillar la palabra elegida como contraseña.

Esto nos dará como resultado la contraseña encriptada siguiente:

0d545153bf7b94d6094a01f5f925163b  -

C. Editar el archivo de configuración

Ahora vamos a decirle a aMule que acepte conexiones y a ponerle esa contraseña. Abre el editor:

nano ~/.aMule/amule.conf

Busca las líneas que dicen, ECPassword y AcceptExternalConnections y déjalas así:

• AcceptExternalConnections=1 (Cambia el 0 por el 1)
• ECPassword=la_contraseña_que_generaste (Pega aquí el hash MD5)

D. Activar la Interfaz Web.

Como has instalado amule-utils, también tienes amuleweb. Si lo activas, podrás gestionar las descargas escribiendo la IP de tu Raspberry en el navegador de tu móvil o tablet (ej: http://192.168.1.50:24711).

Busca también la sección [WebServer] y cambia lo siguiente.

• Enabled=1
• Password=la_contraseña_que_generaste (Puedes usar la misma o generar otra distinta)

E. Prueba de fuego

Guarda los cambios con Ctrl+O, pulsa Enter y sal con Ctrl+X.

Ahora vuelve a lanzar el demonio:

amuled -f

Si todo ha ido bien, esta vez no se cerrará. Se quedará funcionando.

Tip de experto: Como amuled se queda bloqueando la terminal, lo ideal es lanzarlo en segundo plano para que libere la terminal y asi puedas seguir usandola. Esto se logran usando el modificador -f al final del comando.

F.Configuración aMule

Para modificar la configuración de amuled, asegurate que el demonio no se está ejecutando.

killall amuled

Con el demonio fuera de juego, podemos editar nuestras preferencias en el archivo de configuración de amule.

nano /home/usuario/.aMule/amule.conf

La siguiente configuración es una copia de mi archivo amule.conf. Si quieres puedes usarlo copiarlo y adaptarlo a tus necesidades. Yo he modificado las líneas que están resaltadas en verde con respecto al archivo original.

[eMule]
AppVersion=2.3.3
Nick=Usuario_de_aMule
QueueSizePref=50
MaxUpload=5000
MaxDownload=19375
SlotAllocation=20
Port=24662
UDPPort=24672
UDPEnable=1
Address=
Autoconnect=1
MaxSourcesPerFile=300
MaxConnections=300
MaxConnectionsPerFiveSeconds=20
RemoveDeadServer=1
DeadServerRetry=3
ServerKeepAliveTimeout=0
Reconnect=1
Scoresystem=1
Serverlist=1
AddServerListFromServer=0
AddServerListFromClient=0
SafeServerConnect=0
AutoConnectStaticOnly=0
UPnPEnabled=0
UPnPTCPPort=50000
SmartIdCheck=1
ConnectToKad=1
ConnectToED2K=1
TempDir=/home/tu_usuario/.aMule/Temp
IncomingDir=/home/tu_usuario/.aMule/Incoming
ICH=1
AICHTrust=0
CheckDiskspace=1
MinFreeDiskSpace=1
AddNewFilesPaused=0
PreviewPrio=0
ManualHighPrio=0
StartNextFile=0
StartNextFileSameCat=0
StartNextFileAlpha=0
FileBufferSizePref=100
DAPPref=1
UAPPref=1
AllocateFullFile=0
OSDirectory=/home/tu_usuario/.aMule/
OnlineSignature=0
OnlineSignatureUpdate=5
EnableTrayIcon=0
MinToTray=0
Notifications=0
ConfirmExit=1
StartupMinimized=0
3DDepth=10
ToolTipDelay=1
ShowOverhead=0
ShowInfoOnCatTabs=1
VerticalToolbar=0
GeoIPEnabled=0
ShowVersionOnTitle=0
VideoPlayer=
StatGraphsInterval=3
statsInterval=30
DownloadCapacity=300
UploadCapacity=100
StatsAverageMinutes=5
VariousStatisticsMaxValue=100
SeeShare=2
FilterLanIPs=1
ParanoidFiltering=1
IPFilterAutoLoad=1
IPFilterURL=http://upd.emule-security.org/ipfilter.zip
FilterLevel=127
IPFilterSystem=0
FilterMessages=1
FilterAllMessages=0
MessagesFromFriendsOnly=0
MessageFromValidSourcesOnly=1
FilterWordMessages=0
MessageFilter=
ShowMessagesInLog=1
FilterComments=0
CommentFilter=
ShareHiddenFiles=1
AutoSortDownloads=0
NewVersionCheck=0
AdvancedSpamFilter=1
MessageUseCaptchas=1
Language=
SplitterbarPosition=75
YourHostname=
DateTimeFormat=%A, %x, %X
AllcatType=0
ShowAllNotCats=0
SmartIdState=1
DropSlowSources=0
KadNodesUrl=http://upd.emule-security.org/nodes.dat
Ed2kServersUrl=http://emule-security.org/serverlist/server.met
ShowRatesOnTitle=0
GeoLiteCountryUpdateUrl=http://geolite.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz
StatsServerName=Shorty's ED2K stats
StatsServerURL=http://ed2k.shortypower.dyndns.org/?hash=
CreateSparseFiles=1
[Browser]
OpenPageInTab=1
CustomBrowserString=
[Proxy]
ProxyEnableProxy=0
ProxyType=0
ProxyName=
ProxyPort=1080
ProxyEnablePassword=0
ProxyUser=
ProxyPassword=
[ExternalConnect]
UseSrcSeeds=0
AcceptExternalConnections=1
ECAddress=
ECPort=4712
ECPassword=0d545153bf7b94d6094a01f5f925163b
UPnPECEnabled=0
ShowProgressBar=1
ShowPercent=1
UseSecIdent=1
IpFilterClients=1
IpFilterServers=1
TransmitOnlyUploadingClients=0
[WebServer]
Enabled=1
Password=0d545153bf7b94d6094a01f5f925163b
PasswordLow=
Port=24711
WebUPnPTCPPort=50001
UPnPWebServerEnabled=0
UseGzip=1
UseLowRightsUser=0
PageRefreshTime=120
Template=default
Path=amuleweb
[GUI]
HideOnClose=0
[Razor_Preferences]
FastED2KLinksHandler=1
[SkinGUIOptions]
Skin=
[Statistics]
MaxClientVersions=0
[Obfuscation]
IsClientCryptLayerSupported=1
IsCryptLayerRequested=1
IsClientCryptLayerRequired=0
CryptoPaddingLenght=254
CryptoKadUDPKey=1686729473
[PowerManagement]
PreventSleepWhileDownloading=0
[UserEvents]
[UserEvents/DownloadCompleted]
CoreEnabled=0
CoreCommand=
GUIEnabled=0
GUICommand=
[UserEvents/NewChatSession]
CoreEnabled=0
CoreCommand=
GUIEnabled=0
GUICommand=
[UserEvents/OutOfDiskSpace]
CoreEnabled=0
CoreCommand=
GUIEnabled=0
GUICommand=
[UserEvents/ErrorOnCompletion]
CoreEnabled=0
CoreCommand=
GUIEnabled=0
GUICommand=
[HTTPDownload]
URL_1=http://upd.emule-security.org/ipfilter.zip
URL_2=http://emule-security.org/serverlist/server.met
URL_5=http://upd.emule-security.org/nodes.dat
URL_3=http://emule-security.org/serverlist/server.met

Descripción de los puntos más importantes de la configuración de aMule.

Parámetros Críticos de Configuración (amule.conf)

• Nick: Es tu nombre de usuario en la red. Aunque no afecta a la velocidad, sirve para identificarte en las colas de otros usuarios.
• MaxDownload=19375: Define el límite máximo de descarga (en este caso, unos 150 Mbps). Permite que aMule use el ancho de banda necesario sin saturar la CPU de la Raspberry.
• MaxUpload=5000: Define la velocidad de subida. Es vital ser generoso (5 MB/s); en la red eD2k, cuanto más subes, más créditos ganas y más rápido descargas de los demás.
• Slot Allocation=20 : determina cuánta velocidad de subida le das a cada persona que se descarga algo de ti. Con 5000 de subida total, estás abriendo 250 slots simultáneos. Vas a ganar créditos con 250 personas a la vez, lo que te garantiza descargar a máxima velocidad en tiempo récord.
• Port=24662 (TCP): Es el puerto que usa el programa para recibir datos. Debe estar abierto en tu router hacia la IP de la Raspberry para evitar la «ID Baja».
• UDPPort=24672 (UDP): Puerto para la red Kad y búsquedas. También debe estar abierto en el router para que la red funcione al 100%.
• MaxSourcesPerFile=300: El número máximo de fuentes que el programa buscará por cada archivo. Un valor de 300 es el punto de equilibrio ideal para la Raspberry Pi 4.
• MaxConnections=300: Límite de conexiones totales simultáneas. Mantenerlo en 300 evita que la Raspberry se bloquee por exceso de hilos de red abiertos. Si se sube mucho (ej. 500 o más), la Pi suele dar errores de red (epoll).
• MaxConnectionsPerFiveSeconds=20: Controla cuántas conexiones nuevas se intentan cada 5 segundos. Un valor bajo (20) evita que el router colapse al arrancar el programa.

Mantenimiento y Rendimiento del Sistema

• FileBufferSizePref=100: Define el tamaño del búfer en RAM antes de escribir en el disco. Un valor alto (100% o más) reduce el número de escrituras constantes, protegiendo la salud de la tarjeta MicroSD.
• AllocateFullFile=0: Si está en 1, reserva todo el espacio del archivo al empezar. En la Raspberry es mejor dejarlo en 0 para que no se congele el sistema al intentar crear archivos muy grandes de golpe.
• SmartIdState=1: Ayuda a recuperar la ID Alta (flechas verdes) si sufres un micro-corte de internet, siempre que los puertos del router estén bien configurados.
• Serverlist=1: Indica al programa que actualice la lista de servidores conocidos cada vez que se inicia.

Rutas y Seguridad

• IncomingDir y TempDir: Son las carpetas donde se guardan las descargas finalizadas y los archivos temporales. En una Raspberry, si puedes usar un SSD o disco externo, cambia estas rutas para evitar desgastar la tarjeta SD.
• IPFilterURL: La dirección para descargar el filtro de IPs (ej: http://upd.emule-security.org/ipfilter.zip). Es fundamental para bloquear servidores falsos y clientes espía automáticamente.
• Ed2kServersUrl: Dirección para descargar una lista de servidores fiables (ej: http://upd.emule-security.org/server.met). Garantiza que siempre conectes a servidores reales y seguros.

7. El paso final: ¿Quieres que aMule arranque solo?

Para que tu Raspberry Pi sea un servidor de descargas profesional, lo ideal es crear un servicio en systemd. Esto hará que amuled se inicie automáticamente cada vez que enciendas la Pi sin necesidad de abrir una terminal.

En tu terminal homologada ejecuta este comando:

Copia y pega el contenido a tu archivo, no olvides sustituir «tu_usuario» y «tu_grupo» por los tuyos propios.

[Unit]
Description=aMule Master Daemon
After=network.target

[Service]
Type=simple
User=tu_usuario
Group=tu_grupo
ExecStart=/usr/local/bin/amuled
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Guarda con Crtl + o y sal con Crtl + x

Ahora sigue estos pasos para que el sistema reconozca la nueva configuración sin errores:

1. Recarga la configuración:
   sudo systemctl daemon-reload
   (Esto es vital cada vez que editas un archivo .service).
2. Activa el servicio con:
   sudo systemctl enable amule.service
3. Inicia el servicio:
   sudo systemctl start amule.service
4. Comprueba que vive:
   sudo systemctl status amule.service

• Sólo en caso de fallo, si nesitas revivir o reiniciar el servicio puedes usar el comando:
  sudo systemctl restart amule.service

«Al compilar nosotros mismos, el sistema no sabe cómo arrancar el programa automáticamente. Creamos este archivo en /etc/systemd/system/ para que la Raspberry Pi sepa que el ‘cerebro’ de las descargas debe estar siempre vivo, incluso si hay un corte de luz y el SSD se reinicia.»

Notas y advertencias

• Con –with-boost se usa Boost.Asio para networking → evita bugs de wxNet/epoll en ARM/Pi 5.
• Si usas conexiones altas (>300), el bug epoll puede volver; baja a 200-300 como workaround.
• Como asunto relevantes: https://github.com/amule-project/amule/issues/171 (donde recomiendan –with-boost explícitamente).

Vamos a usar un script «inteligente» que recoge todo lo que aMule escupe, calcula los Megabytes y lo envía a Telegram usando un formato que nunca falla.

Paso 1: Configurar aMule

¡OJO! Antes de editar, detén aMule

sudo systemctl stop amule

Vamos a decirle a aMule que ejecute nuestro script. Para ello, debemos editar el archivo amule.conf.

nano ~/.aMule/amule.conf

Busca la sección [UserEvents/DownloadCompleted] y déjala exactamente así:

CoreEnabled=1
CoreCommand=/home/tu_usuario/notificar_amule.sh %NAME %SIZE

Sustituye tu_usuario por el tuyo propio.

Paso 2: Crear el Script

Crea el archivo de tu script, sustituyendo tu_usuario por el tuyo propio:

nano /home/tu_usuario/notificar_amule.sh 

y pega este código (sustituye tu Token y tu ID de Chat):

#!/bin/bash

# --- CONFIGURACION DEL BOT ---
TOKEN="TU_TOKEN_AQUI"
ID_CHAT="TU_ID_AQUI"

# 1. Recogemos todo lo que mande aMule de golpe
TODO="$*"

# 2. Extraemos el tamaño (el último número de la frase)
BYTES=$(echo "$TODO" | grep -oP '\d+$')

# 3. Limpiamos el nombre (quitamos el número del final)
NOMBRE=$(echo "$TODO" | sed 's/[0-9]*$//')

# 4. Calculamos los MB y sacamos la fecha de la Raspberry
TAMANO_MB=$((BYTES / 1048576))
FECHA=$(date +"%d/%m/%Y a las %H:%M")

# 5. El Mensaje (con emoticonos para darle estilo)
MENSAJE="✅ DESCARGA COMPLETADA
----------------------------------
🎵 Archivo: $NOMBRE
⚖ Tamaño: $TAMANO_MB MB
🕒 Finalizado: $FECHA
🥧 Servidor: Raspberry Pi
----------------------------------"

# 6. Envío blindado con urlencode (evita que el mensaje se corte)
/usr/bin/curl -s -X POST "https://api.telegram.org/bot$TOKEN/sendMessage" \
     --data-urlencode "chat_id=$ID_CHAT" \
     --data-urlencode "text=$MENSAJE" > /dev/null

Paso 3: Permisos y Arranque

Para que esto funcione, dale permiso de ejecución al script:

chmod +x /home/tu_usuario/notificar_amule.sh

Ahora, arranca aMule de nuevo:

sudo systemctl restart amule

¡Y listo! A partir de ahora, cada vez que la Mula termine su trabajo, recibirás un «ping» en tu Telegram con toda la información. ¡A disfrutar de la descarga!