Afficheur à LED - 4 digits

Dans un article précédent l'utilisation d'un afficheur LED à 7 segment avait été présentée. Cet composant permet d'afficher un chiffre. Mais il est très rare qu'un seul chiffre suffise pour satisfaire le besoin d'un projet. Aussi existe-t-il des composants similaires regroupant 4 digits. Comme pour les afficheurs à un seul digit, les chiffres sont composés de 7 segments LED (plus un point). Comme c'est soit l'anode, soit la cathode qui est partagée pour réduire le brochage, il est important de consulter la documentation technique avant d'effectuer le câblage.

Dans cet article, le composant utilisé est un afficheur 5641AS à cathodes communes.

Câblage d'un afficheur LED à 4 digits

Brochage de l'afficheur 5641AS

Le brochage de l'afficheur 5641DS est résumé dans le tableau ci-dessous :

N°	Nom	Description
1	e	Segment E.
2	d	Segment D.
3	DP	Point DP.
4	c	Segment C.
5	g	Segment G.
6	GND4	Cathode commune digit 4.
7	b	Segment B.
8	GND3	Cathode commune digit 3.
9	GND2	Cathode commune digit 2.
10	f	Segment F.
11	a	Segment A.
12	GND1	Cathode commune digit 1.

Schéma interne de l'afficheur 5641AS

Lorsqu'on consulte la documentation technique du composant 5641AS, on constate, qu'en fait, il s'agit d'une juxtaposition d'afficheurs à 7 segments, dont les anodes relaves aux segments de même rang sont reliées entre elles. Cela simplifie le câblage certes. Mais cela induit qu'en alimentant à +5V l'un des segment, les segments de même rang vont s'allumer sur les quatre chiffres.

Or, on n'utilise pas un afficheur à quatre digits pour afficher la même chose sur les quatre chiffres. Il va falloir établir un système électronique qui permette de discriminer les quatre chiffres.

L'astuce consiste à afficher en boucle un chiffre après l'autre en ne laissant passer le courant sur la cathode que pour un chiffre à la fois et en modifiant l'alimentation des anodes afin que pour chaque digit, le bon chiffre soit affiché. Lorsque la cathode est connectée à la masse, le chiffre s'affiche, lorsqu'elle est déconnectée, le chiffre s'éteint. Si la boucle est très rapide, le clignotement n'est pas perceptible grâce à la persistance rétinienne.

Discrimination du chiffre à afficher

Le problème est de disposer d'un interrupteur électroniquement pilotable. Pour cela, on va utiliser un transistor S8050 NPN.

Un transistor possède trois broches nommées respectivement Émetteur, Base et Collecteur. Ces trois broches sont reliées à trois éléments constitués d'un cristal semi-conducteur dopé N (comme négatif) ou P (comme positif). La jonction électronique entre un cristal dopés P et un cristal dopé N définit le comportement passant ou non passant du courant dans la jonction. C'est ce qui se passe pour une diode ou deux cristaux dopés respectivement N et P laisse passer le courant dans un sens mais pas dans l'autre. Le transistor a la caractéristique que le courant ne peut passer entre l'émetteur et le collecteur que si la base est alimentée.

Pour les transistors PNP, le courant circule de l'émetteur vers le collecteur lorsque la tension de la base est supérieure à celle du collecteur. Pour les transistors NPN (c'est le cas du S8050), le courant circule du collecteur vers l'émetteur lorsque la tension de la base est supérieure à celle de l'émetteur.

De cette façon, le transistor fonctionne comme un interrupteur télécommandé par la tension fournie sur la base.

Pour chaque digit, la cathode est reliée au collecteur d'un transistor (Q1 à Q4) à travers une résistance de 220 Ω (R5 à R8) pour protéger les segments de LED des surtensions.
L'émetteur des transistors est connecté à la masse (GND de l'Arduino).
La tension fournie sur la base CMDx de chaque transistor, détermine si le courant entre le collecteur vers l'émetteur est passant.
La base des transistors est protégée par une résistance de 1 KΩ (R1 à R4).

Câblage final du projet

Pour afficher un digit x donné, il faut positionner une tension positive sur les anodes adéquate pour le chiffre à afficher et positionner une tension sur la base CMDx du transistor qui commande la cathode du digit. Par programmation, en modifiant très vite, dans la boucle loop(), les tensions des anodes de chaque digit successivement en fonction de chiffre à afficher et en positionnant une tension positive alternativement sur la cathode de chaque chiffre, on aura l'impression que l'affichage est constant sur tous les digits, grâce à la persistance rétinienne.

