Comment utiliser un écran LCD 16 × 2 caractères avec Arduino

Ce didacticiel comprend tout ce que vous devez savoir sur le contrôle d’un écran LCD de caractère avec Arduino. J’ai inclus un schéma de câblage et de nombreux exemples de codes. Ces écrans sont parfaits pour afficher des données de capteur ou du texte et ils sont également assez bon marché.

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

Comme vous le verrez, vous avez besoin de beaucoup de connexions pour contrôler ces écrans. J’aime donc les utiliser avec un module d’interface I2C monté à l’arrière. Avec ce module I2C, vous n’avez besoin que de deux connexions pour contrôler l’écran LCD. Consultez le tutoriel ci-dessous si vous souhaitez également utiliser un module I2C:

Composants matériels

1. LCD LCD 16 × 2 caractères
2. LCD LCD 20 × 4 caractères
3. Arduino Uno Rev 3
4. Breadboard
5. Fils
6. Potentiomètre 10 kΩ
7. Câble USB type A / B

Présentation du matériel

Ces écrans LCD sont disponibles dans de nombreuses tailles différentes (16 × 2 1602, 20 × 4 2004, 16 × 1, etc.), mais ils utilisent tous la même  puce  de contrôleur LCD à interface parallèle HD44780 d’Hitachi. Cela signifie que vous pouvez facilement les échanger. Il vous suffira de modifier les spécifications de taille dans votre code Arduino.

Spécifications de l’écran LCD 16 × 2

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

Brochage LCD 16 × 2

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

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

Test de l’écran LCD et réglage du contraste

Afin de tester l’affichage, vous devrez effectuer les connexions comme indiqué dans la figure ci-dessous.

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

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

Branchez le connecteur USB de l’Arduino pour alimenter l’écran LCD. Vous devriez voir le rétroéclairage s’allumer. Tournez maintenant le potentiomètre jusqu’à ce qu’une (16 × 2 LCD) ou 2 rangées (20 × 4 LCD) de rectangles apparaissent.

• Faites tourner le potentiomètre jusqu’à ce qu’une rangée de rectangles apparaisse.
• Vous pouvez modifier le contraste plus tard si nécessaire.

Comment connecter l’écran LCD à Arduino UNO

Pour contrôler l’écran LCD et afficher les caractères, vous devrez ajouter quelques connexions supplémentaires. Vérifiez le schéma de câblage ci-dessous et le tableau de brochage de l’introduction de cet article.

Nous utiliserons l’écran LCD en mode 4 bits, cela signifie que vous n’avez rien à connecter à D0-D3. La broche R / W est connectée à la terre, cela tirera la broche LOW et réglera l’écran LCD en mode WRITE.

Une fois que vous avez tout câblé, nous pouvons commencer à programmer l’écran LCD.

Exemple de code Arduino pour écran LCD à caractères

Pour contrôler l’écran LCD, nous utiliserons la   bibliothèque LiquidCrystal . Cette bibliothèque doit être préinstallée avec l’  IDE Arduino . Vous pouvez le trouver en allant dans  Sketch> Inclure la bibliothèque> LiquidCrystal .

La bibliothèque LiquidCrystal est dotée de nombreuses fonctions intégrées et facilite le contrôle des écrans LCD de caractères.

L’exemple de code ci-dessous vous montre comment afficher un message sur l’écran LCD. Ensuite, je vais vous montrer comment fonctionne le code et comment vous pouvez utiliser les autres fonctions de la bibliothèque LiquidCrystal.

// 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 la sortie suivante sur l’écran LCD:

Comment fonctionne le code

Après avoir inclus la bibliothèque, l’étape suivante consiste à créer une nouvelle instance de la classe LiquidCrystal. Le est fait avec la fonction  LiquidCrystal(rs, enable, d4, d5, d6, d7). En tant que paramètres, nous utilisons les broches Arduino auxquelles nous avons connecté l’écran. Notez que nous avons appelé l’affichage «lcd». Vous pouvez lui donner un nom différent si vous voulez comme ‘menu_display’. Vous devrez remplacer «lcd» par le nouveau nom dans le reste de l’esquisse.

Dans l’  setup() écran LCD est lancé avec la fonction  begin(cols,rows). Lorsque vous utilisez un écran LCD 20 × 4, changez cette ligne en lcd.begin (20,4);

Dans le,  loop() le curseur est réglé sur la troisième colonne et la première ligne de l’écran LCD avec  lcd.setCursor(2,0). Notez que le comptage commence à 0 et que le premier argument spécifie la colonne. Si vous ne spécifiez pas la position du curseur, le texte sera imprimé à la position d’origine par défaut (0,0) si l’affichage est vide, ou derrière le dernier caractère imprimé.

