Cómo controlar los LEDs WS2812B direccionables individualmente usando Arduino

En este tutorial, aprenderás las características y especificaciones de las tiras de LED WS2812B y cómo controlar los LEDs WS2812B direccionables individualmente usando una placa Arduino.

Después de este tutorial, podrás controlar el color de cada LED individualmente, lo que te permitirá producir efectos excepcionales y complejos de forma sencilla.

Overview

Componentes de hardware

Arduino Uno Rev3	x1	Amazon
Arduino Mega (opcional)	x1	Amazon
Tira de LED WS2812B	x1	Amazon
Resistencia de 220Ω	x1	Amazon
Tablero de pruebas	x1	Amazon
Cables de puente	x10	Amazon
Cable USB tipo A/B	x1	Amazon

Software

Arduino IDE

Makerguides.com participa en el Programa de Asociados de Amazon Services LLC, un programa de publicidad de afiliados diseñado para proporcionar un medio para que los sitios ganen honorarios de publicidad mediante la publicidad y los enlaces a productos en Amazon.com.

Introducción de la tira LED WS2812B

WS2812B es una fuente de luz LED de control inteligente que el circuito de control y el chip RGB están integrados en un paquete de 5050 componentes.

Cada LED direccionable tiene su propio circuito integrado de controlador, lo que le permite controlar el color y el brillo de forma independiente según su utilidad.

Pinout del LED direccionable WS2812B

Cada unidad tiene tres LEDs (ROJO, VERDE y AZUL) y un IC controlador para controlar el color y la luminosidad del led. Consta de 4 pines.

Los detalles de la configuración de las clavijas se enumeran a continuación en forma de tabla:

No.	Nombre de la clavija	Función
1	VDD	Fuente de alimentación para el LED
2	DOUT	Salida de señal de datos de control
3	VSS	Tierra
4	DIN	Entrada de señal de datos de control

Características y especificaciones de la tira LED WS2812B:

Tensión de entrada: 5V DC
Corriente de la señal de entrada: 1uA
Capacitancia de alimentación: 15 pF
Frecuencia de funcionamiento: 400Hz
Velocidad de transmisión de datos: 800Kbps
Control de color de 24 bits (PWM de 8 bits por canal); 16,8 millones de colores por píxel
Potencia: 60LEDS/M - 18 vatios/M
Protección contra el ingreso: IP30 No resistente al agua
IP65: Resistente al agua con revestimiento de silicona
Colores: RGB a todo color, cambio de color de ensueño
Longitud: La longitud de la tira LED direccionable se puede personalizar.

Para más detalles técnicos, consulte la hoja de datos del WS2812B.

Controlador serial direccionable WS2812B

El controlador serie tiene un registro Serial In Serial Out (SISO) de 24 bits, dividido en tres partes de 8 bits como B0-B7, R0-R7 y G0-G7.

Un registro de 24 bits toma los datos en serie y los almacena en el registro. Utilizando los datos recibidos en serie, el controlador controla el brillo y los colores del LED RGB.

Si se combinan estas 256 opciones de tres colores, se obtiene alrededor de un millón de posibilidades disponibles. De este modo, se muestra una gran variedad de colores.

¿Cómo se cablea una tira LED WS2812B?

Siga los pasos mencionados a continuación para interconectar la tira LED WS2812b con Arduino Uno.

Paso 1: Conecta el pin 6 del Arduino Uno con la resistencia de 220 Ω al pin de datos de la tira LED W2812B.

Paso 2: Ahora conecta los 5V de Arduino Uno a los 5V de la tira de LEDs y la tierra de Arduino a la tierra de la tira de LEDs. Es un diagrama completo y lo utiliza.

Ahora conecta el Arduino Uno 5V a los 5V de la tira de LEDs

Estoy usando 10 LEDs WS2812B Strip, pero si usas más de 10-12 LEDs WS2812B RGB, necesitas conectar una fuente de alimentación externa.

¿Cómo se controlan las tiras LED direccionables con Arduino?

El LED RGB WS2812B sólo necesita una única línea de datos para controlar todos los LEDs conectados en serie.

Para controlar las tiras de LED direccionables utilizando Arduino Uno, necesitas instalar la biblioteca de tiras de LED WS2812B en tu IDE de Arduino.

Después de eso, te proporcionaré el código para controlar la tira de LED.

Instalación de las librerías Arduino necesarias

