Matrice Led MAX7219 Arduino : brochage, branchement / câblage, librairie, et exemples de code

Aujourd’hui nous allons voir ensemble les matrices LED, ou plus exactement, les matrices à 8 x 8 leds, pilotées par driver MAX7219. Ainsi, vous pourrez agrémenter vos montages électroniques d’affichages bien lumineux, ou animations vraiment sympathiques 😉

Ici, nous verrons comment se présente une matrice LED monochrome (type 1088AS) et comment elle est gérée par le MAX 7219 (driver). Ensuite, nous verrons comment raccorder l’ensemble Matrice LED + MAX7219 à un Arduino, et comment allumer/éteindre des leds. Enfin, nous verrons comment afficher des caractères personnalisés à l’écran (chiffres, lettres, symboles, …), et ce, là où on souhaite !

Remarque : dans cet article d’introduction, j’utilise uniquement la librairie « LedControl » arduino, afin de rester sur des choses simples, et basiques (pour que chacun puisse bien comprendre le fonctionnement primaire des matrices LED, et leur mise en pratique). Comme d’habitude, n’hésitez pas ensuite à approfondir les choses, et explorer toutes les autres librairies disponibles dans l’IDE Arduino ou ailleurs. Ainsi, vous verrez qu’on peut faire des choses vraiment sympa, avec ces matrices à leds 🙂

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Qu’est-ce qu’une matrice LED ? (exemple du modèle 1088AS à 8 x 8 leds, monochrome)

Une matrice LED est un ensemble de diodes électroluminescentes, disposées sous forme rectangulaire (enfin… le plus souvent !). Les pattes de ces leds sont reliées entre elles de façon particulière, de sorte à former un maillage de lignes et colonnes.

Pour illustrer cela, voici un exemple simple de matrice LED (ici le modèle 1088AS), disposant de 64 leds unicolores, réparties sur 8 lignes de 8 colonnes (chacune notées de 0 à 7, donc) :

Comme vous pouvez le constater, les anodes des leds sont reliées entre-elles au niveau des colonnes, et les cathodes au niveau des lignes. Ainsi, pour allumer une led en particulier, il suffit simplement de sélectionner 1 ligne et 1 colonne. Par exemple, pour allumer la LED en haut/à gauche, il suffit de l’alimenter positivement via la broche 13 (« colonne 0 »), et négativement via la broche 9 (« ligne 0 »).

Bien sûr, il est possible d’allumer plusieurs leds à la fois, mais cela est limité à certaines combinaisons d’alimentation de lignes et colonnes (en fonction des leds qu’on souhaite voir s’illuminer). En effet, le jumelage des anodes en colonnes, et des cathodes en lignes, entraîne des restrictions. Par exemple, si vous souhaitez afficher le symbole « \ » (barre oblique du coin haut/gauche au coin bas/droite), vous ne pourrez pas le faire (enfin… de manière directe, j’entends !) ; car si vous alimentez toutes les colonnes positivement et toutes les lignes négativement pour ce faire, alors toute la matrice led s’allumera, et non la seule partie oblique.

Mais comment fait-on pour afficher une barre oblique alors, par exemple ? Eh bien, c’est tout simple ! En fait, on alimente les matrices une ligne à la fois (ou une colonne à fois, ça revient au même). Et en balayant les lignes (ou colonnes) suffisamment rapidement, la persistance rétinienne de l’œil humain règle le problème de « combinaisons impossibles ». Ainsi, vous voyez une image fixe s’afficher à l’écran, par exemple, alors que celle-ci est affichée ligne après ligne (ou colonne après colonne) !

Remarque : si vous avez bien observé l’image précédente, vous remarquerez que cette matrice led ne comporte ni VCC, ni GND, ni résistance de limitation de courant (et c’est normal !). En clair : il n’y a que des leds, et uniquement des leds, dans cette matrice LED 😉

Bien sûr, il faudra toujours veiller à limiter le courant traversant ces leds. Pour cela, il y a 2 façons de faire :

• soit mettre des résistances en amont de chaque ligne, ou chaque colonne (ce qui ne sera pas génial, car l’intensité lumineuse sera variable, selon le nombre de leds allumées simultanément)
• soit utiliser un driver, qui fixe le courant des lignes ou colonnes à une valeur donnée ; c’est d’ailleurs ce que fait entre autre le circuit intégré MAX 7219, que nous allons voir à présent !

Remarque : pour info, sur une matrice 1088AS à leds rouges, la chute de tension aux bornes d’une led allumée est d’environ 1,8 à 2,5 volts (typiquement 2,1V). Le courant traversant chaque led est couramment 20 ou 40 mA (ce qui peut être ajusté, bien entendu, dans une certaine mesure).

Comment piloter une matrice LED avec un driver MAX 7219 ?

Comme je vous le disais précédemment, une matrice LED induit plusieurs choses :

• il faut tout d’abord sélectionner une ligne, et une ou plusieurs colonnes, pour allumer une ou plusieurs LED
• il faut ensuite balayer chacune des lignes suffisamment rapidement, pour donner l’illusion de l’allumage simultané de toutes les lignes
• et il faut limiter le courant alimentant chaque led ou groupe de leds, en fonction de leur sélection

Comme vous vous en doutez, ce ne serait pas quelque chose de simple à faire, « à la main ». C’est pourquoi on utilise un circuit intégré spécialisé, comme le MAX 7219 (qui est un driver pour matrice 8 x 8 leds unicolores, entre autre). Ainsi, toutes les opérations listées ci-dessus seront exécutées par cette simple puce, ce qui nous simplifiera bien la vie 😉

Et pour ceux qui ne connaîtraient pas encore le MAX7219, voici à quoi il ressemble (avec brochage/pinout), d’un point de vue extérieur !

Comme vous le voyez, il s’agit tout simplement d’un circuit intégré à 24 broches, disponible :

• au format DIP (à broches traversantes ; en package étroit, dit « narrow » en anglais)
• ou au format SOIC (composant monté en surface, donc)

Au besoin, vous trouverez ici le datasheet du MAX 7219 (de chez Maxim Integrated).

Techniquement, la puce MAX 7219 a été conçue pour piloter :

