02 – Afficheur 7 segments

Cette section aborde les afficheurs 7 segments, ceux-ci permettent d’afficher les 10 chiffres, ainsi que certaines lettres.
Ces afficheurs ont leurs heures de gloire derrière eux, on les trouvait un peut partout : réveils, montres, téléviseurs, micro-ondes, etc.. Actuellement, ils sont généralement remplacés par des afficheurs LCD ou des écrans graphiques.
La mise en oeuvre restant simple, ils peuvent rester pratiques pour quelques applications.

Principe de fonctionnement

Un afficheur 7 segments est composé de 7 LEDs (d’où le nom du composant), complété par une LED qui joue le rôle de point. Selon les segments allumés, on voit un nombre :

Exemple d’utilisation

Des constantes sont définies pour les broches de commande des segments, ainsi qu’un tableau qui indique, pour chaque chiffre ou lettre, quels sont les segments allumés. Le bit 0 correspond au segment ‘A’, le bit 1 au segment ‘B’, etc. La LED DP est commandée séparément.

// Configuration des segments (A - G, DP)
 const byte pin7Segments[] = { 4, 5, 6, 7, 8, 9, 10, 11 };
 // Table de conversion caractères -> segments ON
 const byte codeSegments[] = {
  0b00111111,
  0b00000110,
  0b01011011,
  0b01001111,
  0b01100110,
  0b01101101,
  0b01111101,
  0b00000111,
  0b01111111,
  0b01101111,
  0b01110111,
  0b01111100,
  0b00111001,
  0b01011110,
  0b01111001,
  0b01110001
 };

La fonction setup initialise toutes les broches de commande en sortie :

void setup() {
   // All pins are output
   for (int i=0; i<8; i++) {
     pinMode(pin7Segments[i], OUTPUT);  
     digitalWrite(pin7Segments[i], LOW);
   }
 }

Une fonction displayCharacter, qui reçoit en paramètre le chiffre à afficher et l’état du DP, va utiliser le tableau codeSegments pour savoir quelles LED enclencher :

void displayCharacter(byte chiffre, byte dp) {
  if (chiffre > 15)
    return;
  for (int i=0; i<7; i++) {
    digitalWrite(pin7Segments[i], bitRead(codeSegments[chiffre], i));
  }
  digitalWrite(pin7Segments[7], dp);
}

La boucle du programme affiche chaque valeur l’un après l’autre :

void loop() {
   static byte character = 0;
   static byte dpState = 0;

  // Display character
  displayCharacter(character, dpState);

  // Next number
  if (++character == 16) {
    character = 0;
  }

  // Invert DP  
  dpState = !dpState;

  // Dont't run too fast :-)
  delay(2500);
 }

Utiliser un décodeur

Précédemment, c’est le logiciel qui a fait le nécessaire afin que les bons segments soient allumés ou éteints afin de représenter les chiffres et les nombres. C’est ce qui est codé dans le tableau codeSegments, où chaque bit indique l’état d’un segment, cette table est un décodeur logiciel.
Il existe également un circuits intégré qui réalise ce décodage, dès lors, 5 bits au lieu de 8 sont nécessaires (4 bits pour le code BCD et 1 bit pour le point).
Le schéma électrique est le suivant :

Voici un exemple de sketch :

// Configuration des segments (ABCD, DP)
const byte pinDP = 8;
const byte pinBCD_DP[] = { 4, 5, 6, 7, pinDP};

void setup() {
  // All pins are output
  for (int i=0; i<5; i++) {
    pinMode(pinBCD_DP[i], OUTPUT);  
    digitalWrite(pinBCD_DP[i], LOW);
  }
}

void loop() {
  // Données persistances
  static byte character = 0;
  static byte dpState = 0;
  
  // Affiche le caractère
  displayCharacter(character, dpState);
  // Next number
  if (++character == 10) {
    character = 0;
  }

  // Change d'état
  dpState = !dpState;
  
  // Pas trop vite :-)
  delay(1000);
}

// Fonction d'affichage d'un caractère et du point
void displayCharacter(byte chiffre, byte dp) {
  if (chiffre > 15)
    return; 
  for (int i=0; i<4; i++) {
    digitalWrite(pinBCD_DP[i], bitRead(chiffre, i));
  }
  digitalWrite(pinDP, dp);
}

Les avantageas d’utiliser ce convertisseur sont de diminuer le code à exécuter et le nombre de connexions. Les désavantages sont l’augmentation du nombre d’éléments et, pour le circuit considéré, l’impossibilité d’afficher autre chose que des chiffres.