L'afficheur 7 segments
De Wiki L.A.B
Sommaire
Matériel
- Arduino Uno
- Plaque d'essai (breadboard)
- 1 Afficheur 7 segments
- 8 Résistances 1/4W 220Ω (270Ω ou 330Ω peuvent également convenir)
- Straps ou fils de liaison
Principe
Un afficheur 7 segments est le plus simple des afficheurs. On le retrouve très fréquemment lorsqu'il s'agit d'afficher une information numérique. Il est constitué de 7 LED (+1 pour le point) reliées ensemble par leur anode (il en existe aussi reliés par la cathode). On peut commander individuellement.
Classiquement les différentes LED (aussi appelées segments) sont nommées conformément au schéma ci-dessous :
Le composant que nous utiliserons met en correspondance les segments avec les broches physiques (pin) de la manière suivante :
| Pin du composant | Nom du segment |
|---|---|
| 1 | E |
| 2 | D |
| 3 | Anode commune |
| 4 | C |
| 5 | DP |
| 6 | B |
| 7 | A |
| 8 | Anode commune |
| 9 | F |
| 10 | G |
Montage
| Pin du composant | Nom du segment | Pin sur l'Arduino |
|---|---|---|
| 1 | E | D9 |
| 2 | D | D8 |
| 3 | Anode commune | 5V |
| 4 | C | D4 |
| 5 | DP | D5 |
| 6 | B | D3 |
| 7 | A | D2 |
| 8 | Anode commune | |
| 9 | F | D6 |
| 10 | G | D7 |
Programme
Voici le programme qu'il faut éditer dans l'IDE Arduino, puis compiler et charger dans la carte Arduino :
/*
Ce programme met en oeuvre l'utilisation d'un afficheur 7 segments allumant séquentiellement chacune des LED
*/
const int led_A = 2; // le segment A est branché sur la pin 2
const int led_B = 3;
const int led_C = 4;
const int led_D = 8;
const int led_E = 9;
const int led_F = 6;
const int led_G = 7;
const int led_DP = 5;
inline void allumer(int led){
digitalWrite(led, LOW);
}
inline void eteindre(int led){
digitalWrite(led, HIGH);
}
inline void eteindreToutesLesLED(){
eteindre(led_A); // eteint la LED
eteindre(led_B);
eteindre(led_C);
eteindre(led_D);
eteindre(led_E);
eteindre(led_F);
eteindre(led_G);
eteindre(led_DP);
}
inline void allumerEtEteindreLED(int led){
allumer(led);
delay(500); // attente de 1/2 seconde
eteindre(led);
}
void setup() // setup est exécuté une seule fois après la remise à zéro
{
pinMode(led_A, OUTPUT); // la broche led_A (2) est initialisée en sortie
pinMode(led_B, OUTPUT);
pinMode(led_C, OUTPUT);
pinMode(led_D, OUTPUT);
pinMode(led_E, OUTPUT);
pinMode(led_F, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_DP, OUTPUT);
eteindreToutesLesLED();
}
void loop() // loop est exécuté indéfiniment
{
allumerEtEteindreLED(led_A);
allumerEtEteindreLED(led_B);
allumerEtEteindreLED(led_C);
allumerEtEteindreLED(led_D);
allumerEtEteindreLED(led_E);
allumerEtEteindreLED(led_F);
//allumerEtEteindreLED(led_G);
//allumerEtEteindreLED(led_DP);
}
Pour enlever la redondance du code précédent on peut utiliser un tableau. Le tableau permet d'indexer les différentes pin pour pouvoir les utiliser séquentiellement sans dupliquer le code. Les tableaux s'utilisent généralement de pair avec les boucle for.
/*
Ce programme met en oeuvre l'utilisation d'un afficheur 7 segments allumant séquentiellement chacune des LED
*/
//Déclaration des constantes
const int led_A = 2; // le segment A est branché sur la pin 2
const int led_B = 3;
const int led_C = 4;
const int led_D = 8;
const int led_E = 9;
const int led_F = 6;
const int led_G = 7;
const int led_DP = 5;
const int tableauSegment [] = {led_A, led_B, led_C, led_D, led_E, led_F, led_G, led_DP};
const int nbSegment = 8;
// Déclaration des variables globales
int indiceSegmentCourant = 0;
inline void allumer(int led){
digitalWrite(led, LOW);
}
inline void eteindre(int led){
digitalWrite(led, HIGH);
}
inline void eteindreToutesLesLED(){
for(int i=0; i < nbSegment; i++){
int ledAEteindre = tableauSegment[i];
eteindre(ledAEteindre); // eteint la LED
}
}
inline void allumerEtEteindreLED(int led){
allumer(led);
delay(500); // attente de 1/2 seconde
eteindre(led);
}
void setup() // setup est exécuté une seule fois après la remise à zéro
{
pinMode(led_A, OUTPUT); // la broche led_A (2) est initialisée en sortie
pinMode(led_B, OUTPUT);
pinMode(led_C, OUTPUT);
pinMode(led_D, OUTPUT);
pinMode(led_E, OUTPUT);
pinMode(led_F, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_DP, OUTPUT);
eteindreToutesLesLED();
}
void loop() // loop est exécuté indéfiniment
{
int ledAFaireClignoter = tableauSegment[indiceSegmentCourant];
allumerEtEteindreLED(ledAFaireClignoter);
// Passer à la led suivante
++indiceSegmentCourant;
//Lorsque l'on dépasse le dernier indice possible, on retourne à 0
if(indiceSegmentCourant >= nbSegment){
indiceSegmentCourant = 0;
}
}
Pour afficher des chiffres, il faut connaitre (ou retrouver) la table des configurations valides pour l'afficheur :
| Chiffre | Segment DP | Segment G | Segment F | Segment E | Segment D | Segment C | Segment B | Segment A |
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 |
| 2 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | 1 |
| 3 | 0 | 1 | 0 | 0 | 1 | 1 | 1 | 1 |
| 4 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 0 |
| 5 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 1 |
| 6 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | 1 |
| 7 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 |
| 8 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| 9 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 1 |
| A | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 |
| B | 0 | 1 | 1 | 1 | 1 | 1 | 0 | 0 |
| C | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 |
| D | 0 | 1 | 0 | 1 | 1 | 1 | 1 | 0 |
| E | 0 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
| F | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 1 |
/*
Ce programme met en oeuvre l'utilisation d'un afficheur 7 segments en affichant la lettre A
*/
//Déclaration des constantes
const int led_A = 2; // le segment A est branché sur la pin 2
const int led_B = 3;
const int led_C = 4;
const int led_D = 8;
const int led_E = 9;
const int led_F = 6;
const int led_G = 7;
const int led_DP = 5;
const int tableauSegment [] = {led_A, led_B, led_C, led_D, led_E, led_F, led_G, led_DP};
const int nbSegment = 8;
// Déclaration des variables globales
int indiceSegmentCourant = 0;
inline void allumer(int led){
digitalWrite(led, LOW);
}
inline void eteindre(int led){
digitalWrite(led, HIGH);
}
inline void eteindreToutesLesLED(){
for(int i=0; i < nbSegment; i++){
int ledAEteindre = tableauSegment[i];
eteindre(ledAEteindre); // eteint la LED
}
}
inline void allumerEtEteindreLED(int led){
allumer(led);
delay(500); // attente de 1/2 seconde
eteindre(led);
}
void setup() // setup est exécuté une seule fois après la remise à zéro
{
pinMode(led_A, OUTPUT); // la broche led_A (2) est initialisée en sortie
pinMode(led_B, OUTPUT);
pinMode(led_C, OUTPUT);
pinMode(led_D, OUTPUT);
pinMode(led_E, OUTPUT);
pinMode(led_F, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_DP, OUTPUT);
eteindreToutesLesLED();
}
void loop() // loop est exécuté indéfiniment
{
//D'après le tableau, la lettre A correspond à : 0 1 1 1 0 1 1 1
allumer(led_A);
allumer(led_B);
allumer(led_C);
eteindre(led_D);
allumer(led_E);
allumer(led_F);
allumer(led_G);
eteindre(led_DP);
}
Le programme suivant affiche tous les chiffres de 0 à 9 :
/*
Ce programme met en oeuvre l'utilisation d'un afficheur 7 segments en affichant les chiffres les uns après les autres
*/
//Déclaration des constantes
const int led_A = 2; // le segment A est branché sur la pin 2
const int led_B = 3;
const int led_C = 4;
const int led_D = 8;
const int led_E = 9;
const int led_F = 6;
const int led_G = 7;
const int led_DP = 5;
const int tableauSegment [] = {led_A, led_B, led_C, led_D, led_E, led_F, led_G, led_DP};
const int nbSegment = 8;
inline void allumer(int led){
digitalWrite(led, LOW);
}
inline void eteindre(int led){
digitalWrite(led, HIGH);
}
inline void eteindreToutesLesLED(){
for(int i=0; i < nbSegment; i++){
int ledAEteindre = tableauSegment[i];
eteindre(ledAEteindre); // eteint la LED
}
}
inline void allumerEtEteindreLED(int led){
allumer(led);
delay(500); // attente de 1/2 seconde
eteindre(led);
}
void afficher(char chiffre){
eteindreToutesLesLED();
switch(chiffre)
{
case 0 :
allumer(led_A);
allumer(led_B);
allumer(led_C);
allumer(led_D);
allumer(led_E);
allumer(led_F);
break;
case 1 :
allumer(led_B);
allumer(led_C);
break;
case 2 :
allumer(led_A);
allumer(led_B);
allumer(led_D);
allumer(led_E);
allumer(led_G);
break;
case 3 :
allumer(led_A);
allumer(led_B);
allumer(led_C);
allumer(led_D);
allumer(led_G);
break;
case 4 :
allumer(led_B);
allumer(led_C);
allumer(led_F);
allumer(led_G);
break;
case 5 :
allumer(led_A);
allumer(led_C);
allumer(led_D);
allumer(led_F);
allumer(led_G);
break;
case 6 :
allumer(led_A);
allumer(led_C);
allumer(led_D);
allumer(led_E);
allumer(led_F);
allumer(led_G);
break;
case 7 :
allumer(led_A);
allumer(led_B);
allumer(led_C);
break;
case 8 :
allumer(led_A);
allumer(led_B);
allumer(led_C);
allumer(led_D);
allumer(led_E);
allumer(led_F);
allumer(led_G);
break;
case 9 :
allumer(led_A);
allumer(led_B);
allumer(led_C);
allumer(led_D);
allumer(led_F);
allumer(led_G);
break;
}
}
void setup() // setup est exécuté une seule fois après la remise à zéro
{
pinMode(led_A, OUTPUT); // la broche led_A (2) est initialisée en sortie
pinMode(led_B, OUTPUT);
pinMode(led_C, OUTPUT);
pinMode(led_D, OUTPUT);
pinMode(led_E, OUTPUT);
pinMode(led_F, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_DP, OUTPUT);
eteindreToutesLesLED();
}
void loop() // loop est exécuté indéfiniment
{
for(char i=0; i <=9; ++i){
afficher(i);
delay(500);
}
}
Ce programme peut être simplifié en stockant la matrice des configurations directement dans la mémoire flash de l'arduino :
/*
Ce programme met en oeuvre l'utilisation d'un afficheur 7 segments en affichant les chiffres les uns après les autres
*/
//Déclaration des constantes
const int led_A = 2; // le segment A est branché sur la pin 2
const int led_B = 3;
const int led_C = 4;
const int led_D = 8;
const int led_E = 9;
const int led_F = 6;
const int led_G = 7;
const int led_DP = 5;
const int tableauSegment [] = {led_A, led_B, led_C, led_D, led_E, led_F, led_G, led_DP};
const int nbSegment = 8;
const int tableauChiffre[][nbSegment] = {
{1, 1, 1, 1, 1, 1, 0, 0},
{0, 1, 1, 0, 0, 0, 0, 0},
{1, 1, 0, 1, 1, 0, 1, 0},
{1, 1, 1, 1, 0, 0, 1, 0},
{0, 1, 1, 0, 0, 1, 1, 0},
{1, 0, 1, 1, 0, 1, 1, 0},
{1, 0, 1, 1, 1, 1, 1, 0},
{1, 1, 1, 0, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 1, 1, 0},
{1, 1, 1, 1, 0, 1, 1, 0},
{1, 1, 1, 0, 1, 1, 1, 0},
{0, 0, 1, 1, 1, 1, 1, 0},
{1, 0, 0, 1, 1, 1, 0, 0},
{0, 1, 1, 1, 1, 0, 1, 0},
{1, 0, 0, 1, 1, 1, 1, 0},
{1, 0, 0, 0, 1, 1, 1, 0},
};
// Déclaration des variables globales
int indiceSegmentCourant = 0;
inline void allumer(int led){
digitalWrite(led, LOW);
}
inline void eteindre(int led){
digitalWrite(led, HIGH);
}
inline void eteindreToutesLesLED(){
for(int i=0; i < nbSegment; i++){
int ledAEteindre = tableauSegment[i];
eteindre(ledAEteindre); // eteint la LED
}
}
inline void allumerEtEteindreLED(int led){
allumer(led);
delay(500); // attente de 1/2 seconde
eteindre(led);
}
void afficher(char chiffre){
eteindreToutesLesLED();
for(int i = 0; i < nbSegment; ++i){
if(tableauChiffre[chiffre][i] == 1)
{
allumer(tableauSegment[i]);
}
}
}
void setup() // setup est exécuté une seule fois après la remise à zéro
{
pinMode(led_A, OUTPUT); // la broche led_A (2) est initialisée en sortie
pinMode(led_B, OUTPUT);
pinMode(led_C, OUTPUT);
pinMode(led_D, OUTPUT);
pinMode(led_E, OUTPUT);
pinMode(led_F, OUTPUT);
pinMode(led_G, OUTPUT);
pinMode(led_DP, OUTPUT);
eteindreToutesLesLED();
}
void loop() // loop est exécuté indéfiniment
{
for(char i=0; i <=9; ++i){
afficher(i);
delay(500);
}
}
