Construye una Matriz LED Desplazante 48x8 con Arduino – Guía Paso a Paso

Componentes y suministros

Arduino UNO	×	1
Registro de desplazamiento 74HC595 8 bits Serie a Paralelo	×	7
Resistencia 475 ohm	×	56
Header macho 40 posiciones 1 fila (0.1")	×	2
Header hembra 8 posiciones 1 fila (0.1")	×	21
Placa PCB de propósito general 6"x4"	×	4
Matriz LED 8X8	×	6
Transistor BC 548	×	1

Herramientas y máquinas necesarias

• Soldador (genérico)
• Pistola de pegamento caliente (genérica)
• Multímetro digital Digilent Mastech MS8217

Aplicaciones y servicios en línea

• Arduino IDE

Sobre este proyecto

¡Hola a todos!

Este proyecto trata sobre hacer una Matriz LED Programable Desplazante 48x8 usando un Arduino UNO y registros de desplazamiento 74HC595.

Este fue mi primer proyecto con una placa de desarrollo Arduino. Fue un reto que me dio mi profesor para intentar construir uno. En ese momento, ni siquiera sabía cómo parpadear un LED usando un Arduino. Así que creo que incluso un principiante puede hacerlo con un poco de paciencia y comprensión. Encontré el diagrama de circuito en línea y esa fue mi única referencia para construir este proyecto. Empecé con una pequeña investigación sobre registros de desplazamiento y multiplexación en Arduino.

El Circuito

Recopilación de componentes

Reuní todos los componentes de diferentes fuentes. Conseguí esta matriz LED 8x8 de cátodo común de 5mm de un sitio web.

Construcción del prototipo

Se muestra en el circuito que un solo registro de desplazamiento se usa para controlar las 8 filas y para controlar las columnas, usamos un registro de desplazamiento para cada 8 columnas.

Así que si puedes hacer una simple matriz 8x8, puedes simplemente replicar la parte del circuito para el control de columnas y extender la matriz a cualquier número de columnas. Solo necesitas añadir un 74HC595 por cada 8 columnas (un módulo 8x8) que añadas al circuito. Teniendo eso en mente, hice mi prototipo 8x8.

Etapa de soldadura

Tomé placas de puntos separadas para hacer los controles de filas y columnas y extendí cables y headers para conectarlos.

Una vez que hayas hecho exitosamente una matriz 8x8, solo necesitas encadenar más registros de desplazamiento con reloj común para controlar las columnas. Solo necesitas un 74HC595 para controlar todas las filas. Así que basado en el número de columnas, se pueden añadir más registros de desplazamiento, no hay límite para el número de columnas que puedes añadir.

Construyendo la Segunda Mitad

Como no tenía acceso a impresión 3D en ese momento, acudí a un carpintero local para hacer una caja.

La caja que hizo era mucho más grande de lo que esperaba, es mejor diseñar una caja más pequeña usando Fusion 360 u otro software de diseño e imprimirla en 3D. Se hicieron agujeros en la caja para conectar los cables de alimentación y USB.

El Código

El código se encuentra en los adjuntos de este proyecto.

Aquí escanearemos a través de las filas y alimentaremos las líneas de columna con niveles lógicos apropiados. El código determinará la velocidad del mensaje desplazante así como el mensaje que vamos a mostrar. La dirección del desplazamiento es de derecha a izquierda por defecto en el código, pero con una pequeña modificación, se puede implementar en otras direcciones también.

El Resultado

¡Gracias! :)

Código

Código Arduino para Matriz LED 48x8 (C/C++)

/*////////////////////////////////////////////////////////////////////////////////
 * Código Arduino para mostrar caracteres desplazantes en 6 o más matrices 8x8 LED.
 * 
 * El número de matrices puede aumentarse con un pequeño cambio en el código.
 * 
 * Comentarios en cada statement para edición.
 * 
 * Codificado por Prasanth K S
 * 
 * Contacto: kksjunior@hotmail.com
 * /*////////////////////////////////////////////////////////////////////////////////
char msg[] = "WELCOME WIZ"; // Cambia el texto aquí.
int scrollspeed = 5; // Velocidad de desplazamiento (menor = más rápido)
int x;
int y;
// Columnas
int clockPin1 = 2; // Pin Arduino conectado a Clock Pin 11 del 74HC595
int latchPin1 = 3; // Pin Arduino conectado a Latch Pin 12 del 74HC595
int dataPin1 = 4; // Pin Arduino conectado a Data Pin 14 del 74HC595
// Filas
int clockPin2 = 5; // Pin Arduino conectado a Clock Pin 11 del 74HC595
int latchPin2 = 6; // Pin Arduino conectado a Latch Pin 12 del 74HC595
int dataPin2 = 7; // Pin Arduino conectado a Data Pin 14 del 74HC595

// BITMAP
// Los bits en este array representan un LED de la matriz
// 8 es # de filas, 6 es # de matrices LED
byte bitmap[8][7];
int numZones = sizeof(bitmap) / 8; // Una Zona se refiere a una matriz 8x8 (Grupo de 8 columnas)
int maxZoneIndex = numZones - 1;
int numCols = numZones * 8;

// DEFINICIÓN DE FUENTE
byte alphabets[][8] = {
  {0,0,0,0,0}, // @ como ESPACIO
  {31, 36, 68, 36, 31}, // A
  {127, 73, 73, 73, 54}, // B
  {62, 65, 65, 65, 34}, // C
  {127, 65, 65, 34, 28}, // D
  {127, 73, 73, 65, 65}, // E
  {127, 72, 72, 72, 64}, // F
  {62, 65, 65, 69, 38}, // G
  {127, 8, 8, 8, 127}, // H
  {0, 65, 127, 65, 0}, // I
  {2, 1, 1, 1, 126}, // J
  {127, 8, 20, 34, 65}, // K
  {127, 1, 1, 1, 1}, // L
  {127, 32, 16, 32, 127}, // M
  {127, 32, 16, 8, 127}, // N
  {62, 65, 65, 65, 62}, // O
  {127, 72, 72, 72, 48}, // P
  {62, 65, 69, 66, 61}, // Q
  {127, 72, 76, 74, 49}, // R
  {50, 73, 73, 73, 38}, // S
  {64, 64, 127, 64, 64}, // T
  {126, 1, 1, 1, 126}, // U
  {124, 2, 1, 2, 124}, // V
  {126, 1, 6, 1, 126}, // W
  {99, 20, 8, 20, 99}, // X
  {96, 16, 15, 16, 96}, // Y
  {67, 69, 73, 81, 97}, // Z
};

void setup() {
  pinMode(latchPin1, OUTPUT);
  pinMode(clockPin1, OUTPUT);
  pinMode(dataPin1, OUTPUT);
  pinMode(latchPin2, OUTPUT);
  pinMode(clockPin2, OUTPUT);
  pinMode(dataPin2, OUTPUT);
  
  // Limpiar bitmap
  for (int row = 0; row < 8; row++) {
    for (int zone = 0; zone <= maxZoneIndex; zone++) {
      bitmap[row][zone] = 0;
    }
  }
}

// FUNCIONES
// Muestra el array bitmap en la matriz
void RefreshDisplay() {
  for (int row = 0; row < 8; row++) {
    int rowbit = 1 << row;
    digitalWrite(latchPin2, LOW); // Mantener latchPin LOW para transmitir datos
    shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit); // Transmitir datos
    
    // Empezar a enviar bytes de columna
    digitalWrite(latchPin1, LOW); // Mantener latchPin LOW para transmitir datos
    
    // Shift out a cada matriz
    for (int zone = maxZoneIndex; zone >= 0; zone--) {
      shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]);
    }
    
    // Voltear ambos latches a la vez para eliminar parpadeo
    digitalWrite(latchPin1, HIGH); // Devolver latch pin 1 high para señalar chip
    digitalWrite(latchPin2, HIGH); // Devolver latch pin 2 high para señalar chip
    
    // Esperar
    delayMicroseconds(300);
  }
}

