Utiliser un afficheur 7 segments avec une carte Arduino / Genuino

Old school, mais toujours aussi bon.

Image d'entête

par skywodd | | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino LED DEL Afficheur 7 segments


Dans ce tutoriel, nous allons voir ensemble comment utiliser un afficheur 7 segments avec une carte Arduino / Genuino. Nous étudierons le fonctionnement d'un afficheur 7 segments et son utilisation. En bonus, nous ajouterons un décodeur BCD vers 7 segments au montage, pour afficher des chiffres, sans avoir à faire de code compliqué.

Sommaire

Bonjour à toutes et à tous !

Vous avez tous déjà vu et même peut être utilisé des afficheurs 7 segments dans votre vie de tous les jours.

Exemple d'afficheur 7 segments in-situ

Un afficheur 7 segments dans son environnement naturel

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

Un afficheur 7 segments

Un afficheur 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 segments

Agencement d'un afficheur 7 segments

Les afficheurs 7 segments sont constitués de 7 segments, d'où leur nom. Ces segments sont nommés A, B, C, D, E 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 segments

Chiffres 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 ;)

Si on met côte à côté le schéma d'agencement des segments et l'état des segments pour chaque chiffre, on obtient le tableau suivant :

Digit

G

F

E

D

C

B

A

0

OFF

ON

ON

ON

ON

ON

ON

1

OFF

OFF

OFF

OFF

ON

ON

OFF

2

ON

OFF

ON

ON

OFF

ON

ON

3

ON

OFF

OFF

ON

ON

ON

ON

4

ON

ON

OFF

OFF

ON

ON

OFF

5

ON

ON

OFF

ON

ON

OFF

ON

6

ON

ON

ON

ON

ON

OFF

ON

7

OFF

OFF

OFF

OFF

ON

ON

ON

8

ON

ON

ON

ON

ON

ON

ON

9

ON

ON

OFF

ON

ON

ON

ON

A

ON

ON

ON

OFF

ON

ON

ON

B

ON

ON

ON

ON

ON

OFF

OFF

C

OFF

ON

ON

ON

OFF

OFF

ON

D

ON

OFF

ON

ON

ON

ON

OFF

E

ON

ON

ON

ON

OFF

OFF

ON

F

ON

ON

ON

OFF

OFF

OFF

ON

Gardez ce tableau sous le coude pour le moment, il sera utile un peu plus tard ;)

Question piège : cathode ou anode commune ?

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

Exemples 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.

Brochage standard d'un afficheur 7 segments à cathode commune et à anode commune

Brochage standard d'un afficheur 7 segments CC et CA

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

Photographie du matériel nécessaire à la réalisation du montage de démonstration pour un afficheur 7 segments

Matériel nécessaire

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

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

Vue schématique 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.

Photographie du montage de démonstration pour un afficheur 7 segments

Le montage fini

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, voici le câblage :

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

Vue prototypage du montage

Vue schématique du montage de démonstration pour un afficheur 7 segments (version CA)

Vue schématique du montage

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.

1
2
3
4
5
6
7
8
9
/* 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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
/* 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 ;)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
/** 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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
/** 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().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
/** 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é :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
/** 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 :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
/**
 * Exemple de code pour un unique afficheur 7 segments.
 */

