De repente, cada vez que reiniciaba el sistema, la Pi arrancaba pero con la pantalla más negra que los huevos de un burro. 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 los huevos de un burro», 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

Añade o cambia estas líneas:

• POWER_OFF_ON_HALT=1
• HDMI_DELAY=1

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 Raspberry Pi 4, si la dejas trabajar duro, puede ponerse mas caliente que un «Amego Segarro» en una feria. Su procesador puede alcanzar temperaturas que activan el thermal throttling, reduciendo su velocidad para no «derretirse». Es fundamental entender que el procesador empieza a reducir su velocidad automáticamente cuando llega a los 80°C – 85°C para protegerse.

Muchos optan por conectar un ventilador directamente a los pines de 5V, lo cual funciona, pero tiene dos grandes problemas: el ruido constante (¡parece un avión despegando!) y el desgaste innecesario del motor.

En esta entrada, vamos a hacer algo mucho más elegante y profesional. Vamos a configurar un sistema de control por PWM (Modulación por Ancho de Pulsos) utilizando el tercer cable de nuestro ventilador. ¿Qué conseguiremos con esto?

• Silencio absoluto: El ventilador solo girará lo necesario.
• Inteligencia térmica: Crearemos un script en Python que «lee» la mente (y la temperatura) de la CPU.
• Automatización total: Configuraremos un servicio en Linux para que el control sea eterno y arranque solo.
• Protección de hardware: Evitaremos forzar los pines de la placa con una configuración segura.

Si quieres que tu Pi 4 esté siempre fresca sin sacrificar tus oídos, ¡acompáñame en este tutorial!

Conexión del ventilador

Un ventilador PWM (Modulación por Ancho de Pulsos) se compone de 3 cables, esto significa que no solo puedes encenderlo o apagarlo, sino que puedes regular su velocidad (por ejemplo, que gire al 40% si está a 45°C y al 100% si llega a 60°C).

La función de cada cable es:

1. Rojo a un pin de 5V positivo. (Pin 2 o 4). Aquí toma la fuerza.
2. Negro a un pin GND negativo. (Pin 6).
3. Azul (PWM) por ejemplo, pin 18 (GPIO 24).

Como se ve en la imagen anterior, No, se necesita resistencia, ya que el cable azul solo recibe una «señal» de control de muy baja intensidad (lógica), el procesador de la Raspberry no sufre. El transistor ya viene integrado dentro del propio ventilador para gestionar esa señal.

Nota: Algunos ventiladores baratos de 3 cables no soportan PWM por el tercer cable (a veces el tercer cable es solo un sensor de revoluciones, no de control).
– Si el ventilador baja de velocidad: ¡Perfecto! Todo funciona.
– Si el ventilador solo está encendido o apagado: Significa que tu cable azul es un sensor «Tacho» y no admite control de velocidad. En ese caso, el script funcionará a todo o nada. (ON/OFF).

El script.

Con este script, tu Raspberry Pi 4 tendrá un comportamiento idéntico al ventilador de un ordenador portátil moderno. Este no solo enciende o apaga, sino que hace que el ventilador «susurre» cuando hay poca temperatura y «sople» fuerte solo cuando es necesario.

Script (Edición PWM)

Copia y pega el siguiente script en un archivo llamado fanGuard.py

nano fanGuard.py

#!/usr/bin/python3
import RPi.GPIO as GPIO
import time
import subprocess
import sys
from datetime import datetime

# ==========================================
# CONFIGURACIÓN PROPORCIONAL PRO
# ==========================================
PIN_FAN        = 18
FRECUENCIA     = 100
ESPERA         = 3

TEMP_ARRANQUE  = 50
TEMP_MAXIMA    = 65
TEMP_PARADA    = 39
POTENCIA_MIN   = 40
# ==========================================

def obtener_temp_maxima():
    try:
        with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
            temp_cpu = float(f.read()) / 1000

        salida_gpu = subprocess.check_output(["vcgencmd", "measure_temp"]).decode("utf-8")
        temp_gpu = float(salida_gpu.replace("temp=", "").replace("'C\n", ""))

        return max(temp_cpu, temp_gpu)
    except Exception:
        return 55.0

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(PIN_FAN, GPIO.OUT)
pwm = GPIO.PWM(PIN_FAN, FRECUENCIA)
pwm.start(0)

ventilador_activo = False

print("=============================================")
print("  FAN GUARD PRO: CPU + GPU MONITOR  ")
print(f"  Arranque: {TEMP_ARRANQUE}C | Parada: {TEMP_PARADA}C")
print("=============================================")

