Utiliser un écran LCD I2C (16x2) avec Arduino, ESP32 et Pico

L'écran LCD 16x2, qui affiche 2 lignes de 16 caractères, est l'écran le plus répandu dans le monde Arduino. On s'en sert pour afficher des mesures comme la température ou la distance, des menus, des horloges ou des scores de jeu. L'écran lui-même a 16 broches et demande à lui seul au moins 6 broches numériques ; le petit module I2C soudé au dos ramène ce nombre à 2 fils de données. Dans cet article, tu verras pas à pas comment brancher un LCD I2C, trouver son adresse et y afficher ce que tu veux.

Comment fonctionne un écran LCD ?

Ces écrans utilisent une puce de commande appelée HD44780. Chaque caractère est dessiné dans une petite case de 5x8 pixels et la puce contient une table de caractères toute prête : lettres, chiffres et quelques symboles. L'Arduino envoie seulement l'ordre « écris cette lettre à cet endroit » ; transformer la lettre en pixels, c'est le travail de l'écran. Le rétroéclairage LED rend le texte lisible dans le noir, tandis que la couche de cristaux liquides forme le texte en assombrissant les pixels.

Qu'est-ce que l'I2C et pourquoi simplifie-t-il tout ?

L'I2C permet à plusieurs appareils de communiquer sur deux fils : SDA transporte les données et SCL le signal d'horloge. Chaque appareil possède sa propre adresse, et l'Arduino appelle celui qu'il veut par cette adresse. Les modules LCD utilisent généralement l'adresse 0x27 ou 0x3F. Un module horloge, un écran OLED et des capteurs comme le BME280 peuvent partager les mêmes deux fils : tant que leurs adresses sont différentes, tout fonctionne ensemble.

La puce PCF8574 du module convertit les commandes reçues en I2C en 8 signaux parallèles attendus par l'écran. Tu peux utiliser l'écran sans module I2C, mais il faut alors 6 broches, un potentiomètre et beaucoup de fils. Le module économise des broches et simplifie le montage.

Caractéristiques techniques

Câblage du LCD I2C : Arduino, ESP32 et Pico

Le câblage utilise les mêmes quatre fils sur toutes les cartes ; seules les broches de SDA et SCL changent. Pour voir les broches I2C de ta carte, consulte l'outil Brochage.

Trouver l'adresse I2C : le scanner

Si tu n'es pas sûr de l'adresse de ton écran, téléverse le code ci-dessous. Il essaie toutes les adresses de 1 à 126 et affiche dans le moniteur série l'adresse de chaque appareil qui répond. C'est cette adresse que tu utiliseras pour déclarer l'écran.

1#include <Wire.h>
2
3void setup() {
4  Wire.begin();
5  Serial.begin(9600);
6  Serial.println("I2C taranıyor / scanning...");
7  for (byte addr = 1; addr < 127; addr++) {
8    Wire.beginTransmission(addr);
9    if (Wire.endTransmission() == 0) {   // cihaz cevap verdi / device answered
10      Serial.print("Bulundu / found: 0x");
11      Serial.println(addr, HEX);
12    }
13  }
14}
15
16void loop() {
17}

Installer la bibliothèque et afficher du texte

Dans le gestionnaire de bibliothèques, cherche LiquidCrystal I2C et installe la bibliothèque de Frank de Brabander. Le code ci-dessous affiche un message de bienvenue sur la première ligne et, sur la deuxième, le nombre de secondes écoulées depuis le démarrage de l'Arduino.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);  // adres, sütun, satır / address, columns, rows
5
6void setup() {
7  lcd.init();
8  lcd.backlight();               // arka ışığı aç / backlight on
9  lcd.setCursor(0, 0);           // sütun 0, satır 0 / column 0, row 0
10  lcd.print("Merhaba Dunya!");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);           // ikinci satır / second row
15  lcd.print("Sure: ");
16  lcd.print(millis() / 1000);    // saniye / seconds
17  lcd.print(" sn   ");           // eski rakamları sil / clear old digits
18  delay(200);
19}

Les commandes LCD les plus utiles

Faire défiler un texte

