Les programmes de cette page utilisent des afficheurs à cathode commune. Si les vôtres sont à anode commune, reportez vous à l'ancienne version de cette page.

8 Avril 2016

Arduino leçon 14 : les afficheurs 7 segments

Ces afficheurs contiennent 7 leds qui forment un chiffre. Sur la plupart, il existe une 8ème led pour le point décimal.

Les deux types d'afficheurs

Ces 7 led sont toutes reliées soit par leur anode, soit par leur cathode.
Voici les 2 schémas de principe

L'électrode libre peut être reliée à des broches d'Arduino par une résistance mais généralement on utilise un circuit spécialisé (décodeur) qui sélectionne les led en fonction du chiffre souhaité.
Les 4 entrées ont un poids 1,2,4,8. (e indice x vaut 2 puissance x). Les 8 sorties sont reliées aux entrées de l'afficheur.

On voit à droite les 16 chifres hexadécimaux qu'on peut obtenir à partir de 4 entrées.>

ci-dessous le brochage réel.

Programme

taper un chiffre dans le moniteur série et le faire apparaître sur l'afficheur à cathode commune.
On va se passer de décodeur en reliant les pins 5 à 11 d'Arduino aux entrées de l'afficheur par autant de résistances.

Arduino		Afficheur
5	résistance	segment a (pin 7)
6	résistance	segment b (pin 6)
7	résistance	segment c (pin 4)
8	résistance	segment d (pin 2)
9	résistance	segment e (pin 1)
10	résistance	segment f (pin 9)
11	résistance	segment g (pin 10)
GND	direct	cathode (pin 3 ou 8)

/* aff_7_seg.ino
essai d'afficheur 7 segments */

char chiffre;
void afficher (void) ; // nécessaire ou non selon les versions

void setup(){
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
Serial.begin(9600);
eteindre();
}

void loop() {
if (Serial.available()){
chiffre=Serial.read();
if (chiffre>='0' && chiffre<='9'){
Serial.println(chiffre);
afficher();
}
else {
eteindre();
Serial.print(chiffre);
Serial.println(" est refuse.");
}
}
}

