Comment utiliser Afficheur 7 segments avec Arduino

Introduction

Les afficheurs 7 segments sont des dispositifs électroniques couramment utilisés pour afficher des chiffres et des caractères alphanumériques. Ils sont largement utilisés dans les applications nécessitant une interface visuelle simple et efficace. Dans cet article, nous allons explorer comment utiliser un afficheur 7 segments avec une carte Arduino, en exploitant le principe de la persistance rétinienne et en utilisant un décodeur BCD pour simplifier le câblage.

1. Présentation de Afficheur 7 Segments

Afficheurs 7 segments sont des dispositifs composés de sept segments (A, B, C, D, E, F, G) qui peuvent être allumés ou éteints pour former différents chiffres (de 0 à 9) ou certaines lettres de l’alphabet. Chaque segment est contrôlé indépendamment, ce qui permet d’afficher différentes combinaisons pour former des caractères spécifiques.

2. Matériel

Pour cet article ,vous aurez besoin de :

• Un (et plus) afficheur 7 segments (évidemment)
• 8 résistances de 330Ω
• Un (ou deux) décodeurs BCD 7 segments
• Arduino UNO
• Fils de connexions

3. Connexion des Afficheurs 7 Segments à la Carte Arduino

Pour connecter un afficheur 7 segments à une carte Arduino, nous avons besoin de sept broches pour contrôler chaque segment (A, B, C, D, E, F, G) et éventuellement une broche supplémentaire pour le point décimal (DP). Cependant, cela nécessite beaucoup de broches Arduino, ce qui peut être problématique si nous en avons besoin pour d’autres fonctions.

3.1 Principe du Décodeur BCD

Pour simplifier la connexion et économiser des broches, nous utilisons un décodeur BCD (Binaire Codé Décimal). Le décodeur BCD prend en entrée un nombre binaire de 4 bits (représentant un chiffre de 0 à 9) et génère les signaux de contrôle appropriés pour allumer les segments correspondants sur l’afficheur 7 segments.

4. Programmation de l’Affichage des Chiffres

4.1 Affichage d’un Chiffre sur un Seul Afficheur

Avant de commencer à utiliser le décodeur BCD, nous devons comprendre comment afficher un chiffre sur un seul afficheur. Chaque chiffre correspond à une combinaison spécifique de segments allumés. Par exemple, pour afficher le chiffre 0, tous les segments (A, B, C, D, E, F) sont allumés, tandis que pour le chiffre 1, seuls les segments B et C sont allumés.

Nous pouvons utiliser la fonction switch() en Arduino pour gérer les différentes combinaisons de segments pour chaque chiffre. Voici un exemple de code pour afficher un chiffre :

// Définition des broches pour contrôler les segments de l'afficheur 7 segments
const int bit_A = 3;
const int bit_B = 2;
const int bit_C = 8;
const int bit_D = 7;
const int bit_E = 6;
const int bit_F = 4;
const int bit_G = 5;

void setup() {
  // Définir les broches comme sorties
  pinMode(bit_A, OUTPUT);
  pinMode(bit_B, OUTPUT);
  pinMode(bit_C, OUTPUT);
  pinMode(bit_D, OUTPUT);
  pinMode(bit_E, OUTPUT);
  pinMode(bit_F, OUTPUT);
  pinMode(bit_G, OUTPUT);
}

void loop() {
  // Afficher le chiffre 0 sur l'afficheur
  afficherChiffre(0);
  delay(1000);

  // Afficher le chiffre 5 sur l'afficheur
  afficherChiffre(5);
  delay(1000);
}

