L'afficheur 7 segments

De Wiki L.A.B
Révision de 15 décembre 2015 à 13:23 par Adminsys (discussion | contributions) (Page créée avec « ===== Matériel ===== * Arduino Uno * Plaque d'essai (breadboard) * 1 Afficheur 7 segments * 8 Résistances 1/4W 220Ω (270Ω ou 330Ω peuvent également convenir) * Stra... »)

(diff) ← Version précédente | Voir la version courante (diff) | Version suivante → (diff)
Aller à : navigation, rechercher
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 :

7 segment display labeled.png

Le composant que nous utiliserons met en correspondance les segments avec les broches physiques (pin) de la manière suivante :

Schema principe.gif

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

Montage Afficheur 7 Segments

Montage Afficheur 7 Segments


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 :

Programmation
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);
    }  
}
Récupérée de « http://wiki.labaixbidouille.com/index.php?title=L%27afficheur_7_segments&oldid=223 »