¿Cómo controlar una matriz LED RGB de 8×8 con Arduino UNO? 😲👌

  2. Arduino
  3. ¿Cómo controlar una matriz LED RGB de 8×8 con Arduino UNO? 😲👌
¿Cómo controlar una matriz LED RGB de 8×8 con Arduino UNO? 😲👌

¿Quieres darle vida a tu entorno? ¿Te gustaría aprender a controlar LEDs RGB? pues en este blog te algunas opciones muy atractivas que puedes hacer tu mismo de manera muy sencilla 🤩🔦.

Si es la primera vez que vas a emplear Arduino, te recomendamos leer nuestro blog sobre: ¿Cómo empezar con Arduino?

¿Qué son los LEDs RGB? 🤔

Los Leds RGB son diodos que presentan en un mismo encapsulado 3 colores básicos, rojo, verde y azul (Red, Green, Blue) que es por ello que se llaman RGB, además comparten un cátodo común. Al presentar 3 colores principales no solo pueden encenderse de estos, sino también pueden realizar muchas combinaciones de color. Hay diferentes tipos de LEDs RGB en este caso emplearemos los neopixel, ya que vienen incluidos en la matriz WS2812B-64 y esta nos ayudará a poder crear diferentes figuras.

________________________________ ¡COMENCEMOS!!! 🤠 _______________________________

Materiales

  • Arduino UNO
  • Matriz LED RGB Neopixel 8×8 WS2812B-64
  • Jumpers de 3 colores diferentes (se recomienda rojo para la alimentación, negro para GND y otro color como verde para la señal).
  • Acrílico negro traslucido del tamaño de la matriz (el que se empleará es de 7cm x 7cm).

Conexión de componentes

ArduinoMatriz LED RGB
5VV+
Pin digital 6 IN
GNDV-

Mensaje en movimiento 🔠➡️

En Perú nos encontramos en el mes patrio, es por ello que con este proyecto también se quiere conmemorar las fiestas patrias. El presente código mostrará el mensaje: “Felices Fiestas Patrias”. Sin embargo, este puede ser cambiado de acuerdo a tu elección.

#include <Adafruit_GFX.h>         // librería de Adafruit
#include <Adafruit_NeoMatrix.h>  // librería de Adafruit
#include <Adafruit_NeoPixel.h>  // librería de Adafruit
#ifndef PSTR                   // Comprobamos si no hay definiciones
 #define PSTR                 // 
#endif                       // Finalizar el código
#define PIN 6               // Definimos al PIN digital 6 de Arduino para emplearlo como entrada de la matriz

//Aquí definimos el tipo de matriz que estamos empleando, en este caso 8x8
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(8, 8, PIN, 
 NEO_MATRIX_TOP + NEO_MATRIX_LEFT +
 NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE,
 NEO_GRB + NEO_KHZ800);                               

// Colocamos los colores a elección en escala RGB
const uint16_t colors[] = {
 matrix.Color(255, 0, 0), matrix.Color(255,255,255)}; 

void setup() {
 matrix.begin();                       // Declaramos el inicio de funcionamiento de la matriz
 matrix.setTextWrap(false);           // Permitir que el texto se desplace hacia la derecha
 matrix.setBrightness(20);           // Configurar el porcentaje de brillo de los leds 
 matrix.setTextColor(colors[0]);    // Colocar los colores en la matriz
}
int x = matrix.width();           // Dimensionamos el tamaño de recorrido en el eje x
int pass = 0;            

void loop() {
 matrix.fillScreen(0);                        // Apagamos los leds encendidos para poder comenzar
 matrix.setCursor(x, 0);                     //ubicación de inicio de encendido
  matrix.print("FELICES FIESTAS PATRIAS");  // Ingresamos el texto que nos gustaría visualizar
 if(--x < -300) {                          //Dirección y distancia que puede recorrer el texto en el eje x
 x = matrix.width();                
 if(++pass >= 2) pass = 0;                // Da un límite de veces en el cual se mostrará para luego reiniciarlo
 matrix.setTextColor(colors[pass]);
 }
 matrix.show();                        // Enviar la programación al Hardware
 delay(130);                          //modificamos el tiempo de retardo de acuerdo a la preferencia
}

¿No entendiste?🤨… ¡Aquí te lo explicamos!👇😉

Primero se necesita incluir las librerías de Adafruit_GFX.h ; Adafruit_NeoMatrix.h y Adafruit_NeoPixel.h , con ellas podremos utilizar los parámetros ya planteados y programar de manera más sencilla.

Asimismo, añadimos las condiciones de definición con las cuales trabaja Arduino. Sin olvidar definir al Pin digital número 6 del Arduino como el encargado de enviar la programación a la matriz.

#include <Adafruit_GFX.h>         // librería de Adafruit
#include <Adafruit_NeoMatrix.h>  // librería de Adafruit
#include <Adafruit_NeoPixel.h>  // librería de Adafruit
#ifndef PSTR                   // Comprobamos si no hay definiciones
 #define PSTR                 // 
