Aller au contenu


Information tutoriel

  • Ajouté le: juil. 01 2009 05:27
  • Date Updated: sept. 26 2016 12:32
  • Lectures: 23575
 


* * * * *
0 Notes

[Composant] Les afficheurs 7 segments

Posté par Mike118 on juil. 01 2009 05:27
Dans ce tutoriel, vous allez voir ce qu'est un afficheur 7 segments, son principe de fonctionnement, ses différents types et surtout comment l'utiliser...



1 – Présentation

[image d'un afficheur 7 segments]

Les afficheurs 7 segments sont des afficheurs numériques composés de segments généralement appélé A B C D E F et G que l'on va pouvoir allumer ou non afin d'afficher différentes choses. 
 
On associe chaque segment à une lettre de la manière suivante :
Image IPB

Ainsi pour faire un ''1'', on allumera les segments B et C :
Image IPB

Et pour faire un ''A'' on allumera les segments A, B, C, E, F et G :
Image IPB

 
 
Grâce à un 7 segments on va donc pouvoir 

Afficher un nombre décimal : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

mais aussi les lettres pour compter en hexadécimal :A, b, C, d, E, F.
 
Ou encore les lettres, I J L o P S t U et ° 

[Image d'affichage + tableau ]

Image IPBPour information, sachez qu'il peut y avoir un ou deux point en plus des segments A, B, C, D, E, F, G... Souvent, la led qui allume le point se note dp. ( dp1 et dp2 quand il y a deux points en plus  ) 
 
Voici une photo d'un afficheur 7 segments avec deux points :
Image IPB
 
 
 

2 – Fonctionnement et type
 
Rentrons maintenant un peu plus dans le détail: 

Les afficheurs 7 segment sont en fait un assemblage de  LEDs, ainsi ils sont très simple d'utilisation à partir du moment où on sait utiliser des leds et qu'on sait comment elles sont connectée dans l'afficheur ! 

Pour ceux qui ont besoin de se rafraîchir la mémoire sur comment utiliser des led rendez vous ici ! 
 
Pour les autres : Continuons ! 
Il existe deux types d'afficheurs 7 segments :

Afficheurs à anode commune.
Afficheurs à cathode commune.
 
Il faut comprendre par là que c'est la façon dont sont relié les leds à l'intérieur qui diffère. Afin de pouvoir bien utiliser votre afficheur il vous faudra donc nécessairement connaitre cette caractéristique de votre afficheur 7 segment.


2 – a : Les afficheurs à anode commune :


Voici le principe des afficheurs à anode commune : (Schéma de l'intérieur du boitier)
Image IPB

Comme vous l'avez remarqué, toutes les anodes des leds qui composent l'afficheur 7 segments sont reliées ensemble.

Pour utiliser ses afficheurs, il faudra TOUJOURS respecter les consignes d'alimentation des LEDs. C'est à dire le + de l'alimentation sur l'anode et le - sur la cathode.
Tout comme les LEDs, il faudra TOUJOURS ajouter une résistance pour réduire le courant sur chaque segments de l'afficheur.
Sinon vous risquez tout simplement de griller le segment en questions.
Voici comment câbler l'afficheur 7 segment à anode commune pour allumer tout les segments :

Image IPB
Pour éteindre un des segments rien de plus simple, il suffit de déconnecter la résistance du segment que l'on souhaite éteindre, de la masse ! 
La valeur des résistances dépend de la valeur de l'alimentation.

Voici l'équation (simpliste !) permettant de trouver la valeur de la résistance en fonction de notre alimentation :

Image IPB     

 ( Pour rappel, 1.5V représente la tension de la led, 0,016 représente le courant en A qui traverse la led , retour encore une fois au tuto sur l'utilisation des led si besoin ;)

Image IPBExemple :

Alim. : 12V
Image IPB
Sachant que les résistances ont des valeurs normalisées, les valeurs les plus proches sont : 560 ou 680 Ohm.
Il faut savoir qu'avec une résistance de 560 Ohm, les Leds éclaireront beacoup plus que la normal, et qu'avec une résistance de 680 elles éclaireront légèrement moins (680 étant plus proche de la valeur cherché...)

Je choisirais donc une résistance de 680 Ohm +/- 10% si mon afficheur est directement alimenté par du 12V. 
 
 

2 – b : Les afficheurs à cathode commune :


Voici le principe des afficheurs à cathode commune : (Schéma de l'intérieur du boitier)
Image IPB

Comme vous l'avez remarqué, cette fois ci ce sont toutes les cathodes sont relié ensemble.
 
Sur le même principe que précédement voici  maintenant comment  câbler l'afficheur dans ce cas :

Image IPB

cette fois ci pour éteindre un des segments il faudra déconnecter la résistance du segment que l'on souhaite éteindre de la source d'alimentation  ! 
 
 
3 - Utilisation de l'afficheur 7 segments avec arduino 
 
Maintenant si vous avez bien compris le passage précédent, 
 
a) Il va falloir commencer par  recalculer la valeur de la résistance à utiliser.
En effet avec une arduino uno la tension " d'alimentation" qui sera fournis par les pins de la arduino de de 5V ou de 3.3V en fonction du model que vous utiliserez ! 
 
Pour ma part vu que je vais utiliser une arduino uno  ( qui fonctionne en 5V ) je vais utiliser des résistances de 220 ohm ! =)
 
b)Ensuite il va falloir câbler correctement l'afficheur. 
Dans notre cas on va souhaiter piloter indépendamment chacun de segments par notre arduino, du coup chaque segment sera relier à un des pins de l'arduino en passant par une résistance. 

Voici le choix complètement arbitraire que j'ai fait : 
Segment A sur pin A1
Segment B sur pin A0
Segment C sur pin 10 
Segment D sur pin 9
Segment E sur pin 8
Segment F sur pin A2 
Segment G sur pin A3
Segment DP sur pin 11
 
en passant à chaque fois par une résistance bien entendu . 
 
[image câblage]
 
Attaquons le code maintenant :
 
Afin de pouvoir facilement changer cette configuration on utilisera des #define au début du programme

comme ceci
 
#define SEG_A A1
#define SEG_B A0
#define SEG_C 10
#define SEG_D 9
#define SEG_E 8
#define SEG_F A2
#define SEG_G A3
#define SEG_DP 11

maintenant faisons l'initialisation dans le setup 
void setup() {

  // Initialisation de tous les pins  relié à l'afficheur 7 segments en sortie
  pinMode(SEG_A,OUTPUT);
  pinMode(SEG_B,OUTPUT);
  pinMode(SEG_C,OUTPUT);
  pinMode(SEG_D,OUTPUT);
  pinMode(SEG_E,OUTPUT);
  pinMode(SEG_F,OUTPUT);
  pinMode(SEG_G,OUTPUT);
  pinMode(SEG_DP,OUTPUT);

  // Initialisation des états des segments : LOW = 0FF et HIGH = ON si cathode commune et l'inverse sinon
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
  
}



Ensuite afin de simplifier le code vous pouvez faire une fonction pour chaque caractère que vous voulez afficher : 
 
Exemple dans le cas d'un afficheur à cathode commune,  ( il faudra inverser HIGH et LOW dans le cas d'un afficheur à anode commune )
void display0() 
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display1()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display2()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display3()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display4()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display5()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display6()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display7()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display8()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display9()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayA()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayb()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayC()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void displayd()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}


