Comment utiliser un écran LCD 16×2 avec Arduino

Ce tutoriel contient tout ce que vous devez savoir pour contrôler un écran LCD à caractères avec Arduino. J’ai inclus un schéma de câblage et de nombreux exemples de code. Ces écrans sont parfaits pour afficher des données de capteurs ou du texte, et ils sont aussi assez abordables.

La première partie de cet article couvre les bases de l’affichage de texte et de nombres. Dans la seconde moitié, j’expliquerai plus en détail comment afficher des caractères personnalisés et comment utiliser les autres fonctions de la LiquidCrystal bibliothèque Arduino.

Comme vous le verrez, il faut pas mal de connexions pour contrôler ces écrans. C’est pourquoi j’aime les utiliser avec un module I2C interface monté à l’arrière. Avec ce module I2C, vous n’avez besoin que de deux connexions pour piloter l’écran LCD. Consultez le tutoriel ci-dessous si vous souhaitez aussi utiliser un module I2C :

Fournitures

Composants matériels

	16×2 character LCD	× 1	Amazon
	20×4 character LCD	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	10 kΩ potentiometer	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Logiciel

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Présentation du matériel

Ces LCD existent en plusieurs tailles (16×2 1602, 20×4 2004, 16×1, etc.), mais ils utilisent tous le même HD44780 contrôleur LCD à interface parallèle de Hitachi. Cela signifie que vous pouvez facilement les remplacer. Il vous suffira de modifier les spécifications de taille dans votre code Arduino.

Spécifications du LCD 16×2

Tension de fonctionnement	5 V
Contrôleur	Contrôleur LCD Hitachi HD44780
Résolution de l’écran	2 lignes x 16 caractères
Résolution des caractères	5 x 8 pixels
Dimensions du module	80 x 36 x 12 mm
Dimensions de la zone visible	64,5 x 16,4 mm
Coût	Check price

Pour plus d’informations, vous pouvez consulter les fiches techniques ci-dessous. Les fiches 16×2 et 20×4 incluent les dimensions de l’écran LCD, et la fiche HD44780 donne plus de détails sur le pilote LCD Hitachi.

Brochage du LCD 16×2

L’écran LCD possède 16 broches de connexion, numérotées de 1 à 16 de gauche à droite.

Le brochage d’un LCD standard HD44780 est donné dans le tableau ci-dessous :

N° de broche	Symbole	Connexion	Fonction
1	VSS	GND Arduino	Masse du signal
2	VDD	5 V Arduino	Alimentation logique du LCD
3	V0	Potentiomètre 10 kΩ	Réglage du contraste
4	RS	Broche 2 Arduino	Signal de sélection de registre
5	R/W	GND Arduino	Signal de sélection lecture/écriture
6	E	Broche 3 Arduino	Signal d’activation
7 – 14	D0 – D7	–	Lignes du bus de données utilisées en mode 8 bits
11 – 14	D4 – D7	Broches 4 – 7 Arduino	Lignes du bus de données utilisées en mode 4 bits
15	A (LED+)	5 V Arduino	Anode du rétroéclairage LCD
16	K (LED-)	GND Arduino	Cathode du rétroéclairage LCD

Tester le LCD et régler le contraste

Pour tester l’écran, vous devez réaliser les connexions comme indiqué sur la figure ci-dessous.

La plupart des LCD ont une résistance en série intégrée pour le rétroéclairage LED. Vous devriez la trouver à l’arrière de l’écran, connectée à la broche 15 (Anode). Si votre écran n’a pas de résistance intégrée, vous devrez en ajouter une entre le 5 V et la broche 15. Il est généralement sûr d’utiliser une résistance de 220Ω, mais cette valeur peut rendre l’écran un peu sombre. Vous pouvez consulter la fiche technique pour connaître le courant maximal du rétroéclairage et choisir une résistance adaptée.

Une fois le LCD câblé, vous devez régler le contraste de l’écran. Cela se fait en tournant le potentiomètre 10 kΩ dans le sens horaire ou antihoraire.

Branchez le connecteur USB de l’Arduino pour alimenter le LCD. Le rétroéclairage devrait s’allumer. Tournez ensuite le potentiomètre jusqu’à ce qu’une (LCD 16×2) ou deux lignes (LCD 20×4) de rectangles apparaissent.

Vous pourrez ajuster le contraste plus tard si besoin.

Comment connecter le LCD à l’Arduino UNO

Pour contrôler le LCD et afficher des caractères, vous devez ajouter quelques connexions supplémentaires. Consultez le schéma de câblage ci-dessous et le tableau de brochage présenté au début de cet article.

