En este artículo aprenderás cómo controlar tiras de luces LED RGB direccionables WS2812B utilizando los microcontroladores ESP32 y ESP8266 con el lenguaje de programación MicroPython. Descubre cómo crear espectaculares efectos de iluminación y añadir un toque único a tus proyectos de electrónica. ¡Sigue leyendo para sumergirte en el fascinante mundo de la programación de microcontroladores!
Este tutorial muestra cómo controlar los LED RGB direccionables WS2812B (Neopixel) con ESP32 y ESP8266 usando MicroPython.
Hay una biblioteca incorporada en MicroPython que hace que sea extremadamente fácil controlar estos LED: el
neopíxel Biblioteca. Le mostraremos cómo controlar LED individuales, crear funciones para crear efectos de iluminación sorprendentes y crear un proyecto simple para ilustrar cómo funciona todo.
Este tutorial se puede aplicar a cualquier tira o PCB que tenga LED RGB direccionables WS2812B (Neopixel) como:
- Tiras LED RGB direccionables WS2812B
- Anillos LED RGB direccionables WS2812B
- Barras de PCB LED RGB direccionables WS2812B
En este tutorial, controlaremos dos anillos de LED RGB direccionables y una barra de LED direccionable conectada en serie.
requisitos
Para seguir este tutorial, debe tener instalado el firmware MicroPython en su ESP32 o ESP8266. También necesitarás un IDE para escribir el código y subirlo a tu placa. Recomendamos utilizar Thonny IDE o uPyCraft IDE:
- IDE de Thonny:
- Instalación y primeros pasos con Thonny IDE
- Actualización del firmware MicroPython con esptool.py
- IDE de UpyCraft:
- Instale uPyCraft IDE (Windows, Mac OS X, Linux)
- Flashear/cargar firmware MicroPython a ESP32 y ESP8266
Presentamos los LED RGB WS2812B
Los LED WS2812B son LED RGB direccionables que se pueden conectar en serie y controlar individualmente utilizando un solo pin digital de un microcontrolador. Estos LED tienen un IC integrado directamente en el LED que hace todo esto posible.
Puedes soldar varios anillos y varillas de LED y se comportarán como una sola pieza. Cada PCB tiene pines IN y OUT que facilitan el cableado:
La siguiente imagen muestra cómo queda nuestra configuración después de soldar los LED.
Cablear la tira de LED RGB al ESP32 o ESP8266 es muy fácil. Necesitas 5V para el VCC Pin, GND encendido Dimensiones y conecte un GPIO al pin Din (datos). Conectamos el pin de datos a
GPIO5.
Control de LED RGB WS2812B
Hay un módulo MicroPython incorporado llamado neopíxel para controlar LED direccionables WS2812B. Por ejemplo, el siguiente script controla 4 píxeles individuales:
# Complete project details at https://RandomNerdTutorials.com
import machine, neopixel
n = 48
p = 5
np = neopixel.NeoPixel(machine.Pin(p), n)
np[0] = (255, 0, 0)
np[3] = (125, 204, 223)
np[7] = (120, 153, 23)
np[10] = (255, 0, 153)
np.write()
Importando bibliotecas
Primero importe el
neopíxel Y máquina Módulos:
import machine, neopixelCrear un objeto Neopixel
Establezca el número de píxeles de su tira en el norte Variable:
n = 48Guarde el número GPIO que controla la tira en el PAG Variable:
p = 5Crea un objeto NeoPixel llamado
No en el GPIO que definiste anteriormente y con la cantidad de LED que también definiste:
np = neopixel.NeoPixel(machine.Pin(p), n)Control de píxeles individuales
Después de inicializar el objeto Neopixel, puede comenzar a controlar los LED. Controlar un solo píxel es muy fácil. Puedes pensar en la tira como una matriz con norteElementos (número de píxeles en esta tira de ejemplo). Luego lo único que tenemos que hacer es establecer un color para un elemento específico. Por ejemplo, para configurar el primer píxel en rojo:
np[0] = (255, 0, 0)La siguiente figura puede ayudarle a comprender mejor cómo funciona:
Entonces usa eso escribir() Método para que los cambios surtan efecto.
np.write()
Efectos de iluminación LED RGB WS2812
Ahora que sabes cómo controlar píxeles individuales, puedes crear tus propios efectos de iluminación. Le proporcionamos algunas funciones (basadas en los ejemplos de la biblioteca) que puede utilizar en sus propios proyectos.
Eliminar todos los píxeles
Borrar todos los píxeles equivale a configurar todos los píxeles en color (0, 0, 0).
def clear():
for i in range(n):
np[i] = (0, 0, 0)
np.write()
Establecer todos los píxeles del mismo color
De manera similar, para configurar todos los píxeles del mismo color, puede utilizar la siguiente función, que acepta los parámetros de color r, g y b como argumentos.
def set_color(r, g, b):
for i in range(n):
np[i] = (r, g, b)
np.write()
efecto rebote
El rebotar() La función crea un efecto de rebote y acepta los parámetros r, g y b para establecer el color y el tiempo de espera. El tiempo de espera determina qué tan rápido es el efecto de rebote.
def bounce(r, g, b, wait):
for i in range(4 * n):
for j in range(n):
np[j] = (r, g, b)
if (i // n) % 2 == 0:
np[i % n] = (0, 0, 0)
else:
np[n – 1 – (i % n)] = (0, 0, 0)
np.write()
time.sleep_ms(wait)Este efecto muestra un píxel apagado que recorre todas las posiciones de las franjas.
Efecto ciclo
El efecto de ciclo funciona de manera similar al efecto de rebote. Un píxel está activado y recorre todas las posiciones de las franjas, mientras que los demás píxeles están desactivados.
def cycle(r, g, b, wait):
for i in range(4 * n):
for j in range(n):
np[j] = (0, 0, 0)
np[i % n] = (r, g, b)
np.write()
time.sleep_ms(wait)
Efecto arcoiris en movimiento
Para crear un efecto de arco iris en movimiento necesitas dos funciones. El Rueda() La función crea el espectro de colores del arco iris variando cada parámetro de color entre 0 y 255.
def wheel(pos):
Input a value 0 to 255 to get a color value.
The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
return (0, 0, 0)
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)Luego usa el ciclo del arcoiris () Función que devuelve los resultados de la Rueda() Función para difundir el arco iris entre la cantidad de LED de su tira.
def rainbow_cycle(wait):
for j in range(255):
for i in range(n):
rc_index = (i * 256 // n) + j
np[i] = wheel(rc_index & 255)
np.write()
time.sleep_ms(wait)Esta función acepta el tiempo de espera como argumento. El tiempo de espera define la rapidez con la que se mueve el efecto arcoíris.
Una vez que sepa cómo funcionan estas funciones, podrá crear sus propios proyectos para crear efectos de iluminación sorprendentes. Para ver cómo funciona todo en conjunto, en la siguiente sección crearemos un proyecto simple para controlar una serie de LED RGB direccionables.
LED RGB WS2812B con MicroPython: ejemplo de proyecto
Aquí estamos construyendo un circuito simple con 4 botones. Dependiendo del botón que se presione, se crean diferentes efectos de iluminación.
Piezas requeridas
En este proyecto utilizamos dos anillos de LED RGB direccionables con diferentes tamaños y una barra de LED RGB direccionable. Sin embargo, también puedes utilizar una tira de LED RGB o LED RGB direccionables en otras configuraciones.
- ESP32 (lea las mejores placas de desarrollo ESP32) o ESP8266 (leer Las mejores placas de desarrollo ESP8266)
- LED RGB direccionables:
- 4x Apretar botones (botón)
- 4x resistencias de 10kOhm
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Esquema
Tanto para el ESP32 como para el ESP8266 cableamos el circuito de la siguiente manera:
| Botón 1 | GPIO 14 |
| Botón 2 | GPIO 12 |
| Botón 3 | GPIO 13 |
| Botón 4 | GPIO 15 |
| Pin de datos LED RGB direccionable | GPIO5 |
Nota: Puede seleccionar cualquier otro pin digital si es necesario.
ESP32
También puede consultar el siguiente diagrama de circuito para cablear el circuito para ESP32:
ESP8266
Siga el siguiente esquema si está utilizando un EPS8266:
código
Cargue el siguiente código a su ESP32 o ESP8266 como principal.py.
# Complete project details at https://RandomNerdTutorials.com
from machine import Pin
import machine, neopixel, time
# define interrupt handling functions
def button_handler(pin):
global button_pressed
button_pressed = pin
# configure pushbuttons as interrupts
button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button_pressed = button1
# LED strip configuration
# number of pixels
n = 48
# strip control gpio
p = 5
np = neopixel.NeoPixel(machine.Pin(p), n)
# FUNCTIONS FOR LIGHTING EFFECTS
# bounce
def bounce(r, g, b, wait):
for i in range(2 * n):
for j in range(n):
np[j] = (r, g, b)
if (i // n) % 2 == 0:
np[i % n] = (0, 0, 0)
else:
np[n - 1 - (i % n)] = (0, 0, 0)
np.write()
time.sleep_ms(wait)
# cycle
def cycle(r, g, b, wait):
for i in range(n):
for j in range(n):
np[j] = (0, 0, 0)
np[i % n] = (r, g, b)
np.write()
time.sleep_ms(wait)
# function to go through all colors
def wheel(pos):
# Input a value 0 to 255 to get a color value.
# The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
return (0, 0, 0)
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)
# rainbow
def rainbow_cycle(wait):
for j in range(255):
for i in range(n):
rc_index = (i * 256 // n) + j
np[i] = wheel(rc_index & 255)
np.write()
time.sleep_ms(wait)
# turn off all pixels
def clear():
for i in range(n):
np[i] = (0, 0, 0)
np.write()
while True:
if button_pressed == button1:
clear()
elif button_pressed == button2:
bounce(23, 210, 15, 70)
elif button_pressed == button3:
cycle(123, 0, 154, 50)
elif button_pressed == button4:
rainbow_cycle(1)
Cómo funciona el código
Continúe leyendo esta sección si desea aprender cómo funciona el código. De lo contrario, puede pasar directamente a la sección «Demostración».
Comience importando las bibliotecas requeridas:
from machine import Pin
import machine, neopixel, timeLos pulsadores están configurados como interrupciones. Por lo tanto, necesitamos crear una función de manejo de interrupciones que se ejecutará cada vez que ocurra una interrupción; en este caso, controlador_botón() Función.
def button_handler(pin):
global button_pressed
button_pressed = pinLa función de manejo de interrupciones tiene un parámetro de entrada (Bolígrafo), en el que un objeto de la clase Bolígrafo se pasa cuando se produce la interrupción. Esto nos permite saber qué pin generó la interrupción.
En nuestro ejemplo, la función de interrupción del controlador se llama Controlador de botones y lo guarda en el Tecla presionada Variable.
def button_handler(pin):
global button_pressed
button_pressed = pinNota: Tecla presionada se define como una variable global porque queremos que sea accesible en todo el código, no solo dentro del controlador_botón() Función.
Luego configure los botones como pines de interrupción:
button1 = Pin(15, Pin.IN)
button1.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button2 = Pin(14, Pin.IN)
button2.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button3 = Pin(12, Pin.IN)
button3.irq(trigger=Pin.IRQ_RISING, handler=button_handler)
button4 = Pin(13, Pin.IN)
button4.irq(trigger=Pin.IRQ_RISING, handler=button_handler)Por defecto esto es Tecla presionada la variable es igual Botón 1porque este botón borra los LED y queremos que estén apagados de forma predeterminada.
button_pressed = button1Luego creamos un objeto Neopixel.
GPIO5con 48 LED. deberías el norte variable con el número de LED que controlas.
n = 48 # number of pixels
p = 5 # strip control gpio
np = neopixel.NeoPixel(machine.Pin(p), n)Seguidamente definimos las funciones que vimos en un apartado anterior: rebotar(),Ciclo(), Rueda(), ciclo del arcoiris (),Yclaro().
En el bucle while comprobamos qué tecla se presionó y llamamos a una función diferente dependiendo de qué tecla se presionó:
- Botón 1: elimina la tira (todos los Neopixels apagados)
- Botón 2: efecto rebote
- Botón 3: efecto ciclo
- Botón 4: efecto arcoíris
while True:
if button_pressed == button1:
clear()
elif button_pressed == button2:
bounce(23, 210, 15, 10)
elif button_pressed == button3:
cycle(123, 0, 154, 20)
elif button_pressed == button4:
rainbow_cycle(1)Nota: Puede cambiar los argumentos de las funciones anteriores para configurar los LED en diferentes colores o el Esperar Parámetros para hacer que el efecto sea más rápido o más lento.
demostración
Después de cargar el código anterior a tu ESP32 o ESP8266, principal.pypresione el botón de activación/reinicio de ESP para ejecutar el nuevo código.
Pulsando los botones individuales se pueden conseguir diferentes efectos. Puedes ver una demostración en vivo en el siguiente vídeo:
Nota: Si selecciona un efecto presionando el botón, no comenzará hasta que el efecto actual se detenga.
Envolver
En este tutorial, aprendió a controlar los LED RGB direccionables WS2812B (anillos, tiras o barras). Controlar estos LED con MicroPython es gracias al neopíxel Biblioteca. También aprendió a configurar múltiples interrupciones usando MicroPython.
Ahora puedes aplicar los conceptos que aprendiste en este tutorial a tus propios proyectos. Por ejemplo, puede crear un servidor web con varios botones que controle los LED de forma remota.
Tenemos más tutoriales de LED RGB que te pueden gustar:
- ¿Cómo funcionan los LED RGB?
- Node-RED con tira LED RGB direccionable WS2812B
Más tutoriales sobre MicroPython y ESP32 y ESP8266:
- [eBook] Programación MicroPython con ESP32 y ESP8266
- MicroPython: introducción a MQTT en ESP32/ESP8266
- MicroPython con ESP32 y ESP8266: Interactuando con GPIO
Esperamos que hayas disfrutado este proyecto y hayas aprendido algo nuevo.
Gracias por leer.
Control de LED RGB direccionables WS2812B con ESP32 y ESP8266 utilizando MicroPython
Este tutorial muestra cómo controlar los LED RGB direccionables WS2812B (neopixels) con el ESP32 y ESP8266 utilizando MicroPython. Existe una librería integrada en MicroPython que facilita enormemente el control de estos LEDs: la librería neopixel. Te mostraremos cómo controlar LEDs individuales, crear funciones para producir efectos de iluminación increíbles y construir un proyecto simple para ilustrar cómo funciona todo.
Preguntas frecuentes:
-
¿Qué tipos de LEDs se pueden controlar con este tutorial?
Este tutorial puede aplicarse a cualquier tira o placa de circuito impreso que tenga LEDs RGB direccionables WS2812B (neopixels) como:
- WS2812B tiras de LED RGB direccionables
- WS2812B anillos de LED RGB direccionables
- WS2812B barras de LED RGB direccionables
-
¿Cuál es el requisito previo para seguir este tutorial?
Para seguir este tutorial necesitas tener el firmware de MicroPython instalado en tu ESP32 o ESP8266. También necesitas un IDE para escribir y cargar el código en tu placa. Te sugerimos utilizar el IDE Thonny o el IDE uPyCraft.
-
¿Cómo se controlan los LEDs RGB direccionables WS2812B?
Los LEDs WS2812B son LEDs RGB direccionables que pueden conectarse en serie y controlarse individualmente utilizando solo un pin digital de un microcontrolador. Estos LEDs tienen un circuito integrado incorporado en el LED que hace que todo esto sea posible.
-
¿Qué efectos de iluminación se pueden lograr con los LEDs WS2812B mediante MicroPython?
Se pueden lograr varios efectos de iluminación con MicroPython, como el efecto de rebote, efecto de ciclo, efecto de arco iris en movimiento, entre otros. Estos efectos están determinados por funciones que controlan los LEDs de forma creativa.
Qué interesante, definitivamente tengo que probarlo en mi ESP32. ¡Gracias por compartir la información!
¡Wow, qué chévere! Nunca pensé que se podía hacer algo así con MicroPython y LEDs. Definitivamente voy a intentarlo en mi ESP32. ¡Gracias por el artículo!
¡Qué buena idea! Nunca pensé que se podría programar LEDs RGB direccionables con MicroPython en mi ESP32 y ESP8266. ¡Definitivamente voy a probarlo! ¡Gracias por compartir el artículo!
¡Esto suena genial! Me encantaría aprender más sobre cómo hacer esto en mi ESP8266. ¡Gracias por el artículo!
¡Increíble! Me encanta la idea de poder controlar LED RGB direccionables con MicroPython en mi ESP32 y ESP8266. Definitivamente voy a intentarlo. ¡Gracias por el artículo!