try:
    while True:
        temp = obtener_temp_maxima()
        ahora = datetime.now().strftime("%H:%M:%S")
        nivel = 0

        if temp >= TEMP_ARRANQUE:
            ventilador_activo = True
        elif temp <= TEMP_PARADA:
            ventilador_activo = False

        if ventilador_activo:
            if temp >= TEMP_MAXIMA:
                nivel = 100
            elif temp <= TEMP_ARRANQUE:
                nivel = POTENCIA_MIN
            else:
                dif_temp = temp - TEMP_ARRANQUE
                rango_temp = TEMP_MAXIMA - TEMP_ARRANQUE
                rango_potencia = 100 - POTENCIA_MIN
                nivel = int(POTENCIA_MIN + (dif_temp * rango_potencia / rango_temp))
        else:
            nivel = 0

        pwm.ChangeDutyCycle(min(max(nivel, 0), 100))

        # Usamos carácteres ASCII compatibles con todas las terminales
        estado = "[ON]" if ventilador_activo else "[OFF]"
        barra = "#" * (nivel // 10) + "-" * (10 - (nivel // 10))

        print(f"[{ahora}] {estado} Temp: {temp:.1f}C | Potencia: [{barra}] {nivel}%")

        time.sleep(ESPERA)

except KeyboardInterrupt:
    print("\nDeteniendo servicio...")
finally:
    pwm.stop()
    GPIO.cleanup()

Guarda el documento con Ctrl + o y sal con Ctrl + x

No olvides hacerlo ejecutable con:

chmod +x fanGuard.py

Ciclo de funcionamiento.(Configuración 50°C – 65°C)

1. Zona de Silencio Total (Hasta 50°C): El ventilador está en 0% (Apagado). Gracias a tu torre de refrigeración, la Raspberry se mantendrá aquí la mayor parte del tiempo (sobre los 45°C-47°C).
2. El Despertar (A los 50°C): En cuanto el sensor (CPU o GPU) toca los 50.0°C, el ventilador arranca directamente al 40% de potencia. Esto asegura que el aire fluya con fuerza suficiente por las aletas del Ice Tower desde el primer segundo.
3. Zona Dinámica Proporcional (De 50°C a 65°C): El script escala la velocidad de forma lineal:
   • 50°C —————> 40% (Arranque mínimo).
   • 57.5°C ————-> 70% aprox. (Punto medio).
   • 65°C —————> 100% (Potencia máxima).
4. La Bajada con Histéresis (El camino de vuelta): * Si el ventilador está encendido y la temperatura baja de 50°C, no se apaga.
   • Se mantiene soplando al 40% de forma constante mientras baja por los 48°C, 45°C….
   • Solo cuando el sensor marca 39°C o menos, el ventilador se detiene por completo.

¿Por qué este cambio es mejor para tu caso?

Con estos margenes de temperaturas, tenemos un margén de maniobra para no castigar en exceso al ventilador, por lo que:

• Evitas el desgaste: El ventilador gira lo necesario, reduciendo horas de funcionamiento y evitando desgaste del mismo.
• Aprovechas el cobre: Dejas que el disipador trabaje de forma pasiva hasta su límite razonable.
• Enfriamiento real: Cuando arranca a 50°C, lo hace con la misión de bajar hasta los 39°C, asegurando que la placa se quede realmente fresca antes de volver a apagarse.

Tabla resumen de revoluciones (ejemplo estimado):

¿Cómo saber si los porcentajes son correctos para TU ventilador?

Cada ventilador es un mundo. Si notas que al 40% hace un ruido eléctrico pero no gira, puedes subir la variable POTENCIA_MIN a 50. Si por el contrario gira muy fuerte desde el principio, puedes bajarla a 30.

Para alargar la vida útil de los componentes y mantener el máximo rendimiento, lo ideal es mantenerla por debajo de los 60°C en carga de trabajo.

Crear el archivo del servicio

Para hacerlo «eterno» con systemd, tenemos que seguir unos pasos específicos. Es vital que el servicio se ejecute como root (para tener permisos sobre los GPIO) y que gestione bien el apagado, evitando que el ventilador no se quede «silbando» cuando detengas la Raspberry.

Abre el editor para crear el archivo de configuración del sistema:

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

3. Pegar la configuración del servicio

Copia y pega este bloque tal cual, sustituyendo tu_usuario, por el tuyo propio de la ruta en ExecStart):

[Unit]
Description=Control Inteligente de Ventilador PWM con Histeresis
After=multi-user.target

[Service]
Type=simple
User=root
ExecStart=/usr/bin/python3 -u /home/tu_usuario/fanguard.py
Restart=always
RestartSec=10
# Esto asegura que los prints del script se vean en el log del sistema
StandardOutput=inherit
StandardError=inherit

[Install]
WantedBy=multi-user.target

4. Activar el «Modo Eterno»

Ahora ejecuta estos comandos en orden para que el sistema reconozca el nuevo servicio y lo arranque:

1. Recargar el sistema:
   sudo systemctl daemon-reload
2. Activar el inicio automático al arrancar:
   sudo systemctl enable fanguard.service
3. Iniciar el ventilador ahora mismo:
   sudo systemctl start fanguard.service

¿Cómo puedes vigilar tu ventilador ahora?

Como el script ahora corre de fondo («eterno»), ya no verás la barrita de carga directamente en la pantalla, pero puedes «espiarlo» con estos comandos:

• Para ver si está vivo y la temperatura actual:
  sudo systemctl status fanguard.service
• Para ver el funcionamiento en tiempo real (ver los logs):
  journalctl -u fanguard.service -f
• Si quieres detenerlo para hacer cambios en el script:
  sudo systemctl stop fanguard.service
  (Al detenerlo, gracias al bloque finally de tu script, el ventilador se apagará completamente).

¡Listo! Ya tienes un sistema de refrigeración de grado industrial en tu Raspberry Pi 4.

A continuación te explico como tener tu Pi actualizada a la última versión

Verificar el firmware instalado.

El primer comando que debemos conocer es:

sudo rpi-eeprom-update

Cuando se ejecuta sin ningún argumento adicional, este comando muestra el estado actual del firmware del bootloader (cargador de arranque) de la EEPROM. Te indicará la versión actual del bootloader instalado en tu Pi y si hay una versión más reciente disponible. Por sí solo, no instala ninguna actualización, simplemente te informa sobre lo que hay. El bootloader es un pequeño programa almacenado en una memoria no volátil (EEPROM) que se encarga de iniciar la Raspberry Pi antes de que el sistema operativo se cargue desde la tarjeta SD, SSD o NVMe.

Ejemplo de salida de este comando.

