Afficheur sept segments

2014-09-27

Introduction

Cette page vous expliquera comment afficher un chiffre en utilisant un afficheur sept segments. J'utilise personnellement le SC39-11SRWA. Vous aurez également besoin d'une breadboard pour effectuer les connexions confortablement, d'une résistance (quelques centaines de Ω feront l'affaire) et de quelques fils (jumpers).

Le composant

Un afficheur 7 segments (source)
Un afficheur 7 segments (source)

Un afficheur 7 segments est le composant électronique le plus simple qui soit pour représenter un chiffre. Il s'agit simplement de sept DEL dans un boitier en plastique. En choisissant quelles DEL allumer, il est possible de représenter les chiffres décimaux.

La représentation des différents chiffres (source)
La représentation des différents chiffres (source)

Pour utiliser un afficheur sept segments, le rôle de ses connexions doit être connu. Chaque DEL est associée à une pin. Pour fonctionner, l'afficheur doit être relié à la masse (GND) ; pour allumer une DEL, il suffit de la relier à une source de courant.

Il y a une pin pour la masse et une par DEL (source)
Il y a une pin pour la masse et une par DEL (source)

Breadboard

Une breadboard est une structure très pratique pour construire des circuits temporaires. Nous allons nous en servir pour relier facilement l'Arduino à l'afficheur sept segments.

Sur une breadboard, les emplacements sont reliés par groupes, la double ligne centrale est rarement présente (source)
Sur une breadboard, les emplacements sont reliés par groupes, la double ligne centrale est rarement présente (source)

L'important est de savoir comment les différents emplacements sont reliés. Le motif le plus courant est représenté dans l'illustration précédente.

Montage

Pour contrôler complétement l'afficheur, nous allons simplement relier chacune de ses pin à la carte. Il nous faut relier la masse à GND, et les autres à des connexions « Digital » de la carte (1 à 13). Pour utiliser les mêmes connexions que moi, se référer au schéma ci-dessous.

GND est relié à la résistance elle-même relié à la pin centrale de l'afficheur sept segments ; les DEL g, f, e et d sont reliées aux pin 13, 12, 11 et 10 de la carte ; les DEL a, b, c et DP sont reliées aux pin 10, 9, 8, 7 et 6 (source)
GND est relié à la résistance elle-même relié à la pin centrale de l'afficheur sept segments ; les DEL g, f, e et d sont reliées aux pin 13, 12, 11 et 10 de la carte ; les DEL a, b, c et DP sont reliées aux pin 10, 9, 8, 7 et 6 (source)

Une fois ces connexions effectuées, on peut passer à la partie programmation. Pour tester, on peut commencer par simplement faire clignoter la DEL du milieu (G), reliée à la pin 13 de la carte. Pour cela, il suffit d'utiliser le même programme que dans la section d'introduction :

void setup()
{
    pinMode(13, OUTPUT);     
}
void loop()
{
    digitalWrite(13, HIGH);
    delay(1000);
    digitalWrite(13, LOW);
    delay(1000);
}

Note : les spécifications conseillent d'utiliser une résistance pour chaque DEL, mais en utilisant une seule fonctionne.

Programme

Passons à la dernière étape. Plutot que de devoir spécifier à la main quelle DEL allumer sur l'afficheur sept segment, il faudrait faire en sorte de n'avoir qu'à spécifier le chiffre voulu.

Pour un chiffre donné, il faut savoir l'état de chacune des 8 DEL : allumée ou éteinte. Un bit représentant l'état d'une DEL, un octet conviendra parfaitement ! Prennons le chiffre 4 ; en se reportant aux informations sur l'afficheur sept segments, on voit que les DEL B, C, F et G doivent être allumées. Autrement dit :

A B C D E F G DP
0 1 1 0 0 1 1 0

Le nombre binaire 01100110b s'écrit aussi 0x66 en hexadécimal. En répétant cette opération pour chaque chiffre, nous obtenons la représentation de chaque chiffre dans un tableau :

//                 0    1    2    3    4    5    6    7    8    9
byte digits []={0xFC,0x60,0xDA,0xF2,0x66,0xB6,0xBE,0xE0,0xFE,0xF6};

Nous allons également indiquer à quelle pin est reliée chaque DEL :

//              A  B  C  D  E  F  G DP
int  led2pin[]={9, 8, 7,10,11,12,13, 6};

Il ne reste plus qu'à écrire une fonction qui prent comme argument un chiffre et s'occupe d'activer les pin adéquates.

void displayDigit(int d)
{
    byte code = digits[d%10];
    for (int c = 7; c >= 0; c--)
    {   
        digitalWrite(led2pin[c], code%2 ? HIGH : LOW);
        code >>= 1;
    }   
}

Petites explications. On récupère d'abord notre représentation du chiffre sur un octet (le %10 sert simplement à s'assurer qu'on reste dans les limites du tableau). La boucle for va ensuite s'occuper de chaque DEL (c=0 ↔ A, c=1 ↔ B, … c=7 ↔ DP).

code%2 récupère un bit de la représentation et code >>= 1 permet de passer au bit suivant. Ainsi, si le bit est 1, on active la DEL (HIGH), autremenet on la désactive (LOW). led2pin[c] permet de manipuler la pin qu'il faut.

De cette manière on peut écrire un programme comme le suivant, qui affiche les chiffres 4 et 2 en alternance :

byte digits []={0xFC,0x60,0xDA,0xF2,0x66,0xB6,0xBE,0xE0,0xFE,0xF6};
int  led2pin[]={9, 8, 7,10,11,12,13, 6};
void displayDigit(int d)
{
    byte code = digits[d%10];
    for (int c = 7; c >= 0; c--)
    {   
        digitalWrite(led2pin[c], code%2 ? HIGH : LOW);
        code >>= 1;
    }   
}
void setup()
{
    for (int i = 6; i <= 13; i++)
        pinMode(i, OUTPUT);
}
void loop()
{
    displayDigit(4);
    delay(1000);
    displayDigit(2);
    delay(1000);
}