Cela nécessite de monopoliser quatre pins de sortie supplémentaires pour déterminer le digit à afficher à chaque itération. Plutôt que d'utiliser les sorties de l'Arduino, il est préférable d'appliquer la technique de chaînage de convertisseur Série/Parallèle 74HC595 déjà abordée dans l'article sur le pilotage de 16 diodes. Le premier 74HC595 pilote les anodes des segments LED communes à tous les digits, le second pilote les bases des transistors de commande des cathodes pour déterminer le digit à alimenter.

Cette manière d'opérer permet de ne monopoliser que trois pins de sortie de l'Arduino. Et, pour chaque 74HC595 de plus utilisé, deux modules de 4 digits supplémentaires peuvent être pilotés.

Ce qui donne le schéma final suivant :

A remarquer que dans ce schéma, on ne mobilise que 4 pins de sortie du deuxième 74HC595. On pourrait y connecteur un second module 5641AS pour piloter en tout 8 digits. Pour cela il suffirait de interconnecter les anodes relatives aux segments de même rang et piloter les quatre nouvelles cathodes avec quatre transistors supplémentaires. A remarquer également, que l'on peut remplacer le module 5641AS par quatre (ou plus) aficheurs 7-segments 5161AS en procédant de même.

Voici ce schéma mis en oeuvre sur une platine d'expérimentation :

Définition de la classe LedDisplayNDigits

La classe LedDisplayNDigits permet de gérer plusieurs digits d'affichage. Elle s'appuie sur la classe IC74hc595M pour gérer la conversion Série/Parallèle. Cette dernière pouvant prendre en charge 4 74HC595, outre les 8 sorties servies par le premier pour les anodes des afficheurs, les trois autres 74HC595 délivrent 24 sorties parallèles pour les cathodes. La classe LedDisplayNDigits permet donc potentiellement de prendre en charge 24 digits d'affichage.

/* 1 */
#ifndef LedDisplayNDigits_h
#define LedDisplayNDigits_h
/* 2 */
#include "Component.h"
#include "IC74hc595M.h"

/* 3 */
class LedDisplayNDigits : Component {
/* 4 */
IC74hc595M __IC74hc595;
uint8_t __countDigit;
uint8_t *__digits;
uint8_t __posDigit;
static byte DIGITS[16];

public:
/* 5 */
LedDisplayNDigits(uint8_t, uint8_t, uint8_t, uint8_t);
/* 6 */
~LedDisplayNDigits();
/* 7 */
void begin();
void loop();
/* 8 */
void displayDigit(uint8_t, uint8_t);
void setDot(bool, uint8_t);
void clear();
/* 9 */
void displayDecimal(uint32_t);
void displayHexa(uint32_t);
};

#endif // LedDisplayNDigits_h

Application de la bonne pratique consistant à définir les classes d'une bibliothèque entre deux directives #ifndef et #endif en prévention de multiples définitions dans les projets composites.
Inclusion de la définition des autres composants utilisés :

Comme toutes les classes relatives à des composants électroniques, la classe LedDisplayNDigits implémente l'interface Component. Le fichier Component.h doit donc être inclus par la directive #include.
La classe possède un attribut prive de classe IC74hc595M. Le fichier IC74hc595M.h doit également être inclus par la directive #include.

La classe LedDisplayNDigits implémente l'interface Component. Ce qui l'oblige à implémenter les méthodes membres begin() et loop().
Déclaration des attributs privés :

L'attribut __IC74hc595 est une instance de la classe IC74hc595M. Cette classe permet de gérer quatre convertisseurs 74HC595. Pour la classe LedDisplayNDigits , il en faut au moins deux : le premier est utilisé pour piloter les anodes des segments des digits, le second est utiliser pour discriminer les cathodes. Avec un seul afficheur à 4 digit, seulement quatre sorties du deuxième 74HC595 sont utilisées sur les huit disponibles. Avec deux 74HC595, il est donc possible de prendre en charge deux modules de 4 digits. La classe IC74hc595M pouvant gérer quatre 74HC595, il est donc possible de piloter 24 digits.
__countDigit contient le nombre de digits pilotés par l'instance. Ce nombre ne peut dépasser 24.
__digits est l'adresse d'un tableau d'entier non signés sur 8 bits. Ce tableau contient la valeur respective de chaque chiffre affiché sur le digit de rang i. Ce tableau est construit dynamiquement par un appel à l'opérateur new à la construction de l'instance en fonction du paramètre countDigit. Il doit donc être supprimé explicitement dans le destructeur de la classe.
__posDigit est un attribut de travail pour la boucle loop() chargée d'activer alternativement chaque digit. Il contient le rang du digit en cours d'affichage.
Le tableau DIGIT est déclaré en constante de classe static. Il contient la définition, pour chaque chiffre hexadécimal, des segments de l'afficheur qui doivent être activés.