raspberry@pi5:~
$ sudo rpi-eeprom-update
*** UPDATE AVAILABLE ***

Run "sudo rpi-eeprom-update -a" to install this update now.

To configure the bootloader update policy run "sudo raspi-config"

BOOTLOADER: update available
   CURRENT: jue 08 may 2025 14:13:17 UTC (1746713597)
    LATEST: lun 09 jun 2025 09:30:52 UTC (1749461452)
   RELEASE: latest (/usr/lib/firmware/raspberrypi/bootloader-2712/latest)
            Use raspi-config to change the release.

En la salida anterior vemos que tenemos una actualización disponible *** UPDATE AVAILABLE ***, la «actual o CURRENT» del jueves 08 de mayo y la «última o LATEST» de Lunes 09 junio.

Instalar la última versión del firmware.

El segundo comando a conocer es:

sudo rpi-eeprom-update -a

Es el mismo comando rpi-eeprom-update, pero con el argumento -a (de «automatic» o «apply»). Este comando instala automáticamente la última versión disponible del firmware del bootloader de la EEPROM. Si hay una actualización pendiente (como se vería con sudo rpi-eeprom-update), este comando la descargará y la preparará para ser escrita en la EEPROM.

Después de la actualización, esta no se aplica inmediatamente, si no, que debes reiniciar tu Raspberry Pi (sudo reboot) para que los cambios en el bootloader surtan efecto.

La versión que se instala proviene de los repositorios de paquetes de Raspberry Pi OS (generalmente la versión «stable» o «default», a menos que lo hayas configurado de otra manera en /etc/default/rpi-eeprom-update o a través de raspi-config).

Ejemplo de salida de este comando.

raspberry@pi5:~
$ sudo rpi-eeprom-update -a
*** PREPARING EEPROM UPDATES ***

BOOTLOADER: update available
   CURRENT: jue 08 may 2025 14:13:17 UTC (1746713597)
    LATEST: lun 09 jun 2025 09:30:52 UTC (1749461452)
   RELEASE: latest (/usr/lib/firmware/raspberrypi/bootloader-2712/latest)
            Use raspi-config to change the release.
   CURRENT: jue 08 may 2025 14:13:17 UTC (1746713597)
    UPDATE: lun 09 jun 2025 09:30:52 UTC (1749461452)
    BOOTFS: /boot/firmware
'/tmp/tmp.tU0oG2Yfdp' -> '/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

Ahora para que los cambios tengan efecto reinicia tu Raspberry:

sudo reboot

Una vez que reinicies tu Raspberry, verifica el resultado:

sudo rpi-eeprom-update

Como puedes ver, los cambios se han aplicado.

raspberry@pi5:~
$ sudo rpi-eeprom-update
BOOTLOADER: up to date
   CURRENT: lun 09 jun 2025 09:30:52 UTC (1749461452)
    LATEST: lun 09 jun 2025 09:30:52 UTC (1749461452)
   RELEASE: latest (/usr/lib/firmware/raspberrypi/bootloader-2712/latest)
            Use raspi-config to change the release.

Ahora, tanto la CURRENT (actual) como la LATEST (última) están igualadas.

Actualiza tu sistema a la última (no recomendable)

*** A partir de aquí actúa con precaución ***

Existe un tercer comando, el cual es el siguiente:

sudo rpi-update

Este comando se utiliza para actualizar el firmware del sistema (VideoCore), el kernel de Linux y los módulos asociados que residen en la tarjeta SD/SSD/NVMe de tu Raspberry Pi. Este comando, descarga las últimas versiones del kernel, los módulos del kernel, los archivos del árbol de dispositivos (device tree files) y el firmware de VideoCore (la GPU integrada) directamente desde el repositorio de GitHub de Raspberry Pi.

Nota: Es importante destacar que rpi-update suele descargar las versiones más recientes y a menudo experimentales o «bleeding-edge» del firmware y el kernel. Esto significa que puede incluir características nuevas, pero también podría introducir inestabilidad o errores.

Generalmente no se recomienda para la mayoría de los usuarios en entornos de producción o donde la estabilidad es crítica. La forma estándar y más segura de mantener el kernel y el firmware del sistema actualizados es a través de sudo apt update y sudo apt full-upgrade, ya que estos comandos obtienen versiones estables y probadas a través de los repositorios de paquetes de Debian/Raspberry Pi OS.

Úsalo si, estás resolviendo un problema específico que se sabe que se soluciona en una versión muy reciente que aún no está en los repositorios estables de apt, o necesitas probar nuevas caracteristicas o versiones beta del firmware/kernel, o para un caso de uso muy especifico.

Siempre debes reiniciar después de usar sudo rpi-update para que los nuevos componentes del kernel y firmware se carguen.

La siguiente salida muestra un ejemplo de actualización con rpi-update.

raspberry@pi5:~
$ sudo rpi-update
 *** Raspberry Pi firmware updater by Hexxeh, enhanced by AndrewS and Dom
 *** Performing self-update
 *** Relaunching after update
 *** Raspberry Pi firmware updater by Hexxeh, enhanced by AndrewS and Dom
FW_REV:e172b71336f17d6149dd3d6e21f2f7ac14dbeb35
BOOTLOADER_REV:df532a02dc332274e55aa25f8a0637c0922da898
 *** We're running for the first time
 *** Backing up files (this will take a few minutes)
 *** Remove old firmware backup
 *** Backing up firmware
 *** Remove old modules backup
 *** Backing up modules 6.12.25+rpt-rpi-2712
