Panier d’achat

Aucun produit dans le panier.

Filtres disponibles
Home Shop Cart0 Phone
AFFICHEUR-1-BIT-7-SEGMENT-CATHODE
AFFICHEUR 7 SEGMENT 1 BIT CATHODE

4.00 د.م.

4.00 د.م.

Rupture de stock

AFFICHEUR 7 SEGMENT 1 BIT CATHODE

4.00 د.م.

Rupture de stock

Description

Tutoriel : Utiliser un afficheur 7 segment 1 bit avec une carte Arduino


Les afficheurs 7 segments sont des afficheurs à LEDs hérités d’une époque maintenant révolue où chacun pouvait acheter son kit électronique à monter soi même à la boutique d’électronique du coin ou en envoyant son formulaire découpé dans les magazines d’électronique de l’époque. On trouve aujourd’hui de moins en moins d’afficheurs 7 segments dans les appareils du commerce. C’est bien dommage, car il s’agit d’une technologie simple et efficace.

Aucun film d’action ne serait complet sans un vilain méchant avec une bombe affichant le temps restant avant l’explosion sur un afficheur 7 segments et bipant chaque seconde, pour que le héros puisse arrêter le compteur à 00:00:01.

Vous l’aurez compris, dans cet article, on va apprendre à utiliser des afficheurs 7 segments avec une carte Arduino / Genuino.


Les afficheurs 7 segments

Les afficheurs 7 segments sont des afficheurs à LEDs constitués de 7 segments (une LED par segment), qui permettent d’afficher des chiffres et même parfois des lettres en fonction de l’application.

Il y a encore quelques années, les afficheurs 7 segments étaient partout : radio réveil, montre, calculatrice, micro-onde, four, minuteur, systèmes industriels, outil de mesure, etc. Aujourd’hui, les afficheurs 7 segments ont pour la plupart été replacés par des afficheurs LCD ou des écrans graphiques plus haut de gamme. On ne trouve des afficheurs 7 segments que dans des cas d’usage très particuliers : voltmètre pour modélisme, carte électronique DIY ou pour un marché de niche, outils de mesure low cost, etc.

Les afficheurs 7 segments ont été oubliés, car trop sobres, les temps changent, les goûts aussi. Mais comme il s’agit simplement d’une série de LEDs dans un même boitier, au final, c’est technologie très simple à mettre en oeuvre. Et comme on dit, souvent, la solution la plus simple est la meilleure.

Illustration de l'agencement des segments d'un afficheur 7 segmentsAgencement d’un afficheur 7 segments

Les afficheurs 7 segments sont constitués de 7 segments, d’où leur nom. Ces segments sont nommés ABCDE et F par convention, et ils se présentent dans l’ordre illustré ci-dessus.

Chaque segment correspond à une LED qu’il est possible d’allumer ou d’éteindre pour former des chiffres, des lettres et même des caractères spéciaux rudimentaires. En général, les afficheurs disposent de 7 segments et d’un « point décimal » qui peut être utilisé pour afficher des nombres à virgule ou des sous-unités (dixième de seconde par exemple).

PS On le verra dans un prochain article, il existe aussi des versions spécialisées avec des doubles points pour les heures et des apostrophes pour les minutes (pour la notation américaine).

Il existe une multitude de couleurs d’afficheurs 7 segments : rouge, vert, jaune, orange, bleu, blanc, etc. Il existe une multitude de tailles, du petit afficheur de quelques millimètres de côté à plusieurs dizaines de centimètres. À vous de choisir

Au final, qu’importe la couleur et la taille de l’afficheur, le principe de fonctionnement est le même.

Illustration des chiffres et lettres (hexadécimal) affichables avec un afficheur 7 segmentsChiffres de 0 à 9 et lettres de A à F

Afficher des chiffres avec un afficheur 7 segments se résume à allumer les LEDs des segments adéquats. C’est tout.

N’importe quel montage / code capable d’allumer 7 ou 8 LEDs simultanément est capable d’utiliser un afficheur 7 segments. Il n’y a pas plus simple.

Je vous ai fait une illustration des différents chiffres possibles avec un afficheur 7 segments. Si vous avez du mal à lire les chiffres, reculez-vous un peu de votre écran. Une illustration vaut mieux que des mots dans le cas présent