void afficher() {
switch (chiffre){
case '0' :
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
break;
case '1' :
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
break;
case '2' :
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(11, HIGH);
break;
case '3' :
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(11, HIGH);
break ;
case '4' :
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
break ;
case '5' :
digitalWrite(5, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
break ;
case '6' :
digitalWrite(5, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
break ;
case '7' :
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(5, HIGH);
break ;
case '8' :
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
break ;
case '9' :
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
break ;
}
}

void eteindre() {
digitalWrite(5, LOW);
digitalWrite(6, LOW);
digitalWrite(7, LOW);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
}

le décodeur BCD/7 segments

Dans le premier montage, on utilisait 8 sorties d'Arduino pour un afficheur 7 segments. Ici, on en utilisera 4 pour un afficheur.
Lors d'une autre séance, on n'en utilisera pas davantage pour piloter plusieurs afficheurs.

Principe du décodeur 4511

On utilise un décodeur 4511 qui permet d'afficher les chiffres de 0 à 9 sur des afficheurs à cathode commune.
On relie les sorties 2 à 5 d'Arduino aux 4 entrées du décodeur. Selon les fabricants, ces entrées s'appellent ABCD ou D0 D1 D2 D3 ou encore autrement. Quelle que soit leur dénomination, leur ordre est toujours le même.
Les pattes 7, 1, 2, 6 du 4511 correspondent aux valeurs d'entrée 1, 2, 4, 8.
Les entrées /LT, /BK, /LE sont des fonctions actives au niveau bas. C'est pourquoi leur nom est précédé de '/' dans les textes ou surmonté d'une barre dans les schémas. On relie /LT et /Blank à Vcc (+5) et /LE à la masse pour qu'elles ne perturbent pas notre programme.
Les sorties a à g du décodeur sont reliées aux segments de même nom de l'afficheur par 7 résistances.

Le décodeur 7447

Il a le même rôle, mais pour les afficheurs à anode commune.

Remarquez que les sorties a à f sont actives au niveau bas. On voit la barre sur leur nom. Pour un afficheur à anode commune, on applique un niveau bas sur la cathode de chaque diode qu'on veut allumer.

Le programme

On écrit un programme qui compte continuellement de 0 à 9 avec 2 secondes d'arrêt sur chaque chiffre.

/* Aff_7_seg_4511.ino
fait défiler les chiffres de 0 à 9 pendant 2 secondes chacun.
en utilisant le décodeur 4511
*/
#define poids1 2
#define poids2 3
#define poids4 4
#define poids8 5
byte chiffre=0;
long heure;

void setup() {
pinMode (poids1, OUTPUT);
pinMode (poids2, OUTPUT);
pinMode (poids4, OUTPUT);
pinMode (poids8, OUTPUT);
heure = millis();
}

void loop(){
if ( millis() > heure) {
affiche();
heure += 2000;

chiffre = (chiffre + 1) %10;
Serial.println(chiffre);
}
}

void afficher ( ) {

// on éteint les segments
digitalWrite(poids1, HIGH);
digitalWrite(poids2, HIGH);
digitalWrite(poids4, HIGH);
digitalWrite(poids8, HIGH);

digitalWrite(pin, LOW);

switch (chiffre) {
case 0 :
break;
case 1 :
digitalWrite(poids1, LOW);
break;
case 2 :
digitalWrite(poids2, LOW);
break;
case 3 :
digitalWrite(poids1, LOW);
digitalWrite(poids2, LOW);
break;
case 4 :
digitalWrite(poids4, LOW);
break;
case 5 :
digitalWrite(poids1, LOW);
digitalWrite(poids4, LOW);
break;
case 6 :
digitalWrite(poids2, LOW);
digitalWrite(poids4, LOW);
break;
case 7 :
digitalWrite(poids1, LOW);
digitalWrite(poids2, LOW);
digitalWrite(poids4, LOW);
break;
case 8 :
digitalWrite(poids8, LOW);
break;
case 9 :
digitalWrite(poids1, LOW);
digitalWrite(poids8, LOW);
break;
}
digitalWrite(pin, HIGH);
} // fin du switch
}

Décodeur décimal vers 7 segments

Le 7447 comme le 4511 additionne ses entrées de valeurs 1-2-4-8 et commande les sorties correspondant aux segments utiles.
Si on lui envoie une valeur supérieure à 9 (par exemple 8 + 4), il affiche n'importe quoi.

Il existe d'autres décodeurs qui savent compter en hexadécimal (de 0 à 15).
Pour une valeur d'entrée de 10 à 15, ils affichent les lettres A à F.
Ils s'appellent décodeurs hexadécimal vers 7 segments

Le compteur pour afficheur 7 segments

Il existe de nombreux circuits pour piloter des afficheurs 7 segments.
Voici par exemple le CD4033 qui est un compteur dont les sorties sont adaptées aux segments des afficheurs.

Ce circuit compte les impulsions reçues sur son entrée et les décode pour les afficheurs 7 segments.
pin 1 : signal d'entrée du comptage
pin 2 : blocage de l'entrée (la sortie ne change plus)
pins 3 et 4 : servent à ne pas afficher les zéros non significatifs d'un nombre de plusieurs chiffres
pin 5 : retenue . Devient haut quand on arrive à 10. A connecter à l'entrée de l'afficheur de gauche s'il existe.
pin 6, 7, 9, 10, 11 ,12, 13 : les segments a à f
pin 8 : GND (appelée VSS en CMOS)
pin 14 : allume tous les segments
pin 15 : remise à zéro du comptage.
pin 16 : VCC (appelé VDD en CMOS)

Les sorties ne sont pas inversées : ce compteur est prévu pour des afficheurs à cathode commune.
Exemple de montage

Il suffit d'appuyer sur le bouton de gauche pour voir augmenter le chiffre affiché.
Ici, on n'a pas utilisé Arduino mais on peut remplacer le bouton par une sortie d'Arduino. Imaginez un programme qui envoie une impulsion chaque seconde. On peut aussi penser à un montage qui envoit une impulsion chaque fois qu'un rayon lumineux est coupé (comptage d'objets).
Le bouton de droite remet le comptage à zéro.

Une page intéressante (en anglais) sur le CD4033.

haut de la page

Page Précédente : transceivers Page Suivante : le multiplexage