Para utilizar los LEDs direccionables WS2812B con el IDE de Arduino, puede utilizar una biblioteca ya construida de FastLED.h.

Siga los siguientes pasos para instalar la biblioteca FastLED.h en el IDE de Arduino.

Paso 1: Ve a Herramientas > Gestionar Bibliotecas (Ctrl + Shift + I en Windows) para abrir el gestor de bibliotecas en Arduino IDE.

abrir el gestor de bibliotecas en el IDE de Arduino

Paso 2: Ahora, en el cuadro de búsqueda, escriba "FastLED",y podrá ver los diferentes resultados de su búsqueda.

Tienes que hacer clic en Instalar y utilizarlo.

Código Arduino para la tira de LEDs WS2812B

El siguiente código permite utilizar una tira de LED WS2812B para crear varios tipos de magia.

Utilizando un monitor en serie, puedes probar diferentes tipos de operaciones con LEDs.

#include "FastLED.h"

#define RGB_PIN      6             // LED DATA PIN
#define RGB_LED_NUM  10            // 10 LEDs [0...9]
#define BRIGHTNESS   200           // brightness range [0..255]
#define CHIP_SET     WS2812B       // types of RGB LEDs
#define COLOR_CODE   GRB           // sequence of colors in data stream

// Define the array of LEDs
CRGB LEDs[RGB_LED_NUM];

// define 3 byte for the random color
byte  a, b, c;
#define UPDATES_PER_SECOND 100

char iByte = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("WS2812B LEDs strip Initialize");
  Serial.println("Please enter the 1 to 6 value.....Otherwise no any effect show");
  FastLED.addLeds&lt;CHIP_SET, RGB_PIN, COLOR_CODE>(LEDs, RGB_LED_NUM);
  randomSeed(analogRead(0));
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, 500);
  FastLED.clear();
  FastLED.show();
}

void loop() {
  if (Serial.available() > 0) {
    // read the incoming byte:
    iByte = Serial.read();

    switch (iByte) {
      case '1': Toggle_RED_LED();
        Serial.println("1.Toggle LED Complete");
        break;
      case '2': Scrolling_RED_LED();
        Serial.println("2.Scrolling RED LED Complete");
        break;
      case '3': O_W_G_scroll();
        Serial.println("3.Flag Show Complete");
        break;
      case '4':  Rotate_color();
        Serial.println("4.Rotate color Complete");
        break;
      case '5': r_g_b();
        Serial.println("5.R_G_B color Complete");
        break;
      case '6': random_color();
        Serial.println("6.Random color Show Complete");
        break;
    }
  }
}

// RED LED TOGGLE
void Toggle_RED_LED(void) {
  // Red Green Blue
  for (int i = 0; i < RGB_LED_NUM; i++)
    LEDs[i] = CRGB(255, 0, 0 );
  FastLED.show();
  delay(1000);
  for (int i = 0; i < RGB_LED_NUM; i++)
    LEDs[i] = CRGB(0, 0, 0 );
  FastLED.show();
  delay(1000);
}

// Move the Red LED
void Scrolling_RED_LED(void)
{
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Red;
    FastLED.show();
    delay(500);
    LEDs[i] = CRGB::Black;
    FastLED.show();
    delay(500);
  }
}

// Orange/White/Green color green
void O_W_G_scroll() {
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Orange;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::White;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Green;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
}

// Red/Green/Blue color Rotate
void Rotate_color(void) {
  for (int clr = 0; clr < RGB_LED_NUM; clr++) {
    LEDs[clr]     = CRGB::Red;
    LEDs[clr + 1] = CRGB::Green;
    LEDs[clr + 2] = CRGB::Blue;
    FastLED.show();
    delay(100);
    for (int clr = 0; clr < RGB_LED_NUM; clr++) {
      LEDs[clr] = CRGB::Black;
      delay(5);
    }
  }
}

// Blue, Green , Red 
void r_g_b() {
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB ( 0, 0, 255);
    FastLED.show();
    delay(50);
  }
  for (int i = RGB_LED_NUM; i >= 0; i--) {
    LEDs[i] = CRGB ( 0, 255, 0);
    FastLED.show();
    delay(50);
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB ( 255, 0, 0);
    FastLED.show();
    delay(50);
  }
  for (int i = RGB_LED_NUM; i >= 0; i--) {
    LEDs[i] = CRGB ( 0, 0, 0);
    FastLED.show();
    delay(50);
  }
}