#endif                       // Finalizar el código
#define PIN 6               // Definimos al PIN digital 6 de Arduino para emplearlo como entrada de la matriz

Luego de ello, es importante indicar con que tipo de matriz estamos trabajando por lo que estos parámetros ayudan a que Arduino pueda identificarla, estos son propios de la librería que estamos empleando de Adafruit. Con ellos decimos que nuestra matriz es de 8×8 LEDs.

//Aquí definimos el tipo de matriz que estamos empleando, en este caso 8x8
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(8, 8, PIN, 
 NEO_MATRIX_TOP + NEO_MATRIX_LEFT +
 NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE,
 NEO_GRB + NEO_KHZ800);

Seguimos seleccionando los colores que nos gustaría apreciar. Para ello, es necesario colocar los colores en escala RGB para que Arduino pueda identificarlos. Luego de haber seleccionado los colores o el color de preferencia, colocamos sus escalas dentro del parámetro: matrix.Color(x, x, x). Podemos escoger cuantos colores queramos, estos se mostrarán en el orden colocado.

// Colocamos los colores a elección en escala RGB
const uint16_t colors[] = {
 matrix.Color(255, 0, 0), matrix.Color(255,255,255)};
ColorNombre del colorEscala RGB
_______Negro0,0,0
_______Plateado192,192,192
_______Gris128,128,128
_______Blanco255,255,255
_______Marrón128,0,0
_______Rojo 255,0,0
_______Morado128,0,128
_______Fucsia255,0,255
_______Verde0,128,0
_______Verde Lima0,255,0
80800Olivo128,128,0
_______Amarillo255,255,0
_______Azul marino0,0,128
_______Azul0,0,255
_______Verde azulado0,128,128
_______Turquesa0,255,255

Seguidamente, en el void set up() se coloca los siguientes comandos, que nos permitirán configurar el funcionamiento de la matriz. Además, añadimos el comando int que nos ayudará a dimensionar el límite de recorrido que tendrá el texto en el eje x, ya que se desplazará hacia la derecha. Y la variable pass , estará relacionada con la cantidad de colores que podrá tomar el texto.

void setup() {
 matrix.begin();                       // Declaramos el inicio de funcionamiento de la matriz
 matrix.setTextWrap(false);           // Permitir que el texto se desplace hacia la derecha
 matrix.setBrightness(20);           // Configurar el porcentaje de brillo de los leds 
 matrix.setTextColor(colors[0]);    // Colocar los colores en la matriz
}
int x = matrix.width();           // Dimensionamos el tamaño de recorrido en el eje x
int pass = 0;

Dentro del ciclo de instrucciones, primero será necesario limpiar la matriz para poder iniciar, luego ubicar donde comenzarán los leds a encenderse y finalmente colocamos el texto a elección.

void loop() {
 matrix.fillScreen(0);                        // Apagamos los leds encendidos para poder comenzar
 matrix.setCursor(x, 0);                     //ubicación de inicio de encendido
  matrix.print("FELICES FIESTAS PATRIAS");  // Ingresamos el texto que nos gustaría visualizar

El primer condicional if , menciona si el decremento de x es menor a -300, entonces el mensaje que hayamos colocado entrará en el recorrido de x.

El segundo condicional if , afirma que si el incremento de pass es mayor o igual a 2, entonces el valor de pass será igual a 0, es decir los leds volverán a repetir el mismo ciclo de colores de leds. Es decir, si en vez de 2 fuera 3, la condición rellenaría la el recorrido con un mensaje azul a pesar de solo haber colocado rojo y blanco.

 if(--x < -300) {                          //Dirección y distancia que puede recorrer el texto en el eje x
 x = matrix.width();                
 if(++pass >= 2) pass = 0;                // Da un límite de veces en el cual se mostrará para luego reiniciarlo
 matrix.setTextColor(colors[pass]);
 }

Finalmente, mostramos enviamos las instrucciones a la matriz con matrix.show y añadimos el retardo con el que se desplazarán las letras, este puede ser cambiado de acuerdo a su preferencia.

matrix.show();                        // Enviar la programación al Hardware
 delay(130);                          //modificamos el tiempo de retardo de acuerdo a la preferencia
}

Bandera animada 🇵🇪

En este caso se hará la bandera del Perú, pero siguiendo los pasos puedes colocar cualquier otro dibujo.

#include <Adafruit_NeoPixel.h>               //Librería Adafruit
#ifdef AVR
 #include <avr/power.h>                    // Required for 16 MHz Adafruit Trinket
#endif
#define PIN        6                     // Definimos al PIN digital 6 de Arduino para emplearlo como entrada de la matriz
#define NUMPIXELS 64                    //Tamaño de la matriz

//Designamos la variable para la matriz
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