WANT_32BIT:0 WANT_64BIT:1 WANT_64BIT_RT:0 WANT_PI4:1 WANT_PI5:1
##############################################################
WARNING: This update bumps to rpi-6.12.y linux tree
See discussions at:
https://forums.raspberrypi.com/viewtopic.php?t=379745
##############################################################
Would you like to proceed? (y/N)
Downloading bootloader tools
Downloading bootloader images
 *** Downloading specific firmware revision (this will take a few minutes)
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  154M  100  154M    0     0  34.5M      0  0:00:04  0:00:04 --:--:-- 40.8M
*** PREPARING EEPROM UPDATES ***

BOOTLOADER: update available
   CURRENT: jue 08 may 2025 14:13:17 UTC (1746713597)
    LATEST: lun 09 jun 2025 09:30:52 UTC (1749461452)
   RELEASE: latest (/usr/lib/firmware/raspberrypi/bootloader-2712/latest)
            Use raspi-config to change the release.
   CURRENT: jue 08 may 2025 14:13:17 UTC (1746713597)
    UPDATE: lun 09 jun 2025 09:30:52 UTC (1749461452)
    BOOTFS: /boot/firmware
'/tmp/tmp.WxoM2hMLrw' -> '/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
 *** Updating firmware
 *** Updating kernel modules
 *** depmod 6.12.32-v8-16k+
 *** depmod 6.12.32-v8+
 *** Updating VideoCore libraries
 *** Running ldconfig
 *** Storing current firmware revision
 *** Deleting downloaded files
 *** Syncing changes to disk
 *** If no errors appeared, your firmware was successfully updated to e172b71336f17d6149dd3d6e21f2f7ac14dbeb35
 *** A reboot is needed to activate the new firmware

Tabla Comparativa Resumida:

En resumen:

• Utiliza sudo apt update y sudo apt full-upgrade para la mayoría de las actualizaciones generales del sistema operativo, incluyendo el kernel y el firmware de VideoCore en sus versiones estables.
• Si tienes una Raspberry Pi 4 o 5, usa sudo rpi-eeprom-update -a (seguido de un reinicio) para asegurarte de que el bootloader de la EEPROM esté también actualizado.
• Evita sudo rpi-update a menos que sepas exactamente por qué lo necesitas.

Revertir rpi-update.

1. Reinstalar el kernel y el bootloader estables:

Para revertir sudo rpi-update, debes reinstalar las versiones del kernel y el bootloader que están disponibles en los repositorios estables de tu distribución (MX Linux en este caso).

Abre una terminal y ejecuta los siguientes comandos:

sudo apt update

Con esto actulizas la lista de paquetes disponibles.

sudo apt install --reinstall raspi-firmware

Este comando reinstala los paquetes del firmware (microcódigo) esencial para el funcionamiento de la Raspberry Pi, incluyendo partes del kernel y otros componentes de bajo nivel necesarios para que el hardware funcione correctamente. Esto sobrescribe la actualizació de rpi-update con la versión estable del repositorio de MX Linux.

Después de ejecutar estos comandos, reinicia tu Raspberry Pi:

sudo reboot

Los chips puente USB a SATA de JMicron, a veces pueden causar problemas con la Raspberry Pi, especialmente al usarla como dispositivo de arranque. Estos problemas pueden incluir fallos de arranque, desconexión tras un reinicio o bajo rendimiento.

Si el chip es un JMicron Technology Corp., lo mejor es que lo reemplaces por otro como ASMedia Technology Inc.

Con el comando lsusb puedes saber que chip lleva tu adaptador.

raspberry@pi4:~
$ lsusb
Bus 004 Device 002: ID 152d:0578 JMicron Technology Corp. / JMicron USA Technology Corp. JMS578 SATA 6Gb/s
Bus 004 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 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

La salida nos devuelve el chip JMicron Technology Corp., que es el que debemos evitar en la Pi4.

Raspberry@pi4:~
$ lsusb
Bus 002 Device 002: ID 174c:55aa ASMedia Technology Inc. ASM1051E SATA 6Gb/s bridge, ASM1053E SATA 6Gb/s bridge, ASM1153 SATA 3Gb/s bridge, ASM1153E SATA 6Gb/s bridge
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 002: ID 2109:3431 VIA Labs, Inc. Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

En este caso, la salida al comando es el chip ASMedia Technology Inc. compatible con Pi4

Aunque podemos hacer que arranque siguiendo esta guía, no será posible activar el TRIM por ser incompatible con este chip.

Asegúrate de tener la última versión del firmware de tu Pi4 de este forma:

sudo rpi-eeprom-update

Cómo resultado nos dará:

Raspberry@pi4:~
$ sudo rpi-eeprom-update
[sudo] contraseña para Raspberry:
BOOTLOADER: up to date
CURRENT: vie 16 may 2025 10:34:04 UTC (1747391644)
LATEST: vie 16 may 2025 10:34:04 UTC (1747391644)
RELEASE: latest (/usr/lib/firmware/raspberrypi/bootloader-2711/latest)
Use raspi-config to change the release.

VL805_FW: Using bootloader EEPROM
VL805: up to date
CURRENT: 000138c0
LATEST: 000138c0

En la salida anterior vemos que tenemos el último firmware hasta la fecha de este manual.

Si tuvieses que actualizar el firmware tan solo deberás escribir en una terminal:

sudo rpi-eeprom-update -a

Una vez terminada la acualización, deberás reiniciar el sistema.

Antes de seguir con esto, lo mejor es que compres un adaptador compatible para solucionar este problema, pero si no fuese posible, a continuación te explico como usar el puerto usb-3 para conectar tu disco SSD.

Ahora sí, comenzamos ….

