Afficheur LCD

Un afficheur LCD est un petit écran monté sur sa propre carte, prêt à recevoir quelques fils et à afficher ce que le programme lui envoie. C’est la façon la plus directe de donner une lecture à un montage : une mesure, un état, un menu, un compteur qui tourne.

Les afficheurs à cristaux liquides ont deux qualités qui expliquent leur succès : ils consomment très peu pour leur taille, et ils n’ont besoin que de quelques fils. On les trouve partout — dans les stations météo, les chargeurs de batterie, les automates de contrôle, les boîtiers de prototypage.

La boutique en propose quatre modèles complémentaires, à caractères ou graphiques, du deux-lignes au 128 × 64 pixels.

Quatre modèles, quatre usages

Tous se pilotent de la même manière depuis un microcontrôleur, mais ils ne servent pas à la même chose. Le choix se fait sur la quantité d’information à afficher et sur le nombre de broches encore libres :

Un afficheur à caractères est le bon premier choix dans la grande majorité des projets : il coûte peu de broches, la bibliothèque est fournie avec l’IDE Arduino, et l’affichage de texte se fait avec une seule instruction. L’écran graphique ne devient nécessaire que lorsqu’il faut dessiner — une courbe de température, un cadran, une icône.

Caractéristiques techniques

Les valeurs ci-dessous décrivent les modèles à caractères de la boutique, qui forment une seule famille :

Brochage d’un afficheur à caractères

Le connecteur compte 16 broches, sérigraphiées sur la carte. La liste est toujours la même sur cette famille, mais un coup d’œil au marquage avant de câbler évite une erreur coûteuse :

Deux modes pour la même puce. En mode 8 bits, un caractère part en une seule fois sur huit fils. En mode 4 bits, il part en deux moitiés successives sur quatre fils, ce qui double le temps de transmission — un délai invisible à l’œil, et quatre broches d’Arduino économisées. C’est le mode que tout le monde utilise, et celui de la bibliothèque LiquidCrystal dès qu’on lui donne six broches.

Le contraste : une broche, un réglage

La broche V0 attend une tension intermédiaire entre 0 et 5 V ; c’est elle qui décide de l’opacité des caractères. Un potentiomètre de 10 kΩ est la manière la plus simple de l’obtenir : ses deux extrémités sur le 5 V et la masse, son curseur central sur V0. On tourne ensuite jusqu’à ce que le texte apparaisse, puis on n’y touche plus.

L’écran n’est pas éclairé : un afficheur à cristaux liquides ne fait que bloquer ou laisser passer la lumière. Si la page ci-dessus affiche une rangée de rectangles noirs, cela signifie que le module est alimenté et initialisé correctement — il n’y a que le contraste à corriger, sur un demi-tour de vis.

Le rétroéclairage

Les broches 15 et 16 alimentent les diodes placées derrière l’écran. Elles consomment à elles seules l’essentiel du courant du montage, plusieurs dizaines de milliampères pour la version bleue. Deux conséquences pratiques :

• La résistance de limitation. Beaucoup de modules portent déjà la leur, soudée au dos près des broches d’alimentation. Si le vôtre n’en a pas, intercalez une résistance de 220 Ω entre la broche 15 et le 5 V. Sans elle, le rétroéclairage tire trop de courant et vieillit prématurément.
• Le régulateur de la carte. Sur un montage autonome alimenté par pile ou batterie, il vaut mieux ne pas faire porter le rétroéclairage par la carte Arduino. Une alimentation 5 V stabilisée avec les masses reliées rend le montage plus sûr — et pour économiser la batterie, un interrupteur sur la broche 15 suffit à éteindre l’éclairage : la lecture reste possible en pleine lumière.

Mini-projet : le premier texte affiché

Un afficheur 16×02 en mode 4 bits, un potentiomètre pour le contraste, six fils de liaison. Le programme écrit deux lignes, puis affiche un compteur de secondes.

Ce qu’il faut

Les fils mâle-femelle sont ceux qui conviennent ici : la plaque d’essai n’accepte que des broches mâles, tandis que le peigne de l’afficheur en présente déjà. Si votre module se présente nu, avec ses seize trous non équipés, il faut y souder une barrette mâle de 16 broches avant de commencer.

Le câblage

Les broches 7 à 10 (D0 à D3) restent libres : c’est tout l’intérêt du mode 4 bits.

Le programme

À copier dans l’IDE Arduino, puis à téléverser. La bibliothèque LiquidCrystal est fournie avec l’IDE, il n’y a rien à installer.

