Raspberry Pi Pico: Atenuación de un LED mediante PWM (MicroPython)

Aprende a generar señales PWM con la Raspberry Pi Pico usando el firmware MicroPython. A modo de ejemplo, te mostraremos cómo atenuar el brillo de un LED modificando su ciclo de trabajo con el tiempo.

• Instalar y ejecutar MicroPython en Raspberry Pi Pico
• Presentamos PWM
• GPIO y PWM de Raspberry Pi Pico
• La clase machine.PWM
• Atenuación de un LED: script de MicroPython

Prerrequisitos

Para seguir este tutorial, necesitas tener instalado el firmware MicroPython en tu placa Raspberry Pi Pico. También necesitas un IDE para escribir y cargar el código en la placa.

El IDE de MicroPython recomendado para Raspberry Pi Pico es Thonny IDE. Sigue el siguiente tutorial para aprender a instalar Thonny IDE, instalar el firmware de MicroPython y cargar código en la placa.

• Programación de Raspberry Pi Pico con MicroPython

Introducción a PWM (modulación por ancho de pulso)

Lo logra encendiendo y apagando la alimentación muy rápidamente.

Por ejemplo, si alternas el voltaje de un LED entre ALTO y BAJO muy rápido, tus ojos no pueden seguir la velocidad a la que el LED se enciende y apaga; simplemente verás algunas gradaciones en el brillo.

Así es básicamente como funciona PWM: produciendo una salida que cambia entre ALTA y BAJA a una frecuencia muy alta.

El ciclo de trabajo se refiere al porcentaje de tiempo que la energía está encendida en comparación con el tiempo total del ciclo de encendido y apagado; observa el siguiente diagrama.

Al ajustar el ciclo de trabajo, podemos controlar la potencia promedio suministrada al dispositivo. Por ejemplo, un ciclo de trabajo más alto significa que el dispositivo recibe más potencia, mientras que un ciclo de trabajo más bajo resulta en menos potencia. Esto nos permite controlar aspectos como el brillo de los LED, la velocidad de los motores o el volumen de los altavoces.

Por ejemplo, un ciclo de trabajo del 50 % da como resultado un brillo del LED del 50 %, un ciclo de trabajo de 0 significa que el LED está completamente apagado y un ciclo de trabajo de 100 significa que está completamente encendido. Al cambiar el ciclo de trabajo se obtienen diferentes niveles de brillo.

GPIO de Raspberry Pi Pico

La Raspberry Pi Pico incluye 40 pines, 26 de los cuales son GPIO programables que permiten conectar periféricos. Todos los GPIO de la Raspberry Pi Pico pueden emitir señales PWM; están marcados en verde claro en los diagramas.

Puedes usar la siguiente distribución de pines como referencia para identificar y localizar cada GPIO en su placa. La distribución de pines es ligeramente diferente para Pico y Pico W.

La siguiente imagen muestra la distribución de pines del Raspberry Pi Pico (qué funciones admite cada pin).

Los pines marcados en rojo son de alimentación y tienen una salida de 3,3 V. Los pines negros son de tierra. Todos los pines en verde claro se pueden usar como GPIO (entrada y salida) normales.

Raspberry Pi Pico – Canales PWM

La Raspberry Pi Pico cuenta con 

 llamados segmentos. Cada segmento tiene dos canales, lo que suma un total de 

 .

La frecuencia de la señal PWM puede oscilar entre 8 Hz y 62,5 MHz, mientras que el microcontrolador funciona a una frecuencia de 125 MHz.

Dos canales del mismo segmento funcionan a la misma frecuencia, pero pueden tener una velocidad de trabajo diferente

La clase machine.PWM

Para manejar señales PWM con la Raspberry Pi Pico usando MicroPython, utiliza la clase machine.PWM.
Después de crear un objeto PWM, llamado por ejemplo led_pwm:

led_pwm = PWM(Pin(20))

Puedes usar los siguientes métodos:

• led_pwm.freq(FREQUENCY) para establecer la frecuencia de la señal PWM.

• led_pwm.duty_u16(DUTY_CYCLE) para establecer el ciclo de trabajo (duty cycle). Debe ser un valor entre 0 y 65.535 (16 bits).

• led_pwm.deinit() para desactivar el PWM en la porción (slice) de PWM usada por el LED (en este ejemplo, es el GPIO 20, por lo que también detendrá el PWM en el GPIO 21, ya que pertenecen a la misma porción de PWM).

Esquemático

Ahora, creemos un ejemplo para comprender mejor los conceptos de PWM. Crearemos un ejemplo sencillo para atenuar un LED (aumentar y disminuir el brillo suavemente).

Antes de continuar, conecta un LED a la Raspberry Pi Pico. Lo conectaremos al puerto GPIO 20, pero puedes usar cualquier otro.

Piezas necesarias

