C++

Matriz de 11×2 LEDs controlada con Arduino para un R2D2

por

Autor: Julio César Sandria Reynoso
Fecha: 9 de noviembre de 2024

Robot tipo R2D2

En este artículo se presenta un proyecto de creación de una matriz de 11×2 LEDs que se controlan con Arduino para colocarlos en una ranura de un robot similar al R2D2 de las películas Star Wars.

Semanas atrás, uno de los alumnos del Instituto de Robótica de Xalapa (iRoX) llevó su robot R2D2 para hacerle algunas mejoras. Una de esas mejoras consiste en ponerle LEDs en algunas de las ranuras de la cabeza.

Una de esas ranuras es rectangular de 9 cm X 1.2 cm, donde se puede colocar una matriz de 11×2 LEDs por dentro de la cabeza para que se pueda ver su encendido desde el exterior.

Cabeza de R2D2

La idea de poner varios LEDs fue para emular un tanto la forma en que trabaja el robot de las películas, encendiendo de diversas formas los LEDs de esa ranura.

Algunos de los alumnos participaron en el diseño de la sección rectangular para la colocación de los LEDs, inicialmente se consideró una tabla de MDF de 3mm cortada en láser para colocar allí los LEDs, pero se descartó porque con una placa fenólica perforada fue suficiente.

La disposición de los 22 LEDs, con resistencias, transistores y conexiones a Arduino se diseñó en Tinkercad. De hecho, en esta plataforma se hizo también la programación inicial y simulación de su funcionamiento, lo cual se muestra en el artículo Arreglo de 22 LEDS (11×2) con encendido aleatorio con Arduino en Tinkercad.

Arreglo de LEDs en 11 columnas y 2 filas conectados con transistores a Arduino UNO

Después del diseño del circuito en Tinkercad, se procedió a soldar los componentes en la placa fenólica. El material usado es el siguiente:

  • Placa fenólica perforada
  • 22 LEDs de diferentes colores
  • 11 resistencias de 220 Ohms
  • 2 transistores 2N2222
  • 2 resistencias de 1 KOhm
  • Cable UTP
  • Tira de pines macho 90° (14 conectores)
Componentes soldados a la placa fenólica

Una vez soldados todos los componentes como se ve en la imagen «Componentes soldados a la placa fenólica», se conectaron cables Dupont hembra-macho del circuito al Arduino UNO de la siguiente forma:

  • Los primeros 11 cables de izquierda a derecha se conectan a los pines digitales 10 a 0 de Arduino respectivamente.
  • El antepenúltimo cable (amarillo) se conecta al pin analógico A0.
  • El penúltimo cable (naranja) se conecta al pin analógico A1.
  • El último cable (rojo) se conecta a GND.

Una vez conectado todo, se cargó el siguiente programa C++ desde Arduino IDE al Arduino UNO.