#define DELAYVAL 500                 // Tiempo en milisegundos de pausa entre encendido de led a led

void setup() {
  pixels.begin();                 // Iniciamos la matriz
  pixels.setBrightness(20);      //  Porcentaje de brillo de los leds
}
void loop() {  
  pixels.clear();              // Apagamos los leds encendidos para poder comenzar
  int j = 0;                  // Dfinimos a j como el indicador del primer LED
  for(int i=0; i<8; i++) {   // El encendido de LEDs se incrementa en 8 al querer una secuencia de encendido en columnas
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));            // Designamos un color en escala RGB
    pixels.show();   // Envio del color al harware       
    delay(50);      // Pausa antes de encender el siguiente led
    j=j+8;         // Al valor de j se le suma 8 para poder encender los leds de manera continua
  }
  j = 1;          // Segundo LED de la segunda columna
  for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 2;    // Tercer LED de la tercera columna
  for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 3;   // Cuarto LED de la cuarta columna
    for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 255, 255));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 4;  // Quinto LED de la quinta columna
    for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 255, 255));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 5; //Sexto LED de la sexta columna
    for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 6; // Séptimo LED de la séptima columna 
    for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
    j = 7; // Octavo LED de la octava columna 
    for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(50); // Pause before next pass through loop
    j=j+8;
  }
}

Como en el primer código añadimos las librerías necesarias y definimos al PIN digital 6 como la entrada de la matriz.

#include <Adafruit_NeoPixel.h>               //Librería Adafruit
#ifdef AVR
 #include <avr/power.h>                    // Required for 16 MHz Adafruit Trinket
#endif
#define PIN        6                     // Definimos al PIN digital 6 de Arduino para emplearlo como entrada de la matriz
#define NUMPIXELS 64                    //Tamaño de la matriz

En este caso, para referirnos a la matriz la llamaremos pixels y colocaremos un tiempo de retardo de 500 milisegundos para el encendido entre LED y LED.

//Designamos la variable para la matriz
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

#define DELAYVAL 500                 // Tiempo en milisegundos de pausa entre encendido de led a led

Dentro del void set up, indicamos el inicio de funcionamiento de la matriz y el brillo de los LEDs, este puede cambiar de acuerdo a su preferencia. 

void setup() {
  pixels.begin();                 // Iniciamos la matriz
  pixels.setBrightness(20);      //  Porcentaje de brillo de los leds
}

Primero, planteamos la secuencia de encendido, para este caso se encenderán una a una cada columna, donde las columnas 1 , 2 y 3 serán rojas, las 4 y 5 blancas y 6 , 7 y 8 rojas nuevamente. Luego de entender ello, numeramos los LEDs de la matriz.

Dentro del void loop, primero limpiamos la matriz. Luego, nombramos j al primer LED que queremos que se encienda, donde j es igual a 0 de acuerdo a la numeración y con for condicionamos que el encendido de LEDs se incrementará cada 8 y al iniciar con el valor de j en 0 se le sumará 8 que es igual a 8 que será el siguiente LED en encenderse y así de manera sucesiva hasta terminar la columna. 

void loop() {  
  pixels.clear();              // Apagamos los leds encendidos para poder comenzar
  int j = 0;                  // Definimos a j como el indicador del primer LED
  for(int i=0; i<8; i++) {   // El encendido de LEDs se incrementa en 8 al querer una secuencia de encendido en columnas
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));            // Designamos un color en escala RGB
    pixels.show();   // Envio del color al hardware       
    delay(50);      // Pausa antes de encender el siguiente led
    j=j+8;         // Al valor de j se le suma 8 para poder encender los leds de manera continua
  }

La segunda columna inicia con el LED 1 por lo que repetiremos este fragmento de código pero con el valor de j ahora igual a 1 y de igual manera para las demás columnas. Además recordar que se puede configurar la escala RGB a elección. 

  j = 1;          // Segundo LED de la segunda columna
  for(int i=0; i<8; i++) { 
    pixels.setPixelColor(j, pixels.Color(255, 0, 0));       // Designamos un color en escala RGB
    pixels.show();   // Envio del color al hardware     
    delay(50);      // Pausa antes de encender el siguiente led
    j=j+8;         // Al valor de j se le suma 8 para poder encender los leds de manera continua
  }

Conclusiones

  • Lo ideal de este proyecto es que se pueden añadir matrices LED de la misma proporción para obtener una imagen de mayor tamaño y en el caso del mensaje habría mayor espacio para que se muestren las palabras.
  • Recuerda que puedes usar este proyecto para decorar tu dormitorio, tu negocio, tu sala o incluso como obsequio por cumpleaños o días festivos.
  • Se recomienda emplear el acrílico negro traslucido para que el tono de las luces se pueda apreciar mejor con la luz del día.

¿Necesitas ayuda? Escríbenos😉👇

Chat on WhatsApp
28/07/2023
Arduino
Previous Post
Next Post