Lorsque l'on bricole sur ARDUINO, on pilote souvent des capteurs, des relais, des modules de communication, mais il arrive que l'on ait aussi besoin d'afficher des informations et même d'en obtenir de la part de l'utilisateur.
Cet article tente d'explorer le monde des afficheurs à LED, LCD, OLED et TFT utilisables sur nos chers petits microcontrôleurs.
1.1. La LED simple
Commençons par le plus simple :
Une LED peut être commandée directement par une sortie de microcontrôleur, pour peu que l'on respecte le courant de sortie maximal que la sortie peut produire.
Une LED a toujours besoin d'une résistance de limitation de courant :
La résistance R1 peut être calculée comme suit :
R1 = (VCC - VF) / I
- VCC est la tension d'alimentation
- VF est la chute de tension directe de la LED
- I est le courant circulant dans la LED
Attention : la tension VF varie beaucoup en fonction de la couleur et du courant :
Les LEDs simples admettent en général un courant maximal de 20mA, mais il est rare de les faire fonctionner au maximum de leur capacité.
Par exemple une carte ARDUINO PRO MINI est équipée d'une LED POWER en série avec une résistance de 10KΩ. Le courant est donc de :
I = (VCC - VF) / 10000 = (5V - 1.5V) / 10000 = 0.35 mA.
Malgré ce courant assez faible, la LED est parfaitement visible.
1.2. La LED multicolore
Une LED multicolore, 3 ou 4 couleurs, est un assemblage de plusieurs LEDs :
Celle-ci est une LED RGB à anode commune. On trouve les deux modèles, anode ou cathode commune.
Le schéma ci-dessous montre une LED RGB à cathode commune :
Chaque LED ayant une tension VF différente, les résistances R1 à R3 auront forcément une valeur différente.
1.3. Les LEDs de puissance
Une LED de puissance est utilisée lorsqu'une puissance d'éclairage conséquente est nécessaire :
 |
| LED 1W |
Elle nécessite également une résistance de limitation de courant.
On peut trouver des bandeaux de LEDs de puissance :
Ces bandeaux sont déjà équipés de résistances de limitation de courant. On trouve des modèles pouvant être alimentés sous 5V ou 12V.
Qu'il s'agisse de LEDs ou de bandeaux de LEDs, on ne pourra pas alimenter ces composants à l'aide d'une sortie de microcontrôleur. Il faudra forcément adopter une alimentation adaptée et un organe de commande de puissance : transistor, MOSFET, ou relais.
1.4. La LED adressable
Les LEDs adressables peuvent être reliées entre elles sur le même bus, et commandées une par une. La plus courante est la WS2812B :
 |
| WS2812B |
Elles existent également sous forme de bandeaux :
 |