void displayE()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayF()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

afin de simplifier l'utilisation de ces fonctions d'affichage on va encore créer une fonction, 
void displayChiffre(uint8_t i)  // Permet d'afficher un chiffre de 0 à 15 en hexa
{
  switch(i){
  case 0:
  display0();
  break;
  case 1:
  display1();
  break;
  case 2:
  display2();
  break;
  case 3:
  display3();
  break;
  case 4:
  display4();
  break;
  case 5:
  display5();
  break;
  case 6:
  display6();
  break;
  case 7:
  display7();
  break;
  case 8:
  display8();
  break;
  case 9:
  display9();
  break;
  case 10:
  displayA();
  break;
  case 11:
  displayb();
  break;
  case 12:
  displayC();
  break;
  case 13:
  displayd();
  break;
  case 14:
  displayE();
  break;
  case 15:
  displayF();
  break;
  }
}
Vous me direz autant de lignes de codes ?? Mais pour faire quoi ??
En fait maintenant qu'on a fait pas mal de fonctions qui nous facilitent la manipulation de l'afficheur on peut faire très facilement en très peu de ligne pas mal de chose :
 
Exemple :  un compteur qui compte de 0 à 15 en boucle  : 

 
void loop() {
  
for (uint8_t i=0; i<16; i++)
 {
  displayChiffre(i);// on affiche les chiffres en hexa 0 1 2 3 4 5 6 7 8 9 A b C d E F
  delay(1000);
 }
}
Et oui c'est tout ! 
 
