LED, LCD, TFT et ARDUINO (et autres VFD, NIXIE)

LED, LCD, TFT et ARDUINO

(et autres VFD, NIXIE)

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.

Je vais commencer par une recommandation concernant les écrans TFT :
Il ne faut jamais acheter un écran TFT si le vendeur ne précise pas quel est le type de contrôleur utilisé (ST7735R, ILI9225, ILI9341, ILI9488, SSD1289, SSD1963, etc.).
Deuxièmement vous devez vérifier la disponibilité d'une librairie pour votre plateforme (ARDUINO, ESP8266, ESP32, STM32, etc.).

1. Les LEDs et afficheurs à LED

Les LEDs et afficheurs à LEDs comptent parmi les plus anciens composants d'affichages mais sont toujours utilisés. Ils peuvent être du type 7 segments, alphanumériques, barre ou matriciels.

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 :

• FastLED
• NeoPixel
• etc.

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 :

• FastLED
• Polulu 1PA102
• etc.

1.5. L'afficheur 7 segments

On trouve des afficheurs à 7 segments de toutes tailles, entre 3.5mm de haut jusqu'à plus de 100mm, et de diverses couleurs également.

Il en existe deux types principaux :

• anode commune
• cathode commune

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.

Un afficheur peut comporter un ou plusieurs digits, jusqu'à six :

Pour piloter ce type d'afficheur, nous aurons besoin ou non d'un contrôleur.

Multiplexage
Afin de limiter le nombre de sorties de microcontrôleur à utiliser, nous utiliserons des afficheurs multiplexés :

Chaque afficheur est alimenté à tour de rôle suffisamment vite pour que la persistance rétinienne ne voie pas le défilement. Nous utiliserons une fréquence d'environ de 30Hz à 100Hz.

Câblage
Considérons le schéma suivant :

Si vous pilotez les segments à l'aide des broches de sorties d'un ARDUINO ou d'un décodeur 7 segments, vous devez insérer des résistances de limitation de courant.

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 :

• multiplexage
• ajustement de la luminosité
• gestion du point décimal
• affichage de l'heure avec gestion de la colonne (HH:MM ou MM:SS)
• affichage de caractères alphabétiques
• rafraîchissement de l'afficheur sous interruption timer

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 :

La librairie à utiliser est celle-ci :
https://github.com/adafruit/Adafruit_LED_Backpack

Le HT1632C

Le HT1632C est un driver de LEDs pouvant piloter une matrice de 16x24 ou 8x32 LEDs. La luminosité est réglable.

Dans le commerce le choix est assez fourni :

Matrice 16x16

Matrice 8x32

Ajouter une légende

Il existe plusieurs librairies :
https://github.com/adafruit/HT1632
https://github.com/gauravmm/HT1632-for-Arduino

On peut rencontrer des problèmes de maping des LEDs suivant l'origine des panneaux de LEDs, en fonction du constructeur. Le premier point 0,0 n'est pas forcément situé au même endroit.
Il faut essayer différentes librairies.


Le MAX7219 ou MAX7221

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 TM1637 est un circuit DIP20 ou SOP20.

Que vous utilisiez un afficheur du commerce ou le schéma ci-dessus, la librairie à utiliser est celle-ci :
https://github.com/avishorp/TM1637.git
Elle propose un exemple :
https://github.com/avishorp/TM1637/blob/master/examples/TM1637Test/TM1637Test.ino

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 :

https://github.com/rjbatista/tm1638-library.git

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 :

http://www.14core.com/wiring-the-6-digit-7-segment-2-4-inch-ht1621-lcd-display-module-on-microcontroller/

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.

En fonction de la ROM code du circuit, vous aurez ou non la possibilité d'afficher des caractères accentués. Sinon, il vous faudra ajouter ces caractères dans la RAM de l'afficheur.

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 la 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 :

- ILI9225 : https://github.com/Nkawu/TFT_22_ILI9225

- ST7735R : https://github.com/adafruit/Adafruit-ST7735-Library
- ST7789 : https://github.com/ananevilya/Arduino-ST7789-Library.git 

- ILI9341 : https://github.com/adafruit/Adafruit_ILI9341

- LPH9135, ILI9341 : http://www.rinkydinkelectronics.com/library.php?id=51

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 :

• CS
• SDA
• D/CX
• SCL

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

Vous trouverez les manuels ici :
http://www.rinkydinkelectronics.com/library.php?id=51
http://www.rinkydinkelectronics.com/library.php?id=92

Vous trouverez également dans la librairie un fichier recensant les écrans supportés : UTFT_Supported_display_modules_&_controllers.pdf

Le choix du driver à utiliser se fait en passant l'identifiant du bon driver au constructeur de votre objet écran :

UTFT  myGLCD(SSD1963_480,38,39,40,41);

Dans le fichier UTFT.h de la librairie vous trouverez la liste des identifiants de drivers que vous allez pouvoir utiliser.

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é) :

http://www.tube-tester.com/sites/nixie/different/bl-100/sylv.htm

Bonne nouvelle, on trouve des kits :

https://www.akafugu.jp/posts/products/vfd-modular-clock/

10.2. tubes NIXIE

Il est normal de terminer par les plus jolis, les tubes NIXIE :

Leur filament s'alimentent en haute tension, 170V.
 

Vous trouverez ici un projet d'horloge à 6 tubes NIXIE utilisant un ARDUINO PRO MINI et un récepteur DCF77 :

https://www.microfarad.de/nixie-clock/

D'autres projets :
http://www.tube-tester.com/sites/nixie/nixie-clocks/nixie-clocks.htm

11. Quelques lien utiles

https://www.instructables.com/id/The-Arduino-TFT-LCD-Connection/
http://www.mathias-wilhelm.de/arduino/beispiele/lcd-graphic-displays/
https://www.itead.cc/blog/instruction-for-iteadstudio-tft-module
https://www.tubefr.com/l-arduino-tft-lcd-connexion.html

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