L'afficheur 7 segments

L'afficheur 7 segments est un composant optoélectronique permettant d'afficher tous les chiffres décimaux. Il est appelé 7 segments car il est constitué de 7 segments comportant chacun une ou plusieurs led formant le chiffre 8. Une huitième led peut représenter le point décimal.

Dans l'univers Arduino, l'afficheur 7 segments est principalement utilisé pour afficher un nombre comme dans un chronomètre.

Par convention, les segments formant le chiffre 8 sont les 7 premières lettres de l’alphabet (a à g).

Afin de minimiser le nombre de broches de l'afficheur, deux types d'afficheur ont été créés.

Lorsque les cathodes sont reliées entre elles, l’afficheur est dit à cathodes communes. Pour allumer un segment, il faut mettre les cathodes à la masse et appliquer un niveau haut sur le segment à allumer.
Lorsque les anodes sont reliées entre elles, l’afficheur est dit à anodes communes. Pour allumer un segment, il faut mettre les anodes au plus de l’alimentation et appliquer un niveau bas sur le segment à allumer.

Une résistance de protection doit être placée en série avec chaque segment pour limiter le courant dans la led correspondante. Pour afficher un chiffre avec un afficheur 7 segments, il faut au minimum 7 sorties numériques de l'Arduino soit plus d'un tiers des broches de l'Arduino. Pour réduire le nombre de broches utilisées, nous pouvons utiliser un décodeur BCD/7 segments. Avec ce composant, le nombre de broches utilisées passe de 7 à 4. Ci-dessous, nous trouvons la table de vérité d'un décodeur BCD/7 segments pour un afficheur à cathodes communes.

Exemple :

Nous souhaitons afficher sur un afficheur 7 segments à cathodes communes, tous les chiffres de 0 à 9 avec une pause d'une seconde entre chaque chiffre. Nous piloterons directement l'afficheur par 7 sorties de l'Arduino.

Liste du matériel :

1 Arduino Uno
1 plaquette d'essai
1 afficheur 7 segments à cathodes communes
7 résistances de 330 Ω

Câblage :

Programme :

/* Affichage est un programme qui affiche tous les chiffres sur un afficheur 7 segments à cathodes communes */

byte ledPin[7]={2, 3, 4, 5, 6, 7, 8}; // tableau des numéros de broches
byte code[10]={63,6,91,79,102,109,124,7,127,103}; // tableau des codes de chaque chiffre

void setup()
{
for (int x=0; x<7; x++) // initialisation des broches en sortie
{
pinMode(ledPin[x], OUTPUT);
}
}

void loop()
{
for (int y=0; y<10; y++)
{
afficher(code[y]);
delay(1000);
}

}

void afficher(byte x)                                   // fonction qui allume les 7 segments en fonction du chiffre
{
byte chiffre=x;
byte segment=0;
for (int i=2; i<9; i++)
{
segment=chiffre&00000001;                                     // masque pour récupérer le bit de poids faible (segment a)
digitalWrite(i,segment);                                    // allumage du segment correspondant
chiffre=chiffre>>1;                                    // décalage à droite pour récupérer les bit suivants (segment b à g)
}
}

Commentaires :

Les valeurs du tableau code[10] sont issus du tableau de conversion suivant :

Dans l'exemple précédent, nous avons affiché un chiffre sur un afficheur. Cela nécessite au minimum :

4 broches de l’Arduino si nous interfaçons l’information avec un décodeur BCD/7segments.
7 broches de l’Arduino si nous envoyons le code directement sur l’afficheur.

Lorsque nous souhaitons afficher un nombre à deux chiffres, nous allons multiplier le nombre de broches utilisées de l’Arduino par deux (soit 8 ou 14 !!!). Afin de limiter le nombre de broches de l’Arduino, nous réalisons un affichage multiplexé : Le code est envoyé sur les deux afficheurs en même temps mais seul un afficheur est allumé. Nous réalisons un balayage en allumant puis éteignant chaque afficheur à tour de rôle à très grande vitesse ce qui évite de percevoir un clignotement.

La persistance rétinienne est la capacité de l’œil et du cerveau à superposer une ou plusieurs images déjà vue à l’image que l’on est en train de voir. La durée de la persistance rétinienne est plus longue si l’image observée est lumineuse. On estime la durée de la persistance rétinienne à 20 ms environ.

On peut réaliser un afficheur multiplexé avec un grand nombre d’afficheurs à condition de réaliser le balayage en moins de 20 ms.

Au niveau du schéma, les segments 'a' de tous les afficheurs sont reliés. Il en est de même pour tous les autres segments. Les cathodes de chaque afficheur sont commandées par un transistor.

Schéma structurel :

Programme :

/* Affichage multiplexé est un programme qui affiche un nombre sur 2 afficheurs 7 segments à cathodes communes */

byte ledPin[9]={2, 3, 4, 5, 6, 7, 8, 9, 10};
byte code[10]={63,6,91,79,102,109,124,7,127,103};

void setup()
{
for (int x=0; x<9; x++)
{
pinMode(ledPin[x], OUTPUT);
}
}

void loop()
{
digitalWrite(10,HIGH); // on affiche les dizaines pendant 10 ms
digitalWrite(9,LOW);
afficher(code[1]);
delay(10);
digitalWrite(10,LOW); // on affiche les unités pendant 10 ms
digitalWrite(9,HIGH);
afficher(code[0]);
delay(10);
}

void afficher(byte x)
{
byte chiffre=x;
byte segment=0;
for (int i=2; i<9; i++)
{
segment=chiffre&00000001;
digitalWrite(i,segment);
chiffre=chiffre>>1;
}
}

Il existe une bibliothèque qui gère un affichage multiplexé jusqu'à 8 afficheurs à anodes ou à cathodes communes. La bibliothèque et sa documentation peuvent être téléchargée ici.