Ya sea que los llame LED RGB direccionables individualmente, WS2812B o NeoPixels, no se puede negar que son extremadamente populares y imprescindibles para cualquier proyecto brillante y parpadeante.
Lo que distingue a estos LED es su característica única que le permite abordar y controlar individualmente el color y el brillo de cada LED en una tira. Además, puede (teóricamente) conectar en cadena tantos LED como desee y controlarlos todos desde un solo pin del microcontrolador. ¡Cuantos más LED encadenes, más inusuales serán tus animaciones!
Estos LED son excepcionalmente brillantes, producen colores vibrantes y son fáciles de conectar. En este tutorial, aprenderá todo lo que necesita saber sobre los LED direccionables WS2812B y cómo usarlos con un Arduino.
Descripción general del hardware WS2812B
A primera vista, el LED WS2812B puede parecer un LED SMD RGB de formato 5050 (5×5 mm) estándar, pero es mucho más que eso: en realidad contiene un circuito integrado. A continuación se muestra una imagen ampliada del WS2812B.
Si miras de cerca, puedes ver el pequeño chip negro, así como los cables de conexión dorados que conectan el chip a los segmentos de LED rojo, verde y azul.
¿Sabías?
El popular LED RGB direccionable individualmente WS2812 fue lanzado por primera vez por Corporación WorldSemi Finales de 2013. La empresa se hizo un nombre anteriormente con soluciones de controladores LED, en particular el WS2811, un chip SOIC que convierte un LED RGB de ánodo común en un LED controlable en serie.
Cuando empaquetaron el cerebro del WS2811 en un paquete compacto junto con algunos LED, pudieron crear lo que probablemente sea la solución de iluminación LED programable más común disponible en la actualidad.
Profundidad del color
Se trata de LED RGB de 8 bits, lo que significa que cada segmento de LED puede alcanzar 256 niveles de brillo diferentes, creando una paleta de colores de 24 bits, que puede mostrar 16.777.216 (256 x 256 x 256) colores diferentes. Esto significa que puedes hacer casi cualquier color; desde verde azulado hasta siena y blanco fantasma.
Capacidad de cadena
Lo mejor de estos LED es que se pueden conectar fácilmente en cadena: la salida de un LED se puede conectar a la entrada de otro para crear tiras de cientos de LED. Además, sólo se requiere un pin de su microcontrolador para controlar una tira de LED completa.
La tira de LED WS2812B tiene flechas impresas que indican la dirección en la que fluyen los datos. Al conectar la tira al microcontrolador, asegúrese de que las flechas apunten en dirección opuesta al microcontrolador.
Actuación
El WS2812B funciona en el rango de 3,3 V a 5 V. La salida de 5 V de una placa Arduino, por ejemplo, es una fuente de alimentación perfecta para estos LED.
Con brillo máximo, cada segmento de LED rojo, verde y azul consume aproximadamente 20 mA. En otras palabras, cada LED WS2812B puede consumir aproximadamente 60 mA. Incluso con solo diez WS2812B conectados en serie, supera los 600 mA.
Entonces, si planeas unir muchas de estas cosas, asegúrate de que tu fuente de energía sea capaz de manejar el consumo de energía adicional. Para obtener más información, consulte la sección Acerca de Estimación de la demanda de electricidad..
Protocolo de transferencia de datos WS2812B
Aunque se pueden controlar decenas de miles de WS2812B a través de un solo cable, el protocolo no se parece a una interfaz serie UART estándar. Por eso es interesante hablar sobre el protocolo WS2812B porque es único y extremadamente sensible al tiempo.
Tanto el 0 lógico como el 1 lógico requieren un pulso cuadrado, y la longitud del pulso determina cuál es: un pulso corto (0,35 μs) representa un cero, mientras que un pulso largo (0,7 μs) representa un uno. El tiempo entre flancos ascendentes consecutivos debe ser de 1,25 μs.
Los datos se envían en una secuencia de 24 bits, seguida de un pulso de reinicio bajo de 50 µs. Esta secuencia tiene ocho bits para cada color, comenzando con verde, luego rojo y luego azul.
Cuanto mayor sea el valor de un color concreto, más brillante será. Cuando cada color se establece en 0, el LED está apagado. Cuando cada color se establece en 255, el LED será lo más brillante y blanco posible.
Por ejemplo, una secuencia de 24 bits de 100101100000000000000000, que corresponde a un valor «10010110» para el verde (150 cuando se convierte a decimal) y ceros para los 16 bits restantes, produce un color verde puro de brillo medio sin mezcla de rojo o azul.
Aunque se supone que los WS2812B son direccionables, esto no es técnicamente correcto. En realidad, se accede a los LED en forma de cascada simple pero efectiva. El microcontrolador envía secuencialmente datos de color (secuencia de 24 bits) para cada LED de la tira. Cuando un LED recibe datos, no sabe en qué parte de la tira se encuentra; Simplemente almacena los primeros 24 bits de los datos recibidos y envía el resto de los datos a través de la línea. El siguiente LED hace lo mismo: toma los primeros 24 bits de datos que recibe y transmite el resto, y así sucesivamente.
En resumen, el protocolo es muy sensible al tiempo, por lo que para operar los WS2812B necesitará un microcontrolador en tiempo real como un Arduino, ESP32, AVR o PIC; Los microprocesadores como los de Raspberry Pi o pcDuino no pueden ofrecer un pulso constante. Un retraso de unos pocos microsegundos podría hacer que un LED cambie de color de naranja a amarillo.
Distribución de pines de la tira WS2812B
Cada tira de LED tiene tres puntos de conexión: el puerto de entrada, los cables de alimentación auxiliar y el puerto de salida. La tira utiliza conectores JST-SM de 3 pines.
El puerto de entrada
El conector de entrada es un conector JST-SM de 3 pines.
5V (rojo) es el cable de alimentación. Debe conectarse a una tensión de alimentación regulada entre 3,3 V y aproximadamente 5 V.
Entrada de datos (verde) transfiere datos a la tira.
Tierra (blanco) es lo común.
El conector de salida
El conector de salida tiene tres clavijas macho dentro de una cubierta de conector de plástico, cada una con una separación de aproximadamente 0,1 pulgadas. Está diseñado para conectarse al puerto de entrada de otra tira de LED, lo que le permite conectar varias tiras de LED juntas.
5V (rojo) es el cable de alimentación.
Salida de datos (verde) transfiere datos desde la tira.
Tierra (blanco) es lo común.
Los cables de alimentación auxiliar
Ambos puertos tienen cables de alimentación auxiliares adicionales de 5V y GND. Le permiten alimentar la tira de LED en ambos extremos o en múltiples puntos cuando se conectan varias tiras juntas, evitando una caída excesiva de voltaje a lo largo de las tiras.
Si no desea utilizar estos cables adicionales, corte las puntas expuestas y/o aíslelas con un tubo termorretráctil para evitar un cortocircuito.
Estimación de la demanda de electricidad.
Cada LED WS2812B consume aproximadamente 60 miliamperios cuando se configura en brillo máximo (blanco brillante) y se alimenta a 5 voltios. Esto significa que incluso con sólo 60 LED encendidos, su tira de LED podría consumir hasta 3,6 A.
Sin embargo, en la práctica es inusual que todos los LED se enciendan de esta forma. Al mezclar colores y mostrar animaciones, la potencia de salida es significativamente menor.
Aunque es imposible dar una estimación precisa para cada escenario posible, una regla general es que se debe utilizar un tercio del consumo de corriente total (es decir, 20 mA por LED WS2812B) sin efectos adversos. Sin embargo, si está seguro de que cada píxel debe estar completamente encendido, utilice el valor completo de 60 mA.
Los requisitos de energía se pueden estimar aproximadamente multiplicando el número total de LED WS2812B por 20 y luego dividiendo ese número por 1000 para obtener una clasificación de fuente de alimentación de «regla general» (en amperios). Si desea garantizar un margen de seguridad absoluto en todas las situaciones, utilice 60 (en lugar de 20).
Por ejemplo:
60 LED WS2812B × 20 mA ÷ 1000 = al menos 1,2 amperios
-o-
60 LED WS2812B × 60 mA ÷ 1000 = al menos 3,6 amperios
La elección de la fuente de alimentación es suya, pero una fuente de alimentación de gran tamaño proporciona seguridad y confiabilidad adicionales.
Protección de LED WS2812B
Es importante tener en cuenta que los LED WS2812B son muy sensibles. Por lo tanto, se recomienda encarecidamente que tome las siguientes precauciones para protegerse:
- Agregue un capacitor grande (100 a 1000 µF, 6.3 V o superior) a través de los terminales + y – lo más cerca posible de su WS2812B. Este condensador ayuda a suavizar el suministro de energía. Esto protege los LED de la subida de tensión inicial. Además, el consumo de energía del WS2812B fluctúa significativamente, por lo que este capacitor actúa como un «depósito de energía», almacenando energía en caso de un corte de energía.
- Considere agregar una resistencia de 220 y 470 ohmios entre la salida de datos de su microcontrolador y la entrada de la tira de LED para reducir el ruido en esta línea. Algunos productos WS2812B ya incluyen esta resistencia; en caso de duda, agregue uno; ¡No hay nada de malo en duplicarlo!
- Minimiza la distancia entre el microcontrolador y la tira de LED para que la señal sea clara. Esto no suele ser un problema a una distancia de sólo uno o dos metros, pero si se alarga mucho, la tensión puede caer y provocar problemas.
- Haga coincidir el nivel lógico de la línea de datos (cable verde) con el voltaje de entrada. Entonces, si suministra 5 V a la regleta WS2812B, debe conectar la línea de datos a un nivel lógico de 5 V.
- Evite realizar o cambiar conexiones mientras el circuito esté energizado. Si es necesario, siempre conecte tierra primero, luego +5V, luego datos y desconecte en orden inverso.
- Si utiliza una fuente de alimentación separada para la tira de LED, siempre encienda la tira antes de encender el microcontrolador. Esto evita que los LED intenten consumir energía a través de la línea de datos, lo que podría causar problemas al microcontrolador.
- No toque la tira de LED con las manos desnudas. La electricidad estática de su cuerpo puede dañar los LED y provocar un mal funcionamiento.
Conexión de una tira de LED WS2812B a un Arduino
Las tiras LED WS2812B vienen con un conector estandarizado JST-SM de 3 pines y un pigtail macho. Esto facilita la conexión a un microcontrolador y la conexión en cadena de varias tiras de LED.
La conexión es bastante fácil. Primero, identifique el «extremo de entrada» de la tira. Hay una almohadilla de soldadura con la etiqueta «DIN» o «DI» o simplemente «I» (entrada de datos), así como una flecha que indica la dirección en la que fluyen los datos.
Conecte el cable rojo (+5V o +) de la tira de LED direccionable al pin de salida de 5V del Arduino y el cable blanco/amarillo (GND o –) al pin GND del Arduino.
Finalmente, conecta el cable verde (DIN o DI o I) de la tira de LED al pin digital 6 del Arduino mediante una resistencia de 330 ohmios.
Además, recomendamos colocar un condensador grande (100 a 1000 µF, 6,3 V o superior) entre los terminales + y – lo más cerca posible de su WS2812B.
Si solo tienes unos pocos LED Puedes alimentar la tira directamente desde el pin de 5V del Arduino. El Arduino sólo puede suministrar unos 500 mA continuamente al pin de 5V. Cada LED WS2812B puede consumir hasta 60 mA con brillo máximo. Entonces, siempre y cuando solo se utilicen unos pocos LED y el brillo general se mantenga bajo (alrededor del 25%), puedes prescindir de la fuente de alimentación de CC separada y la fuente de alimentación directamente del Arduino. En caso de duda, utilice una fuente de alimentación independiente.
Si tiene un proyecto más grande que requiere más LED, La alimentación USB no será suficiente. En su lugar, debes alimentar la regleta desde una fuente externa.
Encadenar y distribuir energía
Se pueden conectar en cadena varias tiras de LED conectando los puertos de entrada a los puertos de salida. Cuando las tiras se encadenan entre sí de esta manera, se pueden controlar y alimentar como una tira única y continua. Sin embargo, a medida que las cadenas se alargan, la tensión comienza a disminuir, lo que hace que el otro extremo de la tira se oscurezca, cambie de color (se vuelva más roja) o deje de funcionar por completo.
Esta caída de voltaje es proporcional a la corriente que fluye a través de la cinta, lo que significa que aumenta a medida que los LED se configuran con un brillo más alto. Al medir la caída de voltaje y el consumo de corriente de tiras de LED de diferentes longitudes, con todos los LED configurados al brillo máximo, se observaron los siguientes resultados:
- La tira de 30 LED de 1 m consumió 1,5 A y tuvo una caída de voltaje de 0,2 V
- La tira de 60 LED de 2 m de largo consumió 2,9 A y tuvo una caída de voltaje de 0,8 V
- La tira de 120 LED de 2 m de largo consumió 4,7 A y tuvo una caída de voltaje de 1,4 V
- La tira de 5 m de 150 LED consumió 4,1 A y tuvo una caída de voltaje de 2,0 V.
Para resolver este problema, se recomienda alimentar cada conjunto de 180 LED por separado de los cables de alimentación auxiliar. Recuerde: si utiliza diferentes fuentes de alimentación para cada conjunto, corte los cables de alimentación entre conjuntos para evitar cortocircuitos en las fuentes de alimentación.
Instalación de biblioteca
Controlar “desde cero” los LED del WS2812B es todo un reto que aprovecharemos La excelente biblioteca NeoPixel de Adafruit para que podamos centrarnos en las partes divertidas e interesantes en lugar de perder el tiempo con el protocolo extraño.
Para instalar la biblioteca, navegue hasta Bosquejo > incluir biblioteca > Administrar bibliotecas… Espere a que el administrador de la biblioteca descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.
Filtra tu búsqueda escribiendo “Neopixel'. Buscar Adafruit NeoPixel de Adafruta. Haga clic en esta entrada y luego seleccione «Instalar».
Adafruit NeoPixel no es la única biblioteca disponible; hay otros como este Biblioteca FastLEDque tiene funciones avanzadas y es compatible con otros conjuntos de chips LED.
Bocetos de muestra de NeoPixel
La biblioteca Adafruit NeoPixel tiene varios bocetos de ejemplo. Puede utilizar estos bocetos de ejemplo como base para desarrollar su propio código.
Para acceder a los bocetos de muestra, navegue hasta archivo > Ejemplos > Adafruit NeoPixel. Verá una selección de bocetos de muestra.
Ejemplo 1: limpieza de color simple
El primer ejemplo es muy sencillo; Lo único que hace es llenar las tiras de LED de color verde una a una. Este ejemplo le brinda información sobre el uso de la biblioteca NeoPixel para que pueda crear sus propias animaciones.
Sin embargo, antes de cargar el boceto, debes realizar un pequeño cambio para que funcione para ti. El LED_PIN Y LED_COUNT Cada una de las constantes debe configurarse en el pin Arduino que conectó al pin «DIN» de la tira o en la cantidad total de LED en la tira.
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12Una vez que hayas terminado, prueba el boceto.
#include <Adafruit_NeoPixel.h>
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12
// Setting up the NeoPixel library
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin(); // Initialize NeoPixel object
strip.setBrightness(10); // Set BRIGHTNESS to about 4% (max = 255)
}
void loop() {
strip.clear(); // Set all pixel colors to 'off'
// The first NeoPixel in a strand is #0, second is 1, all the way up
// to the count of pixels minus one.
for(int i=0; i<LED_COUNT; i++) {
// Set the i-th LED to pure green:
strip.setPixelColor(i, 0, 255, 0);
strip.show(); // Send the updated pixel colors to the hardware.
delay(500); // Pause before next pass through loop
}
}Si los LED están correctamente conectados y encendidos, debería ver algo como esto.
El WS2812_Definiciones.h El archivo define una lista enorme de colores estándar. Allí encontrarás de todo, desde verde azulado hasta siena y blanco fantasma. Simplemente descargue el archivo, colóquelo en su carpeta de bocetos antes de abrirlo e impórtelo a su boceto.
#include "WS2812_Definitions.h"
Y utilícelo para establecer el color de un píxel, como la línea siguiente cambia el color de un píxel a azul verdoso.
strip.setPixelColor(i, TEAL);
Explicación del código:
Para aprender a escribir tus propios bocetos, comencemos analizando este sencillo boceto.
El boceto comienza insertando el archivo de encabezado Adafruit_NeoPixel.
#include <Adafruit_NeoPixel.h>Hay dos constantes en el mismo ámbito global. LED_PIN Y LED_COUNT Se definen que indican el pin Arduino que conectó al pin “DIN” de la tira y el número total de LED en la tira.
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12A continuación, se llama una instancia de la clase Adafruit_NeoPixel. strip creado. Esto es a lo que se referirá a continuación para controlar la tira. Hay tres argumentos entre paréntesis: LED_COUNT, LED_PIN y un valor que indica el type Número de NeoPixels conectados. En la mayoría de los casos puedes omitir esto y simplemente pasar dos argumentos.
// Setting up the NeoPixel library
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in the strip
// Argument 2 = Arduino pin number
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)En la función setup() el begin() Se llama al método para preparar el pin de datos para la salida.
strip.begin();Luego se ajusta el brillo general de todos los LED. setBrightness(). Este método acepta un único argumento, un número entre 0 (apagado) y 255 (brillo máximo). En este caso, el brillo se ajusta a 10 (aprox. 4%).
strip.setBrightness(10); // Set BRIGHTNESS to about 4% (max = 255)Lo primero que sucede en la función loop() es una llamada a clear()que llena la franja de negro o “off”.
strip.clear();Finalmente, un for El bucle se utiliza para llenar las tiras de LED uno por uno.
Internamente for Cinta setPixelColor() se utiliza para establecer el color de un píxel. El primer argumento pasado al método especifica la posición del LED a lo largo de la tira, desde 0 hasta el número de píxeles menos uno. Los siguientes tres argumentos son el color del LED, expresado como niveles de brillo rojo, verde y azul, donde 0 representa el brillo más tenue (apagado) y 255 representa el brillo máximo.
setPixelColor() solo no hace nada; Debes usar show() para “empujar” los datos de color en la tira.
for(int i=0; i<LED_COUNT; i++) {
strip.setPixelColor(i, 0, 255, 0);
strip.show();
delay(500);
}Para tu información: Hay diferentes formas de llamar setPixelColor(). Cada una de las siguientes líneas puede hacer que el i-ésimo LED se ilumine en verde puro.
strip.setPixelColor(i, 0, 255, 0);
strip.setPixelColor(i, 0x00FF00);
strip.setPixelColor(i, 0x00, 0xFF, 0x00);
uint32_t green = strip.Color(0, 255, 0);
strip.setPixelColor(i, green);Ejemplo 2: ciclo del arcoíris
Esta es sin duda la animación más popular. Se desplaza por todo el arco iris de colores, distribuyendo uniformemente el espectro de colores en la tira de LED.
#include <Adafruit_NeoPixel.h>
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12
// Setting up the NeoPixel library
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin(); // Initialize NeoPixel object
strip.setBrightness(10); // Set BRIGHTNESS to about 4% (max = 255)
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
rainbow(10);
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
// 5 cycles of all colors on wheel
for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
strip.rainbow(firstPixelHue);
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}¡Simplemente sube el código y disfruta del espectáculo!
Ejemplo 3: Carpa de teatro persiguiendo las luces
Esta es una réplica de una antigua carpa de teatro. De hecho, hace que los LED parpadeen uno tras otro, dando la impresión de que están dando vueltas.
#include <Adafruit_NeoPixel.h>
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12
// Setting up the NeoPixel library
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin(); // Initialize NeoPixel object
strip.setBrightness(10); // Set BRIGHTNESS to about 4% (max = 255)
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
// Do a theater marquee effect in various colors...
theaterChase(strip.Color(255, 255, 255), 50); // White
theaterChase(strip.Color(255, 0, 0), 50); // Red
theaterChase(strip.Color( 0, 0, 255), 50); // Blue
}
// Theater-marquee-style chasing lights. Pass in a color, and
// a delay time (in ms) between frames.
void theaterChase(uint32_t color, int wait) {
for(int a=0; a<10; a++) { // Repeat 10 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
}Esto es lo que parece.
Ejemplo 4: copos de nieve
Esta animación crea una serie de píxeles blancos que parpadean aleatoriamente y recuerdan a una nevada.
#include <Adafruit_NeoPixel.h>
// Pin to use to send signals to WS2812B
#define LED_PIN 6
// Number of WS2812B LEDs attached to the Arduino
#define LED_COUNT 12
// Setting up the NeoPixel library
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin(); // Initialize NeoPixel object
strip.setBrightness(10); // Set BRIGHTNESS to about 4% (max = 255)
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
snowflakes(100);
}
void snowflakes(uint8_t wait) {
// Setup the pixel array
int pixel[60];
for(int p=0; p<60; p++){
pixel[p] = random(0,255);
}
// Run some snowflake cycles
for (int j=0; j<200; j++) {
// Every five cycles, light a new pixel
if((j%5)==0){
strip.setPixelColor(random(0,60), 255,255,255);
}
// Dim all pixels by 10
for(int p=0; p<60; p++){
strip.setPixelColor(p, pixel[p],pixel[p],pixel[p] );
pixel[p] = pixel[p] - 10;
}
strip.show();
delay(wait);
}
}Esto es lo que parece.
¡Increíble tutorial! Nunca pensé que fuera tan fácil controlar estos LEDs con Arduino. ¡Gracias por la guía!
¡Me encantó el tutorial! Definitivamente voy a intentarlo en mi próximo proyecto con Arduino. ¡Gracias por compartir!