Circuit MAX7219CNG

Le MAX7219 est un pilote d’affichage : un seul circuit qui allume, éteint, balaie et règle la luminosité de 64 LED pour vous, sans que la carte ait à s’en occuper. Il se place entre votre microcontrôleur et un afficheur 7 segments allant jusqu’à 8 chiffres, une matrice 8 × 8, une barre de LED, ou simplement 64 LED montées comme vous le voulez.

Celui-ci est le boîtier DIP-24, celui qui se plante dans une plaque d’essai — pas le module soudé sur sa petite carte. C’est le composant d’origine, avec ses 24 broches visibles : c’est lui que l’on trouve au coeur de tous les modules MAX7219 du commerce, et c’est lui qu’on remplace quand un module tombe en panne.

Le gain est immédiat. Un afficheur 7 segments de huit chiffres, piloté broche à broche, réclamerait 64 fils et 64 sorties. Ici, trois fils suffisent : le circuit se charge du balayage des chiffres, du décodage des nombres et du réglage de l’intensité.

Caractéristiques techniques

CNG ou ENG ? Les deux se rencontrent : ce sont exactement le même boîtier et les mêmes fonctions, seule la gamme de température diffère. Sur un montage d’intérieur, l’un comme l’autre convient.

Brochage : les 24 broches du DIP

Vu de dessus, le repère d’orientation en haut, la broche 1 est en haut à gauche ; la numérotation descend le long du flanc gauche jusqu’à la 12, puis remonte le flanc droit de la 13 à la 24. La correspondance est la suivante :

Le partage des rôles est simple à retenir : les DIG sont des entrées de courant — elles aspirent le courant vers la masse — et les SEG des sorties de courant, qui l’envoient dans les LED. C’est exactement ce que demande un afficheur à cathode commune, et c’est pour cela que la version à anode commune ne se branche pas directement ici.

Trois fils et seize bits

Chaque écriture est un paquet de 16 bits envoyés à la queue leu leu sur DIN, au rythme de CLK : d’abord l’adresse du registre sur 8 bits, puis la valeur sur 8 bits. Un front montant sur LOAD referme le paquet et recopie ces 16 bits dans le registre visé. Rien n’est écrit avant, ce qui évite d’afficher des états intermédiaires.

Comme les bits entrent par un seul fil, un second circuit se raccorde sans effort : sa broche DIN reçoit la sortie DOUT du premier. Les 16 bits destinés au circuit du bout de la chaîne doivent simplement être décalés de 16 bits par circuit traversé. On pilote ainsi 8 chiffres, puis 16, puis 24, sans ajouter une seule broche à la carte.

Les registres de configuration

Il n’y a que sept adresses à connaître. Chacune est un octet :

En mode sans décodage, les bits d’un registre de chiffre se lisent ainsi, du poids fort au poids faible : dp a b c d e f g. Le chiffre 0 s’écrit donc 0b01111110 — les six segments du tour, sans la barre du milieu ni le point.

Choisir la résistance RSET

C’est le seul composant que le circuit réclame, et le seul réglage que l’on puisse oublier : sans RSET entre la broche 18 et le +5 V, aucun segment ne s’allume. Sa valeur fixe le courant crête dans tous les segments à la fois — le circuit fait environ 100 fois le courant qui la traverse. Les valeurs de la documentation du constructeur, pour un afficheur rouge dont la tension directe est voisine de 2 V :

Ne descendez jamais sous 9,53 kΩ : la documentation donne cette valeur comme un minimum, et 40 mA par segment comme un maximum. Au-delà, il faudrait des pilotes de puissance externes, ce que ce circuit sait aussi faire.

Le courant n’est pas perdu, il chauffe. Entre le +5 V et la tension de la LED, la différence se dissipe dans le circuit. À 40 mA sur huit segments, cela représente près d’un watt : dans un boîtier DIP, cela se traduit par une élévation de température très sensible au toucher. À 20 ou 27 mA, le même montage reste tiède, et c’est une raison de plus de ne pas viser la luminosité maximale.

Deux condensateurs, enfin, sont recommandés par le constructeur et oubliés par presque tout le monde : un 0,1 µF au plus près du circuit entre la broche 19 et la masse, et un 10 µF sur l’alimentation. Ils ne se voient pas et n’améliorent rien de visible — ils évitent les chiffres fantômes sur les montages longs et les fausses écritures quand les LED s’allument toutes en même temps.