le code complet : 
#define SEG_A A1
#define SEG_B A0
#define SEG_C 10
#define SEG_D 9
#define SEG_E 8
#define SEG_F A2
#define SEG_G A3
#define SEG_DP 11



void setup() {

  // Initialisation de tous les pins  relié à l'afficheur 7 segments en sortie
  pinMode(SEG_A,OUTPUT);
  pinMode(SEG_B,OUTPUT);
  pinMode(SEG_C,OUTPUT);
  pinMode(SEG_D,OUTPUT);
  pinMode(SEG_E,OUTPUT);
  pinMode(SEG_F,OUTPUT);
  pinMode(SEG_G,OUTPUT);
  pinMode(SEG_DP,OUTPUT);

  // Initialisation des états des segments : LOW = 0FF et HIGH = ON
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
  
}


void loop() {
  
for (uint8_t i=0; i<16; i++)
 {
  displayChiffre(i);// on affiche les chiffres en hexa 0 1 2 3 4 5 6 7 8 9 A b C d E F
  delay(1000);
 }
}


void display0() 
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display1()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display2()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display3()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display4()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display5()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display6()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display7()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display8()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display9()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayA()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayb()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayC()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void displayd()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}


void displayE()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayF()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayChiffre(uint8_t i)
{
  switch(i){
  case 0:
  display0();
  break;
  case 1:
  display1();
  break;
  case 2:
  display2();
  break;
  case 3:
  display3();
  break;
  case 4:
  display4();
  break;
  case 5:
  display5();
  break;
  case 6:
  display6();
  break;
  case 7:
  display7();
  break;
  case 8:
  display8();
  break;
  case 9:
  display9();
  break;
  case 10:
  displayA();
  break;
  case 11:
  displayb();
  break;
  case 12:
  displayC();
  break;
  case 13:
  displayd();
  break;
  case 14:
  displayE();
  break;
  case 15:
  displayF();
  break;
  }
}

 
4 – Le décodeur



Pour nous aidé à utiliser les afficheurs 7 segments, il existe ce que l'on appelle des décodeurs.

Ces convertisseurs servent à convertir une information binaire en une information qui affichera un nombre sur notre afficheur.

Voici un dessin explicatif :
Image IPB

Cela permet là aussi de simplifier l'utilisation des afficheurs. Il existe différents composant jouant ce rôle, un exemple parmis tant d'autre: le CD4511BE... Mais sachez que vous pouvez facilement réaliser votre propre décodeur avec un arduino !
Pour cela on defini 4 pins en entré numérique et on va convertir l'état de ces 4 entrées en chiffre binaire qui sera le chiffre à afficher grâce à une fonction "decode" qui va effectuer la conversion ! 
 