// Programa C++ para Arduino
// Autor: Julio César Sandria Reynoso
// Fecha: Noviembre 2024
// Arreglo de LEDs de 11 columnas X 2 filas,
// enciende LEDs de forma aleatoria o con ciertos patrones
#define columnas 11
#define filas 2
int Columnas[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int Filas[] = {A0, A1};
int ledColumna[columnas];
int ledFila[columnas];

void setup() {
  for (int col = 0; col < columnas; col++)
    pinMode(Columnas[col], OUTPUT); 
  for (int fila = 0; fila < filas; fila++)
    pinMode(Filas[fila], OUTPUT);
}

void loop() {
  // Enciende un led iniciando en la primera fila de 
  // izquierda a derecha y terminando en la segunda 
  // fila a la izquierda
  for(int t=100; t>=40; t=t-20)
    ledPorFila(t,0);

  // Enciende de 1 a 5 leds de forma aleatoria durante un tiempo
  // de 100 + i*50 ms y apagándolos 0 ms
  for(int i=1; i<6; i++)
    ledsAleatorios(i,100+i*50,0);

  // Enciende 6 leds de forma aleatoria durante 50 iteraciones
  for(int i=0; i<50; i++)
    ledsAleatorios(6,350,0);
}

void ledPorFila(int tEncendido, int tApagado) {
  for(int i=columnas-1; i>=0; i--) {
    digitalWrite(Filas[0], HIGH);
    digitalWrite(Columnas[i], HIGH);
    delay(tEncendido);

    digitalWrite(Filas[0], LOW);
    digitalWrite(Columnas[i], LOW);
    delay(tApagado);
  }
  for(int i=0; i<columnas; i++) {
    digitalWrite(Filas[1], HIGH);
    digitalWrite(Columnas[i], HIGH);
    delay(tEncendido);

    digitalWrite(Filas[1], LOW);
    digitalWrite(Columnas[i], LOW);
    delay(tApagado);
  }
}

void ledsAleatorios(int nLeds, int tEncendido, int tApagado) {
  // Los arreglos ledFila[] y ledColumna[] tienen <columnas> elementos,
  // de los cuales solo se usan <nLeds> elementos en esta función.
  // Es posible que de forma aleatoria se repita un led a encender,
  // pero es imperceptible o poco notorio durante la ejecución.
  // Encendemos los nLeds indicados, durante <tEcendido> milisegundos
  for(int i=0; i<nLeds; i++) {
    ledFila[i] = random(0, filas);
    ledColumna[i] = random(0, columnas);
    digitalWrite(Columnas[ledColumna[i]], HIGH);
    digitalWrite(Filas[ledFila[i]], HIGH);
  }
  delay(tEncendido);
  // Apagamos todos los leds encendidos
  for(int i=0; i<nLeds; i++) {
    digitalWrite(Columnas[ledColumna[i]], LOW);
    digitalWrite(Filas[ledFila[i]], LOW);    
  }
  delay(tApagado);
}

Las siguientes fotografías son del circuito funcionando.

Matriz 22 LEDs con Arduino UNO
Un LED encendido
Algunos LEDs encendidos
Circuito con matriz de 22 LEDs conectado a Arduino UNO dentro de la cabeza de R2D2

Al probar el programa se detectó que algunos LEDs no encendían, por lo que se hizo una revisión exhaustiva, encontrando algunos errores de soldadura, que se fueron resolviendo.

Con este tipo de proyectos, donde los alumnos practican los temas que se van viendo en el iRoX, los alumnos se sienten motivados a aprender aún mucho más.

Si te interesa aprender más sobre programación en C++, Arduino, robótica u otros lenguajes de programación, visita el sitio web del Instituto de Robótica de Xalapa (www.irox.mx) y contáctanos. Si estás en una región cercana a Xalapa, como Veracruz, Boca del Río, Córdoba, Martínez de la Torre, etc., puedes visitar las instalaciones del iRoX entre semana o un sábado y hablar con nuestros profesores sobre proyectos de robótica o tecnología.

Agradecemos a los alumnos que están participando en este proyecto: David, Germán, Fernando, Carlo y Max.

Arreglo de 22 LEDS (11×2) con encendido aleatorio con Arduino en Tinkercad

por
Instituto de Robótica de Xalapa - iRoX

Autor: Julio César Sandria Reynoso
Fecha: 19 de octubre de 2024

En este artículo se presenta un proyecto en Tinkercad (www.tinkercad.com) haciendo un circuito para conectar 22 LEDs en un arreglo de 11 columnas y 2 filas, con encendido aleatorio de los LEDs.

Lo interesante de este proyecto es mostrar cómo, teniendo únicamente 20 pines de entrada/salida en Arduino UNO (14 digitales y 6 analógicos), podemos conectar 22, 30 ó 45 LEDs y controlarlos fácilmente mediante programación C++ en Arduino.

Arreglo de LEDs en 11 columnas y 2 filas conectados con transistores a Arduino UNO

En la imagen se puede ver que en forma de columna, se conectan dos LEDs a cada uno de los pines digitales 0 a 10 de Arduino. Por ejemplo, viendo los LEDs de derecha a izquierda, en los primeros dos LEDs los ánodos (+) se conectan entre si, después a una resistencia de 220 Ohms y la resistencia se conecta al pin 0 de Arduino. Y así sucesivamente se conectan los demás LEDs.

En la primera fila de 11 LEDs (los de arriba), se conectan entre si sus cátodos (-), y todos ellos se conectan a la patilla C (colector) del transistor NPN de la derecha. La patilla E (emisor) se conecta a tierra (GND de Arduino) y la patilla B (base) se conecta a una resistencia de 1 KOhm y ésta al pin analógico A0 de Arduino.

De forma similar, la segunda fila de 11 LEDs se conectan sus cátodos (-) al transistor NPN de la izquierda y la patilla B (base) se conecta con una resistencia de 1 Ohm de por medio, al pin A1 de Arduino.

Para encender los primeros dos LEDs de la derecha, se activa el pin 0 de Arduino con digitalWrite(0,HIGH), pero esto por si solo no enciende ninguno de los dos LEDs. Para encender el primer LED de la derecha-arriba, se debe activar el pin A0 de Arduino con digitalWrite(A0,HIGH). Con esto, se envía el voltaje necesario a la base del transistor de la derecha, lo que cierra el circuito entre el colector y emisor de dicho transistor, permitiendo el flujo de corriente desde el pin 0 de Arduino, pasando por el LED (derecha-arriba), el transistor derecho, hasta el GND de Arduino.

El programa siguiente implementa el encendido de forma aleatoria de un LED durante 15 veces y después el encendido de dos LEDs de forma aleatoria durante 20 veces. Esto se repite mientras se ejecute la simulación en Tinkercad.

// Programa C++ para Arduino
// Arreglo de LEDs de 11 columnas X 2 filas,
// enciende un LED de forma aleatoria y
// después enciende dos LEDs de forma aleatoria
int Columnas[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int Filas[] = {A0, A1};
int columnas = 11;
int filas = 2;

void setup() {
  for (int col = 0; col < columnas; col++)
    pinMode(Columnas[col], OUTPUT); 
  for (int fila = 0; fila < filas; fila++)
    pinMode(Filas[fila], OUTPUT);
}

void loop() {
  // 15 veces encendemos un led de forma aleatoria
  ledAleatorio(15);
  // 20 veces encendemos dos leds de forma aleatoria
  ledAleatorio2(20);
}

void ledAleatorio(int n) {
  int aFila;
  int aColumna;

  for(int i=0; i<n; i++) {
    aFila = random(0, filas);
    aColumna = random(0, columnas);

    digitalWrite(Filas[aFila], HIGH);
    digitalWrite(Columnas[aColumna], HIGH);
    delay(300);

    digitalWrite(Filas[aFila], LOW);
    digitalWrite(Columnas[aColumna], LOW);
    delay(200);
  }
}

void ledAleatorio2(int n) {
  int aFila;
  int aColumna;
  int a2Fila;
  int a2Columna;
  
  for(int i=0; i<n; i++) {
    aFila = random(0, filas);
    aColumna = random(0, columnas);
    a2Fila = random(0, filas);
    a2Columna = random(0, columnas);

    digitalWrite(Filas[aFila], HIGH);
    digitalWrite(Columnas[aColumna], HIGH);
    digitalWrite(Filas[a2Fila], HIGH);
    digitalWrite(Columnas[a2Columna], HIGH);
    delay(300);

    digitalWrite(Filas[aFila], LOW);
    digitalWrite(Columnas[aColumna], LOW);
    digitalWrite(Filas[a2Fila], LOW);
    digitalWrite(Columnas[a2Columna], LOW);
    delay(200);
  }
}

Si te interesa aprender más sobre programación en C++, Arduino, robótica u otros lenguajes de programación, visita el sitio web del Instituto de Robótica de Xalapa (www.irox.mx) y contáctanos. Si estás en una región cercana a Xalapa, como Veracruz, Boca del Río, Córdoba, Martínez de la Torre, etc., puedes visitar las instalaciones del iRoX entre semana o un sábado y hablar con nuestros profesores sobre proyectos de robótica o tecnología.