Tutorial: Ventilador de velocidad variable para Raspberry controlador por temperatura

¿Quieres, como yo, reducir el ruido del ventilador de la Raspberry Pi (o incluso eliminarlo)? Si es así, aquí te traigo la solución definitiva a nuestros problemas de ruido: el ventilador de velocidad variable para Raspberry Pi. Una solución fácil y barata (un par de euros).

Siguiendo este tutorial, vas a poder construir, con muy pocos componentes, un pequeño controlador para que la Raspberry Pi regule la velocidad de su ventilador dependiendo de su temperatura y lo completaremos con un pequeño programa en Python que haga el trabajo de supervisión y control.

Tengo varias Raspberry Pi funcionando en casa para diferentes tareas. Son dispositivos pequeños, con poco consumo de energía y muy estables en su funcionamiento (pueden estar meses funcionando continuamente sin necesitar un reinicio).

He utilizado la Raspberry Pi original (la v1), la Raspberry Pi 2, la Raspberry Pi 3 y sus versiones «intermedias (con la «B» o el «+» añadidas) y la temperatura nunca ha sido un problema. Todas han funcionado estupendamente durante años sin problemas de calor.

La última que añadí, una Raspberry Pi 4, tiene mucha más potencia y rendimiento que las anteriores y eso conlleva que tenga unos requerimientos de refrigeración muy por encima de sus antecesoras. ¿Se puede usar una Raspberry Pi 4 sin ventilador? Si, pero no es recomendable hacer funcionar una Raspberry Pi 4 sin un ventilador que la refrigere.

Se supone que si ponemos una Raspberry Pi 4 es porque necesitamos su potencia en algunos momentos (si no, ¿para qué usar una Raspberry Pi 4?, mejor poner uno de los modelos anteriores, que son más baratos y consumen menos) y en este caso dorarla de un ventilador de refrigeración es casi imprescindible.

La desventaja de añadir un ventilador a la Raspberry Pi 4 es que deja de ser un dispositivo 100% silencioso para convertirse en una pequeña molestia (sobre todo en un dormitorio o despacho silencioso).

¿Cuánto ruido hace una Raspberry Pi 4?

La Raspberry Pi 4 en sí, no hace ruido, no tiene partes móviles, lo que hace ruido es su ventilador…

El nivel de ruido de un ventilador de 5V para una Raspberry Pi 4 puede variar según el modelo y la marca del ventilador, así como su diseño y calidad de construcción. Sin embargo, en general, los ventiladores pequeños de 5V tienden a ser bastante silenciosos, sobre todo si los alimentamos a 3.3V (si, ventiladores de 5V alimentados a 3.3V para que giren más despacio y hagan menos ruido).

El nivel de ruido de un ventilador generalmente se mide en decibelios (dB), y los ventiladores pequeños de 5V diseñados para Raspberry Pi a menudo tienen un nivel de ruido de alrededor de 20 a 30 dB. Esto es relativamente silencioso y no debería ser molesto en la mayoría de las situaciones.

Es importante tener en cuenta que existen algunos factores que pueden influir en el nivel de ruido, como la velocidad a la que funcione el ventilador y la calidad del rodamiento del mismo. Si necesitas un funcionamiento especialmente silencioso, puedes optar por ventiladores con rodamientos de alta calidad, como los rodamientos de fluido o los rodamientos de bolas, que tienden a generar menos ruido que los rodamientos más simples.

En cualquier caso, si el ruido es una preocupación para ti, puedes buscar ventiladores diseñados específicamente para aplicaciones de bajo ruido o aquellos con opciones de control de velocidad para ajustar la velocidad del ventilador según sea necesario, lo que puede ayudarte a mantener un equilibrio entre la temperatura y el ruido.

Teniendo en cuenta todo lo anterior, podemos decir que el ruido del ventilador de una Raspberry Pi 4, una vez que hemos elegido el ventilador (mejor o peor, de mayor o menor calidad) y lo hemos conectado, siempre girará a la misma velocidad, refrigerará de la misma forma y hará el mismo ruido.

Si queremos reducir el ruido, aprovechando el ventilador esté siempre funcionando al máximo (de hecho, ni siquiera necesitamos que el ventilador esté siembre funcionando) la solución está en tener un ventilador velocidad variable para Raspberry Pi.

¿Por qué debería poner un ventilador a una Raspberry Pi 4?

Es bueno poner un ventilador en una Raspberry Pi 4 u otros dispositivos electrónicos similares por varias razones:

1. Refrigeración: La Raspberry Pi 4 puede generar calor, especialmente cuando se ejecutan aplicaciones intensivas en términos de CPU o GPU. Un ventilador ayuda a disipar ese calor de manera más eficiente, lo que evita que la temperatura del dispositivo aumente demasiado. Un funcionamiento a temperaturas más bajas puede ayudar a prevenir el sobrecalentamiento, lo que puede afectar negativamente el rendimiento y la vida útil de la Raspberry Pi.
2. Mayor rendimiento y estabilidad: Mantener la temperatura de la CPU y otros componentes a una temperatura más baja puede permitir que la Raspberry Pi funcione de manera más constante y sin ralentizaciones causadas por el sobrecalentamiento.
3. Prevención de daños: El calor excesivo puede dañar los componentes electrónicos con el tiempo. Un ventilador puede prolongar la vida útil de la Raspberry Pi y prevenir daños a largo plazo.
4. Rendimiento constante en cargas de trabajo intensivas: Si planeas utilizar tu Raspberry Pi para tareas intensivas, como emulación de videojuegos, aprendizaje automático o transcodificación de video, un ventilador puede ser esencial para mantener un rendimiento constante y evitar el estrangulamiento térmico.
5. Reducción de la velocidad del ventilador y el ruido: No necesitas que el ventilador esté siempre a máxima velocidad. Puedes configurar el ventilador para que funcione solo cuando la temperatura alcance cierto umbral, lo que ayuda a reducir el ruido y el consumo de energía.

Todo lo anterior confirma lo que sospechábamos, poner un ventilador en una Raspberry Pi 4 es una buena idea si planeas utilizarla en tareas que generen calor o en entornos donde la temperatura ambiente sea alta. Ayudará a mantener la Raspberry Pi funcionando de manera eficiente y prolongará su vida útil al mantener las temperaturas bajo control.