Nous utiliserons le LCD en mode 4 bits, ce qui signifie que vous n’avez pas besoin de connecter les broches D0-D3. La broche R/W est reliée à la masse, ce qui la met à LOW et configure le LCD en mode ÉCRITURE.

Une fois tout câblé, nous pouvons commencer à programmer le LCD.

Exemple de code Arduino pour LCD à caractères

Pour contrôler le LCD, nous utiliserons la LiquidCrystal bibliothèque. Cette bibliothèque est normalement préinstallée avec l’IDE Arduino. Vous pouvez la trouver en allant dans Sketch > Include Library > LiquidCrystal.

La bibliothèque LiquidCrystal offre de nombreuses fonctions intégrées et facilite grandement le contrôle des LCD à caractères.

Le code d’exemple ci-dessous montre comment afficher un message sur le LCD. Ensuite, je vous expliquerai le fonctionnement du code et comment utiliser les autres fonctions de la bibliothèque LiquidCrystal.

/* Basic Arduino example code for displaying text 
  on 16x2, 20x4 etc. character LCDs. 
  www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Vous devriez voir l’affichage suivant sur le LCD :

Comment fonctionne le code

Après avoir inclus la bibliothèque, l’étape suivante est de créer une nouvelle instance de la classe LiquidCrystal. Cela se fait avec la fonction LiquidCrystal(rs, enable, d4, d5, d6, d7). En paramètres, on utilise les broches Arduino auxquelles l’écran est connecté. Notez que nous avons nommé l’écran ‘lcd’. Vous pouvez lui donner un autre nom comme ‘menu_display’. Il faudra alors remplacer ‘lcd’ par ce nouveau nom dans le reste du sketch.

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

Dans le setup() le LCD est initialisé avec la fonction begin(cols,rows). Pour un LCD 20×4, changez cette ligne en lcd.begin(20,4);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

Dans le loop() le curseur est positionné à la troisième colonne et première ligne du LCD avec lcd.setCursor(2,0). Notez que le comptage commence à 0, et que le premier argument indique la colonne. Si vous ne spécifiez pas la position du curseur, le texte s’affichera à la position par défaut (0,0) si l’écran est vide, ou juste après le dernier caractère affiché.

Ensuite, la chaîne ‘Hello World!’ est affichée avec lcd.print("Hello World!"). Notez qu’il faut mettre des guillemets (” “) autour du texte. Pour afficher des nombres ou variables, les guillemets ne sont pas nécessaires.

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Si vous souhaitez un exemple pour afficher (modifier) des variables sur le LCD, consultez mon tutoriel sur How to use a HC-SR04 Ultrasonic Distance Sensor with Arduino.

Dans l’exemple, j’ai utilisé un écran LCD I2C, mais le code après la configuration est identique pour les deux types.

Autres fonctions de la bibliothèque LiquidCrystal

La bibliothèque LiquidCrystal Arduino propose de nombreuses autres fonctions intégrées qui peuvent vous être utiles. Vous trouverez ci-dessous un aperçu avec explications et extraits de code.

clear()

Efface l’écran LCD et place le curseur en haut à gauche (première ligne, première colonne). Vous pouvez utiliser cette fonction pour afficher différents mots en boucle.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

home()

Place le curseur en haut à gauche du LCD. Utilisez clear() si vous souhaitez aussi effacer l’écran.

cursor()

Affiche le curseur LCD : un underscore (soulignement) à la position du prochain caractère à afficher.

noCursor()

Cache le curseur LCD. L’exemple suivant crée un curseur clignotant à la fin de “cursor()”.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("cursor()");
}

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

blink()

Crée un curseur LCD en forme de bloc clignotant : un rectangle clignotant à la position du prochain caractère à afficher.

noBlink()

Désactive le curseur en bloc clignotant. L’exemple suivant affiche le curseur clignotant pendant 5 secondes puis le désactive pendant 2 secondes.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

display()

Cette fonction allume l’écran LCD et affiche tout texte ou curseur déjà imprimé.

noDisplay()

Cette fonction éteint tout texte ou curseur affiché sur le LCD. Le texte/données ne sont pas effacés de la mémoire LCD, ils réapparaîtront donc lorsque display() sera appelé.

L’exemple suivant crée un effet de texte clignotant.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

write()

Cette fonction permet d’écrire un caractère sur le LCD. Voir la section sur la création et l’affichage de caractères personnalisés ci-dessous pour plus d’infos.

scrollDisplayLeft()

Fait défiler le contenu de l’écran (texte et curseur) d’un espace vers la gauche. Vous pouvez utiliser cette fonction dans la boucle du code avec delay(500) pour créer une animation de texte défilant.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("scrollDisplayLeft() example");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

scrollDisplayRight()

Fait défiler le contenu de l’écran (texte et curseur) d’un espace vers la droite.

autoscroll()

Cette fonction active le défilement automatique du LCD. Chaque caractère affiché pousse les caractères précédents d’un espace. Si le texte s’écrit de gauche à droite (par défaut), l’écran défile vers la gauche ; si c’est de droite à gauche, il défile vers la droite. Cela donne l’impression que chaque nouveau caractère s’affiche toujours au même endroit.

L’exemple suivant active le défilement automatique et affiche les caractères 0 à 9 à la position (16,0) du LCD. Changez en (20,0) pour un LCD 20×4.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Désactive le défilement automatique du LCD.

leftToRight()

Cette fonction fait défiler le texte vers la droite à partir du curseur, comme si l’écran était aligné à gauche (par défaut).

rightToLeft()

Cette fonction fait défiler le texte vers la gauche à partir du curseur, comme si l’écran était aligné à droite.

Comment créer et afficher des caractères personnalisés ?

Avec la fonction createChar() il est possible de créer et d’afficher des caractères personnalisés sur le LCD. C’est particulièrement utile si vous voulez afficher un caractère qui ne fait pas partie du jeu ASCII standard.

Infos techniques : les LCD basés sur le contrôleur Hitachi HD44780 ont deux types de mémoire : CGROM et CGRAM (Character Generator ROM et RAM). La CGROM génère tous les motifs de caractères 5 x 8 points à partir des codes caractères 8 bits standards. La CGRAM peut générer des motifs de caractères définis par l’utilisateur.

Pour les écrans 5 x 8 points, la CGRAM peut écrire jusqu’à 8 caractères personnalisés et pour les écrans 5 x 10 points 4. Pour plus d’infos, consultez la fiche technique.

Exemple de code Arduino pour caractères personnalisés

Le sketch d’exemple suivant crée et affiche huit caractères personnalisés (numérotés de 0 à 7).

/* Example sketch to create and display custom characters on 
   character LCD with Arduino and LiquidCrystal library. 
   For more info see www.www.makerguides.com */

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};
byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};
byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};
byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};
byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};
byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};
byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Specify the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clears the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