PS J’ai ajouté dans l’illustration les lettres de A à F, car l’affichage de chiffres hexadécimaux est très classique avec des afficheurs 7 segments. La vie ne se résume pas aux chiffres de 0 à 9 en informatique 


Question piège : cathode ou anode commune ?

Exemples de références d'afficheurs 7 segmentsExemples de références d’afficheurs 7 segments

Si vous cherchez des afficheurs 7 segments sur internet, vous tomberez parfois sur des afficheurs à « cathode commune » et d’autre fois sur des afficheurs à « anode commune ». Kézako ?

Une LED à deux broches : une anode (le +) et une cathode (le -). Pour contrôler une LED, il faut qu’un courant passe de l’anode à la cathode.

Dans les cas des afficheurs 7 segments, afin de minimiser le nombre de broches à câbler, les anodes ou les cathodes sont précablées ensembles à l’intérieur de l’afficheur. Il y a donc toujours une broche commune et 8 broches séparées pour les segments et le point décimal.

Pour contenter tout le monde, il existe donc deux versions d’afficheurs : une version « à anode commune » (abrégée CA, toutes les anodes sont reliées ensembles) et une autre « à cathode commune » (abrégée CC, toutes les cathodes sont reliées ensembles). La différence est subtile, mais celle-ci implique un câblage totalement différent suivant le type.

Dans un cas il faut relier la broche commune à la masse (cathode commune), dans l’autre à l’alimentation (anode commune). La logique de contrôle s’en retrouve aussi inversée. Dans un cas il faut relier l’alimentation à la broche du segment que l’on souhaite allumer. Dans l’autre, il faut relier la masse à la broche du segment que l’on souhaite allumer.

Dans le cas d’une utilisation avec une carte Arduino, la version à anode commune se traduit par un LOW = segment allumé, HIGH = segment éteint. Pour la version à cathode commune, c’est plus « logique », avec LOW = segment éteint, HIGH = segment allumé.

Prenez bien le temps de regardez quelle version vous devez / pouvez utiliser dans vos montages. Certains circuits de contrôle (comme le CD4511 présenté en bonus par exemple) il ne fonctionne de base qu’avec des afficheurs à cathode commune.

Si vous ne savez pas quoi acheter, prenez des versions à cathode commune. C’est la version la plus standard et la plus simple à utiliser.


Le montage de démonstration

Pour comprendre comment utiliser un afficheur 7 segments, le plus simple et d’en mettre un en application dans un montage de test

Pour réaliser ce premier montage, il va nous falloir :

  • Une carte Arduino UNO (et son câble USB),

  • Un afficheur 7 segments à cathode commune,

  • Huit résistances de 1K ohms – code couleur marron / noir / rouge,

  • Une plaque d’essai et des fils pour câbler notre montage.

Vue prototypage du montage de démonstration pour un afficheur 7 segments (version CC)Vue prototypage du montage

Pour commencer le montage, on câble la broche GND de l’Arduino à la broche commune de l’afficheur 7 segments (broche du milieu en haut ou en bas sur les afficheurs avec un brochage « standard »).

On câble ensuite une résistance de 1K sur chaque segment de l’afficheur (voir brochage dans le chapitre précédent) puis à la carte Arduino au moyen d’un fil. Les segments devront être câblés dans l’ordre ci-dessous :

Segment

Broche Arduino

A

2

B

3

C

4

D

5

E

6

F

7

G

8

DP

9

PS Les broches Arduino ci-dessus ont été choisies de manière totalement arbitraire. Vous pouvez modifier la correspondance des broches en fonction de vos besoins et de votre montage dans le code par la suite ci besoin.

Une fois les 7 segments et le point décimal câblés, il ne reste plus qu’à passer au code


Pourquoi des résistances de 1K ohms ?

Quand on câble une LED sur une carte Arduino, on utilise généralement des résistances de 330 ohms, car cela permet d’avoir un courant de 12mA au travers de la LED et donc une bonne luminosité. Il serait donc logique d’utiliser les mêmes valeurs pour les LEDs d’un afficheur 7 segments. Ou pas.