• soit 1 à 8 afficheurs à 7-segments (donc afficher de 1 à 8 digits, avec point séparateur inclus)
• soit jusqu’à 64 leds individuelles (ou 1 matrice de 8 x 8 leds, donc !)

Mais au-delà de ça, on peut piloter encore plus d’éléments encore, si on chaîne cette puce (si on en met plusieurs en série, j’entends). Ainsi, on peut piloter jusqu’à 64 digits à 7 segments, ou 8 matrices led 8×8 ! Et tout ça, avec 2 fils d’alim et 3 fils de commande uniquement, comme nous allons le voir juste après !

Du reste, au niveau caractéristiques techniques, il y a peu de choses à savoir ou presque, tout du moins au début. Car le MAX 7219 :

• s’alimente avec une tension continue comprise entre 4 et 5,5V (typiquement du 5 volts)
• a une fréquence de balayage d’environ 800 Hz (pour « parcourir » les 8 afficheurs 7-segments, ou 8 lignes de matrice led)
• alimente chaque led jusqu’à 40 mA, en sachant que ceci est :
  • réglable physiquement par une simple résistance, à raccorder sur la broche 18 (nommée « ISET ») du circuit intégré
  • réglable « logiciellement », en jouant sur le « registre PWM du MAX7219 » (offrant 16 niveaux d’intensité d’éclairage, en supplément)
• peut se piloter en SPI, jusqu’à une fréquence de 10 MHz (ce qui est idéal pour nos petits Arduino Uno ou Nano, tournant à 16 MHz, soit 8 MHz maximum au niveau du bus SPI)

À présent, pour que ce soit plus concret, voyons un exemple pratique de raccordement du MAX7219 sur une matrice 1088AS (avec 8×8 leds monochromes, donc).

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Brochage des modules tout équipés (avec MAX7219 en version DIP ou SMD)

Comme nous venons de le voir, le driver MAX7219 existe :

• en version traversant (format DIP), à monter sur support de circuit intégré, ou à souder directement sur PCB
• et en version SMD (format SOIC), à monter en surface

Le saviez-vous ? SMD est un acronyme anglais signifiant « Surface Mounted Device ». C’est l’équivalent de CMS en français, pour « Composant Monté en Surface ».

Au final, il existe donc, en vente sur internet, 2 formats de module tout équipé (selon si le MAX 7219 est au format DIP ou SOIC) :

Mais que ce soit l’une ou l’autre des versions, le schéma de raccordement driver MAX7219 + matrice led 1088AS reste le même. Et ce schéma ressemble généralement à ça (avec le condensateur de filtrage de 10µF parfois omis, par certains fabricants) :

Comme vous le voyez, rien de bien compliqué ! Et peu de composants utilisés au final ! Car on retrouve seulement :

• une puce MAX7219 (format DIP ou SMD)
• une matrice à leds 1088AS (montée sur support débrochable)
• une résistance sur l’entrée ISET du max7219 (faisant 10k ici), définissant le courant max pouvant traverser via chaque led
• un ou deux condensateurs de découplage (suivant les fabricants)
• un connecteur d’entrée (reconnaissable avec la broche « DIN » à l’intérieur)
• et un connecteur de sortie (reconnaissable avec la pin « DOUT » dedans)

Important : comme indiqué précédemment, les modules MAX7219 à matrice led ont 2 connecteurs (l’un avec « DIN » dedans, et l’autre avec « DOUT »). Ceci sert au chaînage de ces modules. Et comme « IN » signifie « entrée » et « OUT » signifie « sortie », faites toujours bien attention à bien faire vos câblages, sans vous tromper ! Car on entrera TOUJOURS par la broche DIN, et sortira toujours par la broche DOUT (qui peut être soit laissée « en l’air », soit branchée à l’entrée DIN du module suivant). Aussi, gardez bien à l’esprit qu’il n’y aura qu’une seule broche DIN branchée par sortie DOUT, de sorte que tous les modules forment une chaîne, s’il y en a plusieurs.

Juste un mot sur la résistance R1 de 10 kohms, branchée sur l’entrée ISET du MAX7219 : en fait, il ne s’agit pas d’une résistance pull-up, ou quelque chose du genre. Il s’agit bel et bien d’une résistance de définition du courant, qu’alimentera chaque led. Ainsi, le courant max pouvant traverser chaque led sera égal à 100 fois le courant entrant via la broche ISET (comme défini par le constructeur, dans son datasheet).

Envie d’un exemple chiffré ? Alors en avant !

Soit :

• Vcc la tension d’alim
• Vled la chute de tension aux bornes d’une led allumée (de la matrice 1088AS raccordée au MAX 7219, j’entends)
• Iled le courant traversant une led allumée (sur notre matrice 8×8 leds, toujours)
• Uset la tension présente sur l’entrée ISET
• Iset le courant entrant via l’entrée ISET
• Rset la résistance placée entre Vcc et l’entrée ISET

Détermination de la formule de calcul permettant de trouver Iset (le courant entrant via ISET)

Avec la loi d’ohm, on peut écrire la formule suivante :

U = R * i (loi d’ohm)
d’où Uset = Rset * Iset
d’où (Vcc-Vled) = Rset * Iset
d’où (Vcc-Vled) = R1 * Iset
d’où Iset = (Vcc-Vled) / R1

Application numérique 1/2 : calcul de Iset (le courant entrant via Iset)

Si :
   Vcc = 5 volts
   R1 = 10000 ohms
   Vled = 2,1 volts (la chute de tension que provoque une led, lorsqu’allumée, sur la matrice)

Alors :
   Iset = (Vcc-Vled) / R1
   d’où Iset = (5-2,1) / 10000
   d’où Iset = 0,00029 A (soit 0,29 mA)

Application numérique 2/2 : calcul de Iled (le courant qui alimentera chacune de nos leds, sur la matrice)

Iled = 100 * Iset
d’où Iled = 100 * 0,00029
d’où Iled = 0,029 (soit 29 mA)

En clair : avec une alimentation 5V et une résistance Iset de 10k, on aura 29 mA de courant max par led, sur notre matrice 1088A !

