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

Tension de fonctionnement5 V
ManetteContrôleur LCD Hitachi HD44780
Résolution d’écran2 lignes x 16 caractères
Résolution des caractères5 x 8 pixels
Module dimensions80 x 36 x 12 mm
Affichage des dimensions de la zone64,5 x 16,4 mm
CoûtVérifiez le prix

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.

LCD
Les broches en haut de l’écran sont numérotées de 1 à 16 de gauche à droite.

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

N ° de brochesymboleConnexionFonction
1VSSGND ArduinoMasse du signal
2VDD5 V ArduinoAlimentation logique pour LCD
3V010 kΩ potentiometerRéglage du contraste
4RSBroche 2 ArduinoEnregistrer le signal de sélection
5R / WGND ArduinoSignal de sélection en lecture / écriture
6ESTBroche 3 ArduinoSignal de validation de fonctionnement
7 – 14J0 – J7Lignes de bus de données utilisées pour le mode 8 bits
11 – 14J4 – J7Broche 4-7 ArduinoLignes de bus de données utilisées pour le mode 4 bits
15A (LED +)5 V ArduinoAnode pour rétroéclairage LCD
16K (LED)GND ArduinoCathode pour rétroéclairage LCD

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.

Lcd 16x2 caractères avec câblage de réglage du contraste arduino-uno
Câblage de réglage du contraste

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.

Réglage du contraste Arduino LCD 16x2
  • 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.

16x2-caractères-LCD-avec-arduino-uno-schéma-câblage-schématique

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.

/ * Exemple de code Arduino de base pour afficher du texte sur des écrans LCD 16×2, 20×4, etc. Plus d’infos: www.makerguides.com * /
// Inclut la bibliothèque:
#include <LiquidCrystal.h>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
// Spécifiez le nombre de colonnes et de lignes de l’écran LCD. Passez à (20, 4) pour un écran LCD 20×4:
lcd. commencer ( 16, 2 ) ;
}
boucle void () {
// Positionne le curseur sur la troisième colonne et la première ligne, le comptage commence à 0:
lcd. setCursor ( 2, 0 ) ;
// Affiche la chaîne ‘Hello World!’:
lcd. print ( “Hello World!” ) ;
// Positionne le curseur sur la troisième colonne et la deuxième ligne:
lcd. setCursor ( 2, 1 ) ;
// Affiche la chaîne ‘LCD tutorial’:
lcd. impression ( “tutoriel LCD” ) ;
}

Vous devriez voir la sortie suivante sur l’écran LCD:

Exemple de didacticiel Arduino LCD 16x2 caractères

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.

// Inclut la bibliothèque:
#include <LiquidCrystal.h>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;

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

void setup () {
// Spécifiez le nombre de colonnes et de lignes de l’écran LCD. Passez à (20, 4) pour un écran LCD 20×4:
lcd. commencer ( 16, 2 ) ;
}

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.

boucle void () {
// Positionne le curseur sur la troisième colonne et la première ligne, le comptage commence à 0:
lcd. setCursor ( 2, 0 ) ;
// Affiche la chaîne ‘Hello World!’:
lcd. print ( “Hello World!” ) ;
// Positionne le curseur sur la troisième colonne et la deuxième ligne:
lcd. setCursor ( 2, 1 ) ;
// Affiche la chaîne ‘LCD tutorial’:
lcd. impression ( “tutoriel LCD” ) ;
}

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.

dégager()

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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
}
boucle void () {
lcd. clear () ;
lcd. print ( “Lundi” ) ;
retard ( 2000 ) ;
lcd. clear () ;
lcd. impression ( “13:45” ) ;
retard ( 2000 ) ;
}

domicile()

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

le curseur()

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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
lcd. print ( “curseur ()” ) ;
}
boucle void () {
lcd. curseur () ;
retard ( 500 ) ;
lcd. noCursor () ;
retard ( 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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
lcd. print ( “exemple blink ()” ) ;
}
boucle void () {
lcd. clignotement () ;
retard ( 5000 ) ;
lcd. noBlink () ;
retard ( 2000 ) ;
}

affichage()

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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
lcd. print ( “Texte clignotant” ) ;
}
boucle void () {
lcd. affichage () ;
retard ( 2000 ) ;
lcd. noDisplay () ;
retard ( 2000 ) ;
}