Desde que tengo la Raspberry Pi 5, apenas uso la Pi 4, pero estoy descubriendo nuevas cosas que ya me hubieran gustado saber hace tiempo, como que Trim no viene activado por defecto, o como aumentar la velocidad de transmision arrancando mi SSD desde un usb 3.0.

Yo empecé a usar Raspberry a partir de la versión 4, siempre usaba el puerto 2.0 para arrancar mi SSD, nunca me funcionó desde el 3.0, pensé que sería incompatible, pero al parecer es un tipo de error que tiene el chipset Jmicron.

En estos caso, la solución pasa por desactivar el protocolo UAS del disco agregando «peculiaridades USB» y hacer que funcione como almacenamiento masivo USB.

UAS es un protocolo de transporte mejorado en comparación con el almacenamiento masivo USB, todas las unidades UAS deben admitir almacenamiento masivo como opción de respaldo. Se le puede indicar al kernel que ignore la interfaz UAS de un dispositivo y solo use almacenamiento masivo: el controlador de almacenamiento usb tiene una opción de peculiaridades (quirks) para este propósito. Como UAS está integrado en el kernel para permitir que el sistema de archivos raíz se instale en un SSD, el quirk debe ir en cmdline.txt como un parámetro de módulo. Este parámetro coincide con el ID del proveedor USB (vid), el ID del producto (pid) y superpone los quirks especificados que deshabilitan funciones específicas para este dispositivo.

Test de velocidad

Vamos a comprobar a que velocidad circula nuestro disco SSD conectado a un puerto usb-2.0

Busca la aplicacion Raspberry Pi Diagnostics, si no la tienes instalada la puedes instalar con:

sudo apt install agnostics

Ejecutala pulsando en Run Tests, cuando termine, pulsa en Show Log.

Observa la línea que dice Secuencial write speed, dando un resultado de 30815 KB/sec, muy por encima del valor objetivo a superar de 10.000 KB/sec, pero no suficiente para aprovechar al máximo la velocidad de nuestro disco.

Personalmente el puerto usb-2.0 me ha dado muchos problemas, sobre todo con perdidas de datos, mi aMule fué testigo de ello. También, las velocidades de subida y bajada estaban limitadas por el puerto usb más que por la velocidad de la línea.

Comprueba el driver de tu disco.

Para ver que drive usa nuestro disco, en una terminal escribe:

lsusb -t

En la imagen anterior, vemos que UAS está activo y eso nos perjudica, así que vamos a cambiar esto.

En Raspberry Pi 4, UAS viene activado de forma predeterminada.

Usando usb-3.0

Para poder arrancar nuestro disco SSD desde el puerto usb-3.0, debemos de hacer una serie de cambios que os detallo a continuación:

Ejecuta un lsusb para comprobar el chipset de tu disco:

Raspberry@pi4:~
$ lsusb
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 003: ID 152d:0578 JMicron Technology Corp. / JMicron USA Technology Corp. JMS578 SATA 6Gb/s
Bus 001 Device 006: ID 058f:6387 Alcor Micro Corp. Flash Drive
Bus 001 Device 002: ID 2109:3431 VIA Labs, Inc. Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Aunque el idVendor y el idProduct lo hemos visto con el comando anterior, vamos a buscarlo mas exactamente.

Ejecuta el siguiente comando en la terminal:

Raspberry@pi4:~
$ sudo dmesg | grep idVendor
[ 2.277689] usb usb1: New USB device found, idVendor=1d6b, idProduct=0002, bcdDevice= 6.06
[ 2.279024] usb usb2: New USB device found, idVendor=1d6b, idProduct=0003, bcdDevice= 6.06
[ 2.687621] usb 1-1: New USB device found, idVendor=2109, idProduct=3431, bcdDevice= 4.21
[ 3.180114] usb 1-1.4: New USB device found, idVendor=152d, idProduct=0578, bcdDevice= 2.09
[ 5085.543847] usb 1-1.1: New USB device found, idVendor=058f, idProduct=6387, bcdDevice= 1.00
[ 5181.556491] usb 1-1.2: New USB device found, idVendor=058f, idProduct=6387, bcdDevice= 1.00
[ 5365.901603] usb 1-1.1: New USB device found, idVendor=058f, idProduct=6387, bcdDevice= 1.00

El resultado de idVendor=152d, idProduct=0578, coinicide con el disco JMicron, resultado del comando lsusb.

Vamos a editar el archivo cmdline.txt desde la terminal:

sudo nano /boot/firmware/cmdline.txt 

Al comienzo de la línea de parámetros, agrega el texto:

usb-storage.quirks=152d:0578:u

Cambia 152d:0578 por el tuyo propio.

Esto quedaría de la siguiente manera:

Guarda con la combinación de tedclas Crtl + O y sal de la aplicación con Crtl + X

Nota: Ten cuidado con este cambio, como te equivoques el sistema no te arrancará.

Para verificar que ha funcionado:

• Apaga tu Raspberry.
• Cambia de tu puerto usb-2 a un puerto usb-3.
• Enciende tu Raspberry.

Si el sistema inicia, es una muy buena señal.

Comprueba el Driver de tu disco.

Para ver que driver usa nuestro disco ahora, en una terminal escribe:

lsusb -t

Como puedes ver ahora nuestro disco usa el Driver=usb-storage en lugar del Driver=uas

Comprueba el Quirk (peculiaridad) de tu disco.

Para verificar que el quirk se haya aplicado correctamente, ejecuta

 dmesg | grep usb-storage

Verifica que el VID y el PID son los de nuestro disco y tienen el quirk aplicado

Test de velocidad

Repetimos el anterior test de velocidad, vuelve a seguir los pasos descritos anteriormente, pero claro, esta vez desde el puerto usb-3.0