Et je parle bien de courant maximal, car ensuite, de manière logicielle, on pourra définir une fraction de ce courant max, pour faire briller plus ou moins nos leds (via 16 niveaux de « contraste », pour être plus précis !).

Bon … on arrête là pour la théorie ! Maintenant, passons à la partie pratique, avec le branchement de ce module MAX7219 sur un Arduino Uno 😉

Comment raccorder une matrice LED MAX7219 à un Arduino Uno ? (via bus SPI ou non)

À présent, voyons comment brancher une matrice LED 8×8 (module MAX7219) sur un Arduino Uno ! Et comme vous allez tout de suite pouvoir le constater, seuls 5 fils suffisent !

En effet, il suffit de :

• 2 fils d’alimentation (pour emmener du +5V au module, qui requiert une tension comprise entre 4 et 5,5 volts, pour son contrôleur/driver MAX7219)
• 3 fils de communication, pour le pilotage SPI de cette matrice

Important : ici, l’alimentation du module MAX 7219 se fait via le +5V de l’Arduino. Comme nous mettons en œuvre qu’un seul module, que l’allumage des leds se fait ligne par ligne, qu’il y a 8 leds par lignes, et qu’une led consomme 40 mA au maximum, la consommation du module sur l’arduino sera de 320 mA maximum. Du coup, si vous branchez plusieurs modules MAX 7219 en série (chaînage), il faudra impérativement prévoir une alimentation externe, à partir d’un certain nombre (fonction de l’intensité d’éclairage modulée logiciellement).

À noter que le pilotage SPI du module à leds MAX7219 est tout ce qu’il y a de plus classique, avec :

• une ligne de sélection (D10/SS → CS)
• une ligne d’horloge (D13/SLK → CLK)
• une ligne pour l’envoi de données (D11/MOSI → DIN)
• et, dans notre cas, aucune ligne pour la réception de données (sur la broche D12/MISO de l’Arduino), car la communication est ici unidirectionnelle (seulement de l’arduino vers la matrice led)

Le saviez-vous ? Il est tout à fait possible d’émuler une communication SPI sur n’importe quelle broche digitale d’un Arduino (bien que ce soit généralement moins rapide et/ou moins régulier qu’une « vraie » communication SPI). Ainsi, il est tout à fait possible d’utiliser d’autres broches pour piloter cette matrice à leds, comme nous verrons dans les exemples #2 et #3, un peu plus bas !

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Quelle librairie utiliser ? (bibliothèque arduino « LedControl »)

Avant toute chose, il faut bien comprendre que piloter une matrice led, telle que présentée sous la forme de module un peu plus haut, revient en fait à piloter la puce MAX7219, sur laquelle la matrice à leds est raccordée. Du coup, si vous cherchez une librairie Arduino permettant de piloter une matrice led 8×8 monochrome, vous pouvez tout aussi bien filtrer vos recherches avec le mot clef « MAX7219 », tout comme « matrice led ».

Par ailleurs, sachez qu’il existe tout un tas de librairies, permettant de gérer une matrice led, pilotée par MAX 7219. Aussi, je vous recommande de démarrer avec la « librairie LedControl » (téléchargeable dans le gestionnaire de bibliothèques de l’IDE Arduino), pour faire vos premiers pas. Car cette librairie est vraiment simple d’utilisation, et simple à comprendre au niveau de ses différentes fonctionnalités. D’ailleurs, voyons comment l’installer sur votre ordi, si ce n’est pas déjà fait !

Installation de la librairie LedControl de Eberhard Fahle (disponible sous Arduino IDE)

Pour installer la librairie LedControl sur votre IDE Arduino, rien de plus simple ! Car il suffit d’ouvrir le menu Outils > Gérer les bibliothèques, de taper « ledcontrol » dans le champ de recherche, et d’appuyer sur la touche ENTRÉE de votre clavier ! Ainsi, s’affichera une liste comme celle-ci à l’écran :

Nota : vérifiez bien qu’il s’agisse de la librairie « LedControl » réalisée par « Eberhard Fahle », si plusieurs s’affichent à l’écran.

Ensuite, il vous suffit de cliquer sur « Installer », pour télécharger cette librairie localement sur votre PC. Une fois fait, vous verrez la mention « Installed » s’afficher, au niveau de cette librairie, dans le gestionnaire de bibliothèques Arduino.

Maintenant, voyons ce qu’a à nous proposer cette bibliothèque, pour piloter nos modules MAX7219, dotés de matrice 8×8 à leds unicolores 🙂

Principales fonctions de cette librairie « Led Control », pour piloter une matrice 8×8 à leds

Comme vous allez voir, la liste des fonctions qui vont nous intéresser dans la librairie LedControl n’est pas très longue ! Et ne vous inquiétez pas si tout cela vous parait quelque peu abstrait au début, car tout prendra sens dans les exemples de code qui suivent 🙂

