Cet article contient tout ce que vous devez savoir pour utiliser un écran à caractères I2C LCD avec Arduino. J’ai inclus un schéma de câblage et de nombreux exemples de code pour vous aider à démarrer.
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 bibliothèque LiquidCrystal_I2C.
Une fois que vous savez comment afficher du texte et des nombres sur l’écran LCD, je vous suggère de consulter les articles ci-dessous. Dans ces tutoriels, vous apprendrez à mesurer et afficher des données de capteurs sur l’écran LCD.
Fournitures
Composants matériels
 | 16×2 character I2C LCD | × 1 | Amazon |
| 20×4 character I2C LCD (alternative) | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires (mâle vers femelle) | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Outils
Logiciels
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.
Bases de l’écran LCD I2C
Ce guide fait partie de notre centre d’articles sur Displays. Ce type d’écran LCD est idéal pour afficher du texte et des nombres, d’où son nom d’écran à caractères.
L’écran LCD I2C utilisé dans ce tutoriel est équipé d’un petit circuit additionnel monté à l’arrière du module. Ce module intègre une puce PCF8574 (pour la communication I2C) et un potentiomètre pour ajuster le rétroéclairage LED.
L’avantage d’un écran LCD I2C est que le câblage est très simple. Vous n’avez besoin que de deux broches de données pour contrôler l’écran. Les écrans LCD standards nécessitent généralement environ 12 connexions, ce qui peut poser problème si vous manquez de broches GPIO disponibles.
Heureusement, vous pouvez aussi acheter le circuit additionnel I2C séparément sur Amazon, ce qui vous permet de facilement mettre à niveau un écran LCD standard.
Pour un tutoriel et un schéma de câblage pour les écrans LCD à caractères standards, veuillez consulter l’article suivant :
Si vous regardez de près l’écran LCD, vous pouvez voir les petits rectangles qui forment les caractères individuels. Chaque rectangle est composé d’une grille de 5×8 pixels. Plus loin dans ce tutoriel, je vous montrerai comment contrôler les pixels individuellement pour afficher des caractères personnalisés sur l’écran.
Spécifications
Les spécifications des écrans LCD 16×2, 20×4 et autres tailles sont essentiellement les mêmes. Ils utilisent tous le même HD44780 Hitachi LCD controller, vous pouvez donc facilement les interchanger. Il vous suffira de modifier les spécifications de taille dans votre code Arduino.
Les spécifications d’un écran I2C 16×2 typique sont indiquées dans le tableau ci-dessous.
Spécifications de l’écran LCD I2C 16×2
| Tension de fonctionnement | 5 V |
| Contrôleur | Contrôleur LCD Hitachi HD44780 |
| Adresse par défaut | 0x27 |
| Résolution de l’écran | 2 lignes × 16 caractères |
| Résolution des caractères | 5 × 8 pixels |
| Dimensions du module | 80 × 36 × 12 mm |
| Dimensions de la zone visible | 64,5 × 16,4 mm |
| Coût | Check price |
Pour plus d’informations, vous pouvez consulter les fiches techniques ci-dessous.
Les fiches techniques des écrans 16×2 et 20×4 incluent les dimensions de l’écran et vous trouverez plus d’informations sur le pilote LCD Hitachi dans la fiche technique HD44780.
La puce PCF8574 est utilisée dans le module I2C à l’arrière de l’écran LCD.
Comment connecter l’écran LCD I2C à l’Arduino UNO
Le schéma de câblage ci-dessous montre comment connecter l’écran LCD I2C à l’Arduino. Le câblage d’un écran LCD I2C est beaucoup plus simple que celui d’un écran LCD standard. Vous n’avez besoin que de 4 broches au lieu de 12.
Les connexions sont également indiquées dans le tableau ci-dessous.
Connexions de l’écran LCD I2C
| Écran LCD à caractères I2C | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Si vous n’utilisez pas un Arduino Uno, les broches SDA et SCL peuvent être situées ailleurs.
Notez qu’un Arduino Uno avec la disposition R3 (brochage 1.0) possède également les broches SDA (ligne de données) et SCL (ligne d’horloge) près de la broche AREF. Consultez le tableau ci-dessous pour plus de détails.
| Carte | SDA | SCL |
|---|---|---|
| Arduino Uno | A4 | A5 |
| Arduino Nano | A4 | A5 |
| Arduino Micro | 2 | 3 |
| Arduino Mega 2560 | 20 | 21 |
| Arduino Leonardo | 2 | 3 |
| Arduino Due | 20 | 21 |
Réglage du contraste de l’écran LCD
Après avoir câblé l’écran LCD, vous devrez ajuster le contraste de l’affichage. Sur le module I2C, vous trouverez un potentiomètre que vous pouvez tourner avec un petit tournevis.
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 (pour un LCD 16×2) ou deux lignes (pour un LCD 20×4) de rectangles apparaissent. Vous pourrez ajuster le contraste plus tard si nécessaire.
Une fois cela fait, nous pouvons commencer à programmer l’écran LCD.
Installation de la bibliothèque LiquidCrystal_I2C pour Arduino
Dans ce tutoriel, j’utiliserai la bibliothèque LiquidCrystal_I2C Cette bibliothèque offre de nombreuses fonctions intégrées qui facilitent la programmation de l’écran LCD.
La dernière version de cette bibliothèque est disponible ici :
Assurez-vous d’avoir installé cette bibliothèque exacte et supprimez toutes les autres bibliothèques portant le même nom (LiquidCrystal_I2C). D’autres bibliothèques peuvent fonctionner aussi, mais elles utilisent peut-être des noms légèrement différents pour les fonctions.
La bibliothèque LiquidCrystal_I2C fonctionne en combinaison avec la bibliothèque Wire.h qui permet de communiquer avec les périphériques I2C. Cette bibliothèque est préinstallée avec l’IDE Arduino.
Pour installer cette bibliothèque, allez dans Tools > Manage Libraries (Ctrl + Shift + I sous Windows) dans le Arduino IDE. Le gestionnaire de bibliothèques s’ouvrira et mettra à jour la liste des bibliothèques installées.
Recherchez maintenant ‘liquidcrystal_i2c’ et trouvez la bibliothèque de Frank de Brabander. Sélectionnez la dernière version puis cliquez sur Installer.
La bibliothèque inclut quelques exemples que vous pouvez utiliser, mais vous devrez les modifier pour correspondre à votre configuration matérielle. J’ai inclus de nombreux exemples de code ci-dessous que vous pouvez utiliser avec le câblage montré précédemment.
Je vais d’abord vous montrer un exemple de code basique, puis expliquer les fonctions plus en détail.
Comment trouver l’adresse I2C de mon écran LCD ?
La plupart des écrans LCD I2C sont livrés avec l’adresse par défaut ‘0x27’, mais elle peut varier selon le lot ou le fabricant. Dans ce cas, vous devrez trouver l’adresse réelle de l’écran avant de pouvoir l’utiliser. Sur le site Arduino, vous trouverez un sketch simple qui scanne le bus I2C à la recherche de périphériques. Si un périphérique est détecté, son adresse s’affiche dans le moniteur série.
/*I2C_scanner
This sketch tests standard 7-bit addresses.
Devices with higher bit address might not be seen properly.
*/
#include "Wire.h"
void setup() {
Wire.begin();
Serial.begin(9600);
while (!Serial);
Serial.println("\nI2C Scanner");
}
void loop() {
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for (address = 1; address < 127; address++ ) {
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0) {
Serial.print("I2C device found at address 0x");
if (address < 16)
Serial.print("0");
Serial.print(address, HEX);
Serial.println(" !");
nDevices++;
}
else if (error == 4) {
Serial.print("Unknown error at address 0x");
if (address < 16)
Serial.print("0");
Serial.println(address, HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000);
}
Si vous téléversez ce sketch sur l’Arduino et l’exécutez, vous devriez voir la sortie suivante dans le Moniteur Série (Ctrl + Shift + M).
Notez l’adresse trouvée, vous en aurez besoin plus tard pour programmer l’écran LCD.
Exemple de code Arduino basique pour écran LCD I2C
Ce sketch d’exemple affichera le classique ‘Hello World!’ sur la première ligne de l’écran LCD et ‘LCD tutorial’ sur la deuxième ligne.
/* I2C LCD with Arduino example code. More info: https://www.makerguides.com */
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD
// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
void setup() {
// Initiate the LCD:
lcd.init();
lcd.backlight();
}
void loop() {
// Print 'Hello World!' on the first line of the LCD:
lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
lcd.print("Hello World!"); // Print the string "Hello World!"
lcd.setCursor(2, 1); //Set the cursor on the third column and the second row (counting starts at 0!).
lcd.print("LCD tutorial");
}
Vous devriez voir la sortie suivante sur l’écran LCD :
Ensuite, je vais expliquer comment fonctionne le code.
Fonctionnement du code
Tout d’abord, les bibliothèques nécessaires sont incluses. Comme mentionné plus tôt, nous avons besoin à la fois de Wire.h et de LiquidCrystal_I2C. Dans la suite de ce tutoriel, je présenterai plus de fonctions intégrées de cette bibliothèque.
#include "Wire.h" // Library for I2C communication #include "LiquidCrystal_I2C.h" // Library for LCD
L’étape suivante consiste à créer un objet LCD avec la classe LiquidCrystal_I2C et à spécifier l’adresse et les dimensions. Pour cela, nous utilisons la fonction LiquidCrystal_I2C(address, columns, rows).
C’est ici que vous devrez changer l’adresse par défaut par celle que vous avez trouvée si elle est différente. Pour un écran 20×4, modifiez cette ligne en LiquidCrystal_I2C(0x27,20,4);
Notez que nous avons nommé l’affichage ‘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.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered) LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
Setup
Dans la fonction setup, l’écran LCD est initialisé avec lcd.init() et le rétroéclairage est activé avec lcd.backlight().
void setup() {
// Initiate the LCD:
lcd.init();
lcd.backlight();
}
Loop
Dans la fonction loop, le curseur est positionné à la troisième colonne et à la première ligne de l’écran avec lcd.setCursor(2,0).
Notez que le comptage commence à 0 et que le premier argument spécifie la colonne. Ainsi, lcd.setCursor(2,1) place le curseur à la troisième colonne et à la deuxième ligne.
Ensuite, la chaîne ‘Hello World!’ est affichée avec lcd.print("Hello World!"). Notez que vous devez mettre des guillemets (” “) autour du texte car nous affichons une text string.
Pour afficher des nombres, les guillemets ne sont pas nécessaires. Par exemple lcd.print(12345).
void loop() {
lcd.setCursor(2, 0); // Set the cursor on the third column and first row.
lcd.print("Hello World!"); // Print the string "Hello World!".
lcd.setCursor(2, 1); //Set the cursor on the third column and the second row.
lcd.print("LCD tutorial"); // Print the string "LCD tutorial".
}
Si vous souhaitez voir un exemple d’affichage (mise à jour) de variables sur l’écran LCD, consultez mon tutoriel sur le capteur de distance ultrasonique HC-SR04 :
Autres fonctions utiles de la bibliothèque LiquidCrystal_I2C
L’exemple ci-dessus montre les bases de l’affichage de texte sur l’écran LCD. Maintenant, examinons les autres fonctions de la bibliothèque LiquidCrystal_I2C.
clear()
Efface l’écran LCD et positionne le curseur en haut à gauche (première ligne et première colonne) de l’affichage. Vous pouvez utiliser cette fonction pour afficher différents mots en boucle.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
}
void loop() {
lcd.clear();
lcd.print("Monday");
delay(2000);
lcd.clear();
lcd.print("13:45");
delay(2000);
}
home()
Positionne le curseur en haut à gauche de l’écran LCD. Utilisez clear() si vous souhaitez aussi effacer l’affichage.
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 “Hello World!”.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("Hello World!");
}
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 forme de bloc. L’exemple suivant affiche le curseur clignotant pendant 5 secondes puis le désactive pendant 2 secondes.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
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 l’écran LCD. Le texte/données ne sont pas effacés de la mémoire de l’écran.
Cela signifie qu’ils seront affichés à nouveau lorsque la fonction display() sera appelée.
L’exemple suivant crée un effet de texte clignotant.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("Blinking text");
}
void loop() {
lcd.display();
delay(2000);
lcd.noDisplay();
delay(2000);
}
write()
Cette fonction permet d’écrire un caractère sur l’écran 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 en combinaison avec delay(500), pour créer une animation de texte défilant.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
lcd.print("Hello World!");
}
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 de l’écran LCD. Cela fait que chaque caractère affiché pousse les caractères précédents d’un espace.
Si la direction du texte est de gauche à droite (par défaut), l’affichage défile vers la gauche, si la direction est de droite à gauche, l’affichage défile vers la droite.
Cela a pour effet d’afficher chaque nouveau caractère au même emplacement sur l’écran.
L’exemple suivant active le défilement automatique et affiche les caractères 0 à 9 à la position (16,0) de l’écran LCD. Changez cette position en (20,0) pour un écran 20×4.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void setup() {
lcd.init();
lcd.backlight();
}
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 défiler le texte vers la droite à partir du curseur, comme si l’affichage était aligné à gauche (par défaut).
rightToLeft()
Cette fonction fait défiler le texte vers la gauche à partir du curseur, comme si l’affichage é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 l’écran LCD. C’est particulièrement utile si vous souhaitez afficher un caractère qui ne fait pas partie de la ASCII character set.
CGROM et CGRAM
Les écrans LCD basés sur le contrôleur Hitachi HD44780 disposent de deux types de mémoire : CGROM et CGRAM (Character Generator ROM et RAM).
Le CGROM génère tous les motifs de caractères 5 x 8 points à partir des codes caractères standard 8 bits. Le CGRAM peut générer des motifs de caractères définis par l’utilisateur.
Pour les écrans 5 x 8 points, le 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 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). Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.
/* Arduino example code to display custom characters on I2C character LCD. More info: www.www.makerguides.com */
// Include the library:
#include "LiquidCrystal_I2C.h"
// Create lcd object of class LiquidCrystal_I2C:
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // Change to (0x27,20,4) for 20x4 LCD.
// 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() {
// Initialize LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create 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);
// Clear the LCD screen:
lcd.clear();
// Print a message to the lcd:
lcd.print("Custom Character");
}
// Print all the custom characters:
void loop() {
lcd.setCursor(0, 1);
lcd.write(0);
lcd.setCursor(2, 1);
lcd.write(1);
lcd.setCursor(4, 1);
lcd.write(2);
lcd.setCursor(6, 1);
lcd.write(3);
lcd.setCursor(8, 1);
lcd.write(4);
lcd.setCursor(10, 1);
lcd.write(5);
lcd.setCursor(12, 1);
lcd.write(6);
lcd.setCursor(14, 1);
lcd.write(7);
}
Vous devriez voir la sortie suivante sur l’écran LCD :
Fonctionnement du 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 (seuls 5 bits sont pris en compte). Il y a 1 octet par ligne de la matrice LED 5 x 8. Dans cet exemple, 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 est composée de 5 chiffres correspondant aux 5 pixels d’un caractère 5 x 8 points. Un 0 signifie pixel éteint et un 1 pixel allumé. Le préfixe ‘B’ est le format binaire spécifique à Arduino.
Il est possible d’éditer chaque ligne à la main, mais je recommande d’utiliser cette application en ligne LCD Custom Character Generator. Cette application crée automatiquement le tableau de caractères et vous pouvez cliquer sur les pixels pour les allumer ou les éteindre.
Dans la fonction 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 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 la boucle, tous les caractères sont affichés avec lcd.write(). Comme argument, nous utilisons le numéro du caractère personnalisé que nous voulons afficher.
lcd.setCursor(0, 1); lcd.write(0);
Conclusion
Dans cet article, je vous ai montré comment utiliser un écran LCD à caractères I2C avec Arduino. Nous avons aussi un article sur How To Control A Character I2C LCD with ESP32, si vous souhaitez travailler avec un microcontrôleur ESP32 à la place.
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.
