Tutoriel Complet Arduino LCD 16×2 : Connexion, Programmation et Affichage de Données

Introduction

Dans ce tutoriel Arduino, nous allons apprendre à connecter et utiliser un écran LCD (Liquid Crystal Display) avec Arduino. Les écrans LCD de ce type sont très populaires et largement utilisés dans de nombreux projets électroniques car ils permettent d'afficher des informations simples, comme des données de capteurs, tout en étant très abordables.

Je les ai déjà utilisés dans plusieurs de mes projets Arduino, que vous pouvez consulter ici :

Projet Système de Sécurité et d'Alarme Arduino
Distributeur Automatique DIY – Projet Mécatronique basé sur Arduino
Projet Mesure de Distance et Niveau à Bulle Numérique Arduino

Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous. Il comprend tout ce qu'il faut savoir sur l'utilisation d'un écran LCD caractère avec Arduino : brochage, schéma de câblage et plusieurs exemples de code.

Qu'est-ce qu'un Écran LCD Caractère ?

Un écran LCD caractère est un type d'affichage unique qui ne peut afficher que des caractères ASCII individuels de taille fixe. En utilisant ces caractères individuels, nous pouvons former du texte.

Si on observe de plus près l'écran, on remarque de petites zones rectangulaires composées d'une grille de 5×8 pixels. Chaque pixel peut s'allumer individuellement, ce qui permet de générer des caractères dans chaque grille.

Tutoriel Complet Arduino LCD 16×2 : Connexion, Programmation et Affichage de Données

Le nombre de zones rectangulaires définit la taille du LCD. Le plus populaire est le LCD 16×2, qui possède deux lignes avec 16 zones rectangulaires ou caractères chacune. Bien sûr, il existe d'autres tailles comme 16×1, 16×4, 20×4, etc., mais ils fonctionnent tous sur le même principe. De plus, ces LCD peuvent avoir différentes couleurs de fond et de texte.

Brochage du LCD 16×2

Il possède 16 broches. La première de gauche à droite est la broche Ground (GND). La deuxième est le VCC qu'on connecte à la broche 5 volts de la carte Arduino. Vient ensuite la broche Vo sur laquelle on peut connecter un potentiomètre pour contrôler le contraste de l'affichage.

Ensuite, la broche RS (Register Select) sert à sélectionner si on envoie des commandes ou des données au LCD. Par exemple, si la broche RS est à l'état bas (0 volt), on envoie des commandes au LCD comme : positionner le curseur à un emplacement spécifique, effacer l'affichage, éteindre l'affichage, etc. Quand la broche RS est à l'état haut (5 volts), on envoie des données ou caractères au LCD.

Vient ensuite la broche R/W qui sélectionne le mode lecture ou écriture vers le LCD. Le mode écriture est utilisé pour envoyer des commandes et données au LCD. Le mode lecture est utilisé par le LCD lui-même lors de l'exécution du programme, ce qu'on n'a pas besoin d'aborder dans ce tutoriel.

Puis la broche E (Enable) qui active l'écriture dans les registres, ou les 8 broches de données suivantes de D0 à D7. C'est par ces broches qu'on envoie les 8 bits de données lorsqu'on écrit dans les registres. Par exemple, pour afficher la lettre majuscule A, on enverra 0100 0001 selon la table ASCII. Les deux dernières broches A et K (anode et cathode) servent au rétroéclairage LED.

Au final, on n'a pas à trop se soucier du fonctionnement interne du LCD, car la bibliothèque LiquidCrystal gère presque tout. Sur le site officiel d'Arduino, vous trouverez les fonctions de la bibliothèque qui facilitent l'utilisation du LCD. On peut utiliser la bibliothèque en mode 4 ou 8 bits. Dans ce tutoriel, nous utiliserons le mode 4 bits, c'est-à-dire seulement 4 des 8 broches de données.

Comment Connecter Arduino au LCD – Schéma de Câblage

Voici comment connecter l'écran LCD 16×2 à une carte Arduino.

