Qu'est ce qu'un afficheur 7 Segments ? Comment le programmer ? Comment l'intégrer à votre projet ?

Introduction

Un afficheur à 7 segments est un technique d’affichage basé sur des segments. Elle permet surtout d’afficher des chiffres. Pour pouvoir afficher des lettres, il vaut mieux utiliser un écran LCD. L’afficheur 7 segments est très utilisé dans les calculatrices ou les radio réveil.

L’afficheur 7 segments, possède comme son nom l’indique 7 segments. Un segment est une portion de l’afficheur qui va permettre d’afficher le chiffre.  En fonction des segments allumés, les chiffres s’afficher. Avec cet afficheur, vous pourrez afficher les nombres de 1 à 9. L’afficheur 7 segments est codé sur 8 bits.

Sommaire masquer
1 Qu'est ce qu'un afficheur 7 Segments ? Comment le programmer ? Comment l'intégrer à votre projet ?
1.1 Introduction
1.1.1 Comment sont représenté les chiffres ?
1.1.2 Cathode ou Anode Commune ?
1.2 Afficher des chiffres sur un 7 segments
1.3 4 afficheurs 7 segments

Comment sont représenté les chiffres ?

  • L’afficheur

L’afficheur est composée de 4 segments verticaux et de 3 segments horizontaux. Les segments sont souvent dispositionné sous forme d’hexagone comme ceci mais les trapèzes et rectangles sont aussi possible. Il existe aussi un point qui permet d’affcicher des nombres décimaux.

Voici la liste des chiffres codable sur un afficheur 7 segments : 

Nombre/Segment A B C D E F G Affichage
0 0 0 0 0 0 0 1
1 1 0 0 1 1 1 1
2 0 0 1 0 0 1 0
3 0 0 0 0 1 1 0
4 1 0 0 1 1 0 0
5 0 1 0 0 1 0 0
6 0 1 0 0 0 0 0
7 0 0 0 1 1 1 1
8 0 0 0 0 0 0 0
9 0 0 0 0 1 0 0
  • Les broches de l’afficheur

Les lettres liées aux broches doivent connectées à la puce 74HC595. Le – doit connecté au ground de la carte Arduino.

Ici on a un exemple de connexion d’un afficheur 7 segments avec 6 broches de chaque côtés. Il y a des lettres qui se connecte à la puce 74HC595 et une brohce décimal si on a un nombre à virgule. Enfin, les broches D1 à D3 se branche sur la carte Arduino.

  • La puce CD4511

Le décodeur CD4511 permet de faire le lien entre la carte Arduino et l’afficheur 7 segements. Il n’est pas obligatoire dans vos circuits, néanmoins il permet de simplifier celui-ci, c’est pourquoi vous le verrez dans les schéma de ce cours.

Il permet d’afficher des chiffres sur des afficheurs 7 segments sans avoir à déterminer soit même l’état de chaque segment. On lui donne la valeur du chiffre en binaire (sur 4 bits) et il fait l’affichage.

Comme on peut voir, il y a des lettres qui correspondent aux branchement à faire avec l’afficheur.

Cathode ou Anode Commune ?

Il existe deux types d’afficheurs, ceux Anode Commune et ceux à Cathode Commune. Il faut comprendre que pour que le courant passe, il faut une différence de potentièle entre les deux points. Par exemple, pour qu’une led s’allume, il faut que l’anode soit branche sur du 5V et la cathode sur le GND. Cette différence de tension entre les deux broches créer le courant.

C’est exactement la même chose ici.

a) Anode Commune

Pour ce type d’afficheur, c’est l’Anode qui est relié au 5V. Ceci veut dire que si on veut que du courant passe il faut que les autres broches soient à l’état bas.

b) Cathode Commune

En ce qui concerne les afficheurs à cathode commune, c’est la cathode qui est relié à la masse. Cela veut dire que si on veut que le courant passe il faut que les broches contrôlable par l’arduino soit à l’état haut.

En ce qui concerne nos circuits nous avons choisit des afficheurs 7 segments à cathode commune.

Afficher des chiffres sur un 7 segments

a) Afficheur 7 Segments simple

On va maintenant voir comment afficher un chiffre sur afficheur 7 segment à cathode commune.

/* On assigne chaque LED à une broche de l'arduino */
unsigned const int A = 13;
unsigned const int B = 12;
unsigned const int C = 11;
unsigned const int D = 10;
unsigned const int E = 9;
unsigned const int F = 8;
unsigned const int G = 7;
unsigned const int H = 6;