// random color show
void random_color(void) {
  // loop over the NUM_LEDS
  for (int i = 0; i < RGB_LED_NUM; i++) {
    // choose random value for the r/g/b
    a = random(0, 255);
    b = random(0, 255);
    c = random(0, 255);
    // Set the value to the led
    LEDs[i] = CRGB (a, b, c);
    // set the colors set into the physical LED
    FastLED.show();

    // delay 50 millis
    FastLED.delay(200);
  }
}

Cómo funciona el código de control de los LEDs WS2812B

He utilizado un IDE de Arduino para programar una placa Arduino Uno.

Paso 1: En primer lugar, es necesario incluir la biblioteca para la tira WS2812B y definir el pin de salida para la tira de LEDs RGB.

A continuación, mencione el número de LEDs en la tira de LEDs con RGB_LED_NUM.

Aquí, estoy usando 10 LEDs. En lugar de 10 LEDs, puedes poner cualquier número de LEDs que tengas disponible.

#include "FastLED.h"
#define RGB_PIN        6
#define RGB_LED_NUM    10
#define BRIGHTNESS     200

BRILLO para controlar el brillo de los LEDs. Puede ajustar cualquier nivel de brillo entre 0 y 255.

#define CHIP_SET WS2812B

En este caso, estoy utilizando el modelo de CHIP_SET número WS2812B, pero puede utilizar cualquier modelo que tenga disponible.

Se puede configurar el tipo de controlador LED.

#define COLOR_CODE GRB

COLOR_ORDER establecerá la secuencia de colores de su controlador LED.

LEDs CRGB[RGB_LED_NUM];

Utilizaré una matriz de LEDs que pueda contener los datos RGB para el número de LEDs que desee.

Paso 2: En la sección de configuración, voy a configurar la tira de LED.

En primer lugar, inicialice el monitor serie y establezca la velocidad de transmisión en baudios a 9600.

FastLED.addLeds&lt;CHIP_SET, RGB_PIN, COLOR_CODE&gt;(LEDs, RGB_LED_NUM);

Utilicé la función de la librería utilizando una tira de LEDs WS2812B conectada al PIN 6 de Arduino, y el driver tiene un orden de LEDs G-R-B. Y la tira tiene 10 nos WS2812B RGB LEDs.

FastLED.setBrightness(BRIGHTNESS);

Con esta función de la biblioteca se puede ajustar el brillo.

FastLED.setMaxPowerInVoltsAndMilliamps(5, 500);

Establezca la potencia máxima en voltios y miliamperios para hacer una placa Arduino segura utilizando esta función.

FastLED.clear();

Con esta función, puedes borrar los LEDs cada vez que cargues un nuevo código.

FastLED.show();

FastLED.show() se utiliza para actualizar el Arduino sobre el estado de la función CRGB.

Paso 3: En el bucle void(), he utilizado 6 casos diferentes para los LEDs para crear algo de magia. En la función CRGB(0, 0, 0 ), el primer argumento es el rojo, el segundo el verde y el tercero el azul.

También es significativo que este valor de color sea de 0 a 255.

for (int i = 0; i < RGB_LED_NUM; i++)

En esta función, el bucle girará hasta 10 veces lo declarado al inicio.

Caso 1:

void Toggle_RED_LED(void) {
  // Red Green Blue
  for (int i = 0; i < RGB_LED_NUM; i++)
    LEDs[i] = CRGB(255, 0, 0 );
  FastLED.show();
  delay(1000);
  for (int i = 0; i < RGB_LED_NUM; i++)
    LEDs[i] = CRGB(0, 0, 0 );
  FastLED.show();
  delay(1000);
}

En el primer bucle for, CRGB(255, 0, 0 ) encenderá el LED rojo y en el segundo bucle for CRGB(0, 0, 0 ) apagará el LED rojo.

Así, 10 LEDs rojos se iluminarán durante 1 segundo y luego se apagarán durante 1 segundo.

Caso 2:

void Scrolling_RED_LED(void) {
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Red;
    FastLED.show();
    delay(500);
    LEDs[i] = CRGB::Black;
    FastLED.show();
    delay(500);
  }
}

10 LEDs rojos se encenderán uno a uno en secuencia.

Caso 3:

void O_W_G_scroll() {
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Orange;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::White;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Green;
    delay(50);
    FastLED.show();
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB::Black;
    delay(50);
    FastLED.show();
  }
}