Il y a une petite différence entre une simple LED et un afficheur 7 segments. Une LED est un voyant, conçu pour être visible, voir même pour éclairer des objets. Un afficheur 7 segments est conçu pour faire de l’affichage à courte distance, il n’y a donc pas besoin d’une grande luminosité.

Un afficheur 7 segments est parfaitement lisible avec un courant de seulement 2mA. Pour une utilisation dans une pièce un peu lumineuse, un courant de 5mA suffit à avoir une luminosité suffisante.

Il est possible d’utiliser des résistances de 330 ohms pour obtenir un courant de 12mA et donc une luminosité très importante. Mais généralement, cela est parfaitement inutile.

N’hésitez pas à tester plusieurs valeurs de résistances entre 1.6K ohms et 330 ohms pour vous faire une idée de la luminosité


Le montage de démonstration (version anode commune)

Pour les curieux qui désirent utiliser un afficheur à anode commune.

Le montage est le même, seulement, la broche commune de l’afficheur est reliée à la broche 5V de la carte Arduino, au lieu de la broche GND.


Le code

Le but du code d’exemple ci-dessous est d’une simplicité déconcertante : afficher des chiffres de 0 à F (15 en hexadécimal) en boucle, tout en faisant clignoter le point décimal.

/* Broches des différents segments de l'afficheur */
const byte PIN_SEGMENT_A = 2;
const byte PIN_SEGMENT_B = 3;
const byte PIN_SEGMENT_C = 4;
const byte PIN_SEGMENT_D = 5;
const byte PIN_SEGMENT_E = 6;
const byte PIN_SEGMENT_F = 7;
const byte PIN_SEGMENT_G = 8;
const byte PIN_SEGMENT_DP = 9;

On va commencer ce code de manière très classique avec les diverses déclarations de constantes pour les broches.

/* Table de correspondance valeur -> états des segments de l'afficheur */
const byte LUT_ETATS_SEGMENTS[] = {
0b00111111,
0b00000110,
0b01011011,
0b01001111,
0b01100110,
0b01101101,
0b01111101,
0b00000111,
0b01111111,
0b01101111,
0b01110111,
0b01111100,
0b00111001,
0b01011110,
0b01111001,
0b01110001
};

On continue ensuite avec une autre constante, un tableau d’octets, qui contiendra notre table de correspondance de chiffre vers segments.

Vous remarquerez que j’ai utilisé une notation binaire dans le tableau afin de rendre le code plus lisible pour ceux qui voudraient vérifier que mes segments correspondent bien aux chiffres

/** Fonction setup() */
void setup() {

/* Toutes les broches en sorties */
pinMode(PIN_SEGMENT_A, OUTPUT);
digitalWrite(PIN_SEGMENT_A, LOW);
pinMode(PIN_SEGMENT_B, OUTPUT);
digitalWrite(PIN_SEGMENT_B, LOW);
pinMode(PIN_SEGMENT_C, OUTPUT);
digitalWrite(PIN_SEGMENT_C, LOW);
pinMode(PIN_SEGMENT_D, OUTPUT);
digitalWrite(PIN_SEGMENT_D, LOW);
pinMode(PIN_SEGMENT_E, OUTPUT);
digitalWrite(PIN_SEGMENT_E, LOW);
pinMode(PIN_SEGMENT_F, OUTPUT);
digitalWrite(PIN_SEGMENT_F, LOW);
pinMode(PIN_SEGMENT_G, OUTPUT);
digitalWrite(PIN_SEGMENT_G, LOW);
pinMode(PIN_SEGMENT_DP, OUTPUT);
digitalWrite(PIN_SEGMENT_DP, LOW);
}

La fonction setup() ne fera pas grand-chose aujourd’hui. Quelques pinMode() et quelques digitalWrite() pour initialiser les broches en sortie et à LOW, mais rien de plus.

/** Fonction loop() */
void loop() {
static byte chiffre = 0;
static byte etat_dp = 0;

/* Affiche le chiffre */
affiche_chiffre_7seg(chiffre, etat_dp);

/* Incrémente le chiffre de 0 à 15 */
if (++chiffre == 16) {
chiffre = 0;
}

/* Fait clignoter le point décimal (inverse l'état à chaque fois) */
etat_dp = !etat_dp;

/* Délai pour la démo */
delay(1000);
}