Pour afficher un texte de plus de 16 caractères, tu peux faire défiler l'écran. Le code ci-dessous écrit le texte puis le décale vers la gauche toutes les 300 millisecondes : un long message défile comme sur une enseigne.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);
5
6void setup() {
7  lcd.init();
8  lcd.backlight();
9  lcd.print("BlueGrays ile elektronik ogren");  // 16 karakterden uzun / longer than 16 chars
10}
11
12void loop() {
13  lcd.scrollDisplayLeft();   // bir adım sola / one step left
14  delay(300);
15}

Caractères personnalisés et lettres accentuées

La table de caractères du HD44780 ne contient pas les lettres accentuées comme é, è, à, ç ; si tu essaies de les afficher, tu verras des symboles sans signification. La solution consiste à définir jusqu'à 8 caractères personnalisés de 5x8 pixels. Chaque ligne s'écrit sous forme d'un octet, et les bits à 1 sont les pixels allumés. L'exemple ci-dessous dessine un cœur ; tu peux dessiner é ou ç de la même manière.

1byte heart[8] = {
2  0b00000,
3  0b01010,
4  0b11111,
5  0b11111,
6  0b01110,
7  0b00100,
8  0b00000,
9  0b00000
10};
11
12// setup() içinde / inside setup()
13lcd.createChar(0, heart);   // 0. yuvaya kaydet / store in slot 0
14lcd.setCursor(15, 0);
15lcd.write(byte(0));         // kalbi göster / show the heart

LCD I2C avec l'ESP32 et le Raspberry Pi Pico

Sur l'ESP32, le même code Arduino et la même bibliothèque fonctionnent ; Wire.begin() utilise par défaut GPIO 21 (SDA) et GPIO 22 (SCL). Pour d'autres broches, écris Wire.begin(SDA, SCL). Sur le Raspberry Pi Pico en MicroPython, copie sur le Pico deux petits fichiers appelés lcd_api.py et pico_i2c_lcd.py, puis utilise-les ainsi :

1from machine import I2C, Pin
2from pico_i2c_lcd import I2cLcd   # Pico'ya kopyalanan dosya / file copied to the Pico
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5addr = i2c.scan()[0]              # ilk bulunan adres / first found address
6lcd = I2cLcd(i2c, addr, 2, 16)    # 2 satır, 16 sütun / 2 rows, 16 columns
7
8lcd.putstr("Merhaba Pico!")
9lcd.move_to(0, 1)                 # sütun 0, satır 1 / column 0, row 1
10lcd.putstr("BlueGrays")

Idées de projets avec un LCD I2C

• Thermomètre numérique : affiche la température et l'humidité ; pour le capteur, vois Capteur de température et d'humidité DHT11.
• Afficheur de distance : affiche en centimètres la distance mesurée par un HC-SR04 ; détails dans Capteur de distance HC-SR04.
• Voltmètre numérique : affiche la tension lue sur une broche analogique.
• Serrure à code : affiche en étoiles le code saisi sur un clavier matriciel.
• Système de menus : parcours les options à l'écran avec un potentiomètre ou deux boutons.
• Mini-jeu : fais esquiver des obstacles à un coureur dessiné avec des caractères personnalisés.

Erreurs fréquentes et solutions

• Écran allumé mais pas de texte : le contraste n'est pas réglé ; tourne le potentiomètre.
• Pavés pleins sur la ligne du haut : l'écran est alimenté mais pas initialisé ; l'adresse est peut-être fausse, SDA et SCL inversés, ou lcd.init() n'est pas appelé.
• Mauvaise adresse : le code indique 0x27 mais l'écran est en 0x3F ; trouve la vraie adresse avec le scanner.
• Anciens chiffres qui restent : un nombre qui passe de 100 à 99 s'affiche 990 ; écris quelques espaces après le nombre. lcd.clear() fonctionne aussi, mais il est lent et fait scintiller l'écran si tu l'appelles souvent dans la boucle.
• Lettres accentuées illisibles : elles ne sont pas dans la table de l'écran ; définis des caractères personnalisés ou évite-les.
• Texte corrompu au hasard : des fils longs et mal fixés ou des composants parasites comme les moteurs peuvent perturber le bus I2C ; garde les fils courts et alimente les moteurs séparément.

Associer l'écran à un capteur est le moyen le plus rapide de réaliser ton premier vrai projet. Dans l'application BlueGrays, tu trouveras des dizaines de projets avec LCD I2C, avec schémas et code prêt à l'emploi ; et pour modifier des valeurs avec un bouton rotatif, Qu'est-ce qu'un potentiomètre ? te sera utile.