Qu'est-ce qu'un afficheur à 7 segments ?
Un afficheur à 7 segments est un composant électronique composé de 7 LED individuelles disposées selon un motif spécifique pour afficher des chiffres (0 à 9) et certaines lettres. Ces LED sont nommées a, b, c, d, e, f, g, et l'afficheur comprend généralement un point décimal (dp) en option.
Selon différentes dispositions et combinaisons, il existe 128 variations (chiffres arabes et caractères) pour l'affichage à 7 segments.
Brochage de l'afficheur à 7 segments
Le brochage d'un afficheur à 7 segments varie en fonction de son type, qui se divise principalement en deux catégories : anode commune et cathode commune.
Configuration des broches
Voici un exemple d'affectation des broches pour un affichage à 7 segments classique (notez que les brochages réels peuvent varier selon le fabricant et le modèle) :
Anode commune :
Toutes les anodes (positives) de l'affichage à 7 segments sont connectées entre elles, et lorsqu'une cathode est mise à l'état bas, la LED correspondante s'allume.
- g, f, a, b, e, d, c, dp : ce sont les broches des segments, correspondant respectivement aux sept segments et au point décimal.
- COM : broche d'anode commune, connectée à VCC.
Cathode commune :
Toutes les cathodes (négatives) de l'affichage à 7 segments sont connectées entre elles, et lorsqu'une anode (positive) est mise à l'état haut, la LED correspondante s'allume.
De même, les broches de segment (g, f, a, b, e, d, c, dp) correspondent aux segments et au point décimal, mais la broche de cathode commune (COM) est connectée à GND.
Câblage de l'afficheur à 7 segments
Pour faire fonctionner un afficheur à 7 segments, les segments individuels (a, b, c, d, e, f, g, dp) doivent être connectés à des broches de sortie spécifiques sur un microcontrôleur. Par exemple, pour un afficheur à 7 segments à cathode commune, l'extrémité négative de chaque segment est connectée à une broche de masse commune, tandis que l'extrémité positive de chaque segment est connectée à une broche de sortie différente sur le microcontrôleur.
Configuration de base du câblage
- L'afficheur à 7 segments comporte 8 broches (7 pour les segments et 1 pour le point décimal).
- Chaque broche correspondant à un segment (a à g) est connectée au microcontrôleur.
- Pour la configuration à cathode commune, connectez la broche de cathode commune à la masse.
Exemple de connexion à Arduino
Lorsqu'on connecte un afficheur à 7 segments à un Arduino, les broches des segments sont généralement connectées à différentes broches numériques de la carte Arduino. Par exemple, dans une configuration à anode commune, les broches des segments peuvent être connectées comme suit :
- a – Broche 7 de l'Arduino
- b – Broche Arduino 8
- c – Broche Arduino 4
- d – Broche Arduino 3
- e – Broche Arduino 2
- f – Broche Arduino 6
- g – Broche Arduino 5
- COM – Broche Arduino 9 (connectée à VCC)
Dans cette configuration, pour éclairer un segment spécifique, la broche Arduino correspondante est réglée sur LOW, tandis que la broche d'anode commune reste sur HIGH.
Comment contrôler un afficheur à 7 segments
La clé pour contrôler un affichage à 7 segments consiste à fournir la tension correcte à chaque segment afin de former le chiffre ou le symbole souhaité.
Affichage des nombres
Pour afficher un chiffre, le microcontrôleur doit activer les segments appropriés. Par exemple :
- Pour afficher 0, les segments a, b, c, d, e et f doivent être allumés, tandis que le segment g reste éteint.
Composants requis
Tout comme pour une matrice LED, ce projet nécessite un câblage et des résistances considérables. Chaque LED ayant besoin de sa propre résistance pour éviter toute brûlure, veillez à disposer d'un nombre suffisant de résistances. Pour l'ensemble du projet, vous aurez besoin des composants suivants :
- Arduino Uno
- Arduino IDE
- Affichage à sept segments
- Fils électriques
- 8 résistances de 220 ohms
- Plaque d'essai
- Câble USB
Exemple de code pour afficher des nombres
int pin_a = 7, pin_b= 6, pin_c = 5, pin_d = 10, pin_e = 11, pin_f = 8, pin_g = 9, pin_p = 4;
// Segment data for digits 0-9
int numTable[10][8] = {
{1, 1, 1, 1, 1, 1, 0, 0}, // 0
{0, 1, 1, 0, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1, 0}, // 2
{1, 1, 1, 1, 0, 0, 1, 0}, // 3
{0, 1, 1, 0, 0, 1, 1, 0}, // 4
{1, 0, 1, 1, 0, 1, 1, 0}, // 5
{1, 0, 1, 1, 1, 1, 1, 0}, // 6
{1, 1, 1, 0, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1, 0}, // 8
{1, 1, 1, 1, 0, 1, 1, 0}, // 9
};
void setup(){
for (int i = 4; i <= 11; i++){
pinMode(i, OUTPUT);
}
}
void loop(){
for (int i = 0; i < 10; i++){
digitalWrite(pin_a, numTable[i][0]);
digitalWrite(pin_b, numTable[i][1]);
digitalWrite(pin_c, numTable[i][2]);
digitalWrite(pin_d, numTable[i][3]);
digitalWrite(pin_e, numTable[i][4]);
digitalWrite(pin_f, numTable[i][5]);
digitalWrite(pin_g, numTable[i][6]);
digitalWrite(pin_p, numTable[i][7]);
delay(1000);
}
}
Dans cet exemple, le numTable tableau contient les données nécessaires pour allumer les segments appropriés pour chaque chiffre.
Projets d'affichage à 7 segments à plusieurs chiffres
Pour les affichages à plusieurs chiffres, le moyen le plus simple de contrôler plusieurs affichages à 7 segments est le multiplexage. Une autre méthode consiste à utiliser la bibliothèque Arduino.
Technique de multiplexage
Avec le multiplexage, plusieurs écrans partagent le même ensemble de broches de commande, et chaque écran est allumé séquentiellement. Ce processus est si rapide que l'œil humain perçoit tous les chiffres comme étant allumés en même temps.
Exemple de code pour le multiplexage d'affichages à 7 segments
const int digitPins[3] = {2, 3, 4}; // Digit selection pins
const int segmentPins[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Segment pins
int numTable[10][8] = { {0, 0, 0, 0, 0, 0, 1, 1}, {1, 0, 0, 1, 1, 1, 1, 1}, ... };
void setup(){
for (int i = 2; i <= 4; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, LOW);
}
for (int i = 6; i <= 13; i++) {
pinMode(i, OUTPUT);
digitalWrite(i, HIGH);
}
}
void loop(){
for (int i = 0; i < 10; i++){
for (int j = 0; j < 3; j++) {
showdigit(i, j);
}
delay(500);
}
}
void showdigit(int num, int digit){
digitalWrite(digitPins[digit], HIGH);
for (int i = 0; i < 8; i++) {
digitalWrite(segmentPins[i], numTable[num][i]);
}
delay(500);
digitalWrite(digitPins[digit], LOW);
}
Utilisation des bibliothèques pour contrôler les afficheurs à 7 segments
Pour plus de commodité, des bibliothèques telles que SevSeg sont disponibles pour simplifier le contrôle des afficheurs à 7 segments. Cette bibliothèque est utile pour contrôler les afficheurs à plusieurs chiffres, car elle abstrait une grande partie du câblage complexe et de la logique de contrôle.
Nous pouvons rechercher et installer SevSeg à partir du menu Arduino : Outils >> Gérer les bibliothèques.
Exemple de code utilisant la bibliothèque SevSeg
#include "SevSeg.h"
SevSeg sevseg;
void setup() {
sevseg.begin(COMMON_CATHODE, 3, digitPins, segmentPins);
}
void loop() {
int readValue = analogRead(A0);
int showValue = map(readValue, 0, 1023, 0, 999);
sevseg.setNumber(showValue, 3);
sevseg.refreshDisplay();
}
Applications des afficheurs à 7 segments
En raison de sa simplicité, de sa facilité d'utilisation et de son faible coût, l'affichage à 7 segments est largement utilisé dans diverses applications, telles que :
- Horloges électroniques : affichage de l'heure et de la date ;
- Calculatrices : affichage des résultats de calcul ;
- Appareils électroménagers : panneaux d'affichage pour des produits tels que les micro-ondes, les climatiseurs et les machines à laver ;
- Tableaux de bord de voitures : affichage d'informations telles que la vitesse et le kilométrage ;
- Équipements industriels : affichage des mesures provenant d'appareils tels que les régulateurs de température et les manomètres ;
- Instruments de laboratoire : affichage des données et résultats expérimentaux ;
- Électronique grand public : affichage du contrôle du volume sur les équipements audio.
Conclusion
Les afficheurs à 7 segments sont des composants polyvalents qui permettent d'afficher facilement des données numériques. Comprendre leur câblage, leurs méthodes de contrôle et leurs applications peut considérablement améliorer la fonctionnalité de vos projets, des horloges simples aux affichages complexes. Que vous utilisiez le multiplexage, des bibliothèques ou des registres à décalage, il existe de nombreuses façons de contrôler efficacement les afficheurs à 7 segments, chacune étant adaptée à différentes exigences de projet.