La fonction loop() est déjà plus intéressante. Elle fait quatre choses :

  • elle affiche le chiffre courant au moyen de la fonction affiche_chiffre_7seg(),

  • elle incrémente de 1 la valeur du chiffre, en repartant de 0 si la valeur dépasse 15,

  • elle fait clignoter le point décimal en inversant son état,

  • elle attend une seconde avant de recommencer.

N.B. La valeur du chiffre et l’état du point décimal sont stockés dans deux variables « statiques » qui conservent leur valeur entre deux exécutions de la fonction loop().

/** Fonction permettant d'afficher un chiffre sur un afficheur 7 segments */
void affiche_chiffre_7seg(byte chiffre, byte dp) {

/* Simple sécurité */
if (chiffre > 15)
return; // Accepte uniquement des valeurs de 0 à 15.

/* Conversion chiffre -> états des segments */
byte segments = LUT_ETATS_SEGMENTS[chiffre];

/* Affichage */
digitalWrite(PIN_SEGMENT_A, bitRead(segments, 0));
digitalWrite(PIN_SEGMENT_B, bitRead(segments, 1));
digitalWrite(PIN_SEGMENT_C, bitRead(segments, 2));
digitalWrite(PIN_SEGMENT_D, bitRead(segments, 3));
digitalWrite(PIN_SEGMENT_E, bitRead(segments, 4));
digitalWrite(PIN_SEGMENT_F, bitRead(segments, 5));
digitalWrite(PIN_SEGMENT_G, bitRead(segments, 6));
digitalWrite(PIN_SEGMENT_DP, dp);
}

La fonction affiche_chiffre_7seg() s’occupe de l’affichage.

Elle commence par vérifier que le chiffre est bien compris entre 0 et 15 (inclus). Elle utilise ensuite le tableau de correspondance pour « convertir » le chiffre en une série d’états pour les segments. Pour finir, elle utilise une série de digitalWrite() pour écrire l’état de chaque segment.

L’extraction de l’état de chaque segment est réalisée par la fonction bitRead(). Cette fonction permet d’extraire la valeur d’un bit d’un nombre entier. Ici chaque bit de la valeur en sortie du tableau correspond à un segment.

Pour les amateurs d’afficheurs à anode commune, voici le code modifié:

/** Fonction permettant d'afficher un chiffre sur un afficheur 7 segments */
void affiche_chiffre_7seg(byte chiffre, byte dp) {

/* Simple sécurité */
if (chiffre > 15)
return; // Accepte uniquement des valeurs de 0 à 15.

/* Conversion chiffre -> états des segments */
byte segments = LUT_ETATS_SEGMENTS[chiffre];

/* Affichage */
digitalWrite(PIN_SEGMENT_A, !bitRead(segments, 0));
digitalWrite(PIN_SEGMENT_B, !bitRead(segments, 1));
digitalWrite(PIN_SEGMENT_C, !bitRead(segments, 2));
digitalWrite(PIN_SEGMENT_D, !bitRead(segments, 3));
digitalWrite(PIN_SEGMENT_E, !bitRead(segments, 4));
digitalWrite(PIN_SEGMENT_F, !bitRead(segments, 5));
digitalWrite(PIN_SEGMENT_G, !bitRead(segments, 6));
digitalWrite(PIN_SEGMENT_DP, !dp);
}

Cette variante est la même que précédemment, mais avec une inversion de valeur pour chaque segment.

Le code complet avec commentaires :

/**
* Exemple de code pour un unique afficheur 7 segments.
* Visite MEGMa.ma
*/

/* Broches des différents segments de l'afficheur */
const byte PIN_SEGMENT_A = 2;
const byte PIN_SEGMENT_B = 3;
const byte PIN_SEGMENT_C = 4;
const byte PIN_SEGMENT_D = 5;
const byte PIN_SEGMENT_E = 6;
const byte PIN_SEGMENT_F = 7;
const byte PIN_SEGMENT_G = 8;
const byte PIN_SEGMENT_DP = 9;