écrivez()

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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
lcd. print ( “exemple scrollDisplayLeft ()” ) ;
}
boucle void () {
lcd. scrollDisplayLeft () ;
retard ( 500 ) ;
}

scrollDisplayRight ()

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

défilement automatique()

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>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
void setup () {
lcd. commencer ( 16, 2 ) ;
}
boucle void () {
lcd. autoscroll () ;
lcd. setCursor ( 16, 0 ) ;
pour ( int x = 0; x < 10; x ++ ) {
lcd. imprimer ( x ) ;
retard ( 500 ) ;
}
lcd. clear () ;
}

noAutoscroll ()

Désactive le défilement automatique de l’écran LCD.

de gauche à droite()

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

de droite à gauche()

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).

/ * Exemple de croquis pour créer et afficher des caractères personnalisés sur un écran LCD de caractères avec Arduino et la bibliothèque LiquidCrystal. Pour plus d’informations, voir www.makerguides.com * /
#include <LiquidCrystal.h>
// Crée un objet LCD. Paramètres: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ;
// Créez des caractères personnalisés:
byte Heart [] = {
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000
};
octet 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
};
Verrou d’octet [] = {
B01110,
B10001,
B10001,
B11111,
B11011,
B11011,
B11111,
B00000
};
void setup () {
// Spécifiez le nombre de colonnes et de lignes de l’écran LCD:
lcd. commencer ( 16, 2 ) ;
// Créer un nouveau personnage:
lcd. createChar ( 0, coeur ) ;
lcd. createChar ( 1, Bell ) ;
lcd. createChar ( 2, extraterrestre ) ;
lcd. createChar ( 3, vérifier ) ;
lcd. createChar ( 4, haut-parleur ) ;
lcd. createChar ( 5, son ) ;
lcd. createChar ( 6, crâne ) ;
lcd. createChar ( 7, Verrouiller ) ;
// Efface l’écran LCD:
lcd. clear () ;
// Imprime un message sur l’écran LCD:
lcd. print ( “Caractère personnalisé” ) ;
}
boucle void () {
// Imprimer tous les caractères personnalisés:
lcd. setCursor ( 0, 1 ) ;
lcd. écrire ( octet ( 0 )) ;
lcd. setCursor ( 2, 1 ) ;
lcd. écrire ( octet ( 1 )) ;
lcd. setCursor ( 4, 1 ) ;
lcd. écrire ( octet ( 2 )) ;
lcd. setCursor ( 6, 1 ) ;
lcd. écrire ( octet ( 3 )) ;
lcd. setCursor ( 8, 1 ) ;
lcd. écrire ( octet ( 4 )) ;
lcd. setCursor ( 10, 1 ) ;
lcd. écrire ( octet ( 5 )) ;
lcd. setCursor ( 12, 1 ) ;
lcd. écrire ( octet ( 6 )) ;
lcd. setCursor ( 14, 1 ) ;
lcd. écrire ( octet ( 7 )) ;
}

Vous devriez voir la sortie suivante sur l’écran LCD:

16x2-character-lcd-arduino-tutorial-custom-characters

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.

// Créez des caractères personnalisés:
byte Heart [] = {
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000
};

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éé.

// Créer un nouveau personnage:
lcd. createChar ( 0, coeur ) ;
lcd. createChar ( 1, Bell ) ;
lcd. createChar ( 2, extraterrestre ) ;
lcd. createChar ( 3, vérifier ) ;
lcd. createChar ( 4, haut-parleur ) ;
lcd. createChar ( 5, son ) ;
lcd. createChar ( 6, crâne ) ;
lcd. createChar ( 7, Verrouiller ) ;

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é.

lcd. setCursor ( 0, 1 ) ;
lcd. écrire ( octet ( 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 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.

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.

    Rejoindre la liste d'attente Nous vous informerons lorsque le produit arrivera en stock. Veuillez laisser votre adresse E-mail et la quantité voulue.

    Main Menu

    بحاجة الى مساعدة ؟