Ah oui … une chose à savoir avant tout, au sujet de cette librairie : ne soyez pas étonné de voir des notions de « numéro » ou « index » de matrice dans ces fonctions, car de base, cette bibliothèque arduino permet de gérer un à plusieurs modules MAX7219 chaînés ensemble (comme nous le verrons dans l’exemple de code #3, un peu plus bas !). Du coup, retenez juste que si vous pilotez seulement une seule matrice, celle-ci aura l’index « 0 » (la suivante 1, et ainsi de suite).

Alors voici les principales fonctions de la librairie « Led Control » (enfin, celles qui seront utiles pour nous, j’entends !) :

• shutdown(numero_de_matrice, statut) permet d’activer ou de désactiver la matrice n° « numero_de_matrice », en mettant son « statut » à true ou false (nota : False = mode d’économie d’énergie / afficheur désactivé, et True = fonctionnement normal / afficheur actif)
• setIntensity(numero_de_matrice, intensite) permet de régler la luminosité de l’affichage led de la matrice n° « numero_de_matrice » (nota : la valeur d’intensité devra être comprise entre 0 et 15, inclus)
• clearDisplay(numero_de_matrice) permet d’éteindre toutes les leds de la matrice n° « numero_de_matrice »
• setLed(numero_de_matrice, numero_de_ligne, numero_de_colonne, etat) permet de mettre à l’état allumé (True) ou éteint (False), la LED située à la ligne « numero_de_ligne » et à la colonne « numero_de_colonne », sur la LED de la matrice n° « numero_de_matrice »
• setRow(numero_de_matrice, numero_de_ligne, valeur) permet de mettre toutes les leds de la matrice n° « numero_de_matrice », situées à la ligne « numero_de_ligne », dans l’état renseigné dans la « valeur » (par exemple : si on envoie la valeur 0b1100 0111 sur la ligne 1, alors les 2 premières et 3 dernières leds de cette ligne seront allumées et les autres éteintes, compte tenu des 1 et de 0 envoyés)
• setColumn(numero_de_matrice, numero_de_colonne, valeur) permet de mettre toutes les leds de la matrice n° « numero_de_matrice », situées à la colonne « numero_de_colonne », dans l’état renseigné dans la « valeur » (par exemple : si on envoie la valeur 0b0001 0110 sur la colonne 4, alors la 4ème, 6ème, et 7ème led de cette colonne seront allumées et les autres éteintes, compte tenu des 1 et de 0 envoyés)

Du reste, si vous souhaitez plus d’informations sur la librairie LedControl d’Eberhard Fahle, n’hésitez pas à faire un saut sur les sites suivants :

• Site Arduino : https://www.arduino.cc/reference/en/libraries/ledcontrol/
• Dépôt GitHub : https://github.com/wayoda/LedControl/
  • LedControl.h (fichier entête)
  • LedControl.cpp (détail des fonctions disponibles)

Code exemple #1 : réaliser un chenillard (allumer les leds, les unes après les autres)

Alors, pour faire nos premiers pas avec une matrice LED 8×8, nous allons commencer par allumer une led, en haut à gauche. Puis l’éteindre, et allumer celle d’à côté en suivant. Et ainsi de suite, jusqu’à former un chenillard, colonne après colonne, et ligne après ligne !

Pour ce faire, je vous propose de partir sur le schéma de câblage suivant, mettant en œuvre un module MAX7219 à matrice led 8×8, et un Arduino Nano (pour que tout soit câblé sur breadboard) :

Et voici ce que cela donne au niveau raccordements, en pratique :

Comme déjà évoqué plus haut, faites bien attention à vous connecter sur l’entrée « DIN » du module MAX7219, et non sur la pin « DOUT ». Car il est facile de se tromper si on ne fait pas attention, du fait que ce module possède 2 connecteurs de branchement semblables, mais différents (l’un étant pour « l’entrée » des signaux, et l’autre, pour la « sortie » des signaux, pour un éventuel chaînage des modules, si souhaité).

Maintenant que nous avons vu la partie matérielle, passons à la partie logicielle ! Et comme vous allez voir, ce n’est pas si compliqué que ça 😉

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prgArduino-1-AllumerLedsChenillard.ino
  
  Description :   Programme permettant de créer un chenillard sur une matrice LED 8x8 pilotée par MAX7219, en faisant allumer
                  une led après l'autre, en utilisant la librairie LedControl (https://www.arduino.cc/reference/en/libraries/ledcontrol/)
                  
  Remarques :     - la librairie utilisée ici sera la "LedControl" de Eberhard Fahle (GitHub : https://github.com/wayoda/LedControl)
                  - l'arduino utilisé ici sera un Arduino Nano
                            
  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Licence :       BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
  Créé le :       01.02.2024

*/

// Inclusion de la librairie LedControl
#include <LedControl.h>

// Définition des broches de raccordement Arduino Nano → Matrice LED pilotée par MAX7219
#define brocheDeSelection               10        // Sortie D10 de l'Arduino (/SS)  vers la broche CS  de la matrice LED
#define brochePourLesDonnees            11        // Sortie D11 de l'Arduino (MOSI) vers la broche DIN de la matrice LED
#define brochePourLhorloge              13        // Sortie D13 de l'Arduino (SCK)  vers la broche CLK de la matrice LED

// Définition des autres "constantes"
#define nombreDeMatricesLedRaccordees   1         // Nombre pouvant aller de 1 à 8 (nombre maxi de matrice led pilotable ici)
#define adresseDeLaMatrice              0         // Pour les 8 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 7
#define delaiAllumageLed                100       // Temps de maintien d'allumage LED, exprimé en millisecondes

// Instanciation de celle-ci
LedControl matriceLed = LedControl(brochePourLesDonnees, brochePourLhorloge, brocheDeSelection, nombreDeMatricesLedRaccordees);


// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation de la matrice LED
  matriceLed.shutdown(adresseDeLaMatrice, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice, 5);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité, donc)
  matriceLed.clearDisplay(adresseDeLaMatrice);          // clearDisplay : éteint toutes les LEDs de la matrice
  
}

// =================
// Boucle principale
// =================
void loop() {

  // *********************
  // Chenillard
  // *********************

  for(int ligne = 0; ligne < 8; ligne++) {                              // Parcours des 8 lignes de la matrice LED
    for(int colonne = 0; colonne < 8; colonne++) {                          // Parcours des 8 colonnes de la matrice LED
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, true);              // Allumage de la LED située à la position ligne/colonne
      delay(delaiAllumageLed);                                                  // Maintien de cette LED allumée, un certain temps
      matriceLed.setLed(adresseDeLaMatrice, ligne, colonne, false);             // Et extinction de cette LED, avant passage à la led suivante
    }
  }
  
}

En clair, dans ce programme :

• on initialise notre module dans la partie setup
• et on allume/éteint une à une les leds, dans la partie loop (en balayant chaque colonne, puis chaque ligne, de façon perpétuelle)

À noter que nous mettons en œuvre seulement 1 matrice ici ; elle aura donc l’index « 0 » dans le code, pour rappel. Du reste, visuellement, voici ce que ça donne, de mon côté :

À présent, approfondissons un peu tout cela, et affichons maintenant des chiffres et des symboles, sur la matrice led MAX7219 !

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Code exemple #2 : afficher des chiffres et des symboles (ou des images personnalisées, si souhaité !)

Avec ce deuxième exemple, nous allons voir comment afficher des chiffres ou des symboles, sur une matrice à 8×8 leds contrôlée par MAX7219. Tout d’abord, au niveau matériel, rien ne change ! Ou presque 😉