Nous utiliserons seulement 6 broches numériques de la carte Arduino. Les registres du LCD D4 à D7 seront connectés aux broches numériques 4 à 7 de l'Arduino. La broche Enable sera connectée à la broche 2 et la broche RS à la broche 1. La broche R/W sera connectée à la masse et la broche Vo au curseur du potentiomètre.

Composants Nécessaires

Écran LCD Caractère 16×2
Potentiomètre (10 kΩ recommandé)
Carte Arduino (Uno, Nano, etc.)
Plaque d'essai (breadboard) et fils de connexion

Réglage du Contraste du LCD

On peut ajuster le contraste du LCD en modifiant la tension d'entrée sur la broche Vo. On utilise un potentiomètre pour pouvoir régler finement le contraste en ajustant la tension d'entrée de 0 à 5V.

Puis-je utiliser le LCD sans Potentiomètre ?

Oui, si vous n'avez pas de potentiomètre, vous pouvez quand même régler le contraste du LCD en utilisant un diviseur de tension composé de deux résistances. Avec le diviseur de tension, il faut régler la tension entre 0 et 5V pour obtenir un bon contraste. J'ai trouvé qu'une tension d'environ 1V fonctionnait très bien pour mon LCD. J'ai utilisé une résistance de 1 kΩ et une de 220 Ω pour obtenir un bon contraste.

Il existe une autre méthode pour régler le contraste du LCD : en fournissant un signal PWM depuis l'Arduino vers la broche Vo du LCD. On peut connecter la broche Vo à n'importe quelle broche PWM de l'Arduino, et dans la section setup, utiliser la ligne de code suivante :

analogWrite(11, 100); // Génère un signal PWM sur la broche D11, valeur 100 (sur 255)

Cela génère un signal PWM sur la broche D11, avec une valeur de 100 sur 255, ce qui correspond à une tension d'environ 2V sur la broche Vo du LCD.

Code Arduino pour LCD

Voici un code simple qui explique le principe de fonctionnement de la bibliothèque LiquidCrystal. C'est le code du premier exemple de la vidéo :

/* 
 * Tutoriel Arduino LCD 
 * Créé par Dejan Nedelkovski, 
 * www.HowToMechatronics.com 
 */
#include <LiquidCrystal.h> // Inclut la bibliothèque LiquidCrystal
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Crée un objet LCD. Paramètres : (rs, enable, d4, d5, d6, d7)

void setup() {
  lcd.begin(16, 2); // Initialise l'interface vers l'écran LCD et spécifie les dimensions (largeur et hauteur)
}

void loop() {
  lcd.print("Arduino"); // Affiche "Arduino" sur le LCD
  delay(3000); // Délai de 3 secondes
  lcd.setCursor(2, 1); // Définit l'emplacement où le texte suivant sera affiché
  lcd.print("LCD Tutorial");
  delay(3000);
  lcd.clear(); // Efface l'affichage
  lcd.blink(); // Affiche le curseur clignotant du LCD
  delay(4000);
  lcd.setCursor(7, 1);
  delay(3000);
  lcd.noBlink(); // Éteint le curseur clignotant
  lcd.cursor(); // Affiche un soulignement à la position du prochain caractère
  delay(4000);
  lcd.noCursor(); // Cache le curseur du LCD
  lcd.clear(); // Efface l'écran LCD
}

Explication du Code

La première chose à faire est d'inclure la bibliothèque LiquidCrystal. On peut le faire via : Croquis > Inclure une bibliothèque > LiquidCrystal. Ensuite, il faut créer un objet LC. Les paramètres de cet objet doivent être les numéros des broches d'entrée numériques de la carte Arduino correspondant aux broches du LCD dans l'ordre : (RS, Enable, D4, D5, D6, D7). Dans le setup, on doit initialiser l'interface vers le LCD et spécifier les dimensions de l'affichage avec la fonction begin().

Dans la boucle, on écrit notre programme principal. Avec la fonction print(), on affiche sur le LCD.