/* Décommenter si utilisation d'un afficheur 7 segments à ANODE commune */
//#define _7SEG_COMMON_ANODE

/* Table de correspondance valeur -> états des segments de l'afficheur */
const byte LUT_ETATS_SEGMENTS[] = {
0b00111111,
0b00000110,
0b01011011,
0b01001111,
0b01100110,
0b01101101,
0b01111101,
0b00000111,
0b01111111,
0b01101111,
0b01110111,
0b01111100,
0b00111001,
0b01011110,
0b01111001,
0b01110001
};

/** Fonction setup() */
void setup() {

/* Toutes les broches en sorties */
pinMode(PIN_SEGMENT_A, OUTPUT);
digitalWrite(PIN_SEGMENT_A, LOW);
pinMode(PIN_SEGMENT_B, OUTPUT);
digitalWrite(PIN_SEGMENT_B, LOW);
pinMode(PIN_SEGMENT_C, OUTPUT);
digitalWrite(PIN_SEGMENT_C, LOW);
pinMode(PIN_SEGMENT_D, OUTPUT);
digitalWrite(PIN_SEGMENT_D, LOW);
pinMode(PIN_SEGMENT_E, OUTPUT);
digitalWrite(PIN_SEGMENT_E, LOW);
pinMode(PIN_SEGMENT_F, OUTPUT);
digitalWrite(PIN_SEGMENT_F, LOW);
pinMode(PIN_SEGMENT_G, OUTPUT);
digitalWrite(PIN_SEGMENT_G, LOW);
pinMode(PIN_SEGMENT_DP, OUTPUT);
digitalWrite(PIN_SEGMENT_DP, LOW);
}

/** Fonction loop() */
void loop() {
static byte chiffre = 0;
static byte etat_dp = 0;

/* Affiche le chiffre */
affiche_chiffre_7seg(chiffre, etat_dp);

/* Incrémente le chiffre de 0 à 15 */
if (++chiffre == 16) {
chiffre = 0;
}

/* Fait clignoter le point décimal (inverse l'état à chaque fois) */
etat_dp = !etat_dp;

/* Délai pour la démo */
delay(1000);
}

/** Fonction permettant d'afficher un chiffre sur un afficheur 7 segments */
void affiche_chiffre_7seg(byte chiffre, byte dp) {

/* Simple sécurité */
if (chiffre > 15)
return; // Accepte uniquement des valeurs de 0 à 15.

/* Conversion chiffre -> états des segments */
byte segments = LUT_ETATS_SEGMENTS[chiffre];

/* Affichage */
#ifndef _7SEG_COMMON_ANODE
digitalWrite(PIN_SEGMENT_A, bitRead(segments, 0));
digitalWrite(PIN_SEGMENT_B, bitRead(segments, 1));
digitalWrite(PIN_SEGMENT_C, bitRead(segments, 2));
digitalWrite(PIN_SEGMENT_D, bitRead(segments, 3));
digitalWrite(PIN_SEGMENT_E, bitRead(segments, 4));
digitalWrite(PIN_SEGMENT_F, bitRead(segments, 5));
digitalWrite(PIN_SEGMENT_G, bitRead(segments, 6));
digitalWrite(PIN_SEGMENT_DP, dp);
#else
digitalWrite(PIN_SEGMENT_A, !bitRead(segments, 0));
digitalWrite(PIN_SEGMENT_B, !bitRead(segments, 1));
digitalWrite(PIN_SEGMENT_C, !bitRead(segments, 2));
digitalWrite(PIN_SEGMENT_D, !bitRead(segments, 3));
digitalWrite(PIN_SEGMENT_E, !bitRead(segments, 4));
digitalWrite(PIN_SEGMENT_F, !bitRead(segments, 5));
digitalWrite(PIN_SEGMENT_G, !bitRead(segments, 6));
digitalWrite(PIN_SEGMENT_DP, !dp);
#endif
}

L’extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l’emploi).


Plus d’information visite notre page Facebook.


Avis

Il n’y a pas encore d’avis.

Soyez le premier à laisser votre avis sur “AFFICHEUR 7 SEGMENT 1 BIT CATHODE”

Votre adresse e-mail ne sera pas publiée.

Tous les résultats de recherche
×