Matrix LED 8×8 MAX7219

Ce module est un afficheur matriciel de 8 × 8 points, soit 64 LED pilotables une par une, réunies sur une carte à peine plus grande qu’un timbre. Derrière la vitre noire se trouve une puce MAX7219 : elle balaie les 64 LED à votre place, limite le courant dans chacune et règle la luminosité. Votre programme, lui, n’écrit que des dessins.

Le raccordement tient en cinq fils, dont trois lignes de données — DIN, CS, CLK. C’est toute la valeur de ce circuit : il décharge le microcontrôleur du travail ingrat (multiplexage, résistances de limitation, table des octets) et laisse la place au contenu. Les 16 niveaux d’intensité se changent par logiciel, sans toucher au câblage.

Un seul bloc de 8 × 8 convient aux symboles, aux chiffres en grand, aux flèches et aux petites animations : feu tricolore, compte à rebours, indicateur d’état, dé personnalisé. Lorsqu’un texte doit défiler, ce module se chaîne avec d’autres du même modèle, ou se remplace par la version longue de 8 × 32 points.

Le module est livré avec son câble de 5 fils à connecteurs femelles : rien à souder pour un premier essai.

Caractéristiques techniques

Brochage et câblage

Le module se raccorde comme un composant unique. Correspondance pour un Arduino Uno ou un Nano, qui disposent du bus SPI matériel :

Les deux connecteurs portent la sérigraphie IN et OUT avec une flèche : les données entrent par le connecteur d’entrée et ressortent par l’autre. Le module branché à l’envers n’est pas détruit, mais l’image affichée devient incohérente — motif en miroir ou points dispersés — ce qui fait chercher la panne dans le programme au lieu du câblage.

Sur un ESP32, le bus VSPI se trouve sur GPIO23 pour DIN et GPIO18 pour CLK ; CS peut être n’importe quel GPIO libre. L’alimentation, elle, reste à prendre sur une sortie 5 V, jamais sur le 3,3 V.

Si un affichage doit défiler ou si le montage comporte plusieurs modules, prévoyez une alimentation 5 V 2 A et reliez impérativement sa masse à celle de la carte de commande : sans référence commune, les trois lignes de données n’ont plus de sens et l’affichage part en désordre.

Ce que la puce fait à votre place

Le MAX7219 possède une mémoire de 8 octets — un octet par ligne — et un jeu de registres de configuration. Un seul composant externe intervient : une résistance qui fixe le courant dans les segments, soit environ 40 mA par LED avec la valeur montée d’usine.

À chaque instant, seuls 8 des 64 points sont réellement allumés : la puce allume une ligne, attend un instant très bref, passe à la suivante, et recommence plusieurs centaines de fois par seconde. L’œil reconstitue l’image complète. C’est ce principe qui explique les appels de courant répétés, mais aussi qu’une photo prise au mauvais moment puisse montrer un affichage incomplet alors que le montage fonctionne parfaitement.

Trois réglages méritent d’être connus : l’intensité, de 0 à 15, qui règle la luminosité de toutes les LED d’un seul coup ; le nombre de lignes balayées, qui doit rester à 8 pour une matrice carrée ; et le mode décodeur, qui convertit automatiquement un chiffre en dessin s’il est activé. Pour des symboles libres, ce mode reste désactivé : chaque bit de l’octet correspond alors à un point.

Applications

• Symboles et icônes — flèche, cœur, visage, feu tricolore : un dessin par tableau d’octets.
• Chiffres en grand — compte à rebours, score, numéro de porte affiché sur une seule colonne.
• Indicateur d’état — une animation courte qui signale une mesure hors seuil mieux qu’un voyant unique.
• Petites animations — deux images alternées suffisent pour un clignotement ou un battement.
• Apprentissage du bus SPI — trois lignes à comprendre, un résultat visible immédiatement : c’est un bon premier montage série.
• Brique d’un bandeau — plusieurs modules chaînés forment un texte défilant, sans câblage supplémentaire côté commande.

Mini-projet : un cœur qui bat sur les 64 LED

Nous allons afficher un cœur et le faire battre, en alternant deux images toutes les 180 millisecondes. Le programme dessine chaque image ligne par ligne : c’est le cœur même du pilotage d’une matrice. Comptez quinze minutes, installation de la bibliothèque comprise.

Ce qu’il faut

Le câblage

Cinq fils, dans l’ordre du connecteur d’entrée :

Le connecteur de sortie reste libre : c’est celui qui servirait à chaîner un second module.

La bibliothèque