/*
 * Premier affichage sur un LCD a caracteres, en mode 4 bits
 * Carte : Arduino Uno R3
 * Montage : afficheur 16x02, contraste sur potentiometre 10 kohms
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
#include "LiquidCrystal.h"
// Broches de commande
const byte PIN_RS = 12;
const byte PIN_EN = 11;
// Quatre fils de donnees seulement : D4 a D7 de l'afficheur
const byte PIN_D4 = 5;
const byte PIN_D5 = 4;
const byte PIN_D6 = 3;
const byte PIN_D7 = 2;
LiquidCrystal lcd(PIN_RS, PIN_EN, PIN_D4, PIN_D5, PIN_D6, PIN_D7);
void setup() {
  lcd.begin(16, 2);              // 16 colonnes, 2 lignes
  lcd.print("Maroc Produits");
  lcd.setCursor(0, 1);
  lcd.print("Afficheur pret");
  delay(2000);                   // on laisse le message a l'ecran
  lcd.clear();
}
void loop() {
  static unsigned long dernier = 0;
  unsigned long secondes = millis() / 1000;
  if (secondes == dernier) return;   // on n'ecrit qu'une fois par seconde
  dernier = secondes;
  lcd.setCursor(0, 1);
  lcd.print("Duree : ");
  lcd.print(secondes);
  lcd.print(" s     ");
}

Comment ça marche

• lcd.begin(16, 2) annonce la géométrie de l’écran et lance la séquence d’initialisation. C’est cette ligne qui place la puce en mode 4 bits, sans qu’on ait à s’en occuper.
• LiquidCrystal lcd(PIN_RS, PIN_EN, PIN_D4, PIN_D5, PIN_D6, PIN_D7) énumère les six broches dans un ordre précis. Intervertir deux de ces fils ne provoque aucune erreur de compilation : l’écran affiche simplement des caractères qui n’ont aucun sens.
• lcd.setCursor(0, 1) place le curseur en colonne 0 de la ligne 1 — la seconde ligne, la numérotation commençant à zéro.
• Le compteur n’est écrit qu’une fois par seconde, en comparant les secondes écoulées à la valeur précédente. Réécrire seize caractères des milliers de fois par seconde sature l’afficheur et fait scintiller l’écran.
• Les espaces en fin de ligne effacent le compteur précédent : sans eux, le nombre de deux chiffres laisserait un reste d’ancien chiffre derrière lui.
• La broche 15 alimente le rétroéclairage en permanence, il n’y a rien à commander dans le programme. Sur un module équipé d’un transistor de commande, le rétroéclairage peut aussi se couper depuis le code — ce n’est pas le cas de tous.

Variante : passer en I2C quand les broches manquent

Le mode 4 bits réclame déjà six broches d’Arduino, et il faut trois fils de plus pour le potentiomètre et l’alimentation. Sur un montage qui a d’autres capteurs à brancher, cela finit par manquer.

Un adaptateur I2C fixé au dos de l’afficheur réduit tout cela à quatre fils — alimentation, masse, SDA et SCL — et ramène le contraste sur une vis posée sur la carte. Le montage se câble alors en deux minutes, et le programme change de bibliothèque sans changer de logique. Pour éviter complètement l’étape de soudure, l’afficheur 16×02 I2C arrive avec son adaptateur déjà en place.

Questions fréquentes

L’afficheur est alimenté mais rien ne s’affiche

Neuf fois sur dix, c’est le contraste : la broche V0 doit recevoir une tension intermédiaire, pas le 5 V ni la masse. Vérifiez le potentiomètre — ses extrémités sur l’alimentation et la masse, son curseur sur V0 — puis tournez la vis lentement, sur un demi-tour complet. Si le rétroéclairage s’allume et que l’écran reste vide, penchez pour le contraste ; s’il ne s’allume pas non plus, le problème est du côté de l’alimentation.

L’écran affiche une rangée de rectangles noirs

C’est le signe que le module est correctement alimenté et initialisé, mais que le contraste est poussé trop loin. Tournez la vis dans l’autre sens jusqu’à voir apparaître le texte. Si des rectangles restent sur une seule ligne alors que l’autre est normale, vérifiez d’abord les quatre fils de données : une ligne entière en blocs vient plus souvent d’un fil de données décroché que d’un défaut du module.

L’écran affiche des caractères illisibles ou à moitié faux

Deux causes possibles, dans cet ordre. Les quatre fils de données sont dans le mauvais ordre : la bibliothèque attend D4, D5, D6, D7 dans l’ordre du programme, et un fil inversé sur deux donne exactement ce genre d’affichage. Ou bien le module a été initialisé en mode 8 bits alors que seules quatre lignes sont câblées : dans ce cas, une ligne de texte sur deux est perdue.

Peut-on afficher un symbole de degré ou une flèche ?

Oui. La puce contient une table de caractères prédéfinis qui va au-delà du clavier : lcd.write(223) affiche le symbole du degré, et les codes 126 à 255 contiennent les lettres grecques, les flèches et quelques symboles courants. Au-delà de cette table, la puce sait aussi dessiner huit caractères personnalisés de cinq par huit points, définis dans le programme — utile pour une icône de batterie ou un curseur.

Quelle différence avec l’écran 128×64 ?

Les deux n’affichent pas de la même façon. Un afficheur à caractères découpe sa mémoire en cases : on écrit à une position, et le caractère apparaît. L’écran 128 × 64 est graphique, sans cases — on y adresse des pixels, et c’est le programme qui compose les lettres et les dessins. Ce dernier demande donc une bibliothèque graphique et un peu plus de code ; en échange, il sait tracer une courbe ou un cadran qu’aucun afficheur à caractères ne peut rendre.

À combiner avec

Pour démarrer sans rien rassembler pièce par pièce, le KIT Starter réunit la carte Uno R3, la plaque d’essai, les fils et les résistances : en y ajoutant l’afficheur de votre choix, vous avez le montage complet de cette page. Si votre projet affiche surtout des chiffres et que la place manque, le module TM1637 tient sur quatre fils et occupe moins de place qu’un 16×02. Et pour un affichage tactile couleur, entièrement piloté en série, la famille des écrans Nextion prend la suite.