Ahora la velocidad es de 140.109 KB/sec, muy superior a la anterior de 30.815 KB/sec

Por último, a modo de ejemplo os dejo el test de mi Raspberry Pi 5, que sin hacer nada de lo anteriormente explicado, arrancando perfectamente desde los puertos usb-3.0

Visto en https://forums.raspberrypi.com/viewtopic.php?f=28&t=245931

Resumiendo.

Evita usar el chipset de JMicron en la Pi4, así te ahorrarás todo este proceso de poder arrancar desde un USB-3, así como tener la compatibilidad completa para activar el TRIM.

Al parecer, Ubuntu corre bien en la Raspberry Pi 5, como puedes ver en YouTube, en un video de Computadoras y Sensores Ubuntu en Raspberry Pi 5 para USO DIARIO ¿a la altura?. Yo no hare la prueba de instalarlo en mi Pi 5, ya que es la responsable de hacer funcionar el blog en el que te encuentras leyendo estas líneas.

La versión que he elegido a sido la nueva 24.10, incompatible con las funciones de raspi-config, imposible de instalar el VNC compatible con RealVNC, no trae instalado el software que gestiona los pines GPIO. En algún que otro reinicio se queda con la pantalla en negro y no arranca.

Aprovecho para decirte que el mejor sistema que he probado hasta ahora para Raspberry es MX-23_rpi_respin,, incluso mejor que el oficial Raspberry Pi Os.

La instalación

La instalación se hace como cualquiera de las imágenes para Raspberry, con el programa Raspberry Pi Imager. Es muy sencilla, tan solo sigue los pasos y responde a las preguntas que se van formulando.

El sitio de Ubuntu tiene un manual muy detallado de como hacer la instalacion. Cómo instalar Ubuntu Desktop en Raspberry Pi 4

Actualizaciones.

Todo terminar de instalar tu sistema deberás de buscar actualizaciones e instalarlas. En una terminal homologada escribe:

sudo apt update && sudo apt -y full-upgrade

Y para actualizar los snap

sudo snap refresh

Ventilador

Con Ubuntu instalado, vas a necesitar de un ventilador para la CPU, de hecho, este se conecta mas veces al consumir mas recursos que otros sistemas como Mx LInux

El ventilador va conectado a los pines GPIO, pero el software que los controla no viene instalado en ninguna versión de Ubuntu.

Para controlar los pines vamos a instalar lgpio. En una terminal pega lo siguiente:

sudo apt install python3-rpi-lgpio python3-lgpio liblgpio1 liblgpio-dev

Tambien agrega tu usuario al grupo dialout

sudo usermod -a -G dialout tu_usuario

Con esto ya puedes ejecutar el script de Python que necesitas para controlar el ventilador de tu cpu.

Sigue en Ventilador para Raspberry Pi 4 y aprende como refrigerar tu Raspberry Pi 4

El otro día, visitando la web de meneame.net, ví un artículo sobre, «LaLiga recibe la peor noticia. Cloudflare ha reactivado ECH a lo grande y eso hace las webs imbloqueables«, y claro, me puse triste por Laliga y me fuí a llorar a un ricón.

La vuelta de ECH (Encrypted Client Hello) es una muy mala noticia para las operadoras, administración y entidades de gestión de derechos, ya que les hace inviable meter el hocico en el tráfico generado por los usuarios. A las operadoras les complica la gestión de los recursos de su red y al resto de entidades les deja sin posibilidad de hacer efectivas las órdenes de bloqueo, que en su mayoría están respaldadas por órganos judiciales.

DNS over HTTPS es una mejora importante en términos de privacidad ya que los gobiernos y/o ISP no podrán aplicar restricciones ni filtrar el contenido que visitan los ciudadanos. Por este motivo algunos gobiernos, como el británico, están haciendo todo lo posible para que no se adopte este protocolo.

A partir de aquí haz un minuto de silencio por tu operadora, entidad de gestión de derechos de autor, gobierno corrupto de tu país (sea cual se al tuyo) etc etc

Pi-hole.

Obviamente tendremos que tener instalado y configurado Pi-hole en nuestra Raspberry Pi.

Para configurar Pi-Hole puedes seguir las instrucciones que encontrarás en el siguiente enlace: Que hacer déspues de instalar pi-hole

Instalar y configurar DNS OVER HTTPS en Raspberry.

Si activamos DNS OVER HTTPS en un navegador, como por ejemplo Firefox o Chrome, únicamente tendremos DNS over HTTPS en el navegador, pero si queremos disponer de DNS sobre HTTPS en la totalidad de nuestras peticiones, recomiendo instalar el cliente DNS de Cloudflare en una Raspberry Pi. De este modo la Raspberry Pi actuará como cliente DNS de la totalidad de equipos que configuremos en nuestra red local.

Instalar el demonio Cloudflared en la Raspberry Pi

Cloudflared será el encargado de resolver la totalidad de peticiones DNS sobre HTTPS. El cliente está disponible para Windows, MacOS y Linux. En nuestro caso, será Linux y lo instalaremos en una Raspberry Pi del siguiente modo.

Ve a la web de desarrolladores de Cloudflare y elige el tipo de paquete y arquitectura que vas a usar en la instalación. Cloudflare Docs

Si no tienes claro que paquete usar y la arquitectura de tu Raspberry Pi, te recomiendo añadir el repositorio e instalar desde ahí, así la instalación escogerá el paquete adecuado para tu equipo.

Instalación desde repositorio

Aquí te dejo las instrucciones para Debian 12 Bookworm.

Cloudflare Package Repository

Abre una terminal y ve ejecutando las siguientes líneas.