Applications

• Un compteur à plusieurs chiffres — afficheur 7 segments de 2, 4 ou 8 chiffres, avec les mêmes trois fils quel que soit le nombre.
• Une matrice 8 × 8 — texte défilant, icônes, petit jeu. Le circuit gère chaque LED comme un point.
• Un vu-mètre — 64 LED allumées en barre, à commander d’un seul octet par colonne.
• Un afficheur de mesure — tension, température, poids, avec réglage de la luminosité selon l’éclairage de la pièce.
• Un affichage à distance du microcontrôleur — la charge du balayage sort du programme, qui reste simple et réactif.
• Réparer un module — le même boîtier se remplace sur une carte de matrice MAX7219 dont le circuit a rendu l’âme.

Mini-projet : un compteur de 0 à 9 en trois fils

Nous allons faire défiler les chiffres de 0 à 9 sur un afficheur 7 segments, avec le circuit à découvert sur une plaque d’essai. Le montage est volontairement limité à un seul chiffre : c’est celui qui montre le mieux le rôle de la résistance RSET. Comptez vingt minutes.

Ce qu’il faut

Le boîtier DIP-24 est large de 7,62 mm : il s’enjambe de part et d’autre de la gouttière centrale de la plaque, broche 1 vers le haut. Repérez-la bien avant de le planter — un circuit retourné n’aime pas du tout la mise sous tension.

Le câblage

Pas de résistance sur les segments. C’est le circuit qui limite le courant, avec la ligne RSET : les huit résistances de 220 Ω qu’exige un câblage direct disparaissent. C’est l’un des vrais avantages de ce composant. Vérifiez simplement que les deux cathodes communes de l’afficheur sont bien raccordées à DIG 0 : si l’une des deux manque, la moitié des segments reste éteinte.

Le programme

À copier dans l’IDE Arduino, puis à téléverser sur la carte. Aucune bibliothèque n’est nécessaire.