lcd.print("Arduino"); // Affiche "Arduino" sur le LCD

La fonction setCursor() sert à définir l'emplacement où le texte suivant sera affiché.

lcd.setCursor(2, 1); // Définit l'emplacement (colonne 2, ligne 1)

La fonction blink() affiche un curseur clignotant et noBlink() l'éteint. La fonction cursor() affiche un curseur de type soulignement et noCursor() le cache. Avec clear(), on efface l'écran LCD.

lcd.clear(); // Efface l'écran LCD

Exemple de Défilement de Texte sur LCD 16×2 et Arduino

Si on a un texte de plus de 16 caractères, on peut le faire défiler en utilisant les fonctions scrollDisplayLeft() ou scrollDisplayRight() de la bibliothèque LiquidCrystal.

Voici un exemple de code :

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Scrolling Text Example");
}

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

On peut choisir le sens du défilement (gauche ou droite) avec scrollDisplayLeft() ou scrollDisplayRight(). La fonction delay() permet de régler la vitesse de défilement.

Pour un contrôle plus précis du défilement, on peut aussi le programmer soi-même avec une boucle "for". Voici un exemple :

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

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

void loop() {
  // Défilement vers la droite
  for (int i = 0; i <= 13; i++) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
  // Défilement vers la gauche
  for (int i = 12; i >= 1; i--) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
}

Comment Générer et Afficher des Caractères Personnalisés sur le LCD

En plus des caractères ASCII, la bibliothèque LiquidCrystal permet de créer et d'afficher des caractères personnalisés sur le LCD.

On peut définir l'apparence de chaque caractère par un tableau de 8 octets. Voici un exemple :

#include <LiquidCrystal.h>

byte heart[8] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

byte smile[8] = {
  B00000,
  B00000,
  B01010,
  B00000,
  B10001,
  B01110,
  B00000,
  B00000
};

byte lock[8] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

byte character[8] = {
  B11111,
  B10101,
  B11111,
  B01010,
  B01110,
  B11111,
  B01110,
  B01110
};

LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.createChar(0, heart);
  lcd.createChar(1, smile);
  lcd.createChar(2, lock);
  lcd.createChar(3, character);
  lcd.clear();
  lcd.print("Custom Character");
}

void loop() {
  lcd.setCursor(1, 1);
  lcd.write(byte(0)); // Affiche le caractère personnalisé 0 (cœur)
  lcd.setCursor(5, 1);
  lcd.write(byte(1)); // Sourire
  lcd.setCursor(9, 1);
  lcd.write(byte(2)); // Cadenas
  lcd.setCursor(13, 1);
  lcd.write(byte(3)); // Personnage
}

On voit comment définir l'apparence du caractère en changeant les 0 en 1 dans la grille de 5×8 pixels.

Dans le setup, il faut créer le caractère personnalisé avec la fonction createChar().

lcd.createChar(0, heart); // Crée un caractère personnalisé

Le premier paramètre est un nombre entre 0 et 7 (on a 8 emplacements pour caractères personnalisés). Le second est le nom du tableau d'octets.

On écrit le caractère personnalisé sur l'affichage avec la fonction write() en passant le numéro du caractère en paramètre.

lcd.write(byte(0)); // Affiche le caractère personnalisé 0 (cœur)

Voir aussi : Tutoriel Écran Tactile Arduino | TFT LCD

Conclusion

Nous avons couvert pratiquement tout ce qu'il faut savoir sur l'utilisation d'un LCD avec Arduino. Ces écrans LCD caractère sont vraiment pratiques pour afficher des informations dans de nombreux projets électroniques. Dans les exemples ci-dessus, j'ai utilisé un LCD 16×2, mais le même principe s'applique à n'importe quelle taille de ces écrans caractères.

J'espère que ce tutoriel vous a plu et que vous avez appris quelque chose de nouveau. N'hésitez pas à poser vos questions dans les commentaires ci-dessous et consultez ma collection complète de 30+ projets Arduino.