Le constructeur de la classe LedDisplayNDigits reçoit trois paramètres correspondant aux pins du 74HC595 Data, Latch et Clock mobilisées sur l'Arduino. Celles-ci sont transmises au constructeur de l'instance __IC74hc595. Le quatrième paramètre countDigit est le nombre de digit que doit prendre en charge l'instance.
Le constructeur de la classe LedDisplayNDigits crée dynamiquement le tableau pointé par __digits par un appel à l'opérateur new. Elle doit donc implémenter un destructeur ~LedDisplayNDigits pour supprimer explicitement ce tableau par un appel à l'opérateur delete.
La classe LedDisplayNDigits implémentant l'interface Component, elle doit implémenter les méthodes begin() et loop().

La méthode begin() doit être invoquée soit dans la fonction setup() du sketch Arduino, soit dans la méthode begin() du composite utilisant l'afficheur LED.
La méthode loop() est utiliser pour diffuser l'affichage chaque digit alternativement en activant sa cathode. Elle doit être invoquée soit dans la fonction loop() du sketch Arduino, soit dans la méthode loop() du composite utilisant l'afficheur LED.

La classe LedDisplayNDigits expose trois méthodes publiques pour gérer l'affichage :

diplayDigit() affiche le chiffre passé en premier paramètre à la position indiquée par le second paramètre.
setDot() modifie la LED DP (le point en bas à droite de l'afficheur) du digit dont la position est passée en second paramètre. Si le premier paramètre est true, la LED DP s'allume. L'état des autres LED du digit n'est pas modifié par cette méthode.
clear() éteint toutes les LEDs de tous les digits, y compris la LED DP.

La classe LedDisplayNDigits expose également deux méthodes pour afficher des nombres.

displayDecimal() affiche le nombre passé en paramètre en décimal.
displayHexa() affiche le nombre passe en paramètre en hexadécimal.

Implémentation de la classe LedDisplayNDigits

Implémentation du tableau DIGITS.

Le tableau DIGITS est un tableau de 16 entiers non signés de type byte (sur 8 bits). Ces trains de bits sont transmis en Série au 74HC595 qui position ses sorties parallèles pour activer les segments indiqué, chaque position de bit correspondant à un segment LED de l'afficheur. Le bit de poids le plus fort est toujours à 0 car 7 segments suffisent pour afficher un chiffre. Le huitième bit est néanmoins utilisable car il correspond à la pin DP de l'afficheur (la LED du point en bas à droite de l'afficheur). Le bit de poids le plu faible (celui le plus à droite) correspond à la LED a.

byte SegmentLedDisplay::DIGITS[16] = {
B00111111, // 0
B00000110, // 1
B01011011, // 2
B01001111, // 3
B01100110, // 4
B01101101, // 5
B01111101, // 6
B00000111, // 7
B01111111, // 8
B01101111, // 9
B01110111, // A
B01111100, // B
B00111001, // C
B01011110, // D
B01111001, // E
B01110001 // F
};

Constructeur de la classe LedDisplayNDigits

Les circuits 74HC595 mobilisent trois pins de l'Arduino. Les numéros de ces trois pins sont passés en paramètre du constructeur de la classe LedDisplayNDigits. Ces trois paramètres sont transmis au constructeur de l'instance __IC74hc595.

dataPin est le numéro de la pin de l'Arduino utilisée pour le flux de données. Cette pin doit être reliée à la pin DS (n°14) du 74HC595.
latchPin est le numéro de la pin de l'Arduino utilisée pour valider le flux de données. Cette pin doit être reliée à la pin ST_CP (n°12) du 74HC595.
clockPin est le numéro de la pin de l'Arduino utilisée pour valider le flux de données. Cette pin doit être reliée à la pin SH_CP (n°11) du 74HC595.

Le quatrième paramètre countDigit est le nombre de digit piloté par l'instance. Ce nombre ne peut pas dépasser 24.

LedDisplayNDigits::LedDisplayNDigits(uint8_t dataPin, uint8_t latchPin, uint8_t clockPin, uint8_t countDigit)
: __IC74hc595(dataPin, latchPin, clockPin, (countDigit / 8) + 2)
{
this->__posDigit = 0;
this->__countDigit = countDigit;
this->__digits = new uint8_t[countDigit];
for (int i = 0; i < countDigit; i++) {
this->__digits[i] = 0;
}
}

Le trois numéros de pins, reçus en paramètres, sont transmis au constructeur de l'instance __IC74hc595.
L'attribut privé __posDigit est utilisé par la boucle loop() pour activer les cathodes des digits alternativement. Il contient le rang du digit activé. La boucle loop() commence par le digit de rang 0.
Le paramètre countDigit est archivé dans un attribut privé __countDigit. Il contient le nombre de digits piloté par l'instance.
Le tableau pointé par l'attribut __digits est créé dynamiquement par un appel à l'opérateur new. La taille du tableau créé dépend du paramètre countDigit passé. Ce tableau contient la valeur du chiffre de chaque digit affiché.
Les valeurs des chiffres affichés du tableau sont initialisées à 0. En effet, quand un tableau est créé dynamiquement par new, les valeurs qu'il contient dépend du contenu de la mémoire utilisée qui peut ne pas être nul.

Destructeur de la classe LedDisplayNDigits

A la construction des instances de la classe LedDisplayNDigits, le tableau point par l'attribut privé __digits est créé dynamiquement par l'opérateur new. Sa taille est variable et dépend du paramètre countDigit passé. Comme, le C++ ne dispose pas de Garbage Collector (ramasse-miette), le tableau créé dynamiquement par new, doit être explicitement supprimé par delete[]. Le destructeur permet de supprimer explicitement ce tableau.

LedDisplayNDigits::~LedDisplayNDigits() {
delete [] this->__digits;
}

Méthode begin()

La méthode begin() est héritée de l'interface Component qui définit un polymorphisme sur tous les composants C++ en les obligeant à implémenter les méthodes begin() et loop(). Cette méthode doit être invoquée soit dans la méthode setup() du sketch Arduino, soit dans la méthode begin() des composites qui utilisent ce composant.

void LedDisplayNDigits::begin() {
this->__IC74hc595.begin();
}

Cette méthode d'un objet composite doit invoquer la méthode begin() de ses composant. Dans le cas de la classe LedDisplayNDigits, elle invoque la méthode begin() de l'instance __IC74hc595 pour initialiser les 74HC595.

Méthode loop()

Dans la classe LedDisplayNDigits, la méthode loop() sert à activer alternativement chaque digit. En effet, toutes les anodes relative aux segments de même rang sont interconnectées. Si toutes les cathodes des digits étaient reliées à la masse (GND de l'Arduino), tous les digits afficheraient la même valeur. C'est pourquoi il ne faut activer la cathode que d'un seul digit à la fois et basculer d'une cathode à l'autre très vite, la persistance rétinienne permettant de percevoir l'affichage simultané de tous les digits.
Pour que cela fonctionne la méthode loop() doit être invoquée soit dans la méthode loop() du sketch Arduino, soit dans la méthode loop() des composites qui utilisent ce composant.

void LedDisplayNDigits::loop() {
this->__IC74hc595.write((0x100 << this->__posDigit) + this->__digits[this->__posDigit]);
this->__posDigit++;
if (this->__posDigit >= this->__countDigit) this->__posDigit = 0;
delay(1);
}

La pin de sortie de la cathode d'un digit dépend de la valeur de travail __posDigit contenant la position du digit affiché pour l'itération en cours. Le rang de la pin de la cathode est à activée est prise en charge par le deuxième 74HC595. Il doit être positionné dans l'octet de poids fort transmis au registre à décalage (d'où la valeur 0x100). Afin d'activer la bonne cathode, la valeur subit un nombre de décalage vers la gauche qui dépend de la position du digit.
La valeur du chiffre à afficher est contenue dans le tableau __digits. La somme de cette valeur contenue dans l'octet de poids faible et de la position de la pin de la cathode contenue dans l'octet de poids fort correspond à la valeur sur deux octets à transmettre aux registres à décalage 74HC595 par l'invocation de la méthode write().
L'attribut __posDigit est incrémenté. Comme sa valeur ne peut dépasser __countDigit, il repasse à 0 en cas de dépassement.
Un délai de 1 ou 2 ms est nécessaire pour stabiliser l'affichage pour éviter d'avoir l'impression que des segments parasites s'affichent.

Méthode publique displayDigit()

La méthode displayDigit() affiche le chiffre dont la valeur digit est passée en paramètre. En principe, digit doit avoir une valeur de 0 à 15. Cependant comme le paramètre digit est passé sur 8 bits, celui-ci est tronqué sur 4 bits pour ne pas provoquer une erreur de dépassement sur la table DIGITS dont la taille est limitée à 16.

void LedDisplayNDigits::displayDigit(uint8_t digit, uint8_t pos) {
this->__digits[pos] = (this->__digits[pos] & 0x80) | DIGITS[digit & 0x0F];
}

Les 7 bits de poids faible contenu __digits[pos], qui correspondent aux 7 segments d'affichage des chiffres, sont d'abord sont positionnés à 0 pour préserver l'état de la LED DP correspondant au bit de poids fort.
digit, tronqué sur les quatre bits de poids le plus faible, correspond à l'index du trains de bits à transmettre via le 74HC595, dans le tableau DIGITS. .
A la fin, l'attribut __digits[pos] contient l'état des 8 LEDs de l'afficheur, l'état de la LED DP n'ayant pas été modifié par cette méthode.
Il n'a pas nécessaire de faire autre chose que de modifier la __digits[pos] pour un digit donné, puisque l'écriture sur les 74HC595 est prise en charge par la méthode loop().

Méthode publique setDot()

La méthode setDot() permet de modifier l'état de la diode DP (le point situé en bas à droite de l'afficheur) sans modifier l'état des autres LEDs. Si le paramètre passé vaut true, le point s'allume.

void LedDisplayNDigits::setDot(bool dotDisplayed, uint8_t pos) {
this->__digits[pos] = (this->__digits[pos] & 0x7F) | (dotDisplayed ? 0x80 : 0);
}

Les 7 bits de poids faible de l'attribut __digits[pos] sont sauvegardés pour préserver l'affichage du chiffre en cours.
Le huitième bit est position à 1 ou à 0 en fonction du paramètre dotDisplayed.
A la fin, l'attribut __digits[pos] contient l'état à jour des 8 LEDs du digit.
Il n'a pas nécessaire de faire autre chose que de modifier la __digits[pos] pour un digit donné, puisque l'écriture sur les 74HC595 est prise en charge par la méthode loop().

Méthode publique clear()

La méthode clear() éteint toutes les LEDs de l'afficheur en transmettant un train de 8 bits à 0.

void LedDisplayNDigits::clear() {
for (int i = 0; i < this->__countDigit; i++) {
this->__digits[i] = 0;
}
}

Chaque élément du tableau __digits est mis à 0.
La boucle loop() affichera successivement la valeur sur tous les digits pris en charge.
A la fin, toutes les sorties du 74HC595 sont à 0. Donc les digits sont éteints.

Méthode publique displayHexa()

La méthode displayHexa() affiche le nombre number passé en paramètre au format hexadécimal.

void LedDisplayNDigits::displayHexa(uint32_t number) {
for (int i = 0; i < this->__countDigit; i++) {
this->displayDigit(number & 0x000F, i);
number >>= 4;
}
}

Pour chaque digit :

La valeur du chiffre à afficher est constituée par les 4 bits de poids faible.
Cette valeur est affichée en invoquant la méthode displayDigit().
number est alors décalé de 4 bits vers la droite. Ce qui fait qu'à l'itération suivante les quatre bits de poids faible seront la valeur du chiffre suivant.

Méthode publique displayDecimal()

La méthode displayDecimal() affiche le nombre number passé en paramètre au format décimal..

void LedDisplayNDigits::displayDecimal(uint32_t number) {
for (int i = 0; i < this->__countDigit; i++) {
this->displayDigit(number % 10, i);
number /= 10;
}
}

Pour chaque digit :

La valeur du chiffre à afficher est le reste de la division de number par 10.
Cette valeur est affichée en invoquant la méthode displayDigit().
number est alors divisé par 10. Ce qui fait qu'à l'itération suivante le reste de la division par 10 sera la valeur du chiffre suivant.

Utilisation de la classe LedDisplayNDigits dans un sketch Arduino

L'utilisation de la classe LedDisplayNDigits dans un sketch Arduino s'effectue comme pour tous les autres composants présentés sur ce blog. Dans l'exemple ci-dessous, les nombres de 1 à n s'affichent successivement sur un afficher à 4 digits toutes les 100 ms.

/* 1 */
#define IC_DATA 2
#define IC_LATCH 3
#define IC_CLOCK 4

/* 2 */
#include "LedDisplayNDigits.h"

/* 3 */
LedDisplayNDigits ledDisplay(IC_DATA, IC_LATCH, IC_CLOCK, 4);

/* 4 */
uint32_t millis0;
uint16_t number;

/* 5 */
void setup() {
ledDisplay.begin();
number = 0;
}

/* 6 */
void loop() {
ledDisplay.loop();
uint32_t now = millis();
if ((now - millis0) > 100) {
ledDisplay.displayDecimal(number);
//ledDisplay.displayHexa(number);
number++;
millis0 = now;
}
}

Il est d'une bonne pratique que de déclarer en constantes les numéros de pins utilisées tant sur l'Arduino que sur les circuits 74HC595 :

IC_DATA est le numéro de pin de l'Arduino sur laquelle est connectée la pin Data du premier 74HC595.
IC_LATCH est le numéro de pin de l'Arduino sur laquelle est connectée la pin Latch des 74HC595.
IC_CLOCK est le numéro de pin de l'Arduino sur laquelle est connectée la pin Clock des 74HC595.

Le sketch utilisant la classe LedDisplayNDigits, la définition de celle-ci doit être incluse par une directive #include.
La classe LedDisplayNDigits est instanciée par la variable ledDisplay à laquelle on passe les numéros de pins sur lequel est connecté le 74HC595 dans l'ordre exigé par le constructeur. On précise que quatre digits sont pris en charge.
Trois variables de travail sont déclarées :

millis0 est l'origine des temps utilisée pour rythmer le fonctionnement de la fonction loop().
number est le nombre qui doit être affiché sur l'afficheur LED.

L'instance ledDisplay est initialisée dans la méthode setup() en invoquant sur celle-ci la méthode bégin(). Les trois variables de travail et l'instance ledDisplay sont initialisées respectivement :

millis0 est initialisée à 0.
digit est initialisée à 0.
dot est initialisée à false.
L'afficheur est réinitialisé à 0 (toutes LEDs éteintes), en invoquant la méthode clear() sur l'instance ledDisplay au cas où il y aurait un reliquat indésirable de l'état des pins de sortie du 74HC595.

La fonction loop() fonctionne comme ceci. Pour chaque itération :

La boucle loop() est invoquée sur le composant ledDisplay. A chaque itération un digit différent est affiché.
Le temps est lu par la méthode millis() et affecté à la variable locale now.
La fonction loop() est rythmée sur un cycle de 100ms. S'il s'est déroulé plus 100 ms depuis la dernière modification de millis0,

Le nombre number est affiché en invoquant la méthode displayDecimal() sur l'instance ledDisplay. A remarquer que l'instruction invoquant displayHexa() est mise en commentaire et peut remplacer displayDecimal().
number est incrémenté.
millis0 prend alors la valeur de now.

Conclusion

Ainsi s'achève la mise en oeuvre d'un afficheur à 4 digits 5641AS avec deux 74HC595 en ne monopolisant que trois pins sur l'Arduino. A noter que n'importe quel afficheur peut être piloté avec la classe LedDisplayNDigits, la distinction ne se faisant que sur la partie électronique et le câblage. Il faut juste s'assurer que les anodes relatives à chaque segment de même rang soit interconnectées. Les cathodes contrôlent chaque digit et sont commandées par un transistor NPN.
Dans le cas où c'est l'anode qui est commune à tous les segments d'un digit, ce sont les cathodes relatives aux segments de même rang qui doivent être interconnectées. Les anodes qui contrôlent chaque digit sont alors commandées par un transistor PNP.
La classe LedDisplayNDigits peut aussi piloter plusieurs modules afficheur LED à un ou à quatre digits en C++. Le nombre de digits cumulés peut aller jusqu'à 24. Il suffit de chaîner le nombre de convertisseur 74HC595 qui convient gérés par la classe IC74hc595M. Les 8 sorties du premier 74HC595 sont utilisées pour les segment de LEDs. Le second peut prendre en charge de 1 à 8 digits. A chaque 74HC595 ajoutés, 8 digits supplémentaires peuvent être pilotés.

Applications Arduino