Utiliser un afficheur LCD 2 X 16 avec une carte Arduino

Il est souvent utile d'afficher des informations numériques ou textuelles produites par une carte Arduino (une mesure effectuée par un capteur, par exemple).   Aussi longtemps que l'Arduino est branché à un ordinateur, on peut utiliser le moniteur série intégré à l'IDE pour afficher ces informations.  Mais si vous désirez mettre au point un dispositif autonome qui pourra fonctionner loin de l'ordinateur, un afficheur à cristaux liquides (ou LCD, pour "liquid crystal display") s'avère une solution pratique, et relativement simple.

Nous parlons aujourd'hui des afficheurs compatibles avec le pilote Hitachi HD44780, qui permettent d'afficher des nombres et des lettres de l'alphabet (2 lignes comportant 16 caractères chacune).  Si vous avez besoin d'afficher des illustrations, un afficheur LCD Nokia 5110 correspondra peut-être mieux à vos besoins.

Connexions

Les afficheurs compatibles avec le pilote HD44780 comportent 16 connecteurs.  Les connexions que je vous propose ici vous permettront d'utiliser sans modification les exemples de sketches fournis avec la bibliothèque LiquidCrystal.  Pour certains projets, il est possible que vous soyez obligé de modifier certaines de ces connexions si d'autres périphériques occupent déjà les mêmes entrées/sorties de l'Arduino.

Les pins 1 et 2 servent à alimenter l'afficheur:

• Pin 1 de l'afficheur --- GND de la carte Arduino
• Pin 2 de l'afficheur --- 5 V de la carte Arduino

La pin 3 sert à régler le contraste de l'afficheur:  on la relie à un potentiomètre de 10 kΩ qui permet de faire d'ajuster sa tension à une valeur située entre 0 et 5 V.

• Pin 3 de l'afficheur --- Curseur d'un potentiomètre dont les deux autres broches sont reliées respectivement à GND et à 5 V.
• Pin 4 "RS" de l'afficheur --- Pin 12 de l'Arduino
• Pin 5 "R/W" de l'afficheur --- GND de l'Arduino
• Pin 6 "Enable" de l'afficheur --- Pin 11 de l'Arduino

Les pins 7, 8, 9 et 10 de l'afficheur ne sont pas branchées, car nous utiliserons l'afficheur en mode 4 bits plutôt qu'en mode 8 bits (ce qui permet d'économiser les entrées/sorties de l'Arduino).

• Pin 11 "D4" de l'afficheur --- Pin 5 de l'Arduino
• Pin 12 "D5" de l'afficheur --- Pin 4 de l'Arduino
• Pin 13 "D6" de l'afficheur --- Pin 3 de l'Arduino
• Pin 14 "D7" de l'afficheur --- Pin 2 de l'Arduino

Les pins 15 et 16 servent à alimenter le rétroéclairage.  Sur certains modèles d'afficheur, le rétroéclairage n'est pas indispensable (sauf pour lire l'affichage dans l'obscurité), alors que pour d'autres modèles l'affichage est illisible si le rétroéclairage n'est pas activé.

• Pin 15 de l'afficheur --- Résistance d'environ 100 Ω*  --- 5 V de l'Arduino
• Pin 16 de l'afficheur --- GND de l'Arduino

(* j'ai un afficheur dont le rétroéclairage ne s'allume qu'à la condition que je n'ajoute aucune résistance)

La bibliothèque LiquidCrystal

Pour présenter les informations sur l'afficheur, nous utiliserons la bibliothèque "LiquidCrystal", qui a été spécialement conçue à cette fin.  Nul besoin de l'installer, puisqu'elle est fournie avec l'IDE.

Pour vérifier rapidement que votre afficheur est bel et bien fonctionnel, téléchargez l'exemple "HelloWord" dans votre Arduino.  Vous devriez voir le message "hello, world!" apparaître sur la première ligne de l'afficheur, alors que sur la deuxième ligne un compteur s'incrémente à chaque seconde.

Si rien ne s'affiche, pas de panique!  Tournez le bouton du potentiomètre qui contrôle le contraste. Sinon, vérifiez à nouveau toutes les connexions.  