/* 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).

Bonus : utilisation d'un décodeur BCD – 7 segments

Si je vous dis qu'il est possible de contrôler un afficheur 7 segments avec seulement 4 broches (5 si on compte le point décimal), ça parait impossible pas vrai ? Et bien c'est possible grâce à un petit circuit logique bien sympathique : le CD4511.

Photographie d'un circuit CD4511

Le CD4511

Le CD4511 est un décodeur BCD vers 7 segments (parfois appelé à tord "démultiplexeur 4 vers 7"). 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.

Le CD4511 ne peut afficher que des chiffres de 0 à 9. Il ne gère pas l'affichage de chiffres hexadécimaux.

PS Le codage BCD est un codage assez simple à comprendre : on prend un nombre quelconque, on le découpe en chiffres et on code chaque chiffre en binaire. Par exemple 123 donne 0001 0010 0011 en BCD (0001 = 1, 0010 = 2, 0011 = 3).

N.B. Il existe des variantes ayant d'autres références dans les séries des circuits CD4000 et 74HC. En cherchant "bcd to 7 segments decoder" sur google vous trouverez pas mal de références ;)

Brochage d'un circuit CD4511

Brochage d'un CD4511

Le CD4511 dispose :

  • d'une broche d'alimentation (VDD) et d'une masse (VSS),

  • de quatre broches de données, nommées A, B, C et D, correspondant à la valeur du chiffre à afficher (sur 4 bits),

  • de sept broches pour les 7 segments de l'afficheur,

  • de trois broches de contrôle permettant d'éteindre tous les segments (/BI), d'allumer tous les segments (/LT) ou de garder temporairement la valeur en mémoire (LE).

Table de vérité d'un circuit CD4511

Table de vérité du CD4511

Le principe de fonctionnement du CD4511 est le suivant :

  • Quand la broche /BI est à LOW, l'afficheur est complètement éteint.

  • Quand la broche /LT est à LOW, l'afficheur est complètement allumé.

  • Quand la broche LE passe de LOW à HIGH, la valeur sur les broches A, B, C et D est conservée en mémoire jusqu'à ce que la broche LE repasse à LOW.

  • Le reste du temps, l'afficheur affiche le chiffre correspondant à la valeur binaire sur les broches A, B, C et D.

N.B. Vous remarquerez que les valeurs des broches A, B, C et D entre 10 et 15 sont vides dans le tableau. Le CD4511 ne peut afficher que des chiffres de 0 à 9.

Le montage

Afin de comprendre le fonctionnement de ce circuit, on va modifier le montage du chapitre précédent pour y inclure un CD4511.

Photographie du matériel nécessaire à la réalisation du montage de démonstration pour un afficheur 7 segments avec un CD4511

Matériel nécessaire

Pour réaliser ce second 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,

  • Un décodeur BCD vers 7 segments de référence CD4511,

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

Vue schématique du montage de démonstration pour un afficheur 7 segments avec un CD4511

Vue schématique du montage

Vue prototypage du montage de démonstration pour un afficheur 7 segments avec un CD4511

Vue prototypage du montage

Pour commencer ce second 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"), comme pour le premier montage.

On câble ensuite une résistance de 1K ohms sur chaque segment de l'afficheur (voir brochage dans le chapitre en début d'article) puis à la correspondante du CD4511 au moyen d'un fil.

Photographie du montage de démonstration pour un afficheur 7 segments avec un CD4511

Le montage fini

Pour finir, il faudra câbler les broches restantes du CD4511 comme précisées ci-dessous :

Broche CD4511

Broche Arduino

VSS

GND

VDD

5V

LT

5V

BI

5V

LE

0V

A

2

B

3

C

4

D

5

On câblera le point décimal de l'afficheur à la broche D6 de la carte Arduino, sans oublier la résistance de 1K ohms en série entre la broche DP de l'afficheur et la carte Arduino.

PS Les broches Arduino pour les broches A, B, C, D et le point décimal 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.

Capture écran du câblage d'un afficheur 7 segments à anode commune avec un CD4511

Extrait de la fiche constructeur du CD4511

Le montage d'un CD4511 avec un afficheur à anode commune est beaucoup plus compliqué. Dans cette situation, il est nécessaire d'utiliser des transistors sur chaque broche de sortie du CD4511 pour inverser la logique d'allumage des segments.

Cette variante du montage ne sera pas étudiée dans cet article par souci de simplicité ;)

Le code

Le but de ce second code est similaire au premier : afficher des chiffres de 0 à 9 en boucle, tout en faisant clignoter le point décimal.

1
2
3
4
5
6
/* Broches du CD4511 et du point décimal de l'afficheur */
const byte PIN_CD4511_A1 = 2;
const byte PIN_CD4511_A2 = 3;
const byte PIN_CD4511_A3 = 4;
const byte PIN_CD4511_A4 = 5;
const byte PIN_SEGMENT_DP = 6;

