Afficheur 7 segments CC

L’afficheur 7 segments est le composant qui donne un chiffre à un montage : sept barres de LED disposées en « 8 », plus un point décimal. Allumez les bonnes barres et vous affichez 0, 1, 2… jusqu’à 9, ainsi que quelques lettres.

Celui-ci est un 5161AS : un seul chiffre rouge de 14,2 mm, dix broches, à cathode commune. Ses deux broches communes (3 et 8) se relient à la masse, et un segment s’allume quand l’Arduino porte sa broche à l’état haut. C’est le sens de câblage le plus commode à programmer : les tables de chiffres que l’on trouve dans les exemples de montage sont écrites pour une cathode commune, un bit à 1 allumant le segment.

Caractéristiques techniques

Brochage : dix broches, deux rangées

Les broches sont numérotées de 1 à 10 dans le sens des aiguilles d’une montre, vu de face, le repère d’orientation en haut à gauche. Pour le 5161AS, la correspondance est celle-ci :

La règle à retenir : les deux broches communes vont au GND, et un segment s’allume quand sa propre broche est mise à l’état haut. C’est exactement l’inverse d’un afficheur à anode commune, où la broche commune va au +5 V et le segment s’allume sur un niveau bas.

Reconnaître une cathode commune avant de câbler

Les deux versions existent dans le même boîtier, avec la même apparence et le même brochage : seul le sens de la LED commune change. Se tromper ne grille rien, mais l’afficheur reste éteint ou s’allume à l’envers, et l’on cherche la faute dans le programme alors qu’elle est dans le tirage.

• La référence est gravée sur la tranche du boîtier : 5161AS pour une cathode commune, 5161BS pour une anode commune. Le « A » de la fin ne veut pas dire « anode » — c’est le piège classique : ici le A désigne la cathode commune.
• Un multimètre en position diode tranche en trois secondes : la pointe noire (COM) sur une broche commune supposée et la pointe rouge sur une broche de segment allume le segment, si et seulement si l’afficheur est à cathode commune. Sur une anode commune, c’est l’inverse : la pointe rouge sur la commune.
• En cas de doute, ne rien souder : un essai sur plaque d’essai avec une résistance de 220 Ω et deux fils répond à la question.

Pourquoi une résistance par segment

Un segment est une LED : sans résistance, il reçoit trop de courant et grille en quelques secondes. Avec 220 Ω sous 5 V, chaque segment reçoit environ 13 mA — largement dans ses limites, et bien lisible dans une pièce éclairée.

Mettez une résistance par segment, et non une seule dans la ligne commune. Avec une résistance unique, les segments allumés se partagent le courant : le « 1 » (deux segments) est éclatant, le « 8 » (sept segments) devient terne. Cet équilibre demande simplement huit résistances plutôt qu’une.

Le courant total reste modeste : huit segments allumés à 13 mA font 104 mA, très en dessous des limites d’un Arduino Uno (20 mA recommandés par broche, 200 mA à travers la puce). Réparti sur huit broches, cet afficheur se pilote donc directement, sans transistor ni driver.

Applications

• Compteur et index d’étapes — nombre de pièces, de passages, de tours, numéro de programme.
• Petit appareil de mesure — température, tension, poids, en affichant un chiffre à la fois.
• Minuterie et compte à rebours — le chiffre des secondes, ou celui des minutes.
• Voyant de niveau — un chiffre de 0 à 9 plutôt qu’une barre de LED.
• Jeu électronique — score, numéro de joueur, dé à affichage unique.

Mini-projet : un dé électronique de 1 à 6

Un bouton, un afficheur, huit résistances : chaque appui fait défiler les six faces puis s’arrête sur une au hasard. Comptez une quinzaine de minutes, soudure exclue.

Ce qu’il faut

Le câblage

Le point décimal reste de côté : une broche pour un détail que ce montage n’affiche pas. Le programme lui réserve tout de même la broche D9 — il suffit de le câbler comme les autres segments, avec sa propre résistance de 220 Ω, pour l’activer.