Pour cela on va ajouter des #define pour les entrées : 
#define BIT0 2
#define BIT1 3
#define BIT2 4
#define BIT3 5
l'initialisation de ses pins en tant qu'entrées numérique dans le setup: 
 

  pinMode(BIT0,INPUT);
  pinMode(BIT1,INPUT);
  pinMode(BIT2,INPUT);
  pinMode(BIT3,INPUT);
la fonction " decode " 
uint8_t decode() // fonction qui retourne le chiffre décodé 
{
   uint8_t result=0; 
   result=digitalRead(BIT0)+2*digitalRead(BIT1)+4*digitalRead(BIT2)+8*digitalRead(BIT3);
   return result;
}
et ce qu'on va simplement exécuter en continu dans le loop : 
 displayChiffre(decode());// on affiche le chiffre décodé en continu 
le code complet : 
#define BIT0 2
#define BIT1 3
#define BIT2 4
#define BIT3 5



void setup() {

  // Initialisation de tous les pins  relié à l'afficheur 7 segments en sortie

  pinMode(SEG_A,OUTPUT);
  pinMode(SEG_B,OUTPUT);
  pinMode(SEG_C,OUTPUT);
  pinMode(SEG_D,OUTPUT);
  pinMode(SEG_E,OUTPUT);
  pinMode(SEG_F,OUTPUT);
  pinMode(SEG_G,OUTPUT);
  pinMode(SEG_DP,OUTPUT);

  // Initialisation des états des segments : LOW = 0FF et HIGH = ON
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
  
  // Ainsi que des 4 entrés du décodeur BIT0 à BIT3

pinMode(BIT0,INPUT);
pinMode(BIT1,INPUT);
pinMode(BIT2,INPUT);
pinMode(BIT3,INPUT);
}


void loop() {
  
  displayChiffre(decode());// on affiche le chiffre décodé en continu 

}

uint8_t decode() // fonction qui retourne le chiffre décodé 
{
   uint8_t result=0; 
   result=digitalRead(BIT0)+2*digitalRead(BIT1)+4*digitalRead(BIT2)+8*digitalRead(BIT3);
   return result;
}

void display0() 
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display1()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display2()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display3()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display4()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display5()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display6()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display7()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void display8()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void display9()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,LOW);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayA()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayb()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayC()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,LOW);
  digitalWrite(SEG_DP,LOW);
}

void displayd()
{
  digitalWrite(SEG_A,LOW);
  digitalWrite(SEG_B,HIGH);
  digitalWrite(SEG_C,HIGH);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,LOW);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}


void displayE()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,HIGH);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayF()
{
  digitalWrite(SEG_A,HIGH);
  digitalWrite(SEG_B,LOW);
  digitalWrite(SEG_C,LOW);
  digitalWrite(SEG_D,LOW);
  digitalWrite(SEG_E,HIGH);
  digitalWrite(SEG_F,HIGH);
  digitalWrite(SEG_G,HIGH);
  digitalWrite(SEG_DP,LOW);
}

void displayChiffre(uint8_t i)
{
  switch(i){
  case 0:
  display0();
  break;
  case 1:
  display1();
  break;
  case 2:
  display2();
  break;
  case 3:
  display3();
  break;
  case 4:
  display4();
  break;
  case 5:
  display5();
  break;
  case 6:
  display6();
  break;
  case 7:
  display7();
  break;
  case 8:
  display8();
  break;
  case 9:
  display9();
  break;
  case 10:
  displayA();
  break;
  case 11:
  displayb();
  break;
  case 12:
  displayC();
  break;
  case 13:
  displayd();
  break;
  case 14:
  displayE();
  break;
  case 15:
  displayF();
  break;
  }
}
 
 



Image IPBVoici la fin de ce tutoriel, j'espère que celui-ci vous sera utile ! Si vous avez des questions, n'hésitez pas à les poser sur le forum !