Afficheur 7 segments CA

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 5161BS : un seul chiffre rouge de 14,2 mm, dix broches, à anode commune. Les huit segments ont leur anode reliée aux deux broches communes, mises au +5 V ; c'est donc l'Arduino qui relie chaque segment à la masse pour l'allumer. Huit fils, huit résistances, et l'afficheur compte tout seul.

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 5161BS, la correspondance est celle-ci :

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

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 sur la broche 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.

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 compteur de 0 à 9 piloté par un bouton

Huit fils, huit résistances et un bouton : chaque appui fait avancer le chiffre d'une unité, et après le 9 on repart à 0. Comptez une quinzaine de minutes, soudure exclue.

Ce qu'il faut

Le bouton se câble directement entre la broche D10 et la masse : la résistance de tirage interne de l'Arduino (INPUT_PULLUP) évite d'en ajouter une, et il n'y a rien à calculer.

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 :

/*
 * Compteur 0 a 9 sur un afficheur 7 segments a anode commune (5161BS)
 * Carte : Arduino Uno -- le bouton incremente le chiffre affiche
 *
 * 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 anode commune, un segment s'allume quand sa broche est au niveau BAS.
// Dans ces masques, un 1 eteint le segment et un 0 l'allume.
// Ordre des bits : a b c d e f g dp
const byte CHIFFRES[10] = {
  0b11000000,   // 0
  0b11111001,   // 1
  0b10100100,   // 2
  0b10110000,   // 3
  0b10011001,   // 4
  0b10010010,   // 5
  0b10000010,   // 6
  0b11111000,   // 7
  0b10000000,   // 8
  0b10010000    // 9
};
byte chiffre = 0;
void afficher(byte valeur) {
  for (byte i = 0; i != 8; i++) {
    boolean allume = (bitRead(CHIFFRES[valeur], i) == 0);
    digitalWrite(PIN_SEGMENTS[i], allume ? LOW : HIGH);
  }
}
void setup() {
  for (byte i = 0; i != 8; i++) {
    pinMode(PIN_SEGMENTS[i], OUTPUT);
  }
  pinMode(PIN_BOUTON, INPUT_PULLUP);
  afficher(chiffre);
}
void loop() {
  static boolean repos = true;
  boolean appui = (digitalRead(PIN_BOUTON) == LOW);
  if (repos && appui) {          // front descendant : le bouton vient d'etre presse
    chiffre = (chiffre + 1) % 10;
    afficher(chiffre);
    delay(200);                  // les rebonds du bouton sont ignores
  }
  repos = !appui;
  delay(5);
}

Comment ça marche

• Chaque chiffre 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 à anode commune, un bit à 1 éteint le segment et un bit à 0 l'allume — c'est pourquoi les masques commencent presque tous par deux 1.
• La fonction afficher() parcourt les huit broches et pose sur chacune le niveau correspondant au bit du masque lue avec bitRead().
• Le bouton est lu en INPUT_PULLUP : au repos la broche est à l'état haut, un appui la met à la masse. Le programme ne réagit qu'au passage de l'état haut vers l'état bas, donc une fois par appui et non pendant toute la pression.
• Le delay(200) qui suit l'incrémentation laisse passer les rebonds mécaniques du bouton : sans lui, un seul appui ferait parfois sauter deux ou trois chiffres.
• Le delay(5) de fin de boucle n'est pas une temporisation de confort : il évite de lire la broche des milliers de fois par seconde, ce qui ne sert à rien.

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 à cathode commune du même format : l'Afficheur 7 segments CC. Elle se câble exactement de la même manière, avec deux différences : sa broche commune va au GND, et un segment s'allume quand sa broche est à l'état haut. Le programme ci-dessus reste valable à condition d'inverser les masques, c'est-à-dire de remplacer chaque bit par son contraire.

Questions fréquentes

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

Dans la grande majorité des cas, c'est la broche commune : elle doit être au +5 V sur un afficheur à anode commune. Reliée à la masse par erreur, elle laisse les segments éteints et produit l'inverse de ce que le programme prévoit. 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.

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

Non, sauf à accepter une luminosité qui change selon le chiffre affiché. Les LED allumées se partagent le courant qui traverse cette résistance unique : elles sont brillantes quand elles sont deux, ternes quand elles sont sept. 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 — les segments s'allument toujours sur un niveau bas, et la broche commune reste sur l'alimentation positive.

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 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 et huit résistances de 220 Ω en plus, vous montez le compteur 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.