void setup(void){
   // définition des broches en sortie
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(H, OUTPUT);
}

//On a ensuite fait différente fonction pour chaque chiffre

void zero() {
  digitalWrite(A, LOW);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void un() {
  digitalWrite(A, LOW);
  digitalWrite(B, LOW);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void deux() {
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, LOW);
  digitalWrite(H, LOW);
}

void trois() {
  digitalWrite(A, HIGH);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void quatre() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, LOW);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void cinq() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void six() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, LOW);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void sept() {
  digitalWrite(A, LOW);
  digitalWrite(B, LOW);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, LOW);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void huit() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, HIGH);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

void neuf() {
  digitalWrite(A, HIGH);
  digitalWrite(B, HIGH);
  digitalWrite(C, HIGH);
  digitalWrite(D, HIGH);
  digitalWrite(E, LOW);
  digitalWrite(F, HIGH);
  digitalWrite(G, HIGH);
  digitalWrite(H, LOW);
}

// On appelle maintenant les fonctions une à une
void loop(void)
{
  zero();
  delay(1000);// pause pour voir le nombre affiché avant de passer au suivant
  
  un();
  delay(1000);
  
  deux();
  delay(1000);
  
  trois();
  delay(1000);
  
  quatre();
  delay(1000);
  
  cinq();
  delay(1000);
  
  six();
  delay(1000);
  
  sept();
  delay(1000);
  
  huit();
  delay(1000);
  
  neuf();
  delay(1000);
}

b) Avec la puce CD4511

On va maintenant voir le même circuit avec la puce CD4511.

const int bit_A = 2;
const int bit_B = 3;
const int bit_C = 4;
const int bit_D = 5;

void setup() {
    // on met les broches en sorties
    pinMode(bit_A, OUTPUT);
    pinMode(bit_B, OUTPUT);
    pinMode(bit_C, OUTPUT);
    pinMode(bit_D, OUTPUT);

    // on commence par écrire le chiffre 0, donc toutes les sorties à l'état bas
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);
}

void loop() {
    char i=0; // variable "compteur"
    for(i=0; i<10; i++) {
        afficher(i); // on appel la fonction d'affichage
        delay(500); // on attend une demi seconde
    }
}

// fonction pour afficher les chiffres
void afficher(char chiffre) {
    // on met à zéro tout les bits du décodeur
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);

    // On allume les bits nécessaires
    if(chiffre >= 8){
        digitalWrite(bit_D, HIGH);
        chiffre = chiffre - 8;
    }
    if(chiffre >= 4){
        digitalWrite(bit_C, HIGH);
        chiffre = chiffre - 4;
    }
    if(chiffre >= 2){
        digitalWrite(bit_B, HIGH);
        chiffre = chiffre - 2;
    }
    if(chiffre >= 1){
        digitalWrite(bit_A, HIGH);
        chiffre = chiffre - 1;
    }
}

4 afficheurs 7 segments

On va maintenant voir l’afficheur 7 segments 4 digits simple :

Pour faire fonctionner le code suivant, vous aurez besoin d’une librairie pour l’afficheur 7 segment : site.

Pour pouvoir l’installer, on vous conseille notre cours sur les librairies.

#include "SevSeg.h" // La librairie 7 segments
SevSeg sept_segments; // On appel la librairie

void setup(){
  byte nombre_chiffre_7_segments = 4; // Nombre de digit de votre 7 segments
  // Les broches de votre 7 segments
  byte Broche_pins[] = {10, 11, 12, 13};
  byte segmentPins[] = {9, 2, 3, 5, 6, 8, 7, 4};

  bool resistance_sur_Segments = true; // On applique une résistance sur chaque segment 
  bool pause_entre_mise_a_jour = true; // On fait une mini pause entre chaque segment
  byte configuration_materiel = COMMON_CATHODE; // On fait un 7 segments a cathode commune
  sept_segments.begin(configuration_materiel, nombre_chiffre_7_segments, Broche_pins, segmentPins, resistance_sur_Segments); // On initialize l'afficheur 7 segments
  sept_segments.setBrightness(90); // On initialize la luminosité de l'afficheur
}

void loop(){
    sept_segments.setNumber(16); // On assigne le nombre 16 à l'afficheur 7 segments
    sept_segments.refreshDisplay(); // On rafraichit l'affichage pour que le nouveau nombre soit pris en compte
}

Avec ce programme vous allez afficher le nombre 16. Néanmois vous pouvez le changer de nombre en modifiant la ligne 18 du code.