Maîtriser la matrice LED 8×8 avec MAX7219 : Défilement de texte et contrôle Bluetooth Android

Dans ce tutoriel Arduino, nous allons apprendre à contrôler une matrice LED 8×8 en utilisant le driver MAX7219 et la carte Arduino. Vous pouvez visionner la vidéo suivante ou lire le tutoriel écrit ci-dessous pour plus de détails.

Présentation

Nous réaliserons trois exemples : le premier expliquera le principe de base du MAX7219, le second montrera comment fonctionne le défilement de texte sur la matrice LED 8×8, et le troisième les contrôlera via Bluetooth et une application Android personnalisée.

Le MAX7219

Examinons de plus près le driver MAX7219. Ce circuit intégré peut piloter 64 LED individuelles en n'utilisant que 3 fils pour la communication avec l'Arduino, et ce qui est encore mieux, on peut mettre plusieurs drivers et matrices en cascade tout en utilisant les mêmes 3 fils.

Les 64 LED sont pilotées par 16 broches de sortie du circuit. Comment est-ce possible ? En réalité, le nombre maximal de LED allumées simultanément est de huit. Les LED sont disposées en ensemble de 8 lignes et 8 colonnes. Le MAX7219 active chaque colonne pendant une très courte période et, en même temps, pilote chaque ligne. En commutant rapidement entre les colonnes et les lignes, l'œil humain ne perçoit qu'une lumière continue.

Notez comment les broches d'une matrice LED 8×8 commune sont agencées en interne ; si vous construisez votre propre matrice, vous devriez en tenir compte.

Notez aussi qu'une carte d'extension courante pour le MAX7219 comporte une résistance entre le 5 V et la broche n°18 du circuit. Cette résistance sert à régler la luminosité ou le courant traversant les LED.

Le tableau suivant, extrait de la fiche technique du circuit, indique la valeur de résistance à utiliser selon la chute de tension directe de vos LED.

Schéma de câblage

Connectons maintenant le module matrice LED 8×8 à la carte Arduino. Voici le schéma :

Le VCC et le GND du module vont sur les broches 5 V et GND de l'Arduino, et les trois autres broches, DIN, CLK et CS, vont sur n'importe quelle broche numérique de l'Arduino. Si on veut connecter plus d'un module, on connecte simplement les broches de sortie de la carte précédente aux broches d'entrée du nouveau module. En fait, ces broches sont toutes identiques, sauf que la broche DOUT de la carte précédente va sur la broche DIN de la nouvelle carte.

Code Arduino de base pour MAX7219

Une fois les modules connectés, regardons le code Arduino du premier exemple. Nous utiliserons la bibliothèque MaxMatrix téléchargeable sur GitHub.

/* Matrice LED 8x8 MAX7219 Exemple 01 par Dejan Nedelkovski, www.HowToMechatronics.com
 * Basé sur la bibliothèque : GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
int DIN = 7, CLK = 6, CS = 5, maxInUse = 1;
MaxMatrix m(DIN, CS, CLK, maxInUse);
char A[] = {4, 8, B01111110, B00010001, B00010001, B01111110};
char B[] = {4, 8, B01111111, B01001001, B01001001, B00110110};
char smile01[] = {8, 8, B00111100, B01000010, B10010101, B10100001, B10100001, B10010101, B01000010, B00111100};
char smile02[] = {8, 8, B00111100, B01000010, B10010101, B10010001, B10010001, B10010101, B01000010, B00111100};
char smile03[] = {8, 8, B00111100, B01000010, B10100101, B10010001, B10010001, B10100101, B01000010, B00111100};
void setup() {
  m.init();
  m.setIntensity(8);
}
void loop() {
  m.setDot(6, 2, true); delay(1000);
  m.setDot(6, 3, true); delay(1000);
  m.clear();
  for (int i = 0; i < 8; i++) { m.setDot(i, i, true); delay(300); }
  m.clear();
  m.writeSprite(2, 0, A); delay(1000);
  m.writeSprite(2, 0, B); delay(1000);
  m.writeSprite(0, 0, smile01); delay(1000);
  m.writeSprite(0, 0, smile02); delay(1000);
  m.writeSprite(0, 0, smile03); delay(1000);
  for (int i = 0; i < 8; i++) { m.shiftLeft(false, false); delay(300); }
  m.clear();
}

Description : On inclut d'abord la bibliothèque MaxMatrix.h, on définit les broches de connexion du module, on indique combien de modules on utilise et on définit l'objet MaxMatrix.

Pour afficher des caractères, il faut les définir dans un tableau de caractères ou d'octets. On voit comment les bits forment les caractères (zéros et uns). Ici, ils sont tournés de 90 degrés, mais l'exemple de la bibliothèque suggère de les utiliser ainsi pour faciliter l'implémentation de la fonction shiftLeft pour le défilement de texte.

Dans le setup, on initialise le module et on règle la luminosité des LED. Dans la boucle, avec setDot() on peut allumer n'importe quelle LED individuelle à une position X, Y (ligne/colonne), et avec clear() on efface l'affichage.

Pour afficher les caractères prédéfinis, on utilise writeSprite(), dont les deux premiers arguments sont la position X et Y du coin supérieur gauche du caractère. À la fin, avec shiftLeft() on déplace ou fait défiler le caractère vers la gauche.

Code Arduino pour défilement de texte sur matrice 8×8

Regardons maintenant l'exemple de défilement de texte et voyons ce qui change.

/* Matrice LED 8x8 MAX7219 Défilement de texte
 * Basé sur la bibliothèque : GitHub | riyas-org/max7219 */