Nota: En el primer apartado (# Add cloudflare gpg key) no veo necesario crear la carpeta keyrings y aplicarle los permisos 0755 ya que la carpeta ya está creada en el sistema y tiene esos mismos permisos. Compruébalo antes y si es así, empieza por donde dice curl – …… (te resalto en negrita las líneas que he usado yo)

Debian Bookworm

# Add cloudflare gpg key
sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null

# Add this repo to your apt repositories
echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared bookworm main' | sudo tee /etc/apt/sources.list.d/cloudflared.list

# install cloudflared
sudo apt-get update && sudo apt-get install cloudflared

Una vez que está instalado sin errores, comprueba la versión que tienes instalada.

cloudflared -v

En mi caso el resultado obtenido ha sido el siguiente:

cloudflared version 2024.9.1 (built 2024-09-10-1730 UTC)

Crear un usuario para Cloudflared

Crearemos un usuario con nombre cloudflared. El usuario no tendrá partición home ni tendrá acceso a la Shell de Linux. Para ello ejecutaremos el siguiente comando en la terminal:

sudo useradd -s /usr/sbin/nologin -r -M cloudflared

Configurar el demonio Cloudflared DNS

El siguiente paso consistirá en generar el archivo de configuración de Cloudflared. Para ello ejecutamos el siguiente comando en la terminal:

sudo nano /etc/default/cloudflared

Una vez se abra el editor de textos nano pegaremos el siguiente código:

# Commandline args for cloudflared
CLOUDFLARED_OPTS=--port 5053 --upstream https://1.1.1.1/dns-query --upstream https://1.0.0.1/dns-query

Seguidamente tendremos que guardar los cambios realizados y cerrar el fichero. En el fichero de configuración hemos definido que tendremos un proxy local escuchando en el puerto 5053. Todas las peticiones DNS se dirigirán al puerto 5053 y serán resueltas por los servidores DNS de Cloudflare mediante protocolo DNS over HTTPS.

Finalmente cambiaremos de usuario y grupo al archivo binario y al archivo de configuración de Cloudflared. Para ello ejecutaremos los siguientes comandos en la terminal:

sudo chown cloudflared:cloudflared /etc/default/cloudflared

sudo chown cloudflared:cloudflared /usr/local/bin/cloudflared

Crear un servicio de Systemd para Cloudflare

Para gestionar el servicio Cloudflare deberemos crear un servicio de systemd. Para ello ejecutaremos el siguiente comando en la terminal:

sudo nano /lib/systemd/system/cloudflared.service

Cuando se abra el editor de texto nano pegaremos el siguiente código:

[Unit]
Description=cloudflared DNS over HTTPS proxy
After=syslog.target network-online.target

[Service]
Type=simple
User=cloudflared
EnvironmentFile=/etc/default/cloudflared
ExecStart=/usr/local/bin/cloudflared proxy-dns $CLOUDFLARED_OPTS
Restart=on-failure
RestartSec=10
KillMode=process

[Install]
WantedBy=multi-user.target

A continuación guardaremos los cambios y cerraremos el fichero.

Seguidamente ejecutaremos el siguiente comando para que Cloudflare se inicie de forma automática cada vez reiniciemos la Raspberry Pi.

sudo systemctl enable cloudflared

Finalmente arrancaremos el servicio ejecutando el siguiente comando en la terminal:

sudo systemctl start cloudflared

Para comprobar que el servicio se haya levantado de forma correcta puedes ejecutar el siguiente comando:

sudo systemctl status cloudflared

Verificar que Cloudflare está funcionando correctamente

Para comprobar que Cloudflare funciona de forma adecuada ejecutaremos el siguiente comando en la terminal:

dig @127.0.0.1 -p 5053 google.com

Si obtienes un resultado parecido al siguiente, puedes estar seguro que todo lo realizado hasta el momento funciona correctamente.

Configurar Pi-Hole para que pueda usar DNS over HTTPS

Para que Pi-hole pueda utilizar el cliente DNS over HTTPS de Cloudflare deberemos realizar lo siguiente:

1. Accedemos al panel de administración de Pi-hole.
2. Clicamos en la Opción Settings.
3. A continuación clicamos en la pestaña DNS.
4. Destildamos absolutamente todos los DNS que tengamos activados.
5. Tildamos el campo Custom 1 (IPv4) y en el mismo campo pegamos 127.0.0.1#5053

Finalmente presionamos en el botón SAVE para que se hagan efectivos los cambios.

CONCLUSIONES Y FUNCIONAMIENTO

Para ver si todo está correcto entra en esta página de cloudflare.

https://www.cloudflare.com/es-es/ssl/encrypted-sni/#results

Te llevará a la web de comprobación de resultados

Pincha sobre Comprobar mi navegador y el resultado tiene que dar como la siguiente imagen.

Los cuatro apartados DNS seguro, DNSSEC, TLS 1.3 y Secure SNI están marcados como favorables.

El funcionamiento de DNS over HTTPS supone una mejora importante en términos de seguridad ya que la totalidad de peticiones DNS están cifradas, por lo que nadie, excepto Cloudflare, tendrá acceso a tu historial de navegación. Y ahora dirás, -¡claro, es que Cloudflare si puede ver mis datos de navegación!- a lo que yo te responderé -¡claro y antes esto era el coño de la Bernarda, en el que cualquiera ( tu operadora, gobierno, entidades de gestión etc) si podían verlos!-

Cloudflare promete que no guardará ningún historial durante más de 24 horas y que no asociará la dirección IP a un origen. A pesar de esto, todo el mundo sabe que del dicho al hecho, hay un buen trecho. Fíjate en Telegram, que tampoco iba a ceder nuestros datos, y cuando a Pável Dúrov (El multimillonario que afirma no poseer propiedades de lujo, aviones o yates) pero que le gusta viajar más que a un tonto un lápiz, a visto que se quedaba en tierra ……………. ¡a cantado la traviata!

Misceláneas

Este documento se ha realizado a través de los siguientes articulos

https://www.flopy.es/dns-sobre-https-doh/

https://geekland.eu/dns-over-https-doh-pi-hole/

Te recomiendo estos articulos

https://bandaancha.eu/articulos/laliga-recibe-peor-noticia-cloudflare-11098

https://bandaancha.eu/articulos/como-activar-ech-chrome-acceder-webs-10689

Existe un nueva entrada actualizada, puedes verla aquí

Raspberry Pi 4 tiene una conexión para ventilador configurada de fábrica al PIN 8 (GPIO 14) que se activa a partir de 60ºC. Aunque el fabricante nos dice que ese rango de temperaturas es correcto, a mi me parece demasiado alto. Por ello he creado un script en Python con el cual podemos decir a qué temperatura queremos poner en marcha el ventilador.

Necesitamos un ventilador de 3 pines, que cuente con un cable rojo 5V positivo, negro para negativo y azul para el control de velocidad.

El funcionamiento es simple, rojo y negro se conectan a 5 voltios de la Raspberry y azul a un pin de nuestra elección para activar o desactivar el ventilador.

En este script, conectaremos el cable azul al pin 18, al cual daremos valor HIGH o LOW, dependiendo de los valores de temperatura que asignemos.

Este tipo de ventilador usa el modo PWM o ancho de pulso para regular el voltaje y así la velocidad de rotación del ventilador, pero eso lo veremos en otro script.

La ejecución del programa es la siguiente:

• Temperatura igual o superior a 45 grados activa el ventilador.
• Entre 44 y 39 grados el ventilador se mantiene activo.
• El ventilador se para al bajar de 39 grados.
• El ventilador se mantiene apagado hasta que la temperatura sea igual o superior a 45 grados.

Eres libre de usar el rango de temperaturas que más te interesen, modifica los valores en el programa.

Este script espera a ejecutar el bucle cada 5 segundos a fin de no cargar los núcleos del procesador y con ello subir artificialmente la temperatura.

Aquí tenemos el código.

#!/usr/bin/python3
# https://linuxete.duckdns.org/
# https://chapuboot.blogspot.com/
# Importa la librería de control de GPIO de la Raspberry
import RPi.GPIO as GPIO

# Importa  la función sleep del módulo time
import time 

#Desactivar advertencias (warnings)
GPIO.setwarnings(False)

#Modo de identificación de GPIO
GPIO.setmode(GPIO.BOARD)

# Configurar pin 18 como salida
GPIO.setup(18, GPIO.OUT)

# Inicializamos pin 18 apagado con False, con True el programa inicia con el ventilador en marcha hasta meterse en el bucle While.
GPIO.output(18, False)

# Función Lectura de temperatura
def get_cpu_temp():
    temperatura = open( "/sys/class/thermal/thermal_zone0/temp" )
    cpu_temp = temperatura.read()
    temperatura.close()
    return float(cpu_temp)/1000

#bucle infinito
while True:
    time.sleep(5) #espera a ejecutar el bucle cada 5 segundos.
    print(get_cpu_temp())
    if get_cpu_temp() >= 45:
        GPIO.output(18, GPIO.HIGH)
    elif get_cpu_temp() <= 44 and get_cpu_temp() >= 40:
        continue
    elif get_cpu_temp() < 39:
        GPIO.output(18, GPIO.LOW)
      

Abre una terminal y escribe:

nano ventilador.py

Copia, pega el código anterior y guarda pulsando las teclas Crtl + o y sal con Crtl + x

Ahora, dale permisos de ejecución con:

chmod +x ventilador.py

Programa la ejecución del programa al inicio con cron, escribe en la terminal:

crontab -e

Al final del texto, pega el siguiente código:

@reboot /usr/bin/python3 /home/tu_usuario/ventilador.py

Sustituye «tu_usuario» por el tuyo propio.

Guarda con Crtl + o y cierra con Ctrl +x

Ahora cada vez que se encienda tu Raspberry el programa se ejecutará al inicio.

Ventiladores disponibles 40 mm y 3 pines

• GeeekPi 2PCS Raspberry Pi 4 PWM Controllable
• Tiendatec
• Ventilador PWM, 5V, 3 pines, 40 mm
• GeeekPi Raspberry Pi Cooling Fan el que estoy usando en mi Raspberry.

Esquema de los pines GPIO

Comprueba que funciona y mantén tu Raspberry mas fresca que una lechuga.

Vamos a ver cómo habilitar la funcionalidad del botón de encendido en la Raspberry Pi 4

Conecta los dos pines del pulsador en PIN 5 (GPIO 3) y 6 (masa) – la polaridad es irrelevante.

En este momento estoy usando como sistema operativo MX-23.2_rpi_respin basada en Debian 12, ya que me parece más estable que la última versión oficial de Raspberry Pi Os, también basada en Debian 12.

A continuación, abre el archivo /boot/firmware/config.txt con cualquier editor de texto, si usas la versión oficial puede ser que varíe la ubicación de ese archivo.

sudo nano /boot/firmware/config.txt

Añade la siguiente línea en la parte inferior:

dtoverlay=gpio-shutdown

Reinicia tu Raspberry Pi 4 y ¡listo!

¡Ahora al pulsar el botón, si nuestra Pi está encendida, se apagará y si estaba apagada, se encenderá!