Ensuite, la chaîne “Hello World!” est imprimé avec  lcd.print("Hello World!"). Notez que vous devez placer des guillemets (”“) autour du texte. Lorsque vous souhaitez imprimer des nombres ou des variables, aucun guillemet n’est nécessaire.

Si vous voulez voir un exemple pour afficher (changer) les variables sur l’écran LCD, consultez mon tutoriel pour le capteur de distance à ultrasons HC-SR04:

• Comment utiliser un capteur de distance à ultrasons HC-SR04 avec Arduino

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

Autres fonctions de la bibliothèque LiquidCrystal

La bibliothèque LiquidCrystal Arduino possède de nombreuses autres fonctions intégrées que vous pourriez trouver utiles. Vous pouvez en trouver un aperçu ci-dessous avec des explications et quelques extraits de code.

clear()

Efface l’écran LCD et positionne le curseur dans le coin supérieur gauche (première ligne et première colonne) de l’écran. Vous pouvez utiliser cette fonction pour afficher différents mots dans une 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()

Positionne le curseur dans le coin supérieur gauche de l’écran LCD. Utilisez clear () si vous souhaitez également effacer l’affichage.

cursor()

Affiche le curseur LCD: un trait de soulignement (ligne) à la position du prochain caractère à imprimer.

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);
}

clignoter()

Crée un curseur LCD de style bloc clignotant: un rectangle clignotant à la position du caractère suivant à imprimer.

noBlink ()

Désactive le curseur LCD de style bloc. 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 le texte ou les curseurs qui ont été imprimés sur l’écran.

noDisplay()

Cette fonction désactive tout texte ou curseur imprimé sur l’écran LCD. Le texte / les données ne sont pas effacés de la mémoire LCD. Cela signifie qu’il sera à nouveau affiché lors de l’appel de la fonction display ().

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 peut être utilisée pour écrire un caractère sur l’écran LCD. Consultez la section sur la création et l’affichage de caractères personnalisés ci-dessous pour plus d’informations.

scrollDisplayLeft()

Fait défiler le contenu de l’affichage (texte et curseur) d’un espace vers la gauche. Vous pouvez utiliser cette fonction dans la section boucle du code en combinaison 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’affichage (texte et curseur) d’un espace vers la droite.

autoscroll()

Cette fonction active le défilement automatique de l’écran LCD. Cela fait que chaque sortie de caractère à l’affichage repousse les caractères précédents d’un espace. Si la direction actuelle du texte est de gauche à droite (valeur par défaut), l’affichage défile vers la gauche; si la direction actuelle est de droite à gauche, l’affichage défile vers la droite. Cela a pour effet de sortir chaque nouveau caractère au même emplacement sur l’écran LCD.

L’exemple d’esquisse suivant permet le défilement automatique et imprime le caractère 0 à 9 à la position (16,0) de l’écran LCD. Changez ceci en (20,0) pour un écran 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 de l’écran LCD.

leftToRight()

Cette fonction fait passer le texte vers la droite du curseur, comme si l’affichage était justifié à gauche (par défaut).

rightToLeft()

Cette fonction fait passer le texte vers la gauche du curseur, comme si l’affichage était justifié à 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 l’écran LCD. Ceci est particulièrement utile si vous souhaitez afficher un caractère qui ne fait pas partie du jeu de caractères ASCII standard.

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

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

Exemple de code Arduino de caractères personnalisés

L’exemple d’esquisse 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 la sortie suivante sur l’écran LCD:

Comment fonctionne le code

Après avoir inclus la bibliothèque et créé l’objet LCD, les tableaux de caractères personnalisés sont définis. Chaque tableau se compose de 8 octets, 1 octet pour chaque ligne. Dans cet exemple, 8 caractères personnalisés sont créés.

En regardant de près le tableau, vous verrez ce qui suit. Chaque ligne se compose de 5 nombres correspondant aux 5 pixels dans un caractère de 5 x 8 points. Un 0 signifie pixel désactivé et 1 signifie pixel activé.

Il est possible d’éditer chaque ligne à la main, mais je recommande d’utiliser cet  outil visuel  sur GitHub. Cette application crée automatiquement le tableau de caractères et vous pouvez cliquer sur les pixels pour les activer ou les désactiver.

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 deuxième argument est le tableau de caractères que nous avons créé.

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

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 c’est le cas,  partagez-le avec un ami  qui aime aussi l’électronique et la fabrication d’objets!

J’aimerais savoir quels projets vous prévoyez de construire (ou avez déjà construits) avec ces écrans LCD. Si vous avez des questions, des suggestions ou si vous pensez que des éléments manquent dans ce didacticiel,  veuillez laisser un commentaire ci-dessous.