Y ya que ponemos un ventilador, mejor que pongamos un ventilador velocidad variable para Raspberry Pi.

¿Cuál es el ventilador para Raspberry Pi 4 más silencioso?

Te puedo decir, sin temor a equivocarme, que el ventilador más silencioso es el ventilador apagado.

Podemos poner ventiladores de mejor calidad, a menor voltaje, de rodamientos de grafeno o Kryptonita, pero todos, sin excepción, hacen ruido.

Si queremos que un ventilador no haga ruido, lo mejor es apagarlo cuando no es necesario y ponerlo a la mínima velocidad que permita tener la temperatura de la Raspberry Pi 4 bajo control (tampoco es necesario que esté siempre «lo más fría posible«).

Ahora bien, si tengo algo que comentarte: Por regla general los ventiladores para Raspberry 4 son muy pequeños (lo normal es que sean de 40mm) y esto significa que, para que den una cantidad de aire importante tienen que girar muy deprisa.

Para mover la misma cantidad de aire, un ventilador más pequeño (como uno de 40 mm) debe girar aproximadamente 9 veces más rápido que un ventilador más grande (como uno de 120 mm).

La relación de velocidad se calcula de la siguiente manera:

Donde:

• D_{ventilador grande}​ es el diámetro del ventilador grande (en este caso, 120 mm).
• D_{ventilador pequeño}​ es el diámetro del ventilador pequeño (en este caso, 40 mm).

Si sustituimos los valores en la fórmula:

En resumen, si queremos tener el ventilador más silencioso posible, deberíamos fijarnos en:

1. Apagar el ventilador cuando no sea necesario
2. Ajustar la velocidad del ventilador al mínimo necesario en cada momento
3. Montar el ventilador más grande que nos sea posible

El ventilador para la Raspberry Pi 4

Para nuestro ventilador de velocidad variable vamos a utilizar un pequeño ventilador de corriente continua de 5V (si tienes curiosidad, puedes ver pulsando aquí los diferentes tipos de ventilador que podemos usar en una Raspberry).

Se trata de un ventilador simple que lo único que tiene es un motor de motor de corriente continua que mueve las aspas. En este caso, su velocidad dependerá el voltaje con el que lo alimentamos.

Tiene solamente dos cables, el positivo y el negativo de alimentación (que, por cierto, puedes conectar al revés y el ventilador girará en sentido contrario).

Comprar en Amazon

Si quieres más detalles sobre por qué he elegido este tipo de ventilador, por qué he decidido variar su velocidad mediante PWM y muchos más detalles sobre el control de velocidad de ventiladores mediante PWM, el siguiente artículo del blog te gustará:

Aunque no es obligatorio leer este artículo, es interesante que lo hagas, ya que sienta las bases para lo que vamos a ver a continuación.

Si ves que te pierdes en las siguientes explicaciones, vuelve aquí y lee el artículo «Controlar la velocidad de un ventilador con PWM«.

¿Como vamos a regular la velocidad del ventilador de la Raspberry Pi 4?

Lo vamos a hacer generando una señal PWM y amplificándola, con un pequeño circuito, ya que la Raspberry Pi no puede suministrar directamente una señal PWM con la energía necesaria para mover un ventilador.

Para ello vamos a escribir un pequeño programa en Python que genere una señal de PWM que tenga un Ciclo de trabajo variable en función de lo rápido que necesite que gire el ventilador para refrigerar la Raspberry Pi 4.

Haremos que la Raspberry Pi 4 ejecute este programa automáticamente y que cada 15 segundos (configurable) el programa modifique, si es necesario, la señal PWM para subir o bajar la velocidad del ventilador.

Este programa tendrá un valor mínimo de Ciclo de trabajo de la señal PWM para asegurarnos de que el ventilador siempre se mueva y que nunca se bloquee por no tener energía suficiente para vencer la inercia y empezar a moverse.

Además, vamos a escribir un pequeño programa auxiliar que nos permitirá averiguar cuál es el Ciclo de trabajo mínimo para que el ventilador arranque y cuál es el Ciclo de trabajo mínimo para que el ventilador no se pare, una vez que está en movimiento (ambos Ciclos de trabajo no tienen por qué ser iguales, y no lo serán).

Para nuestra señal PWM vamos a utilizar los siguientes parámetros:

• Amplitud: 3.3V
• Ciclo de trabajo: Irá desde el mínimo que permita que el ventilador arranque (o no se pare, si ya está en movimiento) hasta el 100%.
• Frecuencia: 25Khz

Solo con alimentar el ventilador con esta señal PWM, en vez de conectarlo directamente a 5V (o 3.3V), tendremos un ventilador velocidad variable en la Raspberry Pi.

El circuito electrónico de amplificación de señal PWM

El consumo normal de los pequeños ventiladores de 5V de 40x40mm es de aproximadamente 150mA.

La Raspberry Pi solamente puede proporcionar de manera segura 16mA, según la documentación oficial de la Raspberry Pi (y 50mA simultáneos, sumando todos sus pines).

Vamos a añadir a nuestra Raspberry Pi 4 un circuito electrónico muy sencillo, con un transistor que, con esa pequeña señal de control, de intensidad limitada, sea capaz de generar una señal igual pero que pueda llegar a un mínimo de 200 o 300mA.

Este tipo de circuitos se suelen llamar «drivers».

Hay dos formas principales de hacerlo (muy similares) y te voy a dejar las dos, para que elijas la que prefieras (aunque mi recomendación es que utilices la versión con MOSFET).

Driver PWM con transistor BJT

Este es el esquema de nuestro driver con transistor BJT:

Salvo que ya tengas los componentes (especialmente el transistor BJT), te recomiendo que construyas el driver PWM con transistor MOSFET que te dejo a continuación.

Este es el prototipo del driver con transistor BJT que construí para hacer las pruebas.

Como ves, la placa está muy sucia (digamos que está muy «trabajada»), debido al gran número de pruebas que hice con diferentes variaciones:

Transistores diferentes en configuración high-side y low-side, diferentes valores de resistencias, muchas mediciones, etc…

Aun utilizando componentes normales «through hole» (no de montaje en superficie), como ves quedó un tamaño muy compacto, para poderlo meter dentro de la caja de la Raspberry Pi 4.