// Convierte fila y columna a bit de bitmap y lo enciende/apaga
void Plot(int col, int row, bool isOn) {
  int zone = col / 8;
  int colBitIndex = x % 8;
  byte colBit = 1 << colBitIndex;
  if (isOn) bitmap[row][zone] = bitmap[y][zone] | colBit;
  else bitmap[row][zone] = bitmap[y][zone] & (~colBit);
}

// Dibuja cada carácter del mensaje una columna a la vez, actualiza display, desplaza bitmap a la izquierda
void XProcess() {
  for (int charIndex = 0; charIndex < (sizeof(msg) - 1); charIndex++) {
    int alphabetIndex = msg[charIndex] - '@';
    if (alphabetIndex < 0) alphabetIndex = 0;
    
    // Dibujar un carácter del mensaje
    // Cada carácter tiene 5 columnas de ancho, bucle dos veces más para crear espacio de 2 píxeles entre caracteres
    for (int col = 0; col < 7; col++) {
      for (int row = 0; row < 8; row++) {
        // Establecer píxel según el alfabeto para columnas 0 a 4, pero siempre dejar columnas 5 y 6 en blanco.
        bool isOn = 0;
        if (col < 5) isOn = bitRead(alphabets[alphabetIndex][col], 7 - row) == 1;
        Plot(numCols - 1, row, isOn); // Dibujar en la columna más a la derecha, el bucle de desplazamiento abajo lo moverá a la izquierda.
      }
      for (int refreshCount = 0; refreshCount < scrollspeed; refreshCount++) RefreshDisplay();
      
      // Desplazar bitmap una columna a la izquierda
      for (int row = 0; row < 8; row++) {
        for (int zone = 0; zone < numZones; zone++) {
          // Este desplazamiento a la derecha se mostraría como desplazamiento a la izquierda en display porque la columna más izquierda está representada por el bit menos significativo del byte.
          bitmap[row][zone] = bitmap[row][zone] >> 1;
          // Desplazar bit más bajo de la siguiente zona como bit más alto de esta zona.
          if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone + 1], 0));
        }
      }
    }
  }
}

void loop() {
  XProcess();
}

Esquemáticos

Solo para referencia. Para conexiones de pines, consultar los comentarios en el código.