En effet, par rapport au montage de l’exemple précédent, j’ai :

• déplacé les lignes D10, D11, et D13 en D2, D3, et D4, pour vous montrer que, bien que la communication Arduino ↔ MAX7219 soit de type SPI, on peut parfaitement se servir ici d’autres broches digitales ; en fait, cela vient du fait que la librairie « LedControl » utilise la fonction « shiftOut » en interne pour piloter ces lignes, ce qui permet de viser n’importe quelle pin de l’arduino, sans se limiter au port SPI
• rajouté une résistance pull-up sur le ligne /CS de la matrice pilotée par le MAX 7219, pour éliminer les « affichages aléatoires au démarrage » (cela filtre au possible les plus ou moins nombreux points allumés à la mise sous tension du module MAX7219, avant que l’arduino n’en prenne la main)

Du coup, pour ce deuxième exemple, voici à quoi le schéma de câblage ressemble :

Et une fois câblé sur breadboard, en photos :

Cela étant vu, voyons maintenant les changements au niveau logiciel, par rapport à l’exemple précédent ! En fait, il n’y a pas grands changements, comme vous le verrez un peu plus bas. En effet, pour l’essentiel, c’est la fonction « setLed » (qui permettait l’allumage d’une led donnée) qui sera remplacée par la fonction « setRow » (qui permettra de définir l’état de toutes les leds comme on souhaite, sur une ligne entière).

Et chose également différente par rapport à l’exemple qui précédait, nous allons adjoindre un « fichier de données », à notre code arduino. Ce fichier contiendra en fait la codification de tous les chiffres et symboles qu’on souhaitera afficher ici. Ainsi, par exemple, pour le chiffre 6, voici comment sera codé cela en mémoire (côté arduino), pour que cela s’affiche tel qu’on le souhaite (côté matrice led, faisant 8 x 8 points lumineux) :

Comme vous le voyez, la représentation binaire dans le code sera ni plus ni moins que la représentation visuelle sur la matrice (en sachant qu’une led allumée = 1, et une led éteinte = 0). Et nous allons procéder ainsi pour tous les symboles et chiffres qu’on voudra afficher sur notre module MAX 7219, à 8×8 leds.

Du coup, voici le fichier contenant les données de cet exemple (tout cela sera/devra être logé dans un fichier nommé « chiffres_et_symboles.h », ici) :

// =======================================================
// Encodage des chiffres et symboles, pour matrice LED 8x8
// =======================================================
// 1) Chiffres 0 à 9
// 2) Symboles +, -, /, *, et %

const byte CHIFFRE_0[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01000010,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_1[] PROGMEM = {
  0b00001000,   // 1ère ligne de leds pour ce chiffre
  0b00011000,   // 2ème ligne de leds pour ce chiffre
  0b00101000,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00001000,   // 6ème ligne de leds pour ce chiffre
  0b00001000,   // 7ème ligne de leds pour ce chiffre
  0b00011100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_2[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b00000100,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00010000,   // 6ème ligne de leds pour ce chiffre
  0b00100000,   // 7ème ligne de leds pour ce chiffre
  0b01111110    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_3[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b00000100,   // 2ème ligne de leds pour ce chiffre
  0b00001000,   // 3ème ligne de leds pour ce chiffre
  0b00011100,   // 4ème ligne de leds pour ce chiffre
  0b00000010,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_4[] PROGMEM = {
  0b00000100,   // 1ère ligne de leds pour ce chiffre
  0b00001100,   // 2ème ligne de leds pour ce chiffre
  0b00010100,   // 3ème ligne de leds pour ce chiffre
  0b00100100,   // 4ème ligne de leds pour ce chiffre
  0b01111111,   // 5ème ligne de leds pour ce chiffre
  0b00000100,   // 6ème ligne de leds pour ce chiffre
  0b00000100,   // 7ème ligne de leds pour ce chiffre
  0b00000100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_5[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b01000000,   // 2ème ligne de leds pour ce chiffre
  0b01000000,   // 3ème ligne de leds pour ce chiffre
  0b01111100,   // 4ème ligne de leds pour ce chiffre
  0b00000010,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_6[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000000,   // 3ème ligne de leds pour ce chiffre
  0b01111100,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_7[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b00000010,   // 2ème ligne de leds pour ce chiffre
  0b00000010,   // 3ème ligne de leds pour ce chiffre
  0b00000100,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00010000,   // 6ème ligne de leds pour ce chiffre
  0b00100000,   // 7ème ligne de leds pour ce chiffre
  0b01000000    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_8[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b00111100,   // 4ème ligne de leds pour ce chiffre
  0b01000010,   // 5ème ligne de leds pour ce chiffre
  0b01000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte CHIFFRE_9[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b01000010,   // 3ème ligne de leds pour ce chiffre
  0b01000010,   // 4ème ligne de leds pour ce chiffre
  0b00111110,   // 5ème ligne de leds pour ce chiffre
  0b00000010,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_ADDITION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00001000,   // 2ème ligne de leds pour ce chiffre
  0b00001000,   // 3ème ligne de leds pour ce chiffre
  0b00111110,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00001000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_SOUSTRACTION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000000,   // 2ème ligne de leds pour ce chiffre
  0b00000000,   // 3ème ligne de leds pour ce chiffre
  0b01111110,   // 4ème ligne de leds pour ce chiffre
  0b00000000,   // 5ème ligne de leds pour ce chiffre
  0b00000000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_DIVISION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000010,   // 2ème ligne de leds pour ce chiffre
  0b00000100,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00010000,   // 5ème ligne de leds pour ce chiffre
  0b00100000,   // 6ème ligne de leds pour ce chiffre
  0b01000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_MULTIPLICATION[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01001001,   // 2ème ligne de leds pour ce chiffre
  0b00101010,   // 3ème ligne de leds pour ce chiffre
  0b00011100,   // 4ème ligne de leds pour ce chiffre
  0b01111111,   // 5ème ligne de leds pour ce chiffre
  0b00011100,   // 6ème ligne de leds pour ce chiffre
  0b00101010,   // 7ème ligne de leds pour ce chiffre
  0b01001001    // 8ème ligne de leds pour ce chiffre
};

const byte SYMBOLE_POURCENTAGE[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b01100010,   // 2ème ligne de leds pour ce chiffre
  0b01100100,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00010000,   // 5ème ligne de leds pour ce chiffre
  0b00100110,   // 6ème ligne de leds pour ce chiffre
  0b01000110,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

Comme vous pouvez le constater, j’ai choisi d’afficher les chiffres de 0 à 9, et les symboles d’addition, soustraction, division, et multiplication (tous ces caractères étant « fait-maison », au passage, mais on aurait très bien pu reproduire une police de caractère libre de droits, par exemple).

Maintenant, voyons le code arduino qui appellera ce fichier, et fera afficher ces caractères sur notre matrice à leds :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prgArduino-2-ChiffresEtSymboles.ino
  
  Description :   Programme permettant de faire défiler des chiffres et des symboles sur une matrice LED 8x8, pilotée par MAX7219
                  
  Remarques :     - la librairie utilisée ici sera la "LedControl" de Eberhard Fahle (GitHub : https://github.com/wayoda/LedControl)
                  - l'arduino utilisé ici sera un Arduino Nano
                            
  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Licence :       BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
  Créé le :       01.02.2024

*/

// Inclusion de la librairie LedControl
#include <LedControl.h>
#include "chiffres_et_symboles.h"

// Définition des broches de raccordement Arduino Nano → Matrice LED pilotée par MAX7219
#define brochePourLhorloge              2         // Sortie D2 de l'Arduino vers la broche CLK de la matrice LED
#define brocheDeSelection               3         // Sortie D3 de l'Arduino vers la broche CS  de la matrice LED
#define brochePourLesDonnees            4         // Sortie D4 de l'Arduino vers la broche DIN de la matrice LED

// Définition des autres "constantes"
#define nombreDeMatricesLedRaccordees   1         // Nombre pouvant aller de 1 à 8 (nombre maxi de matrice led pilotable ici)
#define adresseDeLaMatrice              0         // Pour les 8 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 7

#define delaiEntreChaqueChangementAffichage  500       // Délai d'attente entre chaque changement d'affichage (chiffres et symboles successifs, j'entends)

// Instanciation de celle-ci
LedControl matriceLed = LedControl(brochePourLesDonnees, brochePourLhorloge, brocheDeSelection, nombreDeMatricesLedRaccordees);


// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation de la matrice LED
  matriceLed.shutdown(adresseDeLaMatrice, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.setIntensity(adresseDeLaMatrice, 5);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité, donc)
  matriceLed.clearDisplay(adresseDeLaMatrice);          // clearDisplay : éteint toutes les LEDs de la matrice
  
}

// ===================================
// Fonction : afficherChiffreOuSymbole
// ===================================
void afficherChiffreOuSymbole(byte pointeurVersChiffreOuSymbole[]) {
  
  // Parcours des 8 lignes
  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
    matriceLed.setRow(adresseDeLaMatrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
  }
  
}

// =================
// Boucle principale
// =================
void loop() {

  // ***********************************************************
  // Balayage des chiffres 0 à 9, puis symboles +, -, /, *, et %
  // ***********************************************************

  afficherChiffreOuSymbole(CHIFFRE_0);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_1);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_2);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_3);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_4);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_5);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_6);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_7);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_8);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(CHIFFRE_9);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_ADDITION);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_SOUSTRACTION);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_DIVISION);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_MULTIPLICATION);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(SYMBOLE_POURCENTAGE);
  delay(delaiEntreChaqueChangementAffichage);
  
}