En el siguiente artículo tienes toda la información sobre el driver PWM con transistor BJT:

Driver PWM con transistor MOSFET

Este es el tipo de driver que te recomiendo construir. Entre otras ventajas, su funcionamiento es más eficiente que el driver con transistor BJT y se calienta menos.

Este es el esquema de nuestro driver de señal PWM con transistor MOSFET:

Como ves es muy parecido al driver con transistor BJT que vimos antes.

En el siguiente artículo tienes toda la información sobre el driver PWM con transistor BJT:

El software de control del ventilador velocidad variable para la Raspberry Pi 4

Estoy trabajando en el software.

Esta es la parte del artículo donde más trabajo queda, lo que hay es un trabajo en proceso.

De momento, te dejo algo preliminar para que vayas abriendo boca, comprendas su funcionamiento y veas lo sencillo que es. Nada del código que veas a continuación te aseguro que sea el definitivo.

Ten en cuenta que hasta que lo publique puede haber cambios (y los habrá).

Aunque lo que vamos a hacer es muy sencillo y no debería causar ningún problema, el riesgo siempre está ahí, por lo que te recomiendo que hagas una copia de seguridad completa del contenido de tu Raspberry Pi 4 (te sugiero que, directamente, clones tu tarjeta Micro SD antes de tocar nada).

Generación de una señal PWM con la Raspberry Pi 4

Inicialmente, hice todo este proyecto con la biblioteca RPi.GPIO (que es la recomendada, y con la que lo hace el 99% de gente en internet) y notaba ciertos ruidos en el ventilador.

Atribuía los ruidos y la poca suavidad en el funcionamiento a que no era un ventilador de buena calidad, pero, haciendo pruebas con el osciloscopio, vi que algo no estaba bien…

La señal PWM generada era horrorosa, llena de ruido, en una frecuencia que no era la que yo había establecido y tanto los valores de frecuencia como de ciclo de trabajo eran muy inestables.

Lo más curioso era que el sistema funcionaba y si no hubiera hecho pruebas a fondo con el osciloscopio nunca habría sabido lo mal que estaba resultando. Seguramente hay millones de sistemas como este ‘funcionando’ en el mundo sin saber los problemas que tienen.

Me puse a investigar y encontré que la biblioteca RPi.GPIO no genera las señales PWM por hardware, sino por software (aunque utilices un pin hardware), y lo peor, es que tiene problemas con las señales de más de unos pocos kilohercios.

Utilizando una señal PWM con una frecuencia de 1Khz, por ejemplo, el sistema funcionaba, pero el ventilador hacía un ruido, perfectamente audible, que era peor que tenerlo funcionando a plena potencia.

Una desventaja adicional importante es que cuando la señal PWM se genera por software, es la CPU de la Raspberry Pi la que hace todo el trabajo (y es mucho, porque tiene que estar continuamente atendiendo y activando y desactivando el pin) con lo que el consumo de CPU puede ser alto.

Sigo documentando todo esto, haciendo pruebas, escribiendo y grabando videos para podértelo explicar bien. En breve incluiré la información.

La solución estaba en utilizar otra biblioteca, en lugar de la RPi.GPIO. Una que soporte PWM por hardware.

Hay algunos proyectos (los que menos) que utilizan algún tipo de control PWM por hardware, pero la mayoría tienen problemas o limitaciones.

• Se basan en proyectos obsoletos, o que por debajo los utilizan, o sin soporte como wiringPi
• Necesitan un demonio corriendo (como pigpio), lo que complica la instalación y arquitectura

Generación de una señal hardware PWM con la Raspberry Pi 4

Puedes generar una señal PWM en un pin de una Raspberry Pi 4, de una forma muy fácil, utilizando Python y la biblioteca ‘rpi-hardware-pwm‘.

Lo primero es preparar la Raspberry Pi para que sea capaz de utilizar los dos canales PWM hardware de los que dispone.

Tienes que editar el fichero /boot/config.txt e incluir la línea dtoverlay=pwm-2chan

Para ello, desde la consola ejecuta:

sudo nano /boot/config.txt