En cada bucle for, los 10 LEDs se iluminarán uno a uno, y luego se apagarán uno a uno.

El primer bucle for enciende la luz naranja, y el segundo bucle for apaga todas las luces.

El tercer bucle for enciende la luz blanca, y el cuarto bucle for apaga todas las luces.

El quinto bucle for enciende la luz verde y el sexto bucle for apaga todas las luces.

Caso 4:

void Rotate_color(void) {
  for (int clr = 0; clr < RGB_LED_NUM; clr++) {
    LEDs[clr]     =   CRGB::Red;
    LEDs[clr + 1] = CRGB::Green;
    LEDs[clr + 2] = CRGB::Blue;
    FastLED.show();
    delay(100);
    for (int clr = 0; clr < RGB_LED_NUM; clr++) {
      LEDs[clr] = CRGB::Black;
      delay(5);
    }
  }
}

En el código, la secuencia roja, verde y azul brillará y girará, como 3 LEDs: rojo, verde y azul giran.

Caso 5:

void r_g_b() {
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB(0, 0, 255);
    FastLED.show();
    delay(50);
  }
  for (int i = RGB_LED_NUM; i >= 0; i--) {
    LEDs[i] = CRGB(0, 255, 0);
    FastLED.show();
    delay(50);
  }
  for (int i = 0; i < RGB_LED_NUM; i++) {
    LEDs[i] = CRGB(255, 0, 0);
    FastLED.show();
    delay(50);
  }
  for (int i = RGB_LED_NUM; i >= 0; i--) {
    LEDs[i] = CRGB(0, 0, 0);
    FastLED.show();
    delay(50);
  }
}

El primer bucle hace brillar los 10 LEDs en color azul.

El siguiente bucle vuelve a encender los 10 LEDs, pero esta vez en color verde y en orden inverso. Después de que el bucle encienda los 10 LEDs, esta vez, el color es rojo después de detenerlo.

Caso 6:

void random_color(void) {
  // loop over the NUM_LEDS
  for (int i = 0; i < RGB_LED_NUM; i++) {
    // choose random value for the r/g/b
    a = random(0, 255);
    b = random(0, 255);
    c = random(0, 255);

    //set the value to the led
    LEDs[i] = CRGB (a, b, c);
    // set the colors set into the physical LED
    FastLED.show();

    // delay 50 millis
    FastLED.delay(200);
  }
}

En este código de patrón, los LEDs brillarán con un color aleatorio.

Los LEDs brillarán en un color aleatorio

Salida de la tira de LEDs WS2812B en el terminal de serie

¿Cómo se controlan los LEDs direccionables individualmente?

Para controlar el LED direccionable Indifvual, es necesario actualizar la función CRGB(0,0,0) para seleccionar el color y leds[valor] para seleccionar el número de led.

En el bucle void(), puedes utilizar:

  leds[2] = CRGB(0, 255, 0);
  FastLED.show();
  delay(500);

Aquí, leds[2] significa que el tercer LED será controlado, y CRGB(0, 255, 0) significa que el LED verde brillará.

¿Cuántos LEDs direccionables puede controlar un Arduino?

Cada tira de LEDs necesita un pin de Arduino Uno, y un Arduino Uno tiene 13 pines digitales. Por lo tanto, puede controlar individualmente 13 tiras de LEDs direccionables individualmente.

Conclusión

Después de este tutorial, has aprendido a conectar una tira de LEDs RGB WS2812B con un Arduino y a controlarlos de diferentes maneras.

Espero que hayas encontrado este tutorial informativo. Si lo has hecho, ¡compártelo con un amigo al que le guste la electrónica y hacer cosas!

Me encantaría saber qué proyecto tienes pensado construir o has hecho ya con el Arduino.

Si tienes alguna pregunta o sugerencia o crees que faltan cosas en este tutorial, por favor, comenta abajo.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.

Hiren Tailor

Hiren is a professional Embedded Engineer with a Master’s Degree
in Electronics and Communication Engineering. He is proficient in C and
C++ and enjoys building DIY projects on Arduino, ESP32, PIC32, STM32 & Raspberry PI boards.

Geoff Cremasco

Thursday 9th of November 2023

Thak you for this post. I am in no way technically minded and using Arduino to control lights is very new to me. I am currently teaching myself so I can create a Christmas light show at my house with music here in Sydney. Now I've taken one step closer to controlling strings of addressable LEDs then next step to is to add music and effects!