Grosso modo, les chiffres et symboles seront affichés les uns après les autres, avec une demi seconde d’intervalle, entre chaque changement. Une fois uploadé, voici ce que ça donne de mon côté, en images :

Sympa, non ? Mais on peut aller encore plus loin, si on utilise plusieurs modules branchés en série ! Et c’est ce que nous allons voir à présent, en rajoutant un second module led à celui-ci 😉

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Code exemple #3 : chaînage de modules / matrices MAX 7219 (« daisy chain »)

À présent, voyons comment mettre plusieurs modules MAX7219 en série, pour avoir un affichage sur plusieurs matrices led (8 au maximum, pour rappel). Et pour ne pas trop compliquer les choses, commençons par rajouter un 2ème module à leds, à l’exemple précédent.

Côté montage électronique, voici le nouveau câblage :

Ici, pas grands changements non plus, si ce n’est l’ajout d’un second module MAX 7219, chaîné au précédent. Notez bien, par contre, le sens de branchement des entrées/sorties de ces modules, toujours de « DIN vers DOUT ». En fait, la sortie d’un module sera branchée sur l’entrée du module suivant, jusqu’au dernier (pour lequel la sortie DOUT restera flottante, reliée à rien donc).

À noter également que, pour varier les plaisirs, j’ai cette fois-ci utilisé des modules MAX7219 SMD (pcb de couleur bleue), plutôt qu’un modèle MAX7219 DIP (pcb de couleur verte, comme mis en œuvre dans les deux exemples précédents). Mais bien sûr, cela n’a aucune incidence ici, et on peut même, si on le souhaite, mixer ces modules 🙂

Remarque : si vous chaînez plus de 2 modules en série, il faudra penser à fournir une alimentation +5V externe à l’arduino. En effet, ce dernier ne pourra pas délivrer suffisamment de courant pour alimenter plus de 2 modules environ (car ceux-ci peuvent consommer jusqu’à 320 mA environ, chacun, dans le « pire » des cas).

Voici ce que donne le schéma de raccordement précédent, une fois câblé sur breadboard :

Nota :
– ce sont bien 2 modules 8×8 qui sont utilisés ici, qui semblent être « collés l’un à l’autre », et non un seul module plus long
– par ailleurs, pour limiter le nombre de fils utilisés, j’ai utilisé 2 petites breadboard posée sur une plus grande, pour faire ces raccordements

Maintenant, passons à la partie logicielle ! Et comme vous allez voir, rien ne change (ou presque !). En fait, seul l’adressage des matrices va être la réelle nouveauté, ici !

Tout d’abord, comme tout à l’heure, voici le « fichier de données » accompagnant le code arduino de cet exemple (qui sera nommé / qu’il faudra enregistrer sous le nom «lettres_et_symboles.h)  :