Le programme

À copier dans l’IDE Arduino, puis à téléverser sur la carte :

/*
 * De electronique de 1 a 6 sur un afficheur 7 segments a cathode commune (5161AS)
 * Carte : Arduino Uno -- chaque appui sur le bouton lance un tirage
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
// Ordre des broches : a, b, c, d, e, f, g, dp
const byte PIN_SEGMENTS[8] = {2, 3, 4, 5, 6, 7, 8, 9};
const byte PIN_BOUTON = 10;
// A cathode commune, un segment s'allume quand sa broche est au niveau HAUT.
// Dans ces masques, un 1 allume le segment. Ordre des bits : a b c d e f g dp
// Une face de de va de 1 a 6 : six entrees suffisent, la premiere efface tout.
const byte FACES[7] = {
  0b00000000,   // rien -- afficheur eteint
  0b00000110,   // 1
  0b01011011,   // 2
  0b01001111,   // 3
  0b01100110,   // 4
  0b01101101,   // 5
  0b01111101    // 6
};
void afficher(byte valeur) {
  for (byte i = 0; i != 8; i++) {
    boolean allume = (bitRead(FACES[valeur], i) == 1);
    digitalWrite(PIN_SEGMENTS[i], allume ? HIGH : LOW);
  }
}
void setup() {
  for (byte i = 0; i != 8; i++) {
    pinMode(PIN_SEGMENTS[i], OUTPUT);
  }
  pinMode(PIN_BOUTON, INPUT_PULLUP);
  randomSeed(analogRead(A0));   // A0 laissee en l'air : son bruit sert de graine
  afficher(0);
}
void loop() {
  if (digitalRead(PIN_BOUTON) == LOW) {       // appui : la broche part a la masse
    for (byte i = 0; i != 12; i++) {          // defilement, comme un de qu'on secoue
      afficher(random(1, 7));
      delay(40 + i * 8);                      // le defilement ralentit
    }
    afficher(random(1, 7));                   // la face tiree reste affichee
    delay(300);                               // les rebonds du bouton sont ignores
    while (digitalRead(PIN_BOUTON) == LOW) {  // on attend que le bouton soit relache
      delay(5);
    }
  }
  delay(5);
}

Comment ça marche

• Chaque face est un masque de 8 bits : un bit par segment, dans l’ordre a, b, c, d, e, f, g, dp. Comme l’afficheur est à cathode commune, un bit à 1 allume le segment — les masques s’écrivent donc exactement comme la table de référence des chiffres, sans rien inverser.
• La fonction afficher() parcourt les huit broches et pose sur chacune le niveau correspondant au bit du masque lu avec bitRead().
• randomSeed(analogRead(A0)) donne au générateur de nombres pseudo-aléatoires une graine différente à chaque mise sous tension : sans elle, la même séquence sortirait à chaque démarrage et le dé ne serait pas un dé.
• random(1, 7) renvoie une valeur de 1 à 6 : la borne supérieure est exclue, ce qui correspond exactement aux faces d’un dé.
• La boucle de douze affichages avec un delay qui s’allonge imite le ralentissement d’un dé qu’on secoue. Le bouton est lu en INPUT_PULLUP : au repos la broche est à l’état haut, un appui la met à la masse, et la résistance de tirage interne évite d’en ajouter une.
• La dernière boucle attend que le bouton soit relâché avant de rendre la main : elle garantit un seul tirage par appui, même si le doigt reste posé.

Variante : plusieurs chiffres, ou l’autre sens de câblage

Pour afficher un nombre à plusieurs chiffres, huit broches par chiffre deviennent ingérables. Deux solutions existent : le Circuit MAX7219CNG, qui pilote huit chiffres avec trois fils et se charge lui-même du multiplexage, ou le Module TM1637, qui affiche quatre chiffres sur deux broches seulement.

Le catalogue contient aussi la version à anode commune du même format : l’Afficheur 7 segments CA. Elle se câble de la même manière, avec deux différences : sa broche commune va au +5 V, et un segment s’allume quand sa broche est à l’état bas. Le programme ci-dessus reste valable à condition d’inverser les masques, c’est-à-dire de remplacer chaque bit par son contraire.

Un registre à décalage permet enfin de commander l’afficheur avec trois broches au lieu de huit. Attention dans ce cas au courant : la cathode commune appelle le courant depuis chaque sortie, et la limite de courant totale de ces circuits impose de réduire le courant par segment — en pratique, des résistances de 470 Ω au lieu de 220 Ω.

Questions fréquentes

Mon afficheur reste éteint, ou s’allume à l’envers

Dans la grande majorité des cas, c’est le tirage : sur une cathode commune, la broche commune va au GND et le segment s’allume à l’état haut. Avec un afficheur d’anode commune câblé de cette façon, rien ne s’allume ; avec celui-ci câblé comme un anode commune, tout s’allume à l’envers des chiffres. Vérifiez aussi que les deux broches communes, 3 et 8, sont bien raccordées : si l’une des deux manque, une partie des segments ne répond pas. Contrôlez enfin que les huit broches de segment sont bien en OUTPUT dans setup().

Puis-je mettre une seule résistance sur la broche commune ?

Techniquement oui, mais c’est un mauvais échange. Cette résistance unique verrait passer le courant de tous les segments allumés à la fois, soit jusqu’à huit fois celui d’un segment : elle devrait donc être bien plus faible, et la luminosité changerait selon le chiffre affiché — le « 1 » éclatant, le « 8 » terne. Une résistance par segment impose le même courant à chaque LED, donc un affichage régulier d’un chiffre à l’autre.

Pourquoi huit broches de commande pour sept segments ?

Parce que le point décimal est un huitième segment, appelé dp. C’est lui qui porte le compte à huit, auquel s’ajoutent les deux broches communes : dix broches au total, pour un afficheur qui continue de s’appeler « 7 segments ».

Est-ce que ça tient sur une plaque d’essai ?

Les broches font 0,51 mm de diamètre et sont prévues pour l’enfichage. Les deux rangées étant espacées de 15,24 mm, elles se placent de part et d’autre de la gouttière centrale : faites un essai à blanc avant de câbler, repère d’orientation vers le haut. Si l’écartement ne tombe pas juste sur votre modèle de plaque, soudez l’afficheur sur une plaque à trous et reliez-la par des fils.

Fonctionne-t-il en 3,3 V, avec un ESP32 par exemple ?

Oui. La tension directe d’un segment, environ 2,1 V, reste très en dessous de 3,3 V. Il faut simplement recalculer la résistance de limitation : environ 120 Ω par segment pour 10 mA, au lieu de 220 Ω sous 5 V. Le sens de commande ne change pas — la broche commune reste au GND, et les segments s’allument toujours sur un niveau haut, ce qui convient aux sorties 3,3 V des cartes récentes.

Peut-on afficher des lettres ?

Quelques-unes, oui : A, b, C, d, E, F, H, L, P, U, ainsi que les chiffres hexadécimaux, se dessinent avec sept barres. Le M, le W et la plupart des autres lettres ne sont pas lisibles sur un seul chiffre. Pour du texte, un afficheur LCD 1602 en I2C ou un module à matrice de points est plus adapté.

À combiner avec

Le Kit Arduino Uno maroc réunit la carte Uno, la plaque d’essai, les fils et des composants : avec l’afficheur, huit résistances de 220 Ω et un bouton en plus, vous montez le dé de cette page. Si vous partez de zéro, le trio Uno R3 + cable usb, plaque d’essai 400 points et fils mâle-mâle suffit. Et pour afficher un nombre à plusieurs chiffres dès le départ, visez directement le Circuit MAX7219CNG.