| Bandeau WS2812B |
On peut faire varier leur couleur et leur luminosité à l'aide de quelques ligne de code.
L'avantage de ces LEDs est qu'elles peuvent être commandées à l'aide d'une seule sortie de microcontrôleur. L'alimentation devra être dimensionnée correctement, car chacune d'elles peut consommer jusqu'à 3 x 20mA.
Voici le schéma généralement utilisé :
Il existe des librairies capables de piloter ces LEDs :
Ces LEDs ont toutefois un inconvénient : il faut rafraîchir leur état en continu. Elles sont peu adaptées à des applications ayant des temps de traitement bloquants plus ou moins longs, ou aux applications multitâche.
Un autre type de LED adressable existe : l'APA102. Elle est autonome et mémorise l'état de ses 3 couleurs. Il suffit de lui envoyer l'ordre de changement de couleur et luminosité une seule fois.
Leur aspect est le même que celui des WS2812B mais elles ont 6 broches :
Elles existent également sous forme de bandeau.
Des librairies spécialisées existent également :
Dans le premier cas, les anodes des LEDs sont reliées entre elles.
Dans le deuxième cas, les cathodes des LEDs sont reliées entre elles.
La plupart des contrôleurs spécialisés vous permettront de vous passer de ces résistances.
Supposons que nous pilotions les segments à l'aide de 8 résistances connectées sur 8 sorties d'un ARDUINO et que les digits soient multiplexés également à l'aide de 4 sorties du même ARDUINO.
Chaque sortie de pilotage de segment devra supporter le courant d'un segment à la fois. Chaque sortie de pilotage de digit devra fournir au maximum 8 fois le courant d'un segment.
Une sortie peut délivrer 20mA sans que la tension ne chute dramatiquement.
Cela donnera donc 20mA / 8 = 2.5mA pour chaque segment.
La tension directe d'une LED rouge est de 1.8V, ce qui donne aux bornes de la résistance : 5V - 1.6V = 3.4V.
Chaque résistance aura comme valeur : 3.4V / 2.5mA = 1.36KΩ.
Le rendement lumineux des afficheurs est important, 2.5mA suffisent dans la majeure
partie des cas. Au delà il faudra ajouter un transistor sur chaque
anode ou cathode commune.
Pilotage direct
Il est possible de piloter un afficheur 7 segments directement à partir des sorties d'un ARDUINO :
Ce montage mobilise 12 broches de la carte. Cela peut être gênant. Mais il est possible d'utiliser quelques pins analogiques en lieu et place de pins digitales.
Les quatre afficheur sont multiplexés à grande vitesse, c'est à dire que chacun d'eux est alimenté à tour de rôle, et comme la rémanence de l’œil humain est importante, le clignotement est imperceptible.
Ce genre de montage est particulièrement intéressant dans le cas où l'on dispose de 12 broches libres, car il ne nécessite que huit résistances et aucun autre composant externe.
Il existe une excellente librairie :
https://github.com/sigvaldm/SevenSeg
Cette librairie vous soulagera d'un grosse partie du travail :
Elle fonctionne avec des afficheurs à anode ou cathode commune. Le nombre de digits est simplement limité par le nombre de pins de votre carte (9 digits pour une UNO ou une NANO).
Un petit sketch :
#include <TimeLib.h>
#include <SevenSeg.h>
#define NDIGITS 4
SevenSeg disp(5, 3, 6, 9, 10, 4, 8);
const int digitPins[NDIGITS] = {A2, A1, A0, A3};
void setup() {
disp.setDigitPins(NDIGITS, digitPins);
disp.setCommonAnode();
disp.setTimer(2);
disp.startTimer();
disp.setDPPin(7);
disp.clearDisp();
disp.setRefreshRate(50);
disp.setDutyCycle(40);
}
void loop() {
setTime(14, 33, 05, 7, 2, 2019);
time_t t = now();
disp.writeClock(hour(t), minute(t));
delay(1000);
disp.write(1359);
for (int i = 0 ; i < 100 ; i++) {
disp.setDutyCycle(i);
delay(50);
}
for (int i = 100 ; i > 0 ; i--) {
disp.setDutyCycle(i);
delay(50);
}
disp.setDutyCycle(50);
disp.write(1);
delay(1000);
disp.write(33);
delay(1000);
disp.write(212);
delay(1000);
disp.write(3456);
delay(1000);
disp.write(0.1);
delay(1000);
disp.write(0.1234);
delay(1000);
disp.write(34.56);
delay(1000);
disp.write("Done");
delay(1000);
}
ISR(TIMER2_COMPA_vect) {
disp.interruptAction();
}
Le CD4511
Le
CD4511 permet de piloter les segments d'un afficheur à cathode commune :
Ce montage mobilise 10 broches de la carte, soit deux de moins que le montage précédent. Si l'on se passe de réglage de la luminosité on a besoin de 9 broches.
Il est possible de faire varier la luminosité en jouant sur le rapport cyclique de chaque digit à l'aide de la pin BL (blank) du CD4511.
Les
quatre afficheur sont multiplexés. Chaque sortie de l'ARDUINO (D7 à D10) est capable de fournir 20mA, ce qui implique que chaque segment ne pourra recevoir que 20mA / 8 = 2.5mA. Si l'on a besoin de plus de courant on peut insérer un petit transistor NPN entre les sorties D7 à D10 et chaque cathode :
Par rapport à la solution précédente, très souple, une solution à base de CD4511 souffre de pas mal de lacunes :
- pas d'affichage de nombres négatifs
- pas de gestion du point décimal ni de la colonne
- pas d'affichage de caractères alphabétiques
- peu de librairies, ou des librairies pauvres en fonctionnalités
Aucune librairie ne gère le multiplexage. Certaines permettent de gérer un CD4511 par afficheur.
Il serait possible d'écrire une librairie pratiquement aussi puissante que celle utilisée dans le chapitre précédent, au prix de gros efforts.
Cela demande un travail conséquent. Autant opter pour 74HC595 ou un contrôleur spécialisé.
Le CD4511 avec un grand nombre d'afficheurs
Le 74LS138 et le 74HC154 sont des décodeurs 3 vers 8 lignes et 4 vers 16 lignes. Il permettent de piloter un plus grand nombre d'afficheurs sans requérir un grand nombre de sorties de l'ARDUINO :
Le 74LS138 et le 74HC154 n'ont pas une capacité en courant très élevée (quelques mA). Comme précédemment, si l'on a besoin de plus de courant on peut insérer un petit transistor NPN entre les sorties et chaque cathode :
Le 74HC47 ou 74LS47
Le
74HC47 permet de piloter des afficheurs à anode commune. Son utilisation est analogue à celle du CD4511.
1.6. Les contrôleurs spécialisé
Utiliser un contrôleur spécialisé comporte pas mal d'avantages :
- il ne nécessite aucune résistance
- il se charge à la place du processeur du multiplexage de l'afficheur
- la luminosité est réglable.
- le point décimal est géré
Le HT16K33
Le
HT16K33
est un driver de LEDs pouvant piloter une matrice de 16x8 LEDs et un
clavier matriciel à 13x3 touches. La luminosité est réglable.
Certains afficheurs du commerce en sont équipés :
Le
MAX7219 ou le MAX7221 est capable de piloter 8 afficheurs 7 segments + DP ou 64 LEDs à cathode commune. La luminosité est réglable.
On trouve beaucoup d'afficheurs du commerce qui en sont équipés :
Les librairies à utiliser sont celles-ci :
https://github.com/wayoda/LedControl
https://github.com/MajicDesigns/MD_Parola
Comme ces panneaux sont chaînables on peut rencontrer des problèmes de maping suivant l'origine, en fonction du constructeur. Le premier panneau n'est pas forcément situé au bon endroit, gauche ou droite. La librairie MD_Parola permet en général de s'en sortir car elle permet de contrôler différents modèles.
Le PCA9685
Le
PCA9685 est un driver de LEDs I2C PWM 16 canaux.
Il dispose de fonctions avancées :
- PWM 12 bits : fréquence variable de 24Hz à 1526Hz
- luminosité des LED programmable
- allumage / extinction des LED avec un temps programmable
- etc.
Le TLC5947
Le
TLC5947 est un driver de LEDs PWM 24 canaux permettent de réaliser des animations lumineuses.
Il dispose de fonctions avancées :
- PWM 12 bits
- courant dans les LED ajustable par une seule résistance
Le TM1637
Le
TM1637 est capable de piloter 6 afficheurs 7 segments + DP à anode commune et
un clavier matriciel à 16 touches.
Certains afficheurs du commerce en sont équipés :
Voici un exemple de schéma d'une réalisation personnelle :
Pourquoi réaliser un montage soi-même alors que l'on peut trouver des modules tout faits ? Cela peut être intéressant dans le cadre d'un intégration à une carte plus élaborée.
Le TM1638
Le
TM1638 est capable
de piloter 8 afficheurs 10 segments à anode commune ou cathode commune
et un clavier matriciel à 24 touches. La luminosité est réglable.
Certains afficheurs du commerce en sont équipés :
La librairie à utiliser est celle-ci :
Le câblage de l'afficheur sur ces deux modules diffère. La librairie en tient compte.
Le module 8 touches doit être instancié de la manière suivante :
#include <TM1638.h>
// data pin 4, clock pin 5 and strobe pin 6
TM1638 module(4, 5, 6);
void setup() {
module.setupDisplay(true, 1); // set active, luminosity = 1
mode = 0;
}
Le module 16 touches doit être instancié différemment :
#include <TM1638.h>
#include <TM1638QYF.h>
// data pin 4, clock pin 5 and strobe pin 6
TM1638QYF module(4, 5, 6);
void setup() {
module.setupDisplay(true, 1); // set active, luminosity = 1
mode = 0;
}
Si vous alimentez le module par le 5V de l'ARDUINO, réglez la luminosité sur 1, car sinon l'afficheur consomme trop et peut empêcher le chargement de l'application. Sinon, il vous faut une alimentation externe.
A cette liste il faut ajouter les expanders d'I/O que l'on peut également utiliser pour piloter des leds. Ils n'offrirons cependant l'avantage d'un réglage de luminosité des LEDs, sauf s'ils gèrent le PWM, comme le SX1509 :
https://riton-duino.blogspot.com/2019/02/les-extensions-de-gpios-de-larduino.html
1.7. Les afficheurs de grande taille
Certains afficheurs de grande taille sont construits à l'aide de LEDs en série et parallèle, comme celui-ci :
 |