/*
 * Compteur de 0 a 9 sur un afficheur 7 segments pilote par un MAX7219
 * Carte : Arduino Uno
 * Montage : MAX7219 en DIP-24 et afficheur 5161AS a cathode commune
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

const byte PIN_DIN = 11;   // broche 1 du MAX7219
const byte PIN_CS  = 10;   // broche 12 (LOAD) du MAX7219
const byte PIN_CLK = 13;   // broche 13 du MAX7219

// Adresses des registres du MAX7219
const byte REG_DECODAGE  = 0x09;
const byte REG_INTENSITE = 0x0A;
const byte REG_BALAYAGE  = 0x0B;
const byte REG_MARCHE    = 0x0C;
const byte REG_TEST      = 0x0F;

// Un bit par segment, dans l'ordre du circuit : dp a b c d e f g
const byte CHIFFRES[10] = {
  0b01111110,   // 0
  0b00110000,   // 1
  0b01101101,   // 2
  0b01111001,   // 3
  0b00110011,   // 4
  0b01011011,   // 5
  0b01011111,   // 6
  0b01110000,   // 7
  0b01111111,   // 8
  0b01111011    // 9
};

// Envoie 16 bits : l'adresse du registre, puis la valeur.
// Le front montant de LOAD recopie ces 16 bits dans le registre vise.
void ecrire(byte registre, byte valeur) {
  digitalWrite(PIN_CS, LOW);
  shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, registre);
  shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, valeur);
  digitalWrite(PIN_CS, HIGH);
}

void afficher(byte chiffre) {
  ecrire(0x01, CHIFFRES[chiffre]);   // 0x01 : le chiffre branche sur DIG 0
}

void setup() {
  pinMode(PIN_DIN, OUTPUT);
  pinMode(PIN_CS, OUTPUT);
  pinMode(PIN_CLK, OUTPUT);
  digitalWrite(PIN_CS, HIGH);

  ecrire(REG_MARCHE, 0x01);      // sortie de veille : le premier reglage a faire
  ecrire(REG_DECODAGE, 0x00);    // aucun decodage, on envoie le motif des segments
  ecrire(REG_BALAYAGE, 0x00);    // un seul chiffre allume
  ecrire(REG_INTENSITE, 0x08);   // luminosite moyenne, de 0 a 15
  ecrire(REG_TEST, 0x00);        // pas de test d'affichage
}

void loop() {
  byte chiffre = 0;
  while (chiffre != 10) {
    afficher(chiffre);
    delay(500);
    chiffre++;
  }
}

Comment ça marche

• shiftOut() envoie un octet bit par bit, poids fort en tête, exactement comme le circuit l’attend. Deux appels : l’adresse, puis la valeur.
• digitalWrite(PIN_CS, HIGH) referme le paquet. C’est ce front montant, et lui seul, qui écrit réellement dans le registre — tout ce qui précède n’est qu’un décalage dans un registre interne.
• La table CHIFFRES écrit chaque chiffre sous forme de motif de segments, dans l’ordre du circuit : le point décimal d’abord, puis a, b, c, d, e, f, g. Le 8, tous segments allumés, s’écrit donc 0b01111111.
• Le mode sans décodage est choisi exprès : le circuit laisse alors la valeur intacte, ce qui permet de dessiner aussi bien un chiffre qu’une barre de niveau ou des lettres. Avec le décodeur activé, il n’accepterait que les chiffres de 0 à 9 et quelques symboles.
• REG_MARCHE est écrite avant tout le reste, et l’ordre a son importance : à la mise sous tension le circuit démarre en veille et rien ne s’allume, même une fois la table de chiffres envoyée.
• REG_BALAYAGE à 0 n’allume que DIG 0. Ce n’est pas qu’une économie de fils : le chiffre reste allumé en permanence au lieu d’être balayé, ce qui explique la résistance RSET plus élevée conseillée plus haut.

Pour aller plus loin

• Afficher sans clignoter — remplacez delay(500) par un compteur à base de millis(), pour que la boucle reste libre de lire un bouton ou un capteur pendant l’affichage.
• Automatiser le dessin des chiffres — activez le décodeur (REG_DECODAGE à 0x01 pour le premier chiffre) et envoyez la valeur du chiffre au lieu de son motif.
• Régler la luminosité au clavier — REG_INTENSITE accepte de 0 à 15 ; une valeur intermédiaire est souvent plus lisible qu’une valeur maximale dans une pièce sombre.
• Vérifier le câblage en une seconde — REG_TEST à 0x01 allume tous les segments d’un coup. Si un segment manque, la faute est dans le fil correspondant, pas dans le programme.
• Dessiner autre chose que des nombres — en mode sans décodage, chaque octet est libre : une barre de niveau, une flèche, une lettre (A, b, C, d, E, F, H, L, P, U se dessinent sans peine).

Variante : huit chiffres et plus, toujours en trois fils

Le câblage ne change pas quand on ajoute des chiffres, il se répète. Chaque chiffre supplémentaire prend sa propre broche DIG pour la cathode, et les huit broches SEG sont mises en commun sur tous les afficheurs. Le programme envoie ensuite un octet par chiffre, sur les registres 0x01 à 0x08, et le circuit fait défiler l’affichage assez vite pour que l’oeil ne voie qu’une image continue. C’est le principe du multiplexage, et c’est là que 40 mA par segment redeviennent la bonne valeur : chaque chiffre n’est plus allumé qu’un huitième du temps.

Pour aller au-delà de huit chiffres, plusieurs circuits se chaînent par DOUT : 16 chiffres, 24 chiffres, autant que nécessaire, toujours avec les trois mêmes fils partant de la carte. Chaque circuit ajoute son propre RSET et ses propres condensateurs de découplage.

Si vous préférez ne pas câbler tout cela, le catalogue propose des matrices 8 × 8 avec le MAX7219 déjà soudé et son bornier d’entrée, ainsi qu’une matrice 8 × 32 qui réunit quatre circuits en cascade sur une seule carte. On y retrouve le même circuit, les mêmes registres et les mêmes trois fils — la différence est qu’il n’y a plus rien à souder.

Questions fréquentes

Puis-je brancher mon afficheur à anode commune ?

Non, pas directement. Ce circuit est prévu pour des afficheurs à cathode commune : ses broches DIG aspirent le courant vers la masse et ses broches SEG l’envoient dans les LED. Sur un afficheur à anode commune, le sens est inversé et rien ne s’allume normalement. Si c’est votre cas, l’afficheur 7 segments CA ne conviendra qu’avec un montage à transistors, ou avec le MAX7221, variante du même circuit prévue entre autres pour ce genre d’adaptation.

Rien ne s’allume du tout

Trois causes, dans l’ordre de fréquence. Le circuit a été laissé en veille : la première écriture doit être 0x0C à 1, sans quoi l’écran reste noir quel que soit le reste du programme. La résistance RSET manque ou est mal placée : sans elle entre la broche 18 et le +5 V, aucun segment ne reçoit de courant. Ou une masse manque : les broches 4 et 9 doivent toutes les deux être reliées, et les deux cathodes communes de l’afficheur également. En dernier recours, envoyez 0x0F à 1 : si tous les segments s’allument, le câblage est bon et le problème est dans le programme.

Tous les chiffres affichés sont faux, ou les segments ne correspondent pas

Le brochage de l’afficheur et celui du circuit ne cadrent pas. Reprenez la table de câblage segment par segment : sur un afficheur 10 broches, la correspondance des lettres a à g n’est pas dans l’ordre des numéros de broches, et une inversion entre deux segments produit un chiffre parfaitement lisible mais faux. Ce symptôme n’a rien à voir avec le programme.

Puis-je l’utiliser avec un ESP32 ou une carte en 3,3 V ?

Il faut alors deux précautions. Le circuit s’alimente en 5 V — en dessous de 4,0 V il ne fonctionne plus — et ses entrées logiques demandent au moins 3,5 V pour être reconnues comme un niveau haut, ce qu’une sortie 3,3 V n’est pas garantie de fournir. Prévoyez donc une alimentation en 5 V et un adaptateur de niveau sur les trois lignes DIN, CLK et LOAD. Le balayage, lui, ne dépend pas de la carte : une fois les 16 bits écrits, le circuit continue tout seul.

Faut-il des condensateurs ?

La documentation en demande deux : un 0,1 µF entre la broche 19 et la masse, au plus court, et un 10 µF sur l’alimentation. Sur une plaque d’essai et avec un seul chiffre, le montage fonctionne souvent sans — mais dès que les segments s’allument par paquets, l’appel de courant fait vaciller l’alimentation et l’on voit apparaître des chiffres fantômes, des segments faibles ou des écritures perdues. Ce sont les premiers composants à ajouter quand un montage marché sur table devient instable.

Le circuit devient chaud, est-ce normal ?

Jusqu’à un point, oui. Ce circuit limite le courant mais ne le découpe pas : la différence entre le +5 V et la tension de la LED part en chaleur dans le boîtier. À 40 mA sur huit segments, comptez près d’un watt et un boîtier très chaud au doigt. Deux leviers : une résistance RSET plus grande — 20 ou 30 kΩ au lieu de 10 kΩ — et un registre d’intensité plus modéré. Un boîtier tiède est normal, un boîtier qui laisse une trace après quelques secondes ne l’est pas.

Combien de LED puis-je piloter ?

64 par circuit : huit chiffres de huit segments, ou une matrice 8 × 8, ou huit barres de huit LED. En cascade, chaque circuit supplémentaire ajoute ses 64 LED sans consommer une broche de plus sur la carte. Au-delà d’une certaine longueur, la limite n’est plus le circuit mais l’alimentation : huit segments à 40 mA font déjà 320 mA, et il faut compter les appels de courant de tous les circuits allumés en même temps.

À combiner avec

Pour le montage de cette page, il vous faut l’afficheur 7 segments CC — c’est le seul du catalogue qui se branche directement sur ce circuit —, deux résistances 10 kΩ pour la ligne RSET, une plaque d’essai 830 points, des fils mâle-mâle et une carte Uno R3. Le Kit Arduino Uno maroc réunit déjà la carte, la plaque, les fils et les résistances : il ne reste que l’afficheur et le circuit à ajouter.

Pour un affichage plus large sans câblage, les matrices 8 × 8 MAX7219 et la matrice 8 × 32 embarquent ce même circuit prêt à l’emploi. Et si l’objectif est seulement d’afficher quatre chiffres avec un minimum de fils, le module TM1637 s’en charge en deux broches, sans résistance ni condensateur à prévoir.