Une seule bibliothèque suffit : MD_MAX72XX, de Marco Colli, disponible dans le gestionnaire de bibliothèques de l’IDE Arduino. Elle gère la table des octets, les registres et l’orientation de la matrice, ce qui évite d’écrire soi-même la moindre ligne de protocole.

Le programme

/*
 * Coeur qui bat sur un module MAX7219 8 x 8 (64 LED)
 * Carte : Arduino Uno
 * Bibliotheque : MD_MAX72XX, de Marco Colli
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
#include "MD_MAX72XX.h"
// Type de materiel : FC16_HW correspond aux modules 8 x 8 du commerce
#define TYPE_MATERIEL MD_MAX72XX::FC16_HW
// Selection du module ; DIN reste sur D11 et CLK sur D13 par le bus SPI
#define BROCHE_CS 10
// Un seul bloc de 8 x 8
#define NB_MODULES 1
MD_MAX72XX afficheur(TYPE_MATERIEL, BROCHE_CS, NB_MODULES);
// Deux images du meme coeur : une grande, une petite, pour le battement
// Chaque octet represente une ligne, le bit de poids fort etant le point de gauche
const uint8_t COEUR_GRAND[8] = {0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18, 0x00};
const uint8_t COEUR_PETIT[8] = {0x00, 0x24, 0x7E, 0x7E, 0x3C, 0x18, 0x00, 0x00};
unsigned long dernierBattement = 0;
bool phase = false;
void dessiner(const uint8_t image[8]) {
  // On parcourt les huit lignes et on ecrit l'octet correspondant
  for (uint8_t ligne = 0; ligne != 8; ligne++) {
    afficheur.setRow(0, ligne, image[ligne]);
  }
}
void setup() {
  afficheur.begin();
  afficheur.setIntensity(4);          // luminosite de 0 a 15
  dessiner(COEUR_PETIT);              // premiere image affichee des le demarrage
  dernierBattement = millis();
}
void loop() {
  // Toutes les 180 ms, on inverse la phase et on redessine
  if (millis() - dernierBattement >= 180) {
    dernierBattement = millis();
    phase = !phase;
    dessiner(phase ? COEUR_GRAND : COEUR_PETIT);
  }
}

Comment ça marche

• MD_MAX72XX afficheur(TYPE_MATERIEL, BROCHE_CS, NB_MODULES) déclare l’afficheur : son brochage interne, la broche de sélection et le nombre de blocs. Avec cette forme du constructeur, DIN et CLK passent par le bus SPI matériel de la carte, d’où leur absence de la liste.
• setRow(0, ligne, octet) écrit une ligne entière : le premier argument est l’index du module, le deuxième la ligne de 0 à 7, le troisième les huit points. C’est la fonction à connaître, tout le reste en découle.
• 0x66 s’écrit 01100110 en binaire, du point le plus à gauche au plus à droite : deux points, deux vides, deux points, deux vides. C’est le haut du cœur, d’où ses deux bosses.
• millis() renvoie le temps écoulé depuis la mise sous tension. Comparer l’écart à 180 ms rythme le battement sans jamais bloquer le programme : rien n’empêcherait d’y ajouter un bouton ou une mesure à côté.
• phase = !phase inverse un simple booléen, et l’opérateur ? choisit l’image correspondante : deux lignes suffisent pour une animation.
• setIntensity(4) place la luminosité au quart. Une valeur élevée se remarque surtout par la chaleur et la consommation, rarement par la lisibilité en intérieur.

Pour aller plus loin

• Vérifier le câblage en une seconde — appelez afficheur.control(MD_MAX72XX::TEST, MD_MAX72XX::ON) dans setup() : les 64 points s’allument d’un coup. Un point manquant désigne une LED ou une ligne fautive, pas le programme.
• Une autre image — remplacez les deux tableaux par les vôtres. Un dessin de 8 × 8 lignes se prépare en coloriant les cases d’une grille, puis en lisant chaque ligne comme un octet.
• Rotation et miroir — afficheur.transform(0, MD_MAX72XX::TSL) décale l’image d’une colonne, et les constantes TFLIP, TRC ou TINV la retournent ou l’inversent. Pratique quand la carte est montée tournée dans un boîtier.
• Plusieurs images en mémoire — un tableau de tableaux const uint8_t ANIMATION[4][8] et un index qui avance à chaque battement donnent une animation de quatre images.
• Chiffres en grand — la bibliothèque fournit setChar(), qui dessine une lettre ou un chiffre avec la police intégrée.
• Un rythme piloté par une mesure — faites dépendre l’intervalle des 180 ms d’un capteur : le cœur bat alors plus vite quand la température monte.

Variante : chaîner plusieurs modules

Un second module se raccorde par le connecteur de sortie du premier : DOUT du premier vers DIN du second, plus VCC, GND, CS et CLK mis en commun. Côté programme, seule la constante NB_MODULES change. Deux modules donnent 16 colonnes, quatre en donnent 32 — l’équivalent d’une carte longue assemblée à la main.

Prévoyez alors une alimentation externe plutôt que la sortie de la carte de commande, et pensez au condensateur de découplage près du connecteur d’entrée : c’est lui qui absorbe les appels de courant et sépare un montage qui tient la journée d’un montage qui se corrompt par intermittence.

Questions fréquentes

L’image est en miroir, ou décalée d’une ligne

Deux causes. Le module est d’abord peut-être monté à l’envers par rapport à la sérigraphie IN et OUT : les données entrent alors par le mauvais côté. Sinon, le type de matériel ne correspond pas au brochage réel de la carte : FC16_HW couvre la grande majorité des modules du commerce, mais quelques cartes utilisent un autre câblage. Changer cette seule constante suffit à trancher, et les exemples livrés avec la bibliothèque servent de référence.

Rien ne s’allume

Contrôlez d’abord VCC et GND : le MAX7219 a besoin de 5 V et fonctionne mal en dessous de 4 V. Vérifiez ensuite la broche CS : c’est un front sur cette ligne qui valide réellement les données envoyées, et une broche erronée dans le programme bloque tout sans message d’erreur. Enfin, une inversion entre DIN et CLK n’éteint pas l’afficheur mais ne produit rien de lisible. L’appel de test décrit plus haut tranche en une seconde entre un problème de câblage et une erreur de code.

Des points parasites, ou un affichage qui se corrompt par intermittence

C’est presque toujours l’alimentation. Les 64 points ne s’allument pas ensemble mais par lignes, ce qui crée des appels de courant brefs et répétés ; une source trop faible fait chuter la tension à cet instant et fausse la donnée en cours de transfert. Baissez l’intensité, ajoutez un condensateur près du connecteur d’entrée, et si le montage comporte plusieurs modules, passez à une alimentation 5 V séparée avec la masse mise en commun.

Puis-je l’alimenter en 3,3 V ?

Le MAX7219 demande au minimum 4 V : un montage alimenté en 3,3 V ne fonctionnera pas de façon fiable, même si les trois lignes de données, elles, tolèrent généralement les niveaux 3,3 V d’une carte ESP32 ou d’un Raspberry Pi. La solution consiste donc à alimenter le module en 5 V et à ne garder que DIN, CS et CLK côté 3,3 V. Si l’affichage se montre erratique, intercalez un adaptateur de niveau sur ces trois lignes.

Combien de modules peut-on chaîner ?

Rien ne limite le nombre en théorie : chaque module ajoute ses huit octets au bout de la même chaîne, avec cinq fils entre deux modules. La limite réelle est celle de l’alimentation et du temps de rafraîchissement, puisqu’il faut réécrire huit octets par module à chaque image. Au-delà de trois ou quatre modules, une source 5 V dédiée et de bonne qualité devient indispensable.

Quelle différence avec l’afficheur 8 × 32 ?

C’est le même principe, avec quatre blocs câblés en cascade sur une seule carte, déjà alignés et vissés ensemble. Le 8 × 32 convient au texte défilant, ce module-ci suffit dès qu’un symbole, un chiffre ou une animation courte est nécessaire — et il coûte moins de fils à reprendre si l’on se trompe.

À combiner avec

Pour le montage de cette page, une carte Uno R3 et des fils mâle-mâle suffisent ; le Kit Arduino Uno maroc réunit la carte, la plaque d’essai et les fils, ce qui laisse l’afficheur comme seul achat. Pour rendre le montage autonome, ajoutez une alimentation 5 V 2 A : elle alimente l’afficheur et la carte en même temps.

Si l’objectif est un texte défilant, la matrice 8 × 32 MAX7219 prend le relais en quatre blocs déjà chaînés, et le même programme fonctionne en changeant le nombre de modules. Pour quatre chiffres seulement, le module TM1637 se contente de deux fils, mais ne sait pas dessiner de symbole. Si vous préférez câbler la puce vous-même, le circuit MAX7219 en boîtier DIP se commande par les mêmes trois fils et les mêmes registres.

Pour animer l’affichage selon le monde extérieur, un capteur DHT11 fournit température et humidité, et un bouton poussoir permet de changer d’image à la main. Une horloge de bureau repose sur le module temps réel DS3231, qui garde l’heure juste même après une coupure. Et si l’affichage doit être piloté à distance, un ESP32 commande la matrice en Wi-Fi tout en alimentant le montage.