// =======================================================
// Encodage des lettres et symboles, pour matrices LED 8x8
// =======================================================
// 1) Lettres N, E, S, et O (nord, est, sud, et ouest, en fait)
// 2) Symboles ↑, →, ↓, et ← (haut, droite, bas, et gauche)

const byte LETTRE_N[] PROGMEM = {
  0b10000001,   // 1ère ligne de leds pour ce chiffre
  0b11000001,   // 2ème ligne de leds pour ce chiffre
  0b10100001,   // 3ème ligne de leds pour ce chiffre
  0b10010001,   // 4ème ligne de leds pour ce chiffre
  0b10001001,   // 5ème ligne de leds pour ce chiffre
  0b10000101,   // 6ème ligne de leds pour ce chiffre
  0b10000011,   // 7ème ligne de leds pour ce chiffre
  0b10000001    // 8ème ligne de leds pour ce chiffre
};

const byte LETTRE_E[] PROGMEM = {
  0b11111111,   // 1ère ligne de leds pour ce chiffre
  0b10000000,   // 2ème ligne de leds pour ce chiffre
  0b10000000,   // 3ème ligne de leds pour ce chiffre
  0b11111100,   // 4ème ligne de leds pour ce chiffre
  0b10000000,   // 5ème ligne de leds pour ce chiffre
  0b10000000,   // 6ème ligne de leds pour ce chiffre
  0b10000000,   // 7ème ligne de leds pour ce chiffre
  0b11111111    // 8ème ligne de leds pour ce chiffre
};

const byte LETTRE_S[] PROGMEM = {
  0b01111110,   // 1ère ligne de leds pour ce chiffre
  0b10000001,   // 2ème ligne de leds pour ce chiffre
  0b10000000,   // 3ème ligne de leds pour ce chiffre
  0b10000000,   // 4ème ligne de leds pour ce chiffre
  0b01111110,   // 5ème ligne de leds pour ce chiffre
  0b00000001,   // 6ème ligne de leds pour ce chiffre
  0b10000001,   // 7ème ligne de leds pour ce chiffre
  0b01111110    // 8ème ligne de leds pour ce chiffre
};

const byte LETTRE_O[] PROGMEM = {
  0b00111100,   // 1ère ligne de leds pour ce chiffre
  0b01000010,   // 2ème ligne de leds pour ce chiffre
  0b10000001,   // 3ème ligne de leds pour ce chiffre
  0b10000001,   // 4ème ligne de leds pour ce chiffre
  0b10000001,   // 5ème ligne de leds pour ce chiffre
  0b10000001,   // 6ème ligne de leds pour ce chiffre
  0b01000010,   // 7ème ligne de leds pour ce chiffre
  0b00111100    // 8ème ligne de leds pour ce chiffre
};

const byte FLECHE_HAUT[] PROGMEM = {
  0b00001000,   // 1ère ligne de leds pour ce chiffre
  0b00011100,   // 2ème ligne de leds pour ce chiffre
  0b00101010,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00001000,   // 6ème ligne de leds pour ce chiffre
  0b00001000,   // 7ème ligne de leds pour ce chiffre
  0b00001000    // 8ème ligne de leds pour ce chiffre
};