#include <MaxMatrix.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = {
  3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // espace
  1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
  3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
  5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
  2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
  2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
  3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \
  2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // ^
  4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // d
  4, 8, B00111000, B01010100, B01010100, B01111111, B00000000, // e
  3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // s
  4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // t
  5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // u
  5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // v
  5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // w
  4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // x
  3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // y
  3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // z
  3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  4, 8, B00001000, B00000100, B00001000, B00000100, B00000000  // ~
};
int DIN = 7, CLK = 6, CS = 5, maxInUse = 2;
MaxMatrix m(DIN, CS, CLK, maxInUse);
byte buffer[10];
char text[] = "HowToMechatronics.com "; // Texte défilant
void setup() {
  m.init();
  m.setIntensity(15);
}
void loop() {
  printStringWithShift(text, 100);
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

Description : Ici, on inclut une bibliothèque supplémentaire pour PROGMEM, qui est un modificateur de variable utilisé pour stocker des données dans la mémoire flash au lieu de la SRAM. Quand on a une grande base de variables statiques, comme ici pour définir lettres et caractères, il vaut mieux les stocker en mémoire flash car elle est bien plus grande (32 Ko) que la SRAM (2 Ko).

Ensuite, avec un tableau de caractères, on définit le texte défilant et dans la boucle, la fonction personnalisée printStringWithShift affiche le texte défilant sur la matrice LED avec une vitesse de défilement définie en millisecondes par le second argument. Cette fonction extrait d'abord les caractères de la chaîne de texte, puis affiche ces caractères en défilement sur la matrice LED.

Application Android pour contrôler la matrice LED 8×8 via Bluetooth

Une fois qu'on a compris comment fonctionne le MAX7219, on peut réaliser le troisième exemple : un projet Arduino pratique où on construit une application Android personnalisée pour contrôler la matrice LED via Bluetooth. Avant de continuer, je vous suggère de consulter mes tutoriels détaillés sur l'utilisation du module Bluetooth HC-05 et la création d'une application Android personnalisée avec MIT App Inventor.

Voici le code Arduino et voyons les modifications par rapport à l'exemple précédent.

/* Matrice LED 8x8 MAX7219 Défilement de texte Contrôle Android via Bluetooth
 * par Dejan Nedelkovski, www.HowToMechatronics.com
 * Basé sur la bibliothèque : GitHub | riyas-org/max7219 */
#include <MaxMatrix.h>
#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
// ... (tableau CH identique au-dessus, omis pour la brièveté)
int dIn = 7, clk = 6, cs = 5, maxInUse = 2;
MaxMatrix m(dIn, cs, clk, maxInUse);
SoftwareSerial Bluetooth(8, 7);
byte buffer[10];
char incomebyte;
int scrollSpeed = 100;
char text[100] = "HowToMechatronics.com ";
int brightness = 15;
int count = 0;
char indicator;
void setup() {
  m.init();
  m.setIntensity(brightness);
  Bluetooth.begin(38400); // Débit par défaut du module Bluetooth
}
void loop() {
  printStringWithShift(text, scrollSpeed);
  if (Bluetooth.available()) {
    indicator = Bluetooth.read();
    // Si bouton "Send" pressé dans l'app Android, effacer le texte précédent
    if (indicator == '1') {
      for (int i = 0; i < 100; i++) { text[i] = 0; m.clear(); }
      while (Bluetooth.available()) {
        incomebyte = Bluetooth.read();
        text[count] = incomebyte;
        count++;
      }
      count = 0;
    }
    // Réglage de la vitesse de défilement
    else if (indicator == '2') {
      String sS = Bluetooth.readString();
      scrollSpeed = 150 - sS.toInt(); // Millisecondes, soustraction car valeur plus faible = vitesse plus élevée
    }
    // Réglage de la luminosité
    else if (indicator == '3') {
      String sB = Bluetooth.readString();
      brightness = sB.toInt();
      m.setIntensity(brightness);
    }
  }
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) { printCharWithShift(*s, shift_speed); s++; }
}
void printString(char* s) {
  int col = 0;
  while (*s != 0) {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7 * c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
  }
}

Description : On inclut d'abord la bibliothèque SoftwareSerial.h pour la communication Bluetooth et on définit les variables nécessaires. Dans le setup, on initialise le Bluetooth à son débit par défaut de 38400 bauds. J'ai mis le message initial à « HowToMechatronics.com » avec une vitesse de défilement de 100 ms.

Dans la boucle, avec Bluetooth.available() on vérifie s'il y a des données entrantes sur le port série. Si c'est vrai, avec Bluetooth.read() on commence à lire le port série, un octet par itération. Le premier octet entrant est toujours stocké dans la variable « indicator » et selon sa valeur, on choisit de changer le message texte, la vitesse de défilement ou la luminosité de la matrice LED.

Si on regarde les blocs de code de l'application Android, on voit que quand on clique sur le bouton « Send », on envoie d'abord l'octet d'indication, ici « 1 », ce qui signifie qu'on veut changer le message texte. Côté Arduino, on efface tout le tableau de caractères et on efface aussi l'affichage de la matrice LED. Ensuite, dans la boucle « while », on lit le reste des données du port série, qui est le message tapé dans la zone de texte de l'application Android.

Si la variable indication est « 2 », cela signifie qu'on a changé la position du curseur de vitesse de défilement, donc on lit sa nouvelle valeur avec Bluetooth.readString() et on ajuste la vitesse. De la même façon, on ajuste la luminosité des LED.

Vous pouvez télécharger l'application Android ici :

AndrodApp for Arduino 8x8 LED Matrix Control (fichier .apk, 1,48 Mo)
AndrodApp for Arduino 8×8 LED Matrix Control .aia file (fichier source MIT App Inventor, 34,06 Ko)

C'est tout pour ce tutoriel. Si vous avez des questions, utilisez la section commentaires ci-dessous.