void loop() {
  // Print all the custom characters:
  lcd.setCursor(0, 1);
  lcd.write(byte(0));
  lcd.setCursor(2, 1);
  lcd.write(byte(1));
  lcd.setCursor(4, 1);
  lcd.write(byte(2));
  lcd.setCursor(6, 1);
  lcd.write(byte(3));
  lcd.setCursor(8, 1);
  lcd.write(byte(4));
  lcd.setCursor(10, 1);
  lcd.write(byte(5));
  lcd.setCursor(12, 1);
  lcd.write(byte(6));
  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}

Vous devriez voir l’affichage suivant sur le LCD :

Comment fonctionne le code

Après avoir inclus la bibliothèque et créé l’objet LCD, les tableaux des caractères personnalisés sont définis. Chaque tableau contient 8 octets, un par ligne. Ici, 8 caractères personnalisés sont créés.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

En regardant de près le tableau, vous verrez ceci : chaque ligne contient 5 chiffres correspondant aux 5 pixels d’un caractère 5 x 8 points. 0 signifie pixel éteint, 1 signifie pixel allumé.

Il est possible d’éditer chaque ligne à la main, mais je recommande d’utiliser cette visual tool sur GitHub. Cette application crée automatiquement le tableau de caractères et vous pouvez cliquer sur les pixels pour les allumer ou les éteindre.

Dans le setup(), les caractères personnalisés sont créés avec lcd.createChar(num, data).

Le premier argument de cette fonction est le numéro du caractère personnalisé (0-7) et le second est le tableau de caractères que nous avons créé.

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

Dans le loop() tous les caractères sont affichés avec lcd.write(). En paramètre, on utilise le numéro du caractère réservé.

  lcd.setCursor(0, 1);
  lcd.write(byte(0));

Conclusion

Dans cet article, je vous ai montré comment utiliser un écran LCD alphanumérique avec Arduino. J’espère que vous l’avez trouvé utile et instructif. Si vous avez des questions, des suggestions, ou si vous pensez que des éléments manquent dans ce tutoriel, n’hésitez pas à laisser un commentaire ci-dessous.

Bon bricolage 😉