const byte FLECHE_DROITE[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00000100,   // 2ème ligne de leds pour ce chiffre
  0b00000010,   // 3ème ligne de leds pour ce chiffre
  0b01111111,   // 4ème ligne de leds pour ce chiffre
  0b00000010,   // 5ème ligne de leds pour ce chiffre
  0b00000100,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

const byte FLECHE_BAS[] PROGMEM = {
  0b00001000,   // 1ère ligne de leds pour ce chiffre
  0b00001000,   // 2ème ligne de leds pour ce chiffre
  0b00001000,   // 3ème ligne de leds pour ce chiffre
  0b00001000,   // 4ème ligne de leds pour ce chiffre
  0b00001000,   // 5ème ligne de leds pour ce chiffre
  0b00101010,   // 6ème ligne de leds pour ce chiffre
  0b00011100,   // 7ème ligne de leds pour ce chiffre
  0b00001000    // 8ème ligne de leds pour ce chiffre
};

const byte FLECHE_GAUCHE[] PROGMEM = {
  0b00000000,   // 1ère ligne de leds pour ce chiffre
  0b00010000,   // 2ème ligne de leds pour ce chiffre
  0b00100000,   // 3ème ligne de leds pour ce chiffre
  0b01111111,   // 4ème ligne de leds pour ce chiffre
  0b00100000,   // 5ème ligne de leds pour ce chiffre
  0b00010000,   // 6ème ligne de leds pour ce chiffre
  0b00000000,   // 7ème ligne de leds pour ce chiffre
  0b00000000    // 8ème ligne de leds pour ce chiffre
};

Par rapport à l’exemple précédent, j’ai simplement :

• remplacé les chiffres « 0 à 9 » par les lettres « N, E, S, et O » (pour signifier « nord », « est », « sud », et « ouest », par exemple)
• remplacé les symboles « +, -, /, * » par les symboles « ↑→↓← » (pour signifier « haut », « droite », « bas », et « gauche »)

En clair : nous allons représenter les 4 points cardinaux (nord/sud/est/ouest), avec la flèche correspondante (tout ceci restant fictif, bien entendu, car c’est juste pour l’exemple !).

Ici, comme nous allons mettre en œuvre 2 matrices leds, la répartition se fera de la sorte :
– la première matrice affichera la première lettre du point cardinal (N pour nord, E pour est, S pour sud, et O pour ouest)
– et la deuxième matrice, la direction correspondante à ce point cardinal (↑ pour nord, → pour est, ↓ pour sud, et ← pour ouest)

Et comme nous avons 4 points cardinaux à afficher, nous les balayerons les uns après les autres, en boucle !

Voici ce que cela donne au final, en vidéo :

Et pour réaliser cela, voici le code arduino correspondant :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prgArduino-3-ChainageModules.ino
  
  Description :   Programme permettant de faire défiler des lettres et des symboles sur 2 matrices LED 8x8 chaînées, pilotées par MAX7219
                  
  Remarques :     - la librairie utilisée ici sera la "LedControl" de Eberhard Fahle (GitHub : https://github.com/wayoda/LedControl)
                  - l'arduino utilisé ici sera un Arduino Nano
                            
  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Licence :       BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
  Créé le :       03.02.2024

*/

// Inclusion de la librairie LedControl
#include <LedControl.h>
#include "lettres_et_symboles.h"

// Définition des broches de raccordement Arduino Nano → Matrice LED pilotée par MAX7219
#define brochePourLhorloge      2     // Sortie D2 de l'Arduino vers la broche CLK de la matrice LED
#define brocheDeSelection       3     // Sortie D3 de l'Arduino vers la broche CS  de la matrice LED
#define brochePourLesDonnees    4     // Sortie D4 de l'Arduino vers la broche DIN de la matrice LED

// Définition des autres "constantes"
#define nombreDeMatricesLedRaccordees           2   // Nombre pouvant aller de 1 à 8 (nombre maxi de matrice led pilotable ici)
#define adresseDeLaPremiereMatrice              0   // Pour les 8 matrices max évoquées ci-dessus, leurs index respectifs (adresses) vont de 0 à 7
#define adresseDeLaDeuxiemeMatrice              1   // (la 1ère matrice aura l'index 0, et la seconde, l'index 1)
#define delaiEntreChaqueChangementAffichage  2000   // Délai d'attente entre chaque changement d'affichage (chiffres et symboles successifs, j'entends)

// Instanciation de celle-ci
LedControl matriceLed = LedControl(brochePourLesDonnees, brochePourLhorloge, brocheDeSelection, nombreDeMatricesLedRaccordees);


// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation de la matrice LED
  matriceLed.shutdown(adresseDeLaPremiereMatrice, false);       // shutdown     : "true" active le mode "sommeil", tandis que "false" active le mode "normal"
  matriceLed.shutdown(adresseDeLaDeuxiemeMatrice, false);
  matriceLed.setIntensity(adresseDeLaPremiereMatrice, 5);       // setIntensity : valeur pouvant aller de 0 à 15 (pour 16 niveaux de luminosité, donc)
  matriceLed.setIntensity(adresseDeLaDeuxiemeMatrice, 5);
  matriceLed.clearDisplay(adresseDeLaPremiereMatrice);          // clearDisplay : éteint toutes les LEDs de la matrice
  matriceLed.clearDisplay(adresseDeLaDeuxiemeMatrice);
  
}

// ===================================
// Fonction : afficherChiffreOuSymbole
// ===================================
void afficherChiffreOuSymbole(byte indexMatrice, byte pointeurVersChiffreOuSymbole[]) {
  
  // Parcours des 8 lignes
  for (int ligne = 0; ligne < 8; ligne++){
    // Et affichage des 8 colonnes pour chacune de ces lignes, avec fonction :
    // setRow(numero_de_matrice, numero_de_ligne, valeur_pour_cette_ligne)
    matriceLed.setRow(indexMatrice, ligne, pgm_read_byte_near(pointeurVersChiffreOuSymbole + ligne));
  }
  
}

// =================
// Boucle principale
// =================
void loop() {

  // ****************************************************************
  // Balayage des lettres et symboles par paires (N↑, E→, S↓, et O←)
  // ****************************************************************

  afficherChiffreOuSymbole(adresseDeLaDeuxiemeMatrice, LETTRE_N);
  afficherChiffreOuSymbole(adresseDeLaPremiereMatrice, FLECHE_HAUT);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(adresseDeLaDeuxiemeMatrice, LETTRE_E);
  afficherChiffreOuSymbole(adresseDeLaPremiereMatrice, FLECHE_DROITE);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(adresseDeLaDeuxiemeMatrice, LETTRE_S);
  afficherChiffreOuSymbole(adresseDeLaPremiereMatrice, FLECHE_BAS);
  delay(delaiEntreChaqueChangementAffichage);

  afficherChiffreOuSymbole(adresseDeLaDeuxiemeMatrice, LETTRE_O);
  afficherChiffreOuSymbole(adresseDeLaPremiereMatrice, FLECHE_GAUCHE);
  delay(delaiEntreChaqueChangementAffichage);
  
}

Avouez que ce n’est franchement pas très compliqué ! Car au final, pour afficher des caractères particuliers à l’écran, il suffit d’indiquer l’index de la matrice led visée, et de cibler le caractère à envoyer. Tout simplement !

Du reste, ce code peut être étendu afin de pouvoir piloter jusqu’à 8 matrices à leds (avec des index pouvant aller de 0 à 7, donc), et comme toujours, avec 3 lignes de commande seulement !

Rappel important : si vous utilisez plusieurs matrices leds ensemble, n’oubliez pas de fournir une alimentation 5 volts externe, afin de ne pas trop tirer de courant sur votre arduino. Sinon certains composants de ce dernier pourraient s’endommager … !

Aperçu	Description	Lien achat
	Module MAX7219 leds 8x8 (version DIP)
	Module MAX7219 leds 8x8 (version SMD)

Liens et téléchargements

Pour ceux que ça intéresse, vous trouverez ci-après les 3 programmes exemples présentés ci-dessus, au format ZIP :

• Code arduino exemple #1 : prgArduino-1-AllumerLedsChenillard.zip
• Code arduino exemple #2 : prgArduino-2-ChiffresEtSymboles.zip
• Code arduino exemple #3 : prgArduino-3-ChainageModules.zip

Et comme support, le datasheet du MAX 7219, si besoin !

Matrice Led MAX7219 arduino : conclusion !

Nous voici au terme de cet article d’introduction aux matrices LED 8×8 monochromes, pilotées par driver MAX7219 ! J’espère que tout cela vous aura plu, et que cela vous donnera des idées pour vos futurs projets.

Perso, j’avais dans l’idée de concevoir une « boussole électronique » avec affichage sur matrice led, d’où les lettres et symboles nord/est/sud/ouest du dernier exemple. Enfin … reste juste à trouver du temps pour concrétiser cela, comme d’habitude 😉

Alors à bientôt !
Jérôme.

À découvrir aussi : découvrir l’écran compatible Nokia 5110, pour afficher encore plus de choses !

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 09/11/2024