Le code commence comme son petit frère avec les déclarations des constantes pour les broches A, B, C, D et DP du CD4511 et de l'afficheur.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
/** Fonction setup() */
void setup() {
  
  /* Toutes les broches en sorties */
  pinMode(PIN_CD4511_A1, OUTPUT);
  digitalWrite(PIN_CD4511_A1, LOW);
  pinMode(PIN_CD4511_A2, OUTPUT);
  digitalWrite(PIN_CD4511_A2, LOW);
  pinMode(PIN_CD4511_A3, OUTPUT);
  digitalWrite(PIN_CD4511_A3, LOW);
  pinMode(PIN_CD4511_A4, OUTPUT);
  digitalWrite(PIN_CD4511_A4, LOW);
  pinMode(PIN_SEGMENT_DP, OUTPUT);
  digitalWrite(PIN_SEGMENT_DP, LOW);
}

La fonction setup() place en sortie et à LOW chaque broche au moyen d'un appel à pinMode() et à digitalWrite().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
/** 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 à 9 */
  if (++chiffre == 10) {
    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);
}

Le code de la fonction loop() est un copier-coller du code précédent. La seule différence est que l'incrémentation de la valeur du chiffre limite la valeur maximum à 9 au lieu de 15.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
/** Fonction permettant d'afficher un chiffre sur un afficheur 7 segments */
void affiche_chiffre_7seg(byte chiffre, byte dp) {

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

  /* Affichage */
  digitalWrite(PIN_CD4511_A1, bitRead(chiffre, 0));
  digitalWrite(PIN_CD4511_A2, bitRead(chiffre, 1));
  digitalWrite(PIN_CD4511_A3, bitRead(chiffre, 2));
  digitalWrite(PIN_CD4511_A4, bitRead(chiffre, 3));
  digitalWrite(PIN_SEGMENT_DP, dp);
}

Le code de la fonction affiche_chiffre_7seg() est aussi très similaire à la version précédente. Le code vérifie que la valeur du chiffre est inférieure ou égale à 9 et envoie en binaire cette valeur sur les broches A, B, C et D, sans conversion ou autre.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/**
 * Exemple de code pour un unique afficheur 7 segments avec un décodeur BCD vers 7 segments CD4511.
 */

/* Broches du CD4511 et du point décimal de l'afficheur */
const byte PIN_CD4511_A1 = 2;
const byte PIN_CD4511_A2 = 3;
const byte PIN_CD4511_A3 = 4;
const byte PIN_CD4511_A4 = 5;
const byte PIN_SEGMENT_DP = 6;


/** Fonction setup() */
void setup() {
  
  /* Toutes les broches en sorties */
  pinMode(PIN_CD4511_A1, OUTPUT);
  digitalWrite(PIN_CD4511_A1, LOW);
  pinMode(PIN_CD4511_A2, OUTPUT);
  digitalWrite(PIN_CD4511_A2, LOW);
  pinMode(PIN_CD4511_A3, OUTPUT);
  digitalWrite(PIN_CD4511_A3, LOW);
  pinMode(PIN_CD4511_A4, OUTPUT);
  digitalWrite(PIN_CD4511_A4, 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 à 9 */
  if (++chiffre == 10) {
    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 > 9)
    return; // Accepte uniquement des valeurs de 0 à 9.

  /* Affichage */
  digitalWrite(PIN_CD4511_A1, bitRead(chiffre, 0));
  digitalWrite(PIN_CD4511_A2, bitRead(chiffre, 1));
  digitalWrite(PIN_CD4511_A3, bitRead(chiffre, 2));
  digitalWrite(PIN_CD4511_A4, bitRead(chiffre, 3));
  digitalWrite(PIN_SEGMENT_DP, dp);
}

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).

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.