Pour afficher un texte, on utilise la commande "print".  Le texte débute toujours à la position du curseur.   Lorsque vous écrivez quelque chose, le curseur se déplace automatiquement à la position qui suit immédiatement le texte affiché.

La position du curseur se règle au moyen de la commande "setCursor(colonne, ligne)".  Il est important de noter que la première ligne en haut porte le numéro 0, et la première colonne à gauche porte le numéro 0.  L'instruction "lcd.setCursor(0,0)" positionnera donc le curseur en haut à gauche.

Si vous désirez que l'utilisateur entre du texte qui apparaîtra à l'afficheur, il peut être utile de montrer un symbole clignotant qui indique la position du curseur, en utilisant la commande "blink".  Pour des exemples de situation où on affiche du texte tapé par l'utilisateur, vous pouvez vous référer à mon article Arduino, clavier numérique et afficheur LCD.

Je vous propose ci-dessous un sketch de mon crû, qui a l'avantage d'être commenté en français.  

Dans un premier temps, un texte fixe apparaît, centré sur l'écran.  Je fais ensuite défiler un texte vers la gauche et vers la droite, j'affiche un texte caractère par caractère, je fais clignoter un texte, puis je fais apparaître un curseur clignotant et je change sa position (voir l'afficheur en action sur la vidéo ci-dessous).

	/**********************************************************
	Utilisation d'un afficheur LCD 16 X 2 (compatible Hitachi
	HD44780 et de la bibliothèque LiquidCrystal.
	http://electroniqueamateur.blogspot.ca/2017/01/utiliser-un-afficheur-lcd-2-x-16-avec.html
	**********************************************************/
	// Nous indiquons que nous utiliserons la bibliothèque
	// LiquidCrystal:
	#include <LiquidCrystal.h>
	// Définition des pins de l'Arduino qui sont branchées
	// aux pins de l'afficheur LCD
	const int pinRS = 12; // pin 4 (RS) de l'afficheur branchée à pin 12 de l'Arduino
	const int pinEnable = 11; // pin 6 (Enable) de l'afficheur branchée à pin 11 de l'Arduino
	const int pinD4 = 5; // pin 11 (D4) de l'afficheur branchée à pin 5 de l'Arduino
	const int pinD5 = 4; // pin 12 (D5) de l'afficheur branchée à pin 4 de l'Arduino
	const int pinD6 = 3; // pin 13 (D6) de l'afficheur branchée à pin 3 de l'Arduino
	const int pinD7 = 2; // pin 14 (D7) de l'afficheur branchée à pin 2 de l'Arduino
	// Initialisation de la bibliothèque LiquidCrystal en utilisant les pins définies ci-dessus:
	LiquidCrystal lcd(pinRS, pinEnable, pinD4, pinD5, pinD6, pinD7);
	// Préparation de deux chaînes de caractère
	// qui seront affichées lettre par lettre:
	char ligne1[ ] = "Lettre par"; // 16 caractères max
	char ligne2[] = "lettre..."; // 16 caractères max
	void setup() {
	// On indique que notre afficheur comporte 2 lignes de 16 caractères:
	lcd.begin(16, 2);
	}
	void loop() {
	// *****Affichage d'un texte fixe:****************************************
	// On place le curseur au troisième caractère (2) de la première ligne (0)
	lcd.setCursor(2, 0);
	// On écrit un message (il débutera à la position du curseur):
	lcd.print("Electronique");
	// On place le curseur au quatrième caractère (3) de la deuxième ligne (1)
	lcd.setCursor(3, 1);
	// On écrit un message sur la 2e ligne:
	lcd.print("en amateur");
	// on laisse le temps de lire le message
	delay(3000);
	// on efface:
	lcd.clear();
	// *****Texte défilant vers la gauche:****************************************
	// On place le curseur au premier caractère (0) de la première ligne (0)
	lcd.setCursor(0, 0);
	// On écrit un message qui débute à la position du curseur:
	lcd.print("Texte defilant");
	delay(1000);
	// On place le curseur au premier caractère (0) de la deuxième ligne (1)
	lcd.setCursor(0, 1);
	// On écrit un message qui débute à la position du curseur:
	lcd.print("Vers la gauche");
	delay (1000);
	// On déplace le texte de 16 position vers la gauche
	for (int i = 0; i < 16; i++) {
	lcd.scrollDisplayLeft();
	delay(300);
	}
	// on efface:
	lcd.clear();
	// *****Texte défilant vers la droite:****************************************
	// On place le curseur au premier caractère (0) de la première ligne (0)
	lcd.setCursor(0, 0);
	// On écrit un message:
	lcd.print("Texte defilant");
	delay(1000);
	// On place le curseur au premier caractère (0) de la deuxième ligne (1)
	lcd.setCursor(0, 1);
	// On écrit un message:
	lcd.print("Vers la droite");
	delay (1000);
	// déplacement de 16 position vers la droite
	for (int i = 0; i < 16; i++) {
	lcd.scrollDisplayRight();
	delay(300);
	}
	// on efface:
	lcd.clear();
	// *****Affichage d'un texte un caractère à la fois:**************************
	//curseur placé au début de la première ligne
	lcd.setCursor(0, 0);
	delay(800);
	// on écrit, un après l'autre, tous les caractères de la chaîne "ligne1"
	for (int i = 0; i < (sizeof(ligne1) - 1); i++) {
	lcd.print(ligne1[i]);
	delay(300);
	}
	// On place le curseur au 7e caractère de la 2e ligne:
	lcd.setCursor(6, 1);
	// on écrit, un après l'autre, tous les caractères de la chaîne "ligne2"
	for (int i = 0; i < (sizeof(ligne2) - 1); i++) {
	lcd.print(ligne2[i]);
	delay(300);
	}
	delay(1000);
	//on efface
	lcd.clear();
	// *****Affichage d'un texte clignotant:****************************************
	// On place le curseur au huitième caractère (7) de la première ligne (0)
	lcd.setCursor(7, 0);
	// On écrit un message qui débute à la position du curseur:
	lcd.print("Je");
	// On place le curseur au cinquième caractère (4) de la deuxième ligne (1)
	lcd.setCursor(4, 1);
	// écriture de la deuxième ligne:
	lcd.print("clignote!");
	// on fait clignoter le messages à quelques reprises:
	for (int i = 0; i < 3; i++) {
	delay(1000);
	lcd.noDisplay();
	delay(500);
	// Turn on the display:
	lcd.display();
	}
	delay(2000);
	// on efface:
	lcd.clear();
	// *****Affichage d'un curseur clignotant:****************************************
	// On place le curseur au premier caractère (0) de la première ligne (0)
	lcd.setCursor(0, 0);
	// On écrit un message qui débute à la position du curseur:
	lcd.print("Curseur:");
	// On montre le curseur clignotant pendant 3 secondes (il se trouve immédiatement
	// après le mot qu'on vient d'écrite
	lcd.blink();
	delay(3000);
	// On place le curseur au premier caractère (0) de la deuxième ligne (1)
	lcd.setCursor(0, 1);
	// On écrit un message qui débute à la position du curseur:
	lcd.print("(Ou va-t-il?)");
	// On déplace progressivement le curseur vers la droite:
	for (int i = 9; i <= 15; i++) {
	lcd.setCursor(i, 0);
	delay(800);
	}
	lcd.noBlink();
	lcd.clear();
	}

view raw LCD_demo.ino hosted with ❤ by GitHub

Vous serez peut-être intéressé par cet article qui montre comment produire une progress bar sur un LCD.

Pour quelques exemples d'utilisation d'un afficheur LCD à l'intérieur d'un projet impliquant l'Arduino, vous pouvez consulter les articles suivants:  Arduino, clavier numérique et afficheur LCD, Une horloge pour votre Arduino et Mesurer une température avec un Arduino.

Vous pouvez également apprendre à utiliser un afficheur LCD avec un Raspberry Pi, une carte MSP430 Launchpad, ou une carte Pinguino ou une carte STM32 Nucleo.

Yves Pelletier   (Twitter, Facebook)