void afficherChiffre(int chiffre) {
  switch(chiffre) {
    case 0:
      digitalWrite(bit_A, HIGH);
      digitalWrite(bit_B, HIGH);
      digitalWrite(bit_C, HIGH);
      digitalWrite(bit_D, HIGH);
      digitalWrite(bit_E, HIGH);
      digitalWrite(bit_F, HIGH);
      digitalWrite(bit_G, LOW);
      break;
    case 1:
      digitalWrite(bit_A, LOW);
      digitalWrite(bit_B, HIGH);
      digitalWrite(bit_C, HIGH);
      digitalWrite(bit_D, LOW);
      digitalWrite(bit_E, LOW);
      digitalWrite(bit_F, LOW);
      digitalWrite(bit_G, LOW);
      break;
    // ... Ajouter les autres cas pour les chiffres 2 à 9
    default:
      // Éteindre tous les segments en cas de chiffre invalide
      digitalWrite(bit_A, LOW);
      digitalWrite(bit_B, LOW);
      digitalWrite(bit_C, LOW);
      digitalWrite(bit_D, LOW);
      digitalWrite(bit_E, LOW);
      digitalWrite(bit_F, LOW);
      digitalWrite(bit_G, LOW);
      break;
  }
}

4.2 Utilisation de Plusieurs Afficheurs en Parallèle

Maintenant que nous savons comment afficher un chiffre sur un seul afficheur, nous allons passer à l’affichage de chiffres sur plusieurs afficheurs en utilisant le décodeur BCD et la commutation par transistor.

4.2.1 Utilisation de Transistors pour la Commutation

Nous utilisons des transistors bipolaires NPN pour commuter les afficheurs. Chaque transistor est contrôlé par une broche de la carte Arduino. Lorsque la broche est à l’état haut, le transistor est saturé et l’afficheur correspondant s’allume. Lorsque la broche est à l’état bas, le transistor est bloqué et l’afficheur s’éteint.

4.2.2 Schéma de Commutation des Afficheurs

Pour utiliser plusieurs afficheurs, nous allons les connecter en parallèle sur les sorties du décodeur BCD. Ensuite, nous allons utiliser des transistors pour commuter les afficheurs et n’afficher qu’un chiffre à la fois. Cela se fait en alternant rapidement entre les deux afficheurs pour donner l’impression qu’ils fonctionnent en même temps.

4.2.3 Exemple de Code pour Afficher des Chiffres sur Deux Afficheurs en Alternance

Voici un exemple de code pour afficher un compteur qui compte de 0 à 99 en utilisant deux afficheurs en alternance :

// définition des broches du décodeur 7 segments

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

const int alim_dizaine = 6; // les dizaines
const int alim_unite = 7;   // les unites

void setup()
{
    pinMode(bit_A, OUTPUT);
    pinMode(bit_B, OUTPUT);
    pinMode(bit_C, OUTPUT);
    pinMode(bit_D, OUTPUT);
    pinMode(alim_dizaine, OUTPUT);
    pinMode(alim_unite, OUTPUT);

    // Les broches sont toutes mises à l'état bas
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, LOW);
}

void loop() // fonction principale
{
    // boucle qui permet de compter de 0 à 99 (= 100 valeurs)
    for(char i = 0; i<100; i++)
    {
        // appel de la fonction affichage avec envoi du nombre à afficher
        afficher_nombre(i);
    }
}

// fonction permettant d'afficher un nombre sur deux afficheurs
void afficher_nombre(char nombre)
{
    long temps; // variable utilisée pour savoir le temps écoulé...
    char unite = 0, dizaine = 0; // variable pour chaque afficheur

    if(nombre > 9) // si le nombre reçu dépasse 9
    {
        dizaine = nombre / 10; // on récupère les dizaines
    }

    unite = nombre - (dizaine*10); // on récupère les unités

    temps = millis(); // on récupère le temps courant

    // tant qu'on a pas affiché ce chiffre pendant au moins 500 millisecondes
    // permet donc de pouvoir lire le nombre affiché
    while((millis()-temps) < 500)
    {
        // on affiche le nombre

        // d'abord les dizaines pendant 10 ms

        // le transistor de l'afficheur des dizaines est saturé,
        // donc l'afficheur est allumé
        digitalWrite(alim_dizaine, HIGH);
        // on appel la fonction qui permet d'afficher le chiffre dizaine
        afficher(dizaine);
        // l'autre transistor est bloqué et l'afficheur éteint
        digitalWrite(alim_unite, LOW);
        delay(10);

        // puis les unités pendant 10 ms

        // on éteint le transistor allumé
        digitalWrite(alim_dizaine, LOW);
        // on appel la fonction qui permet d'afficher le chiffre unité
        afficher(unite);
        // et on allume l'autre
        digitalWrite(alim_unite, HIGH);
        delay(10);
    }
}