| FORYARD FYS-40011BUHR-21 |
Un décodeur classique ne pourra pas le piloter, sauf si l'on ajoute une électronique de puissance, car chaque segment requiert une tension d'environ 10V.
Un MIC5891 sera le bienvenu car il accepte une tension d'alimentation de 5V à 50V. Il est adapté au pilotage d'afficheurs à anode commune. Le MIC5841 permettra de piloter des afficheurs à cathode commune.
La tension directe d'un segment est de 10V pour 20mA. On pourra adopter une tension d'alimentation de 12V et une résistance par segment.
R = (12V - 10V) / 20mA = 100ΩComme avec le CD4511 on pourra multiplexer les afficheurs.
2. Le LCD 7 segments
Les afficheurs LCD 7 segments existent sous divers formats et ils peuvent être équipés ou non d'un contrôleur.
2.1. LCD sans contrôleur
Ce type d'afficheur possède un certain nombre de broches :
- 4 digits : 40 broches
- 6 digits : 50 broches
Ce type d'afficheur possède une broche commune (backplane) et autant de broches que de segments. Certains écrans possèdent plusieurs backplane.
La tension entre électrodes doit toujours avoir une valeur moyenne
proche de 0 (inférieure à 50mV) pour éviter de détruire les cristaux
liquides par électrolyse.
Les signaux appliqués au backplane et aux segments doivent donc être alternatifs, et doivent avoir une fréquence allant de 30Hz à 200Hz :
Le pilotage peut être effectué en utilisant les pins digitales d'un processeur, un expander de GPIOs ou un contrôleur spécialisé.
2.1.1 Piloter un LCD avec un contrôleur spécialisé
Le pilotage à l'aide d'un contrôleur spécialisé soulage le processeur de la tâche de génération des signaux alternatifs.
Il existe une grande variété de contrôleurs, dont voici les plus connus :
| Contrôleur |
Bus |
Tension |
Consommation |
Segments |
Boîtier |
|---|
| HT1621 |
I2C |
2.4V - 5.2V |
150µA |
32x4 |
LQFP44 |
| HT1623 |
I2C |
2.4V - 5.2V |
150µA |
48x4 |
LQFP100 |
| HT1625 |
I2C |
2.4V - 5.2V |
150µA |
64x4 |
LQFP100 |
| PCF2112 |
I2C |
2.25V - 6V |
20µA |
32 |
VSO40 |
| PCF8562 |
I2C |
1.8V - 5.5V |
3.5µA |
32 x 4 |
TSSOP48 |
| PCF8566 |
I2C |
2.25V - 6V |
30µA |
24 x 4 |
VSO40 DIP40 |
| PCF8577 |
I2C |
2.5V - 6V |
50µA |
32 |
VSO40 DIP40 |
| PCF85134 |
I2C |
1.8V - 5.5V |
24µA |
60 x 4 |
LQFP80 |
Le PCF8577 est obsolète, mais il est encore disponible en
boîtier DIP ou
VSO40 sur AliExpress. Les autres circuits sont disponibles en France en version CMS.
L'intégration de ce genre d'afficheur demande un travail conséquent :
Le schéma a été réalisé avec KICAD.
Pour récupérer le projet complet incluant le sketch, voir plus bas : 13. Téléchargement
Le PCF8577 en version DIP peut facilement être placé sous l'afficheur :
L'afficheur est un
Varitronix VI-402 :
Le contraste est excellent même avec un angle de vision de 45°.
La consommation de ce petit module est de 120 µA.
2.1.2 Piloter un LCD avec un registre à décalage
Il est possible de piloter un LCD avec un registre à décalage, par exemple un ou plusieurs 74HC595 :
La pin 13 de l'ARDUINO est utilisée pour piloter le point commun de
l'afficheur (backplane) en opposition de phase avec les segments, à une
fréquence de 30 à 100Hz environ.
Sur ce schéma il suffit d'ajouter deux autres 74HC595 pour piloter les deux digits de gauche.
Le pilotage des segments est réalisé à l'aide d'une interruption timer à 50Hz, ce qui permet de garantir la régularité des signaux envoyés à l'afficheur.
Le schéma a été réalisé avec KICAD.
Pour récupérer le projet complet incluant le sketch, voir plus bas : 13. Téléchargement.
2.1.3 Piloter un LCD avec un expander
Il est aussi possible de piloter un LCD avec un expander, par exemple un ou plusieurs MCP23017 :
La pin 13 de l'ARDUINO est utilisée pour piloter le point commun de l'afficheur (backplane) en opposition de phase avec les segments, à une fréquence de 30 à 100Hz environ.
Sur ce schéma il suffit d'ajouter un second MCP23017 pour piloter les deux digits de gauche.
Le pilotage des segments ne peut être réalisé simplement à l'aide d'une interruption timer à cause de l'utilisation de l'I2C. La chose n'est certainement pas impossible à réaliser en ré-autorisant les interruptions, mais cela demande un peu de travail.
Le processeur devra donc générer ces signaux en continu et ne pas perdre trop de temps en traitements annexes.
La solution précédente à base de 74HC595 est préférable et plus rapide.
Le schéma a été réalisé avec KICAD.
Pour récupérer le projet complet incluant le sketch, voir plus bas : 13. Téléchargement.
2.1.4 Piloter un LCD avec un processeur spécialisé
Et pourquoi ne pas adopter un processeur capable de piloter le LCD ?
Il existe un grand nombre de processeurs 8 bits MICROCHIP :
| Processeur |
Flash |
Ram |
Tension |
Consommation |
Segments |
Boîtier |
|---|
| ATMEGA169 |
16K |
1K |
1.8V - 6V |
350μA |
4 x 25 |
TQFP64 |
| ATMEGA329 |
32K |
1K |
1.8V - 6V |
350μA |
4 x 25 |
TQFP64 |
| ATMEGA649 |
64K |
2K |
1.8V - 6V |
350μA |
4 x 25 |
TQFP64 |
| ATMEGA3290 |
32K |
1K |
1.8V - 6V |
350μA |
4 x 40 |
TQFP100 |
| ATMEGA6490 |
64K |
2K |
1.8V - 6V |
350μA |
4 x 40 |
TQFP100 |
Les consommations sont données pour
1 MHz à 1.8V.
Ils peuvent fonctionner à 32kHz et 1.8V et consomment dans ce cas 40μA.
Ils consomment 100nA en sleep mode à 1.8V.
Il existe un BSP ARDUINO pour ces processeurs :
https://github.com/MCUdude/ButterflyCore/tree/master/avr
Et des processeurs 32 bits à base de Cortex M0 :
| Processeur |
Flash |
Ram |
Tension |
Consommation |
Segments |
Boîtier |
|---|
| ATSAML22N16A |
64K |
8K |
1.62V – 3.63V |
50μA/MHz |
4 x 44 |
TQFP100 |
| ATSAML22N17A |
128K |
16K |
1.62V – 3.63V |
50μA/MHz |
4 x 44 |
TQFP100 |
| ATSAML22N18A |
256K |
32K |
1.62V – 3.63V |
50μA/MHz |
4 x 44 |
TQFP100 |
Leur fréquence d'horloge peut aller jusqu'à 30MHz.
Ils consomment 3.5µA en sleep mode.
Il existe aussi des séries à base de Cortex M4 mais on sort du domaine amateur.
Des PICs existent aussi :
| Processeur |
Flash |
Ram |
Tension |
Consommation |
Segments |
Boîtier |
|---|
| PIC16F19155 |
14K |
1K |
2.3V - 5.5V |
32 μA/MHz |
96 |
DIP28 |
| PIC16F19156 |
28K |
2K |
2.3V - 5.5V |
32 μA/MHz |
96 |
DIP28 |
| PIC16F19175 |
14K |
1K |
2.3V - 5.5V |
32 μA/MHz |
184 |
DIP40 |
| PIC16F19176 |
28K |
2K |
2.3V - 5.5V |
32 μA/MHz |
184 |
DIP40 |
| PIC16F19185 |
14K |
1K |
2.3V - 5.5V |
32 μA/MHz |
248 |
TQFP48 |
| PIC16F19186 |
28K |
2K |
2.3V - 5.5V |
32 μA/MHz |
248 |
TQFP48 |
| PIC16F19195 |
14K |
1K |
2.3V - 5.5V |
32 μA/MHz |
360 |
TQFP64 |
| PIC16F19196 |
28K |
2K |
2.3V - 5.5V |
32 μA/MHz |
360 |
TQFP64 |
| PIC16F19197 |
56K |
4K |
2.3V - 5.5V |
32 μA/MHz |
360 |
TQFP64 |
Attention: les options de multiplexage limitent le nombre de segments utilisables en fonction du nombre de backplanes de l'afficheur.
Reportez-vous au paragraphe MULTIPLEXING OPTIONS de la datasheet.
Les consommations sont données pour VCC =
1.8V.
Ils peuvent fonctionner à 32kHz et 1.8V et consomment dans ce cas 8μA.
Ils consomment 100nA en sleep mode à 1.8V.
La liste complète de ces processeurs MICROCHIP est
ICI.
MICROCHIP fournit quelques notes d'application :
https://www.microchip.com/wwwcategory/taxonomysearch/#/TaxonomySearch/GetSearchResults/Display/Segmented%20LCD/Application
2.2. LCD avec contrôleur
Il existe heureusement des afficheurs que l'on peut piloter à travers une interface série. Et ils ne coûtent pas plus cher qu'un contrôleur seul.
HT1621
Celui-ci,
acheté sur AliExpress a une taille de 2.4'. Il utilise un contrôleur
HT1621. Il possède une LED de backlight qui permet d'éclairer le panneau.
Il consomme environ 300µA sous 3.3V, 600µA sous 5V et 4mA avec le backlight allumé.
On est loin des 20µA d'un PCF2112, mais la facilité a un coût.
Voici les informations concernant le câblage :
Avec un ARDUINO on utilise généralement cette librairie pour le piloter :
https://github.com/5N44P/ht1621-7-seg.git
Si vous cherchez à éteindre le backlight vous constaterez peut-être qu'il reste allumé en permanence. Voici l'astuce pour parvenir à l'éteindre :
Le point rouge représente un pont de soudure permettant d'allumer le backlight en permanence. Il faut l'éliminer avec de la tresse à dessouder.
Le point bleu représente un pont de soudure permettant d'allumer le backlight à l'aide de la pin LED+. Il faut l'ajouter.
Remarque : j'ai essayé ce LCD en 3.3V et 5V. Le contraste est meilleur en 5V.
En regardant l'écran bien face, le contraste est correct.
Plus on déplace l'angle de vision vers le haut, plus les segments éteints sont visibles. Avec un angle d'environ 20°, les segments paraissent tous actifs.
Plus on déplace l'angle de vision vers le bas, plus les digits deviennent gris.
L'angle de vision optimal est donc assez faible.
3. Le LCD alphanumérique
Ces
écrans LCD sont alphanumériques. Les modèles les plus courants
permettent d'afficher 2x16 ou 4x20 caractères.
Ils sont basés sur le très connu circuit HD44780.
On trouve aussi du 2x40 ou 4x40 caractères :
Il existe mêmes
des modèles graphiques :
Il existe des cartes enfichables directement sur ARDUINO UNO :
Elles sont déjà équipées d'un potentiomètre de réglage de contraste et possèdent généralement 6 boutons.
3.1. Pilotage en parallèle
Généralement, on les pilote à l'aide de 6 sorties de l'ARDUINO, comme sur ce schéma :
Sur certains afficheurs, le rétro-éclairage est à alimenter par les pins 17 et 18.
Sur
la pin 3 VO ou VEE il faut appliquer une tension à l'aide d'un
potentiomètre. Ceci permet de régler le contraste. Sinon, l'afficheur
restera désespérément vide.
La résistance du rétro-éclairage de 2.2KΩdu schéma est élevée. Diminuer sa valeur pour une luminosité plus élevée. Elle est même optionnelle.
Mise en œuvre
La première chose à faire est de souder une barrette de contacts mâles à 16 points sur l'afficheur. Ainsi vous pourrez facilement l'enficher sur une breadboard ou un connecteur de PCB :
Quelques erreurs communes conduisent souvent à l'échec :
- on a déjà vu des néophytes poser l'afficheur sur la barrette, sans soudure, et s'étonner du mauvais fonctionnement.
- la pin R/W doit être reliée à la masse.
- ne pas oublier de le régler le potentiomètre de contraste.
- ces afficheurs ont du mal à fonctionner en 3.3V. La tension nécessaire à l'obtention d'un contraste optimal est insuffisante.
- ces afficheurs ne fonctionnent pas sans backlight, en tous cas vous ne verrez pas grand chose sur le LCD.
Avec un ARDUINO on utilise généralement cette librairie pour les piloter :
https://github.com/arduino-libraries/LiquidCrystal
Les raccordements du schéma ci-dessus sont effectués en respectant l'ordre des pins des exemples de cette librairie. Mais vous êtes libres de choisir d'autres pins de l'ARDUINO si vous modifiez le constructeur en conséquence :
// initialize the library with the numbers of the interface pins
// RS, E, D4, D5, D6 ,D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Dans la fonction setup() il suffit d'appeler la méthode begin() avec le nombre de colonnes et de lignes :
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
}
La
première chose à faire est bien entendu de charger un exemple de la
librairie afin de valider le montage, et régler le contraste par la même
occasion (Display.ino par exemple).
3.2. Pilotage en I2C
On peut adjoindre à ces afficheurs un module I2C pour les piloter en série, libérant ainsi 4 sorties digitales pour une autre utilisation :
Ces modules utilisent un circuit PCF8574.
Ce module doit être soudé sur l'afficheur à l'aide d'une barre de contacts mâles à 16 points. On peut également souder un connecteur femelle sur le dos de l'afficheur afin de pouvoir les désolidariser si besoin.
Ensuite reliez les quatre broches VCC, GND, SDA et SCL à l'ARDUINO.
Rappel : sur ARDUINO UNO, NANO ou MINI :
- SDA = A4
- SCL = A5
Sur ADRUINO MEGA :
- SDA = pin 20
- SCL = pin 21
Le potentiomètre de réglage du contraste est directement implanté sur le module. Ne pas oublier de le régler.
Il arrive souvent des déboires aux amateurs avec ce type de module, en particulier l'inversion des fils SDA et SCL du bus I2C.
Ces modules, en fonction de la configuration adoptée par le constructeur, peuvent avoir diverses adresses I2C. Les adresses 0x27 ou 0x3F sont souvent utilisées.
Le logiciel
scanner I2C vous permettra de lever le doute et surtout de vérifier qu'il est bien visible sur le bus.
Certains modules vous permettent également de modifier l'adresse I2C en reliant des plots de soudure :
On utilise généralement cette librairie pour les piloter :
https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
Avec cette librairie il est possible d'activer ou désactiver le backlight.
Ici encore l
a
première chose à faire est de charger un exemple de la
librairie afin de valider le montage, et aussi régler le contraste (HelloWorld.ino par exemple).
Certains modules I2C ont un câblage différent sur les sorties de l'afficheur.
Cette librairie vous donnera plus de liberté de configuration :
https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
- elle est capable de piloter des écrans équipés de circuits PCF8574 ou MCP23008.
- elle est capable d'auto-détecter l'adresse I2C
Elle permet également de configurer les pins utilisées entre l'expander I2C et l'afficheur grâce à un vaste choix de constructeurs :
LiquidCrystal_I2C (uint8_t lcd_Addr);
// Constructor with backlight control
LiquidCrystal_I2C (uint8_t lcd_Addr, uint8_t backlighPin, t_backlighPol pol);
LiquidCrystal_I2C( uint8_t lcd_Addr, uint8_t En, uint8_t Rw, uint8_t Rs);
// Constructor with backlight control
LiquidCrystal_I2C(uint8_t lcd_Addr, uint8_t En, uint8_t Rw, uint8_t Rs,
uint8_t backlighPin, t_backlighPol pol);
LiquidCrystal_I2C(uint8_t lcd_Addr, uint8_t En, uint8_t Rw, uint8_t Rs,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7 );
// Constructor with backlight control
LiquidCrystal_I2C(uint8_t lcd_Addr, uint8_t En, uint8_t Rw, uint8_t Rs,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7,
uint8_t backlighPin, t_backlighPol pol);
3.3. Incompatibilité des libriairies I2C
ATTENTION:
Les deux librairies Arduino-LiquidCrystal-I2C-library et new-liquidcrystal sont incompatibles car leur fichier LiquidCrystal_I2C.h porte le même nom.
Une erreur courante consiste à essayer les exemples de la librairie Arduino-LiquidCrystal-I2C-library et de ne pas parvenir à le compiler.
Par exemple (Arduino-LiquidCrystal-I2C-library) :
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
lcd.begin();
lcd.print("Hello, world!");
}
void loop()
{
}
Le constructeur prend 3 paramètres adresse : colonnes, lignes
la méthode begin() ne prend pas de paramètres.
Le même exemple (new-liquidcrystal) :
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27);
void setup()
{
lcd.begin(16,2);
lcd.print("Hello, world!");
}
void loop()
{
}
Le constructeur prend 1 paramètre : adresse
la méthode begin() prend 2 paramètres : colonnes, lignes
Conclusion : soit vous installez la librairie Arduino-LiquidCrystal-I2C-library soit vous installez new-liquidcrystal, mais pas les deux. Si vous n'avez pas d'afficheurs exotiques, installez plutôt Arduino-LiquidCrystal-I2C-library.
3.4. Utilisation
Sur un PCB, je vous conseille de prévoir quatre colonnettes pour fixer l'afficheur, car celui-ci est lourd. Le connecteur 16 points ne suffira pas à le maintenir.
Ces
écran sont très utilisés par les amateurs, mais sont malgré tout dépassés par les modèles graphiques qui
permettent d'afficher plus d'informations dans un encombrement réduit.
Par contre ils sont assez faciles à intégrer dans un boîtier, comme ici :
https://riton-duino.blogspot.com/2018/02/une-alimentation-symetrique-6-18v.html
4. Les petits afficheurs OLED
Ces écrans OLED de 0.91 et 0.96 pouces permettent cette fois-ci un affichage graphique sur 128x32 ou 128x64 points.
Certains permettent un affichage en couleurs, mais attention, souvent ils sont simplement bicolores : la partie haute est jaune, la partie basse est bleue.
Malgré leur petite taille ils permettent d'afficher autant d'informations qu'un LCD 2 ou 4 lignes, en choisissant une police de caractères adaptée.
Ils sont basés sur le circuit SSD1306.
On trouve des modèles fonctionnant en I2C, d'autres en SPI.
Ils fonctionnent en 3.3V et 5V. La consommation dépend du nombre de points affichés. Le 0.96 pouces 128x64 avec un affichage équivalent à celui de la photo ci-dessus devrait consommer aux alentours de 5mA à 6mA.
Avec un ARDUINO on utilise généralement cette librairie pour les piloter :
https://github.com/adafruit/Adafruit_SSD1306
La librairie contient quelques exemples. Vous choisirez celui qui correspond à votre écran : I2C, SPI, 128x32 ou 128x64.
Voici un petit sketch permettant de démarrer un écran OLED I2C:
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 0
Adafruit_SSD1306 display(OLED_RESET);
void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
}
void loop() {
char *text = "HELLO WORLD";
static int count = 0;
char countAsText[10];
int16_t x1, y1;
uint16_t w, h;
// efface la mémoire de l'écran
display.clearDisplay();
// police petite taille
display.setTextSize(1);
// indispensable, sinon l'écran reste noir
display.setTextColor(WHITE);
// récupère les coordonnées et la taille x y du texte
display.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
// déplace le curseur : texte centré, 1ère ligne (y = 0)
display.setCursor((display.width() - w) / 2, 0);
// écrit dans la mémoire de l'écran
display.print(text);
// convertit l'entier en chaîne
itoa(count, countAsText, 10);
// récupère les coordonnées et la taille x y du texte
display.getTextBounds(countAsText, 0, 0, &x1, &y1, &w, &h);
// déplace le curseur : texte centré, 2ème ligne
// (y = hauteur de police + 2 pixels d'interligne)
display.setCursor((display.width() - w) / 2, h+2);
// écrit dans la mémoire de l'écran
display.print(count++);
// provoque l'affichage
display.display();
delay(1000);
}
La librairie AdaFruit occupe pas mal d'espace en mémoire RAM.
Cette autre librairie plus légère permet d'afficher uniquement du texte. Elle possède pas mal de polices de caractères :
https://github.com/greiman/SSD1306Ascii
Il existe aussi des écrans OLED plus grands, 1.5 pouce 128x128 par exemple. Ils restent chers mais commencent à se démocratiser :
ecran-oled-ssd1351
5. Les écrans TFT série
Ces écrans existent dans différentes tailles entre 1.5 et 2.8 pouces, avec des résolutions allant de 128x128 à 320x240 points.
Ils possèdent souvent un lecteur SD-CARD.
Ils sont basés sur des circuits divers et variés :
- LPH9135 : 128x128
- ST7735R : 128x160
- ST7789 : 240x240
- ILI9225 : 176x220
- ILI9341 : 240x320
Ils se pilotent en I2C ou SPI.
Ils sont souvent capables de fonctionner en 3.3V et 5V, étant souvent équipés de convertisseurs de niveaux.
Voici les librairies permettant de les utiliser :
- ILI9341 : https://github.com/adafruit/Adafruit_ILI9341
La liste n'est pas exhaustive bien sûr.
La grande majorité de ces écrans peuvent être pilotés grâce à la librairie UTFT, qui dispose d'une collection de drivers imposante.
Cette librairie a une occupation mémoire importante. En fonction de la taille de votre application vous serez probablement amené à vous orienter sur une ARDUINO MEGA.
Et bien entendu, commencez par un exemple simple de la librairie que vous aurez choisi. Cela vous permettra de valider vos branchements.
5.1. ST7735
Certains écrans SPI ST7735 sont sérigraphiés de manière étrange, comme s'il s'agissait d'écrans I2C, par exemple celui-ci acheté sur AliExpress :
C'est un écran 1.8" 128x160.
Il s'agit d'un écran équipé d'un chip ST7735, donc SPI, mais SPI 3 ou 4 lignes comme on peut le voir dans la datasheet du ST7735 :
La librairie Adafruit ST7735 gère cet écran sur 4 lignes.
La sérigraphie est à interpréter de la manière suivante (entre parenthèses les pins à raccorder sur une carte ARDUINO UNO, NANO ou MINI) :
- VCC : 5V
- GND
- GND
- NC
- NC
- NC
- CLK : CLK (pin D13)
- SDA : MOSI (pin D11)
- RS : data command (au choix, par exemple D8)
- RST : reset (au choix, par exemple D9)
- CS : chip select (au choix, par exemple D10)
Sur celui-ci la sérigraphie fait encore plus penser à un écran I2C :
C'est un écran 1.44" 128x128.
Le raccordement est le suivant :
- GND
- VCC : 3.3V
- SCL : CLK (pin D13)
- SDA : MOSI (pin D11)
- RES : reset (au choix, par exemple D9)
- RST : data command (au choix, par exemple D8)
- CS : chip select (au choix, par exemple D10)
- BL : 3.3V
Pour démarrer, essayez un exemple de la librairie Adafruit.
Le constructeur de l'objet écran aura cette allure :
#define TFT_CS 10
#define TFT_RST 9
#define TFT_DC 8
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
5.2. ST7789
Ici aussi la sérigraphie fait penser à un écran I2C.
C'est un écran 1.3" 240x240.
Le raccordement est le suivant :
- GND
- VCC : 3.3V
- SCL : CLK (pin D13)
- SDA : MOSI (pin D11)
- RES : reset (au choix, par exemple D9)
- DC : data command (au choix, par exemple D8)
- BLK : 3.3V
J'ai testé celui-ci acheté sur AliExpress :
Comme on peut le remarquer il ne possède pas de broche CS (chip select). La librairie Adafruit ST7735-ST7789 ne permet pas de le piloter (elle devrait normalement fonctionner avec un écran possédant une broche CS).
Avec la librairie
Arduino-ST7789 par contre, aucun problème.
#define TFT_DC 8
#define TFT_RST 9
Arduino_ST7789 tft = Arduino_ST7789(TFT_DC, TFT_RST); //for display without CS pin
Cet écran de 1.3 pouces est petit mais sa résolution de 240x240 est impressionnante.
5.3. ILI9341
J'ai testé celui-ci acheté sur AliExpress :
C'est un écran 2.8" équipé d'une dalle tactile.
Cet écran est capable de fonctionner en 3.3V c'est à dire qu'il est directement connectable sur une ESP8266, ESP32 ou ARDUINO PRO MINI 3.3V.
Pour le brancher sur un ARDUINO UNO ou NANO en 5V quelques résistances de 10KΩ suffisent (entre parenthèses les pins à raccorder sur une carte ARDUINO UNO, NANO ou MINI) :
- VCC : 5V ou 3.3V
- GND
- CS : pin D10
- RST : pin D8
- DC : pin D9
- MOSI : pin D11
- SCK : pin D13
- LED : 5V ou 3.3V
- MISO : pin D12
Pour démarrer, essayez un exemple de la librairie Adafruit.
Le constructeur de l'objet écran aura cette allure :
#define TFT_DC 9
#define TFT_CS 10
#define TFT_MOSI 11
#define TFT_CLK 13
#define TFT_RST 8#define TFT_MISO 12
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);
Il est également possible de piloter cet écran avec la librairie
UTOUCH :
#define TFT_DC 9
#define TFT_CS 10
#define TFT_MOSI 11
#define TFT_CLK 13
#define TFT_RST 8
UTFT myGLCD (ILI9341_S5P, TFT_MOSI, TFT_CLK, TFT_CS, TFT_RST, TFT_DC);
Avec ce genre d'écran on atteint la taille maximale pour un écran SPI. Le rafraîchissement prend un certain temps.
Pour la partie écran tactile je ne dispose pas d'informations sur le type de driver à installer. Je creuse ...
On trouve également des écrans 2.4" ou 2.8" break-out pour ARDUINO UNO ou MEGA2560 :
Il semblerait que la partie tactile de certains de ces écrans se gère à l'aide de pins analogiques.
6. Les écrans TFT de grande taille
Nous abordons ici une catégorie d'écrans dont la taille peut aller de 2.4 jusqu'à 7 pouces.
Et ils vous offrent une fonction sympathique : la dalle tactile !
Ils sont basés sur de nombreux circuits :
- ILI9325C : 240x320
- SSD1289 : 240x320
- SSD1963 : 800x480
Ils se pilotent
grâce à une interface parallèle 8 ou 16 bits.
Ces
écrans fonctionnent majoritairement sous 3.3V, mais on trouve des
cartes adaptatrices dans le commerce (voir chapitre suivant).
L'interface la plus utilisée sur ces écrans est l'ITDB02, qui se présente sous la forme d'un connecteur 40 points.
On peut trouver aussi des shields directement enfichables sur ARDUINO UNO :
Ici encore la librairie
UTFT sera capable de piloter un grand nombre de ces écrans.
On lui adjoindra la librairie
UTOUCH pour la gestion de la dalle tactile.
Là encore, étant donné l'occupation mémoire importante de ces librairies, une ARDUINO MEGA sera probablement nécessaire.
La librairie contient de nombreux exemples adaptés à différentes tailles d'écran. Essayez celui qui correspond au vôtre (avant tout lire le chapitre plus bas "Les librairies UTFT et UTOUCH", car il faudra certainement choisir un driver).
6.1. Astuce
Comment récupérer les broches SPI d'un shield TFT ? Ces broches sont normalement utilisées par la SD.
En rallongeant les connecteurs comme ceci :
En utilisant ce type de connecteur :
7. L'interface ITDB02
Ce connecteur 40 points est présent sur une majorité d'écrans de grande taille.
C'est une interface standardisée, c'est à dire qu'il est possible de changer d'écran sur un projet en conservant la même connectique.
Ils équipent souvent des shields adaptables sur ARDUINO UNO et surtout MEGA ou DUE.
Ces cartes sont de
simples adaptateurs de connectique avec convertisseurs de niveaux.
L'écran fonctionne en 3.3V et le shield convertit les niveaux de sortie 5V en 3.3V acceptable par l'écran.
La majorité sont équipés d'un régulateur 3.3V.
Certains sont équipés d'un jumper permettent de les alimenter en 3.3V ou 5V.
Dans le cas ou on les alimente en 3.3V, les convertisseurs de niveau sont inutiles mais fonctionnent quand même bien sûr.
Il existe des
shields prévus pour l'ARDUINO DUE, sans convertisseurs de niveau.
Ce shield est un modèle intéressant :
Acheté ici :
AliExpress
Il est décrit comme shield 2.8 et 3.2 pouces. Mais je pilote sans problème un 4.3 et un 7 pouces :
4.3 pouces
7 pouces
Avec UTFT (voir plus bas 8. Les librairies UTFT et UTOUCH) :
4.3 pouces :
UTFT myGLCD(ITDB43,38,39,40,41);
7 pouces :
UTFT myGLCD(CTE70,38,39,40,41);
Par contre ce n'est pas le cas avec celui-ci :
Je n'ai pas réussi à faire quoi que ce soit avec cet adaptateur. Il
s'agit probablement d'un problème de brochage, mais sans doc que faire ?
Si quelqu'un a la solution je suis à l'écoute.
Comme l'interface ITDB02 est standardisée, il est possible d'utiliser ces shields avec un grand nombre d'écrans.
J'ai déjà utilisé
CELUI-CI, vendu avec un écran 3.2" :
Et j'ai remplacé l'écran 3.2" par
cet autre 4.3" :
Ce n'est ensuite qu'une question de code. Il suffit de changer de driver. Une simple modification du constructeur UTFT suffit (voir plus bas 8. Les librairies UTFT et UTOUCH) :
3.2" : SSD1289
UTFT myGLCD(SSD1289, 38, 39, 40, 41);
4.3" : SSD1963
UTFT myGLCD(SSD1963_480, 38, 39, 40, 41);
8. Les librairies UTFT et UTOUCH
Ensuite pour valider ce choix vous pourrez essayer un des nombreux exemples fournis. N'oubliez pas de modifier le constructeur de l'objet UTFT de l'exemple afin de lui passer l'identifiant du bon driver. Même si la résolution est celle qui convient, le choix du driver dans l'exemple ne l'est pas forcément.
Si vous voyez un tas de points de couleur sur toute la surface de votre écran, cela veut dire que le driver n'est pas le bon.
Enfin, il vous restera à calibrer votre écran tactile à l'aide du logiciel fourni dans le répertoire examples/Arduino/UTouch_Calibration de la librairie UTOUCH.
Là encore vous devrez modifier ce logiciel afin d'utiliser le bon driver d'écran.
// SSD1963 & Arduino Mega
UTFT myGLCD(ITDB43,38,39,40,41); // Remember to change the model parameter to suit
// your display module!
UTouch myTouch(6,5,4,3,2);
Ensuite il suffit de compiler ce code et le téléverser dans l'ARDUINO.
Je vous conseille d'utiliser un stylet ou un crayon de papier pour effectuer votre calibration.
Le logiciel affiche successivement des petits carrés blancs avec une croix au centre. Pointez bien le centre de chaque croix avec le stylet.
Ensuite le logiciel affiche 3 valeurs que vous reporterez dans le fichier UTouchCD.h de la librairie UTOUCH.
Cette calibration est valable pour un écran donné, et malheureusement la librairie UTOUCH impose de modifier le fichier UTouchCD.h pour chaque écran.
Je vous conseille de placer un commentaire accompagnant chaque jeu de valeurs, et de commenter les valeurs non utilisées :
//#define CAL_X 0x00234F89UL
//#define CAL_Y 0x0066CEAFUL
//#define CAL_S 0x8031F1DFUL
// SSD1963
#1
#define CAL_X 0x03EB8043UL
#define CAL_Y 0x039580E4UL
#define CAL_S 0x801DF10FUL
Le commentaire SSD1963 #1 identifie un écran de type SSD1963 sur lequel je colle une étiquette #1.
Comme il faut modifier UTouchCD.h à chaque changement d'écran, il vous sera difficile de travailler sur plusieurs projets en même temps.
On peut éventuellement s'en sortie avec quelques directives de compilation :
// retirer le commentaire devant l'identifiant de l'écran à utiliser
//#define SSD1289_1
#define SSD1963_1
#ifdef SSD1289_1
#define CAL_X 0x00234F89UL
#define CAL_Y 0x0066CEAFUL
#define CAL_S 0x8031F1DFUL
#endif
#ifdef SSD1963_1
#define CAL_X 0x03EB8043UL
#define CAL_Y 0x039580E4UL
#define CAL_S 0x801DF10FUL
#endif
8.1 Polices de caractères
Un grand nombre de polices de caractères existent pour la librairie UTFT :
Exemples :
http://www.rinkydinkelectronics.com/r_fonts.php
Vous pouvez bien entendu les coder vous-même :
http://www.rinkydinkelectronics.com/h_utft_fonts_101.php
9. Afficheurs EPAPER
Ces afficheurs pourraient faire l'objet d'un long article à eux seuls. Il en existe une variété infinie jusqu'à des tailles de 800x600.
Ils sont alimentés en général en 3.3V et proposent une interface SPI.
Il faut faire attention lors de l'achat. Certains sont livrés brut avec un connecteur plat que vous aurez du mal à interfacer avec une carte microcotrôleur :
D'autres sont implantés sur un module plus facile à utiliser :
Ils peuvent également faire partie d'une offre à base d'ESP32 :
Il faut vérifier la disponibilité d'une librairie pour le contrôleur. Il est malheureusement impossible d'en fournir une liste tant le nombre de fabricants est important.
10. Afficheurs historiques
Nous allons terminer cet article en évoquant les afficheurs du passé, qui sont malgré tout toujours disponibles et pilotable à l'aide de nos microcontrôleurs actuels.
10.1. Le écrans et tubes fluorescents VFD
Ces écrans à tubes fluorescents ont une esthétique sans égale :
Ils sont alimentés en 5V et se pilotent aussi en 5V.
Celui-ci, le Futaba
US162SD03CB possède même une librairie pour ARDUINO :
https://playground.arduino.cc/Main/FutabaUsVfd
On trouve aussi du 2x40 caractères :
Il existe aussi
des modèles graphiques :
Et bien sûr certains afficionados ne jurent que par les tubes VFD :
Leur filament s'alimente en 1.5V ou 3V.
Vous trouverez ici un joli projet d'horloge à 6 tubes VFD utilisant un ATMEGA8515 (le code n'est pas publié) :
https://www.akafugu.jp/posts/products/vfd-modular-clock/
12. Conclusion
J'espère vous avoir aidé à mieux comprendre le monde des écrans LCD et TFT et vous avoir apporté suffisamment d'éléments pour vous inciter à essayer.
Les questions sont les bienvenues.
13. Téléchargement
Ce lien permet de récupérer les schéma et sketches des solutions de pilotage d'afficheurs 7 segments LCD :
https://bitbucket.org/henri_bachetti/arduino-7segments-lcd
Cette page vous donne toutes les informations nécessaires :
https://riton-duino.blogspot.com/p/migration-sous-bitbucket.html
Cordialement
Henri
14. Mises à jour
30/10/2018 : 3
. sketch OLED
03/01/2019 : 5.1. ST7735
04/01/2019 : 5.2. ILI9341
04/01/2019 : 8.1 Polices de caractères
30/01/2019 : 2. Le LCD 7 segments
03/02/2019 : 2.1.3 Piloter un LCD avec un expander
04/02/2019 : 2.1.2 Piloter un LCD avec un registre à décalage
06/02/2019 : 1. L'afficheur à LED
07/02/2019 : Ajout d'un sketch dans 1.1. L'afficheur 7 segments (Pilotage direct)
16/02/2019 : 2.1.4 Piloter un LCD avec un processeur spécialisé
01/03/2019 : modifications 3. Le LCD alphanumérique
10. Afficheurs historiques
03/07/2019 : Le PCA9685
06/11/2019 : 5.2. ST7789
25/11/2019 : 9. Afficheurs EPAPER
26/03/2020 : Le HT1632C