Aquí hay una lista de las piezas que necesitas para construir el circuito:

• Raspberry Pi Pico
• LED de 5 mm
• Resistencia de 330 ohmios
• Tablero de circuitos
• cables puente

Esquema – Raspberry Pi Pico

Puedes utilizar el siguiente diagrama como referencia para conectar el LED a la placa Raspberry Pi Pico.

Script – RPi Pico Atenuación de un LED

El siguiente código crea una señal PWM en GPIO 20 y aumenta y disminuye el ciclo de trabajo a lo largo del tiempo para atenuar el LED.

# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-pwm-micropython/
from machine import Pin, PWM
from time import sleep

# Set up PWM Pin
led = machine.Pin(20)
led_pwm = PWM(led)
duty_step = 129  # Step size for changing the duty cycle

#Set PWM frequency
frequency = 5000
led_pwm.freq (frequency)

try:
    while True:
      # Increase the duty cycle gradually
      for duty_cycle in range(0, 65536, duty_step):
        led_pwm.duty_u16(duty_cycle)
        sleep(0.005)
        
      # Decrease the duty cycle gradually
      for duty_cycle in range(65536, 0, -duty_step):
        led_pwm.duty_u16(duty_cycle)
        sleep(0.005)
        
except KeyboardInterrupt:
    print("Keyboard interrupt")
    led_pwm.duty_u16(0)
    print(led_pwm)
    led_pwm.deinit()

Cómo funciona el código

from machine import Pin, PWM

from time import sleep

led = machine.Pin(20)

led_pwm = PWM(led)

duty_step = 129 # Tamaño de paso para cambiar el ciclo de trabajo

#Set PWM frequency 
frequency = 5000 
led_pwm.freq (frequency)

led.duty(duty_cycle)

for duty_cycle inrange(0,65536, duty_step):
    led_pwm.duty_u16(duty_cycle)
    sleep(0.005)

range(start, stop, step)

• Start: un número que especifica en qué posición comenzar. Queremos comenzar con ciclo de trabajo 0;

• Stop: un número que especifica en qué posición queremos detenernos, sin incluir ese valor. El ciclo de trabajo máximo es 65.535. Por eso, usamos 65.535 + 1, que es 65.536.

• Step: un número entero que especifica la incrementación. Por defecto, la incrementación es 1.

En cada ciclo for, configuramos el ciclo de trabajo del LED al valor actual de duty_cycle:

led_pwm.duty_u16(duty_cycle)

Después de eso, la variable duty_cycle se incrementa por el step que especificaste.

Cuando el ciclo de trabajo alcanza el brillo máximo, disminuimos el brillo gradualmente de forma similar.

# DISMINUYE EL CICLO DUTY GRADUALMENTEfor duty_cycle in range(65536, 0, -duty_step):
led_pwm.duty_u16(duty_cycle)
sleep(0.005)

El bloque try encierra el código que queremos ejecutar.

El bloque except se ejecuta si ocurre un error específico dentro del bloque try. En este caso, captura el error KeyboardInterrupt, que se lanza cuando el usuario interrumpe el programa presionando Ctrl+C en la terminal o detiene el programa en el IDE. Cuando se detecta este error, se ejecuta el código dentro del bloque except.

Dentro del bloque except, configuramos el ciclo de trabajo del LED a 0 (totalmente apagado) usando led.duty_u16(0) y llamamos a led.deinit() para apagar el PWM.

except KeyboardInterrupt:
    print("Keyboard interrupt")
    led_pwm.duty_u16(0)
    print(led_pwm)
    led_pwm.deinit()

Demostración

Guarda el código en tu placa Raspberry Pi Pico usando Thonny IDE o cualquier otro IDE de MicroPython de tu preferencia.

Sigue las siguientes instrucciones si estás usando Thonny IDE.

Copia el código proporcionado en un archivo sin título (untitled) de Thonny IDE.

Con el código copiado al archivo, haz clic en el  icono 

 . Luego, selecciona  

 .

Guarde el archivo con el siguiente nombre:  

 Sobrescriba cualquier archivo existente con el mismo nombre.

 Cuando nombras un archivo main.py

La Raspberry Pi Pico ejecutará ese archivo automáticamente al arrancar. Si le asigna un nombre diferente, se guardará en el sistema de archivos de la placa, pero no se ejecutará automáticamente al arrancar.

Reinicia tu placa (desconéctala y conéctala a tu ordenador). Haz clic en el botón verde “Ejecutar script actual” o pulsa F5.

 

Tenga en cuenta que el LED conectado a GPIO 20 comenzará a “respirar”, aumentará y disminuirá su brillo gradualmente con el tiempo.

Puedes detener la ejecución del programa presionando  

 + 

 o haciendo clic en el botón DETENER. Observa que el LED se apagará y se imprimirá un mensaje en la terminal.

Concluyendo