Y tras la última línea que empiece por dtoverlay (que posiblemente esté comentada, con una almohadilla ‘#’), incluye la línea:

dtoverlay=pwm-2chan

Esto habilitará el PWM por hardware en los GPIO por defecto: GPIO_18 para PWM0 y GPIO_19 para PWM1.

Si quieres, puedes utilizar (en vez de la línea anterior), la línea:

dtoverlay=pwm-2chan,pin=12,func=4,pin2=13,func2=4

Esto habilitará el PWM por hardware en los GPIO alternativos: GPIO_12 para PWM0 y GPIO_13 para PWM1.

Ahora reinicia la Raspberry Pi, para que los cambios tengan efecto, con:

sudo reboot

Cuando vuelva a arrancar la Raspberry Pi, entra de nuevo en la consola e instala la biblioteca rpi-hardware-pwm con:

sudo apt-get update
sudo apt-get install rpi-hardware-pwm

Programa de prueba y calibración de la señal PWM para el ventilador concreto

La Raspberry Pi ya está preparada para generar una señal PWM por hardware.

Ahora necesitamos un software, que nos permita hacer dos cosas:

• Probar de una forma fácil que, efectivamente, funciona.
• Averiguar los ciclos de trabajo mínimos para que nuestro ventilador concreto (cada uno es diferente) no se pare.

Para ello he creado un programa muy sencillo que nos permite llamarlo con tres parámetros en la línea de comandos de la Raspberry Pi:

1. Un 0 para utilizar el canal PWM0 en GPIO_18 PWM0 y PWM1 en GPIO_19 (o PWM0 en GPIO_12 PWM0 y PWM1 en GPIO_13, si has elegido los pines alternativos en el fichero /boot/config.txt.
2. La frecuencia en hertzios. Por ejemplo, 25000 para 25Khz.
3. El ciclo de trabajo (un número entre 0 y 100).

Para salir y detener el PWM, solo tienes que pulsar [Enter].

También puedes interrumpir y salir del programa con Ctrl-C. En este caso la señal PWM no se detendrá.

El código es el siguiente:

import sys
from rpi_hardware_pwm import HardwarePWM

def set_pwm(pin, frequency, duty_cycle):
    pwm = HardwarePWM(pin, frequency)
    pwm.start(duty_cycle)
    input("Presiona Enter para detener el PWM...")
    pwm.stop()

if __name__ == "__main__":
    if len(sys.argv) != 4:
        print("Uso: python pwm_generator.py <canal_pwm> <frecuencia> <ciclo_de_trabajo>")
        sys.exit(1)

    pin = int(sys.argv[1])
    frequency = float(sys.argv[2])
    duty_cycle = float(sys.argv[3])

    try:
        set_pwm(pin, frequency, duty_cycle)
    except KeyboardInterrupt:
        pass

Guarda este programa en un archivo llamado «pwm_generator.py».

Puedes ejecutar el programa con el siguiente comando:

python pwm_generator.py <canal_pwm> <frecuencia> <ciclo_de_trabajo>

Reemplaza:

• <canal_pwm> Por el canal PWM que quieres usar (0 o 1). Por ejemplo, un 0 para utilizar el canal PWM0 del GPIO_18.
• <frecuencia> Por la frecuencia en hertzios que quieres te tenga la señal PWM. Por ejemplo, 25000 para 25Khz.
• <ciclo_de_trabajo> por el ciclo de trabajo que quieres, por ejemplo, «50» para un ciclo de trabajo del 50%.

Por ejemplo, para generar en el canal 0 de PWM (PWM0) en el GPIO_18 una señal a 25Khz con un ciclo de trabajo del 75%, tienes que ejecutar en la consola:

python hardware_pwm_generator.py 0 25000 75

Lectura de la temperatura de la CPU de la Raspberry Pi

Vamos a ver qué tenemos que hacer para leer la temperatura de la CPU de la Raspberry Pi de una forma sencilla, para ir poco a poco y que sea entendible. Más adelante veremos como modificar la señal PWM en base a la temperatura.

Para leer la temperatura de la CPU de una Raspberry Pi puedes utilizar la biblioteca psutil.

Asegúrate de tener la biblioteca psutil instalada en tu Raspberry Pi. Puedes instalar psutil con el siguiente comando:

sudo apt-get update
sudo apt-get install psutil

Aquí tienes un programa simple en Python que utiliza la biblioteca psutil para leer la temperatura de la CPU y la imprime en la consola cada 5 segundos:

import psutil
import time

def get_cpu_temperature():
    try:
        temperature = psutil.sensors_temperatures()['coretemp'][0].current
        return temperature
    except Exception as e:
        print(f"Error al obtener la temperatura de la CPU: {e}")
        return None

def main():
    try:
        while True:
            temperature = get_cpu_temperature()

            if temperature is not None:
                print(f"Temperatura de la CPU: {temperature}°C")

            time.sleep(5)

    except KeyboardInterrupt:
        pass

if __name__ == "__main__":
    main()

Puedes escribirlo en el fichero temperature_reader.py (como hicimos antes con pwm_generator.py), con:

sudo nano temperature_reader.py

Diferentes versiones de Raspberry Pi y de Linux pueden llamar al sensor de temperatura con un nombre diferente a ‘coretemp’.

Si te da un error parecido a «Error al obtener la temperatura de la CPU: ‘coretemp’» seguramente sea porque tu sensor no se llama ‘coretemp’ y tendrás que averiguar su nombre.

Una vez sepas el nombre, tendrás que sustituir en la línea 6 el nombre ‘coretemp’ por el nombre de tu sensor.

Por ejemplo, tanto en la Raspberry Pi 3 con la que empecé a hacer las pruebas como en la Raspberry Pi, este sensor se llamaba ‘cpu_thermal’.

Puedes utilizar este pequeño código para averiguarlo imprimiendo la lista de todos los sensores disponibles para entender qué nombres están presentes en tu sistema:

import psutil
import time

def get_cpu_temperature():
    try:
        sensors_data = psutil.sensors_temperatures()
        if 'coretemp' in sensors_data:
            temperature = sensors_data['coretemp'][0].current
            return temperature
        else:
            print("No se encontraron datos del sensor 'coretemp'. Sensores disponibles:", sensors_data.keys())
            return None
    except Exception as e:
        print(f"Error al obtener la temperatura de la CPU: {e}")
        return None

def main():
    try:
        while True:
            temperature = get_cpu_temperature()

            if temperature is not None:
                print(f"Temperatura de la CPU: {temperature}°C")

            time.sleep(5)

    except KeyboardInterrupt:
        pass

if __name__ == "__main__":
    main()

Este script imprimirá la lista de sensores disponibles en tu sistema si no puede encontrar el sensor ‘coretemp’. Al ejecutar el script, podrás ver qué nombres de sensores están presentes, y podrás ajustar el código en consecuencia para leer la temperatura desde el sensor correcto.

Programa de lectura de la temperatura y ajuste de la velocidad del ventilador

Para leer la temperatura de la CPU de una Raspberry Pi 4 y generar una señal PWM con un ciclo de trabajo proporcional a la temperatura de la CPU, utilizaremos, como hemos visto antes, la biblioteca psutil para obtener la temperatura de la CPU y, de nuevo, la biblioteca rpi-hardware-pwm para generar la señal PWM. A continuación, te proporciono un programa que hace esto:

# Importar la biblioteca rpi-hardware-pwm
from rpi_hardware_pwm import HardwarePWM

# Importar la biblioteca psutil para leer la temperatura de la CPU
import psutil

# Importar la biblioteca time para usar la función sleep
import time

# Importar la biblioteca atexit para usar la función atexit
import atexit

# Definir el canal PWM que utilizaremos (El canal 0, o PWM0, por defecto está asignado a GPIO_18)
canal_pwm = 0

# Definir la frecuencia de trabajo en Hz
frecuencia = 25000

# Definir la temperatura mínima y máxima para activar la salida PWM en grados Celsius
temp_min = 45
temp_max = 60

# Definir el ciclo de trabajo mínimo y máximo en porcentaje
ciclo_min = 55
ciclo_max = 100

# Definir grados de histéresis
hysteresis = 2

# Define canal PWM y frecuencia
pwm = HardwarePWM(canal_pwm, frecuencia)

# Haz que al terminar el programa el ventilador se detenga
atexit.register(pwm.stop)

# Crear una variable para guardar el ciclo de trabajo anterior
ciclo_anterior = 0

# Crear una variable para guardar el tiempo transcurrido desde la última impresión de la temperatura
tiempo = 6

# Crear una variable para guardar el tiempo ciclo de trabajo
ciclo_de_trabajo = 0

# Crear una variable global para el modo de depuración
debug = True

# Crear una función para imprimir mensajes de depuración solo si el modo de depuración está activo
def print_debug(mensaje):
    # Si el modo de depuración es True, imprimir el mensaje en la consola
    if debug:
        print(mensaje)

# Definir una función para calcular el ciclo de trabajo proporcional a la temperatura
def calcular_ciclo_de_trabajo(temp, temp_min, temp_max, ciclo_min, ciclo_max, histeresis):
    # Si la temperatura es menor que la mínima, devolver 0
    if temp < temp_min:
        return 0
    # Si no, calcular el ciclo de trabajo usando una regla de tres
    else:
        # Si la temperatura es mayor que la mínima más los grados de histéresis, aplicar la fórmula
        if temp > (temp_min + histeresis):
            ciclo = (temp - temp_min) * (ciclo_max - ciclo_min) / (temp_max - temp_min) + ciclo_min
        # Si no, usar el ciclo mínimo
        else:
            ciclo = ciclo_min
        # Si el ciclo es mayor que 100, usar 100
        if ciclo > 100:
            ciclo = 100
        # Devolver el ciclo redondeado al entero más cercano
        return round(ciclo)

# Poner en marcha el generador PWM con un ciclo de trabajo del 0%
pwm.start(ciclo_de_trabajo)

# Crear un bucle infinito
while True:
    # Leer la temperatura de la CPU en grados Celsius
    temp =   psutil.sensors_temperatures()['cpu_thermal'][0].current

    # Calcular el ciclo de trabajo usando la función definida
    ciclo_de_trabajo = calcular_ciclo_de_trabajo(temp, temp_min, temp_max, ciclo_min, ciclo_max, histeresis)

    # Si han pasado más de 5 segundos desde la última impresión de la temperatura, imprimir la temperatura en la consola
    if tiempo >= 5:
        # print_debug(f"La temperatura de la CPU es {temp:.2f} °C. El ciclo de trabajo es de {ciclo_de_trabajo:.0f}%")
        # Reiniciar el tiempo transcurrido
        tiempo = 0
    # Si no, incrementar el tiempo transcurrido en 1 segundo
    else:
        tiempo += 1

    # Si ventilador arranca desde parado (el ciclo de trabajo anterior era 0 y el actual no lo es), iniciar con un ciclo del 100% durante 1 segundo para vencer la inercia
    if ciclo_anterior == 0 and ciclo_de_trabajo != 0:
        pwm.change_duty_cycle(100)
        print_debug(f"Arrancando ventilador... (temperatura {temp:.2f}ºC)")
        # print_debug(f"Cambiado ciclo de trabajo a {ciclo_de_trabajo}% (1)")
        # print_debug(f"Ciclo de trabajo anterior {ciclo_anterior}% (1)")
        time. Sleep(1)

    # Cambiar el ciclo de trabajo del PWM
    pwm.change_duty_cycle(ciclo_de_trabajo)
    ciclo_anterior = ciclo_de_trabajo
    print_debug(f"Temperatura: {temp:.2f}ºC. Ciclo de trabajo: {ciclo_de_trabajo:.0f}%")

    # Esperar 5 segundos antes de repetir el bucle
    time. Sleep(5)

Puedes grabar el programa en un fichero con nombre temperature_pwm_controller.py mediante:

sudo nano temperature_pwm_controller.py

Este programa lee la temperatura de la CPU cada 5 segundos y ajusta el ciclo de trabajo del PWM de acuerdo con la temperatura.

Hay varios parámetros que puedes ajustar según tus necesidades y preferencias.

• canal_pwm = 0: Te permite elegir el canal PWM que quieres utilizar.
• frecuencia = 25000: La frecuencia de la señal PWM. Ten en cuenta que una señal de una frecuencia más baja provocará un ruido audible que puede ser molesto.
• temp_min = 45: La temperatura por debajo de la cual el ventilador estará parado.
• temp_max = 60: La temperatura que no quieres que se sobrepase. A partir de esta temperatura el ciclo de trabajo de la señal PWM será del 100%.
• ciclo_min = 55: Ciclo de la señal PWM para tu ventilador y preferencias. No pongas una señal demasiado baja que pueda hacer que el ventilador no gire.
• ciclo_max = 100: El ciclo de trabajo máximo al que quieres que se genere la señal PWM.
• histeresis = 1: Para que el ventilador no esté continuamente parándose y poniéndose en marcha, este es el valor de «zona gris». La temperatura tendrá que variar más que este valor para que el ventilador cambie entre movimiento y parado.

Hacer que se inicie automáticamente al arrancar la Raspberry Pi 4

No tendría mucho sentido que cada vez que arrancásemos la Raspberry Pi tuviéramos que entrar en la consola y ejecutar un programa, de manera que lo vamos a automatizar.

Para que el script se ejecute automáticamente al arrancar la Raspberry Pi, hay varias formas de hacerlo.

Ejecución automática con systemctl

Para ejecutar un script de Python en el arranque de una Raspberry Pi utilizando systemd, puedes seguir estos pasos:

En este ejemplo el nombre del script es temperature_pwm_controller.py y la ruta completa donde está es /home/pi/:

1. Crea el script de Python:
   Asegúrate de tener un script de Python llamado temperature_pwm_controller.py en la ruta /home/pi/.
2. Asegúrate de que el script sea ejecutable:

   chmod +x /home/pi/temperature_pwm_controller.py

3. Crea un archivo de servicio para systemd:
   Crea un archivo de servicio en la ubicación /etc/systemd/system/. Puedes nombrarlo, por ejemplo, temperature_pwm_controller.service.

[Unit]
Description=Controlador de PWM basado en temperatura
After=multi-user.target

[Service]
Type=simple
ExecStartPre=/bin/sleep 30
ExecStart=/home/pi/temperature_pwm_controller.py

[Install]
WantedBy=multi-user.target

Asegúrate de reemplazar /home/pi/temperature_pwm_controller.py con la ruta completa de tu script de Python, si lo has modificado.

4. Recarga systemd:

   sudo systemctl daemon-reload

5. Habilita e inicia el servicio:

   sudo systemctl enable temperature_pwm_controller.service
   sudo systemctl start temperature_pwm_controller.service

6. Verifica el estado del servicio:

   sudo systemctl status temperature_pwm_controller.service

Puedes parar el servicio con:

   sudo systemctl stop temperature_pwm_controller.service

Puedes ejecutar el servicio con:

   sudo systemctl start temperature_pwm_controller.service

Estos pasos deberían configurar tu script temperature_pwm_controller.py para ejecutarse automáticamente en el arranque de tu Raspberry Pi utilizando systemd. Asegúrate de ajustar las rutas y nombres de archivo según tus necesidades específicas.

Ejecución automática con rc.local

Teóricamente de esta forma también es posible hacerlo, pero yo no he conseguido que me funcione bien con rc.local. Te lo dejo aquí solamente por si systemctl te da problemas, y quieres intentarlo de este modo, o por si ves el error y quieres dejar la solución en los comentarios.

El archivo rc.local, se ejecuta después de que se inician todos los servicios del sistema.

Para usar este método, tienes que editar el archivo rc.local y añadir el comando para ejecutar tu script antes de la línea “exit 0”. Por ejemplo, si tu script se llama temperature_pwm_controller.py y está en el directorio /home/pi, tendrías que poner algo así:

python3 /home/pi/temperature_pwm_controller.py &

Puedes editar el fichero rc.local con:

sudo nano /etc/rc.local

Fíjate en que no es necesario que ejecutemos el script cada quince segundos ya que realmente está siempre funcionando, realizando su trabajo cada 15 segundos.

Es importante mencionar que el uso de rc.local ha disminuido en sistemas más modernos, ya que muchas distribuciones de Linux han adoptado sistemas de inicio más avanzados como systemd. Sin embargo, aún es posible encontrar sistemas que utilicen rc.local, especialmente en entornos más antiguos o en configuraciones personalizadas.

Los últimos toques al código

Para finalizar el código y dejarlo redondo, si quieres puedes pulir algunos detalles.

Yo todavía no lo he implementado, lo haré cuando esté más estable, pero te lo dejo aquí, a modo de ideas, por si quieres implementarlo

Modo automático

Podemos incluir un parámetro, –on_pi_start, cuando llamemos al script desde systemctl para que el script lo sepa y funcione en modo ‘automático’: Cosas como deshabilitar el debug, si estaba activado, o poner un intervalo de prueba distinto.

python3 /home/pi/temperature_pwm_controller.py --on_pi_start

Para que el script sepa que se ha ejecutado de esta forma, podemos añadir al script las líneas:

# Comprobar si el programa se ha ejecutado en el arranque de la Raspberry Pi
if "--on_pi_start" in sys.argv:
    debug = False
else:
    atexit.register(pwm.stop)

He modificado además que atexit.register(pwm.stop) solo se ejecute en modo interactivo, deteniendo el ventilador al terminar el script.

Importaremos la biblioteca ‘sys’ para poder leer los argumentos que hemos pasado en la línea de comandos.

# Importar el módulo sys
import sys

Añadiendo información al log (syslog)

Como lo bien hecho bien parece, vamos a ser buenos convecinos con el sistema Linux y vamos a enviar al log de sistema (syslog) información sobre si el script ha arrancado correctamente o ha encontrado algún problema.

Tengo pendiente incluirlo en temperature_pwm_controller.py cuando esté más estable.

Para enviar al log esta información, vamos a usar el módulo syslog de Python, que te permite enviar mensajes al sistema usando la función syslog.syslog(priority, message). El argumento priority indica el nivel de severidad del mensaje, y el argumento message es el texto que quieres enviar.

Por ejemplo, puedes hacer algo así:

# Importar el módulo syslog
import syslog

# Intentar ejecutar el script
try:
    # Aquí va el código de tu script
    # Si todo va bien, enviar un mensaje de éxito a syslog con prioridad INFO
    syslog.syslog(syslog.LOG_INFO, "El script se ha ejecutado correctamente")
except Exception as e:
    # Si ocurre algún error, enviar un mensaje de error a syslog con prioridad ERR
    syslog.syslog(syslog.LOG_ERR, f"El script ha fallado con el error: {e}")

Así, podrás ver en el log de syslog si tu script se ha ejecutado correctamente o si ha habido algún problema.

Con esto tendremos un ventilador velocidad variable en la Raspberry Pi.

El código final (el script o programa que hace la magia)

#!/usr/bin/env python3

# Importar la biblioteca rpi-hardware-pwm
from rpi_hardware_pwm import HardwarePWM

# Importar la biblioteca psutil para leer la temperatura de la CPU
import psutil

# Importar la biblioteca time para usar la función sleep
import time

# Importar el módulo sys
import sys

# Importar la biblioteca atexit para usar la función atexit
import atexit


# Definir  en intervalo de prueba en segundos (cada cuantos segundos debe leer la temperatura y ajustar el ciclo de trabajo de la señal PWM)
intervalo_de_prueba = 10

# Definir el canal PWM que utilizaremos (El canal 0, o PWM0, por defecto está asignado a GPIO_18)
canal_pwm = 0

# Definir la frecuencia de trabajo en Hz
frecuencia = 25000

# Definir la temperatura mínima y máxima para activar la salida PWM en grados Celsius
temp_min = 50
temp_max = 65

# Definir el ciclo de trabajo mínimo y máximo en porcentaje
ciclo_min = 60
ciclo_max = 100

# Definir grados de histéresis
histeresis = 2

# Define canal PWM y frecuencia
pwm = HardwarePWM(canal_pwm, frecuencia)

# Haz que al terminar el programe el ventilador se detenga
# atexit.register(pwm.stop)

# Crear una variable para guardar el ciclo de trabajo anterior
ciclo_anterior = 0

# Crear una variable para guardar el tiempo transcurrido desde la última impresión de la temperatura
tiempo = 6

# Crear una variable para guardar el tiempo ciclo de trabajo
ciclo_de_trabajo = 0

# Crear una variable global para el modo de depuración
debug = True

# Crear una función para imprimir mensajes de depuración solo si el modo de depuración está activo
def print_debug(mensaje):
    # Si el modo de depuración es True, imprimir el mensaje en la consola
    if debug:
        print(mensaje)

# Definir una función para calcular el ciclo de trabajo proporcional a la temperatura
def calcular_ciclo_de_trabajo(temp, temp_min, temp_max, ciclo_min, ciclo_max, histeresis):
    # Si la temperatura es menor que la mínima, devolver 0
    if temp < temp_min:
        return 0
    # Si no, calcular el ciclo de trabajo usando una regla de tres
    else:
        # Si la temperatura es mayor que la mínima más los grados de histéresis, aplicar la fórmula
        if temp > (temp_min + histeresis):
            ciclo = (temp - temp_min) * (ciclo_max - ciclo_min) / (temp_max - temp_min) + ciclo_min
        # Si no, usar el ciclo mínimo
        else:
            ciclo = ciclo_min
        # Si el ciclo es mayor que 100, usar 100
        if ciclo > 100:
            ciclo = 100
        # Devolver el ciclo redondeado al entero más cercano
        return round(ciclo)

# Comprobar si el programa se ha ejecutado en el arranque de la Raspberry Pi
if "--on_pi_start" in sys.argv:
    debug = False    
else:
    atexit.register(pwm.stop)

# Poner en marcha el generador PWM con un ciclo de trabajo del 0%
pwm.start(100)
time.sleep(1)

# Crear un bucle infinito
while True:
    # Leer la temperatura de la CPU en grados Celsius
    temp =   psutil.sensors_temperatures()['cpu_thermal'][0].current

    # Calcular el ciclo de trabajo usando la función definida
    ciclo_de_trabajo = calcular_ciclo_de_trabajo(temp, temp_min, temp_max, ciclo_min, ciclo_max, histeresis)

    # Si han pasado más de 5 segundos desde la última impresión de la temperatura, imprimir la temperatura en la consola
    if tiempo >= 5:
        # print_debug(f"La temperatura de la CPU es {temp:.2f} °C. El ciclo de trabajo es de {ciclo_de_trabajo:.0f}%")
        # Reiniciar el tiempo transcurrido
        tiempo = 0
    # Si no, incrementar el tiempo transcurrido en 1 segundo
    else:
        tiempo += 1

    # Si el ventilador arranca desde parado (el ciclo de trabajo anterior era 0 y el actual no lo es), iniciar con un ciclo del 100% durante 1 segundo para vencer la inercia
    if ciclo_anterior == 0 and ciclo_de_trabajo != 0:
        pwm.change_duty_cycle(100)
        # pwm.start(100)
        print_debug(f"Arrancando ventilador... (temperatura {temp:.2f}ºC)")
        # print_debug(f"Cambiado ciclo de trabajo a {ciclo_de_trabajo}% (1)")
        # print_debug(f"Ciclo de trabajo anterior {ciclo_anterior}% (1)")
        time.sleep(1)

    # Cambiar el ciclo de trabajo del PWM
    pwm.change_duty_cycle(ciclo_de_trabajo)
    # pwm.start(ciclo_de_trabajo)
    ciclo_anterior = ciclo_de_trabajo
    print_debug(f"Temperatura: {temp:.2f}ºC. Ciclo de trabajo: {ciclo_de_trabajo:.0f}%")

    # Esperar los segundos que hayamos indicado como intervalo de prueba antes de repetir el bucle
    time.sleep(intervalo_de_prueba)

Conexión del driver PWM a la Raspberry Pi 4 y puesta en marcha

Ya tenemos todo lo necesario y podemos unir las piezas, hardware y software, y poner en marcha nuestro ventilador de velocidad variable para Raspberry Pi.

Elección del pin de la Raspberry Pi 4 al que vamos a conectar el driver.

Todos los pines de salida de la Raspberry Pi 4 pueden sacar una señal PWM, pero hay que tener en cuenta que no todos los pines son iguales, a la hora de generar una señal PWM.

• Pines PWM software: Generarán la señal por software. Será la CPU de la Raspberry Pi 4 la encargada de generar la señal y consumirá recursos de CPU, como cualquier otro programa.
• Pines PWM hardware: Generarán la señal por hardware. Será la CPU de la Raspberry Pi 4 solo tendrá que pedirle a uno de sus «generadores hardware PWM» que genere la señal deseada y podrá desentenderse. El hardware especializado en generar señales PWM se ocupará de su generación y la CPU no tendrá que hacer nada, por lo que no consumirá recursos de la CPU dejando toda su capacidad y potencia para otros programas.

Los pines 12/13 y 18/19 generan la señal PWM por hardware, mientras que todos los demás pines generan la señal PWM por software.

Te recomiendo que utilices uno de los pines 12/13 y 18/19, salvo que tengas un buen motivo para no hacerlo, como el siguiente:

El hardware PWM y el jack de auriculares utilizan los mismos circuitos de la Raspberry Pi, por lo que no podrás utilizarlos al mismo tiempo. Dicho de otra manera: si usas el jack de auriculares de la Raspberry Pi 4 tendrás que utilizar PWM por software, con todas sus limitaciones.

IMPORTANTE: Si no utilizas el pin 18, recuerda actualizar el código con el pin que hayas decidido utilizar. Estos ejemplos están preparados para utilizar el GPIO 18 (pin 12 en el puerto de expansión de la Raspberry Pi 4)

Calibración de la señal PWM para tu ventilador

Como vimos en detalle en el artículo «Controlar la velocidad de un ventilador con PWM«, y hemos recordado anteriormente, en este mismo artículo, cada ventilador responde de una forma diferente a las señales PWM.

Cada ventilador tiene un Ciclo de trabajo mínimo para que el ventilador empiece a girar desde que está parado. En unos ventiladores puede ser el 30% y en otros el 70% por lo que es necesario que lo pruebes tú mismo con tu ventilador.

Cada ventilador tiene también un Ciclo de trabajo mínimo para que no se detenga cuando ya está en movimiento. No podrás bajar el Ciclo de trabajo a, digamos, un 3%, esperando que así el ventilador funcione muy despacio. Con tan poca energía se parará mucho antes de bajar hasta ese 3%.

Para que te hagas a la idea, el ventilador con el que estoy haciendo las pruebas ahora mismo se para cuando el ciclo de trabajo baja a un 50%, aproximadamente.

Tienes que tener presente que ambos Ciclos de trabajo no tienen por qué ser iguales (y no lo serán).

El ventilador necesita más energía (un Ciclo de trabajo más alto) para vencer la resistencia para ponerse en marcha y necesitará menos energía para mantenerse en movimiento, una vez que ya lo está.

Todo lo anterior significa que tendrás que calibrar tu ventilador concreto para encontrar esos dos valores del Ciclo de trabajo.

Podrás calibrar tu ventilador fácilmente utilizando el «Programa básico» que te he dejado antes (puedes pichar aquí para ir a él).

Tendrás que, con el ventilador parado, ir ejecutando el programa varias veces, subiendo cada vez el Ciclo de trabajo, hasta que el ventilador se ponga en marcha. Una vez hayas encontrado ese «Ciclo de trabajo mínimo desde parado» puedes utilizar ese valor, aumentándolo un porcentaje como margen de seguridad (puedes probar con un 10%).

Luego, con el ventilador en marcha, tendrás ir ejecutando el programa varias veces, bajando cada vez el Ciclo de trabajo, hasta que el ventilador se detenga. Una vez hayas encontrado ese «Ciclo de trabajo mínimo desde en movimiento» puedes utilizar ese valor, aumentándolo un porcentaje como margen de seguridad (puedes probar con un 10%).

Control de velocidad super simple, sin software

La fundación Raspberry, sabiendo que la Raspberry Pi 4 necesitaría un ventilador, incluyó de forma nativa en su sistema operativo la posibilidad de activar su control mediante temperatura fácilmente desde uno de los menús de configuración de la Raspberry Pi.

Las posibilidades de control son bastante reducidas ya que solo se puede indicar una temperatura, por debajo de la cual el ventilador se parará y se pondrá en marcha de nuevo, al 100% de velocidad, al superarla. No incluye control de velocidad.

Es una funcionalidad simple, pero está disponible de forma nativa, sin tener que instalar ningún software adicional.

Ten en cuenta que, al no regular la velocidad, sino solamente encender y apagar el ventilador (0 o 100%) puede ser incluso más ruidoso que tener el ventilador a plena potencia si esos cambios se producen a menudo. Te recomiendo que lo pruebes para ver cómo resulta en tu caso particular.

¿Y si mi Raspberry Pi no es la 4, que pasa con otros modelos?

La Raspberry Pi 5 es demasiado nueva y aún no la he usado, por lo que no te podré decir mucho sobre ella, pero si he tenido todos los modelos anteriores a la 4 y te puedo hablar sobre ellos.

Puedo decirte que, en los modelos anteriores de Raspberry Pi, 1, 2 3 y sus variaciones, el consumo de energía es mucho más bajo que en la Raspberry Pi 4 y nunca he necesitado utilizar un ventilador y su temperatura siempre se ha mantenido dentro de limites muy razonables.

Aun así, si quieres o necesitas añadir el ventilador en alguno de esos modelos, no te será difícil.

El driver PWM es exactamente el mismo que he utilizado para la Raspberry Pi 4 y el software probablemente funcione tal cual, o con cambios mínimos.

Tola la investigación y el desarrollo lo ha hecho con una Raspberry Pi 3, solo cuando lo tenía terminado lo he instalado en la Raspberry Pi 4. El motivo es, simplemente, que la única Raspberry Pi 4 que tengo la tenía ocupada para cosas de la domótica de la casa, y no podía estar quitándola.

Si lo pruebas con otras versiones, te pido que dejes un mensaje en los comentarios y así podré actualizar el artículo con esa información.

De momento te puedo decir:

Raspberry Pi 4

Todavía no lo he probado, pero lo haré en breve. Realmente es el modelo al que va dirigido, principalmente.

Raspberry Pi 3

Es el modelo en el que he hecho la investigación y el desarrollo por lo que debería funcionar.

Raspberry Pi 2

Cuando esté terminado lo probaré en esta versión, aunque no tiene mucha utilidad porque no se calienta y no necesita ventilador.

No confundas hardware y software de tu Raspberry Pi

Lo que acabamos de ver es respecto al hardware de la Raspberry Pi, pero también el software puede ser diferente.

La versión concreta de sistema operativo que tenía instalada en la Raspberry Pi 3 era: «Raspbian GNU/Linux 11 (bullseye) armv71 (32bit) con user space de 32 bit.

El sistema operativo que tenía instalado en la Raspberry Pi 4 era: «Raspbian GNU/Linux 11 (bullseye) aarch64 (64bit) con user space de 32 bit.

Si has seguido el tutorial y encuentras algo diferente o que no te funciona no estaría de más de comprobaras tu versión.

Para ver la versión del sistema operativo instalada en tu Raspberry Pi, puedes utilizar el siguiente comando:

cat /etc/os-release

Este comando te mostrará el nombre y la versión del sistema operativo que se está ejecutando en tu dispositivo.

Si deseas saber si el sistema operativo es de 32 o 64 bits, puedes utilizar el siguiente comando:

uname -m

Este comando te mostrará la arquitectura del procesador de tu Raspberry Pi. Si la salida es armv7l, entonces estás utilizando un sistema operativo de 32 bits. Si la salida es aarch64, entonces estás utilizando un sistema operativo de 64 bits 12.

Para ver si el espacio de usuario de tu Raspberry Pi es de 32 o 64 bits, puedes utilizar el siguiente comando:

getconf LONG_BIT

Este comando te mostrará la arquitectura del procesador de tu Raspberry Pi. Si la salida es 32, entonces estás utilizando un espacio de usuario de 32 bits, si la salida es 64, entonces estás utilizando un espacio de usuario de 64 bits.

¿Y ahora qué?

En este artículo hemos visto lo que tenemos que hacer para controlar la velocidad del ventilador de la Raspberry Pi dependiendo de la temperatura de su CPU.

Si no lo has hecho, te sugiero que leas los siguientes artículos, donde se amplía la información sobre cada uno de los aspectos que hemos visto aquí, resumidos: