Construire une matrice LED défilante 48x8 avec Arduino – Guide étape par étape

Composants et fournitures

Arduino UNO	×	1
Registre à décalage 74HC595 8 bits série vers parallèle	×	7
Résistance 475 ohms	×	56
Connecteur mâle 40 positions 1 rangée (0,1")	×	2
Connecteur femelle 8 positions 1 rangée (0,1")	×	21
Circuit imprimé universel 6"×4"	×	4
Matrice LED 8x8	×	6
Transistor BC 548	×	1

Outils et machines nécessaires

• Fer à souder
• Pistolet à colle chaude
• Multimètre numérique autorange Digilent Mastech MS8217

Applications et services en ligne

• Arduino IDE

À propos de ce projet

Bonjour à tous !

Ce projet consiste à réaliser une matrice LED programmable défilante 48x8 en utilisant un Arduino UNO et des registres à décalage 74HC595.

C'était mon premier projet avec une carte de développement Arduino. C'était un défi lancé par mon professeur pour essayer d'en construire une. À ce moment-là, je ne savais même pas comment faire clignoter une LED avec un Arduino. Je pense donc qu'un débutant peut le faire avec un peu de patience et de compréhension. J'ai trouvé le schéma de circuit en ligne et c'était ma seule référence. J'ai commencé par des recherches sur les registres à décalage et le multiplexage sur Arduino.

Le circuit

Rassembler les composants

J'ai rassemblé tous les composants de différentes sources. J'ai obtenu cet afficheur matrice LED 8x8 cathode commune 5mm sur un site en ligne.

Construction du prototype

Comme le montre le schéma, un seul registre à décalage contrôle les 8 rangées et pour contrôler les colonnes, on utilise un registre à décalage par 8 colonnes.

Donc si vous arrivez à faire une simple matrice 8x8, vous pouvez simplement répliquer la partie du circuit pour le contrôle des colonnes et étendre la matrice à n'importe quel nombre de colonnes. Il suffit d'ajouter un 74HC595 pour chaque 8 colonnes (un module 8x8) ajouté au circuit. En gardant cela à l'esprit, j'ai fait mon prototype 8x8.

Étape de soudure

J'ai pris des plaques à trous séparées pour faire les contrôles de rangées et colonnes et j'ai étendu les fils et connecteurs pour les relier.

Une fois que vous avez réussi à faire une matrice 8x8, vous n'avez qu'à chaîner plus de registres à décalage avec une horloge commune pour piloter les colonnes. Il faut juste un seul 74HC595 pour piloter toutes les rangées. Selon le nombre de colonnes, plus de registres peuvent être ajoutés, il n'y a pas de limite au nombre de colonnes.

Construction de la seconde moitié

Comme je n'avais pas accès à l'impression 3D à l'époque, j'ai fait appel à un menuisier local pour faire un boîtier.

Le boîtier qu'il a fait était beaucoup plus grand que prévu. Il vaut mieux concevoir un boîtier plus petit avec Fusion 360 ou un autre logiciel de CAO et l'imprimer en 3D. Des trous ont été faits dans le boîtier pour connecter l'alimentation et le câble USB.

Le Code

Le code se trouve dans les pièces jointes de ce projet.

Ici, nous balayons les rangées et alimentons les lignes de colonnes avec les niveaux logiques appropriés. Le code détermine la vitesse de défilement du message ainsi que le message à afficher. Le sens du défilement est de droite à gauche par défaut dans le code, mais avec une petite modification, il peut être implémenté dans d'autres directions.

Le Résultat

La matrice affiche le message défilant correctement.

Merci ! :)

Code complet

/*//////////////////////////////////////////////////////////////////////////////// 
 * Code Arduino pour afficher des caractères défilants sur 6 ou plus matrices 8x8 LED. 
 * Le nombre de matrices peut être augmenté avec une petite modification du code. 
 * Des commentaires sont donnés dans chaque instruction pour l'édition. 
 * Codé par Prasanth K S 
 * Contact : kksjunior@hotmail.com 
 *//////////////////////////////////////////////////////////////////////////////// 

char msg[] = "WELCOME WIZ"; // Changez le texte ici. 
int scrollspeed = 5; // Vitesse de défilement (plus bas = plus rapide) 
int x, y; 

// Colonnes 
int clockPin1 = 2; // Broche Arduino connectée à Clock Pin 11 du 74HC595 
int latchPin1 = 3; // Broche Arduino connectée à Latch Pin 12 du 74HC595 
int dataPin1 = 4;  // Broche Arduino connectée à Data Pin 14 du 74HC595 

// Rangées 
int clockPin2 = 5; // Broche Arduino connectée à Clock Pin 11 du 74HC595 
int latchPin2 = 6; // Broche Arduino connectée à Latch Pin 12 du 74HC595 
int dataPin2 = 7;  // Broche Arduino connectée à Data Pin 14 du 74HC595 

// BITMAP 
// Les bits dans ce tableau représentent une LED de la matrice 
// 8 = # de rangées, 6 = # de matrices LED 
byte bitmap[8][7]; 
int numZones = sizeof(bitmap) / 8; // Une zone = une matrice 8x8 (groupe de 8 colonnes) 
int maxZoneIndex = numZones - 1; 
int numCols = numZones * 8; 

// DÉFINITION POLICE 
byte alphabets[][8] = { 
  {0,0,0,0,0}, // @ comme ESPACE 
  {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); 

  // Effacer bitmap 
  for (int row = 0; row < 8; row++) { 
    for (int zone = 0; zone <= maxZoneIndex; zone++) { 
      bitmap[row][zone] = 0; 
    } 
  } 
} 

// FONCTIONS 
// Affiche le tableau bitmap dans la matrice 
void RefreshDisplay() { 
  for (int row = 0; row < 8; row++) { 
    int rowbit = 1 << row; 
    digitalWrite(latchPin2, LOW); 
    shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit); 
    
    digitalWrite(latchPin1, LOW); 
    for (int zone = maxZoneIndex; zone >= 0; zone--) { 
      shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]); 
    } 
    // Basculer les deux latches en même temps pour éliminer le scintillement 
    digitalWrite(latchPin1, HIGH); 
    digitalWrite(latchPin2, HIGH); 
    delayMicroseconds(300); 
  } 
} 

// Convertit ligne et colonne en bit bitmap et l'allume/éteint 
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[row][zone] | colBit; 
  else bitmap[row][zone] = bitmap[row][zone] & (~colBit); 
} 

// Trace chaque caractère du message une colonne à la fois, met à jour l'affichage, décale le bitmap vers la gauche. 
void XProcess() { 
  for (int charIndex = 0; charIndex < (sizeof(msg) - 1); charIndex++) { 
    int alphabetIndex = msg[charIndex] - '@'; 
    if (alphabetIndex < 0) alphabetIndex = 0; 
    
    // Dessine un caractère du message 
    // Chaque caractère fait 5 colonnes de large, on boucle 2 fois de plus pour créer 2 pixels d'espace entre caractères 
    for (int col = 0; col < 7; col++) { 
      for (int row = 0; row < 8; row++) { 
        // Définit le pixel selon l'alphabet pour les colonnes 0 à 4, mais laisse toujours les colonnes 5 et 6 vides. 
        bool isOn = 0; 
        if (col < 5) isOn = bitRead(alphabets[alphabetIndex][col], 7 - row) == 1; 
        Plot(numCols - 1, row, isOn); 
      } 
      for (int refreshCount = 0; refreshCount < scrollspeed; refreshCount++) 
        RefreshDisplay(); 
      
      // Décale le bitmap d'une colonne vers la gauche 
      for (int row = 0; row < 8; row++) { 
        for (int zone = 0; zone < numZones; zone++) { 
          // Ce décalage vers la droite s'affiche comme un défilement vers la gauche car la colonne la plus à gauche est représentée par le bit de poids faible de l'octet. 
          bitmap[row][zone] = bitmap[row][zone] >> 1; 
          // Décale le bit de poids faible de la zone suivante comme bit de poids fort de cette zone. 
          if (zone < maxZoneIndex) 
            bitWrite(bitmap[row][zone], 7, bitRead(bitmap[row][zone + 1], 0)); 
        } 
      } 
    } 
  } 
} 

void loop() { 
  XProcess(); 
}