// fonction écrivant sur un seul afficheur
// on utilise le même principe que vu plus haut
void afficher(char chiffre)
{
    digitalWrite(bit_A, LOW);
    digitalWrite(bit_B, LOW);
    digitalWrite(bit_C, LOW);
    digitalWrite(bit_D, LOW);

    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;
    }
}

5. Contraintes des Évènements et Utilisation de la Fonction millis()

5.1 Explication du Phénomène de Persistance Rétinienne

Lorsque nous alternons rapidement entre les afficheurs pour former un affichage continu, cela crée l’illusion que les deux afficheurs fonctionnent simultanément. Cela est dû au phénomène de persistance rétinienne, où l’image reste brièvement gravée sur la rétine, donnant l’impression de continuité.

5.2 Utilisation de la Fonction millis() pour l’Affichage Continu

Au lieu d’utiliser la fonction delay(), qui bloque le programme pendant une période spécifique, nous pouvons utiliser la fonction millis() pour créer un affichage continu sans bloquer d’autres tâches. La fonction millis() renvoie le nombre de millisecondes écoulées depuis le démarrage du programme Arduino.

5.3 Exemple de Code pour Afficher Deux Chiffres en Utilisant la Fonction millis()

// ... (Mêmes déclarations de broches et de fonctions que dans les exemples précédents)

unsigned long tempsPrecedent = 0;
const long intervalleAffichage = 100; // Intervalles en millisecondes

int compteur = 0;

void loop() {
  unsigned long tempsActuel = millis();

  if (tempsActuel - tempsPrecedent >= intervalleAffichage) {
    tempsPrecedent = tempsActuel;

    // Afficher les dizaines
    digitalWrite(alim_unite, LOW);
    digitalWrite(alim_dizaine, HIGH);
    afficherChiffre(compteur / 10);
    delay(1);

    // Afficher les unités
    digitalWrite(alim_dizaine, LOW);
    digitalWrite(alim_unite, HIGH);
    afficherChiffre(compteur % 10);
    delay(1);

    compteur++;
    if (compteur > 99) {
      compteur = 0;
    }
  }
}

// ... (Fonction afficherChiffre() identique à l'exemple précédent)

Conclusion

Dans cet article, nous avons appris comment utiliser un afficheur 7 segments avec une carte Arduino en utilisant un décodeur BCD pour économiser des broches. Nous avons également exploré la persistance rétinienne pour créer l’illusion d’un affichage continu en alternant rapidement entre deux afficheurs. En utilisant des transistors et la fonction millis(), nous avons pu afficher un compteur de 0 à 99 sur deux afficheurs en alternance.

Les afficheurs 7 segments offrent une interface simple mais efficace pour afficher des chiffres et des caractères alphanumériques, et leur utilisation avec Arduino ouvre un large éventail de possibilités pour créer des projets interactifs et informatifs. Que ce soit pour afficher des mesures, des indicateurs ou des informations de suivi, les afficheurs 7 segments peuvent être un excellent ajout à vos projets électroniques.

Lien outilles

1. Téléchargement de l’Arduino IDE : https://www.arduino.cc/en/software
2. Pour plus d’articles : https://www.moussasoft.com/tutoriels-electroniques
3. Twitter: Moussa Lhoussaine (@Moussasoft_com) / Twitter

Arduino – Home