Brancher un LCD 16x2 sur Arduino sans I2C : mode 4 bits
Brancher un LCD 16x2 sur Arduino sans module I2C : rôle des 16 broches, mode 4 bits, contraste, LiquidCrystal, carrés noirs résolus et écran LCD 20x4.
Quand tu branches un LCD 16x2 sur Arduino sans module I2C, tu utilises 12 des 16 broches de l'écran : six vont à des broches numériques de l'Arduino, les autres servent à l'alimentation, au contraste et au rétroéclairage. Cela paraît chargé, mais ce câblage te fait vraiment comprendre le fonctionnement de l'écran, t'évite de chercher une adresse I2C, il est plus rapide que l'I2C et ne bloque pas ton projet si tu n'as pas de module I2C. La plupart des LCD des kits de démarrage Arduino sont d'ailleurs livrés sans module I2C.
Dans ce guide, tu découvriras le rôle de chacune des 16 broches, pourquoi on n'utilise que 4 lignes de données (mode 4 bits), comment brancher le potentiomètre de contraste et les commandes de la bibliothèque LiquidCrystal. Ensuite, tu créeras des caractères personnalisés pour une barre qui se remplit avec un potentiomètre, tu passeras à un LCD 20x4 et tu utiliseras le même écran avec un ESP32 et un Raspberry Pi Pico. Les dernières sections expliquent comment résoudre les problèmes les plus fréquents, comme les « carrés noirs » et l'« écran vide », et quand il vaut mieux passer à un module I2C.

Comment fonctionne un LCD 16x2 ?
La puce noire en forme de goutte au dos de l'écran est le contrôleur HD44780 (ou un clone exact), la langue commune de presque tous les LCD à caractères. L'Arduino lui envoie deux types d'octets : des commandes (effacer l'écran, placer le curseur, allumer l'affichage) et des caractères (le code de la lettre à afficher). La broche RS indique ce qui est envoyé : RS à LOW pour une commande, RS à HIGH pour un caractère. La broche E (enable) est le signal « donnée prête, lis-la maintenant » : une fois l'octet placé sur les lignes de données, E passe brièvement à HIGH et la puce lit l'octet sur le front descendant. La puce contient une mémoire d'affichage de 80 caractères (DDRAM), une ROM de police avec 208 caractères intégrés et une petite mémoire (CGRAM) pour les 8 caractères personnalisés que tu concevras.
| Caractéristique | Valeur |
|---|---|
| Contrôleur | HD44780 ou compatible (KS0066, SPLC780) |
| Affichage | 16 colonnes × 2 lignes, caractères de 5 × 8 pixels |
| Alimentation | 4,5–5,5 V (il existe aussi des versions spéciales 3,3 V) |
| Courant logique | Environ 1–2 mA |
| Courant du rétroéclairage | Environ 15–30 mA (LED, selon le modèle) |
| Bus de données | Parallèle 8 bits ou 4 bits |
| Caractères personnalisés | 8 (CGRAM) |
| Durée des commandes | La plupart 37 µs, clear() et home() environ 1,5 ms |
Le rôle des 16 broches
| Broche | Nom | Rôle | Connexion |
|---|---|---|---|
| 1 | VSS | Masse | GND |
| 2 | VDD | Alimentation logique | 5V |
| 3 | V0 (VO, VEE) | Réglage du contraste | Curseur d'un potentiomètre de 10 kΩ |
| 4 | RS | Sélection commande (LOW) ou caractère (HIGH) | Arduino D12 |
| 5 | RW | Lecture (HIGH) ou écriture (LOW) | GND (on ne fait qu'écrire) |
| 6 | E | Impulsion de donnée valide | Arduino D11 |
| 7–10 | D0–D3 | Bits de données bas | Non connectées en mode 4 bits |
| 11 | D4 | Bit de données 4 | Arduino D5 |
| 12 | D5 | Bit de données 5 | Arduino D4 |
| 13 | D6 | Bit de données 6 | Arduino D3 |
| 14 | D7 | Bit de données 7 | Arduino D2 |
| 15 | A (LED+) | Anode du rétroéclairage | 5V via 220 Ω |
| 16 | K (LED−) | Cathode du rétroéclairage | GND |
Mode 4 bits : pourquoi 4 lignes de données au lieu de 8 ?
Le HD44780 peut recevoir un octet soit d'un coup sur 8 lignes de données (mode 8 bits), soit en deux moitiés sur les lignes D4–D7 (mode 4 bits). En mode 4 bits, la moitié haute de l'octet part d'abord, puis la moitié basse, avec une impulsion sur E pour chacune. C'est deux fois plus long, mais on ne le remarque pas : écrire un caractère prend toujours environ 50 µs et rafraîchir tout l'écran moins de 2 ms. En échange, quatre broches de l'Arduino sont libérées. La bibliothèque LiquidCrystal choisit automatiquement le mode 4 bits quand on passe six broches au constructeur ; laisser D0–D3 non connectées est sans danger, car la puce dispose de résistances de tirage internes sur ces broches.
Le potentiomètre de contraste

C'est la tension sur la broche V0 qui décide si le texte est visible. Ce qui fait tourner le cristal liquide, c'est la différence entre VDD et V0 ; sur les modules 5 V standard, la meilleure image s'obtient généralement avec V0 autour de 0,3–1 V. Quand V0 se rapproche de 0 V, le fond des caractères fonce aussi et les cases vides apparaissent comme des carrés noirs ; quand il se rapproche de 5 V, le texte disparaît totalement. Pour le premier montage, un potentiomètre est donc le plus pratique : une broche extérieure sur 5V, l'autre sur GND, la broche centrale sur V0, puis tourne doucement jusqu'à ce que le texte soit net. Une fois le réglage trouvé, tu peux remplacer le potentiomètre par une résistance fixe : 1 à 2,2 kΩ entre V0 et GND conviennent à la plupart des modules.
Pas à pas : ton premier texte avec Arduino
- Soude une barrette mâle de 16 broches sur le LCD et enfiche l'écran sur la breadboard ; sur une grande breadboard, il reste de la place pour les fils de chaque côté.
- Amène le 5V et le GND de l'Arduino sur les rails d'alimentation. Relie les broches 1 (VSS) et 16 (K) du LCD à GND, la broche 2 (VDD) au 5V et la broche 15 (A) au 5V via 220 Ω. En branchant l'Arduino en USB, le rétroéclairage doit s'allumer.
- Branche le potentiomètre et tourne-le. Avant même de téléverser du code, 16 carrés noirs doivent apparaître sur la ligne du haut : cela montre que l'écran et le contraste fonctionnent.
- Relie la broche 5 (RW) à GND. Puis RS à D12, E à D11, et D4–D7 respectivement à D5, D4, D3 et D2.
- Vérifie dans le gestionnaire de bibliothèques que LiquidCrystal est installée (elle est fournie avec l'IDE Arduino) et téléverse le code ci-dessous.
- Quand les carrés disparaissent et que le texte apparaît, ajuste une dernière fois le contraste au potentiomètre.
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9 lcd.begin(16, 2); // 16 sütun, 2 satır / 16 columns, 2 rows
10 lcd.print(F("Merhaba Arduino!"));
11 lcd.setCursor(0, 1); // sütun 0, satır 1 / column 0, row 1
12 lcd.print(F("Sure:"));
13}
14
15void loop() {
16 unsigned long s = millis() / 1000;
17 lcd.setCursor(6, 1);
18 lcd.print(s);
19 lcd.print(F(" sn ")); // eski haneleri boşlukla sil / overwrite old digits with spaces
20 delay(200);
21}Le code applique deux petites habitudes importantes. D'abord, avant d'écrire la valeur qui change, il se place à cet endroit avec setCursor() au lieu d'appeler clear(), et ajoute quelques espaces après le nombre. clear() est une commande lourde d'environ 1,5 ms qui fait scintiller l'écran si on l'utilise dans la boucle ; de plus, inutile d'effacer et de réécrire tout l'écran. Les espaces évitent qu'un ancien chiffre reste affiché quand le nombre raccourcit (par exemple de 100 à 99). Ensuite, les textes fixes passent par la macro F() et restent ainsi en mémoire programme plutôt qu'en RAM. Un écran 16x2 affiche au maximum 16 caractères par ligne ; un texte plus long déborde à droite et reste invisible.
| Commande | Ce qu'elle fait |
|---|---|
| lcd.begin(16, 2) | Initialise l'écran et indique colonnes et lignes |
| lcd.print(valeur) | Affiche du texte, un entier ou un décimal ; lcd.print(3.14159, 2) affiche deux décimales |
| lcd.setCursor(colonne, ligne) | Choisit la position d'écriture ; on compte à partir de 0 |
| lcd.clear() | Efface l'écran et ramène le curseur au début (1,5 ms) |
| lcd.cursor() / lcd.noCursor() | Affiche ou masque le curseur souligné |
| lcd.blink() / lcd.noBlink() | Active ou désactive le curseur bloc clignotant |
| lcd.display() / lcd.noDisplay() | Allume ou éteint l'affichage sans effacer la mémoire |
| lcd.scrollDisplayLeft() | Décale tout l'affichage d'une colonne vers la gauche |
| lcd.createChar(n, tableau) | Charge un caractère personnalisé dans l'emplacement 0–7 |
| lcd.write(byte(n)) | Écrit un caractère personnalisé ou un code de la ROM |
Caractères personnalisés : une barre qui se remplit avec un potentiomètre
Chaque case de caractère est une grille de 5 colonnes et 8 lignes de pixels. Pour définir un caractère personnalisé, tu écris chaque ligne sous forme d'un nombre de 5 bits : 1 pour un pixel allumé, 0 pour un pixel éteint. Le HD44780 accepte 8 caractères personnalisés à la fois. L'exemple ci-dessous utilise cinq de ces emplacements pour des blocs dont 1, 2, 3, 4 et 5 colonnes sont remplies depuis la gauche. Avec 16 cases × 5 colonnes, tu obtiens une barre de 80 pas qui se remplit et se vide en douceur au potentiomètre ; idéale pour un volume, un niveau de batterie ou un pourcentage de capteur. Nous avons montré comment dessiner des lettres turques (ş, ğ, ı, ç) dans l'article sur le LCD I2C ; la même commande createChar fonctionne exactement pareil en liaison parallèle.
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8]; // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10 for (int n = 0; n < 5; n++) {
11 byte row = 0;
12 for (int c = 0; c <= n; c++) row |= (0b10000 >> c); // soldan doldur / fill from the left
13 for (int r = 0; r < 8; r++) bars[n][r] = row;
14 lcd.createChar(n, bars[n]); // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15 }
16}
17
18void setup() {
19 lcd.begin(16, 2);
20 buildBars();
21 lcd.setCursor(0, 0); // createChar sonrası konum ayarla / set position after createChar
22 lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26 int raw = analogRead(A0);
27 int steps = map(raw, 0, 1023, 0, 80); // 16 hücre x 5 sütun / 16 cells x 5 columns
28 int percent = map(raw, 0, 1023, 0, 100);
29
30 lcd.setCursor(12, 0);
31 if (percent < 100) lcd.print(' ');
32 if (percent < 10) lcd.print(' ');
33 lcd.print(percent);
34 lcd.print('%');
35
36 lcd.setCursor(0, 1);
37 for (int cell = 0; cell < 16; cell++) {
38 int fill = steps - cell * 5; // bu hücreye düşen sütun / columns in this cell
39 if (fill >= 5) lcd.write(byte(4));
40 else if (fill > 0) lcd.write(byte(fill - 1));
41 else lcd.print(' ');
42 }
43 delay(50);
44}La commande createChar déplace le curseur de la mémoire d'affichage vers la mémoire des caractères ; après avoir chargé des caractères personnalisés, il faut donc appeler setCursor() avant d'écrire, sinon le premier texte risque de ne pas s'afficher. Les caractères ne sont stockés qu'en CGRAM et disparaissent à la coupure d'alimentation, c'est pourquoi on les recharge dans setup() à chaque démarrage. Si tu modifies la définition d'un caractère pendant qu'il est affiché, toutes les cases qui le montrent changent en même temps ; c'est avec cette astuce qu'on crée de petites animations.
LCD 20x4 : même câblage, écran plus grand
Les LCD de 20 colonnes et 4 lignes utilisent la même puce HD44780 et les mêmes 16 broches ; le câblage est identique et, dans le code, il suffit d'écrire lcd.begin(20, 4). Leur rétroéclairage consomme un peu plus (40–60 mA) : évite donc de réduire la résistance série, pour ménager le rail 5V de l'Arduino en usage prolongé. La seule bizarrerie à connaître est l'ordre des lignes : dans la mémoire d'affichage, la fin de la ligne 1 continue sur la ligne 3, et celle de la ligne 2 sur la ligne 4. Si tu écris un long texte sans setCursor(), il passe donc de la ligne 1 à la ligne 3, et non à la ligne 2. Appeler setCursor(0, ligne) au début de chaque ligne supprime complètement le problème.
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7 lcd.begin(20, 4);
8 for (int row = 0; row < 4; row++) {
9 lcd.setCursor(0, row); // her satırı açıkça seç / select every row explicitly
10 lcd.print(F("Satir / Row "));
11 lcd.print(row + 1);
12 }
13}
14
15void loop() {
16 lcd.setCursor(15, 3);
17 lcd.print(millis() / 1000 % 100000); // 5 haneye sığsın / fit in 5 digits
18 delay(500);
19}LCD parallèle avec l'ESP32
Un LCD 16x2 standard n'offre pas assez de contraste s'il n'est pas alimenté en 5 V, alors que les broches de l'ESP32 sont en 3,3 V. Bonne nouvelle : tant que RW est relié à GND, le LCD n'applique jamais de tension sur les lignes, il se contente d'écouter. Comme le HD44780 alimenté en 5 V considère comme HIGH toute entrée au-dessus d'environ 2,2 V, les signaux 3,3 V de l'ESP32 suffisent et aucun convertisseur de niveau n'est nécessaire. Relie le VDD du LCD à la broche VIN de la carte ESP32 (5 V de l'USB). La bibliothèque LiquidCrystal fonctionne de la même façon sur l'ESP32 ; évite simplement les broches qui ont un rôle particulier au démarrage, comme GPIO 0, 2, 12 et 15.
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9 lcd.begin(16, 2);
10 lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14 lcd.setCursor(0, 1);
15 lcd.print("Heap: ");
16 lcd.print(ESP.getFreeHeap() / 1024); // boş bellek (KB) / free memory (KB)
17 lcd.print(" KB ");
18 delay(1000);
19}LCD parallèle avec le Raspberry Pi Pico (MicroPython)
La même logique vaut pour le Raspberry Pi Pico : alimente le LCD en 5 V par VBUS (broche 40), relie RW à GND et amène les signaux directement sur des broches GP. MicroPython ne dispose pas d'une bibliothèque LiquidCrystal toute prête, voici donc un court pilote qui gère lui-même le mode 4 bits. Il suit la séquence d'initialisation de la fiche technique du HD44780 : attente de 50 ms après la mise sous tension, trois passages forcés en mode 8 bits, puis bascule en mode 4 bits et allumage de l'affichage. Chaque caractère est envoyé en deux moitiés (quartets), avec une brève impulsion sur E après chacune.
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9 def __init__(self, rs, e, d4, d5, d6, d7):
10 self.rs = Pin(rs, Pin.OUT, value=0)
11 self.e = Pin(e, Pin.OUT, value=0)
12 self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13 time.sleep_ms(50) # güç geldikten sonra bekle / wait after power-up
14 for _ in range(3):
15 self._nibble(0x03) # 8-bit moda zorla / force 8-bit mode
16 time.sleep_ms(5)
17 self._nibble(0x02) # 4-bit moda geç / switch to 4-bit mode
18 self.command(0x28) # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19 self.command(0x0C) # ekran açık, imleç kapalı / display on, cursor off
20 self.clear()
21 self.command(0x06) # soldan sağa yaz / write left to right
22
23 def _nibble(self, value):
24 for i, pin in enumerate(self.data):
25 pin.value((value >> i) & 1)
26 self.e.value(1) # E darbesi / E pulse
27 time.sleep_us(1)
28 self.e.value(0)
29 time.sleep_us(50) # komut süresi (37 µs) / command time (37 µs)
30
31 def _write(self, value, rs):
32 self.rs.value(rs)
33 self._nibble(value >> 4) # önce üst yarı / upper half first
34 self._nibble(value & 0x0F)
35
36 def command(self, cmd):
37 self._write(cmd, 0)
38
39 def clear(self):
40 self.command(0x01)
41 time.sleep_ms(2) # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43 def move_to(self, col, row):
44 offsets = (0x00, 0x40, 0x14, 0x54) # 16x2 ve 20x4 satır adresleri / row addresses
45 self.command(0x80 | (offsets[row] + col))
46
47 def putstr(self, text):
48 for ch in text:
49 self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57 lcd.move_to(0, 1)
58 lcd.putstr("Sayac: {:<9d}".format(count))
59 count += 1
60 time.sleep(1)Carrés noirs, écran vide et autres problèmes
Presque tous les problèmes d'un LCD parallèle ressemblent à l'un de quelques symptômes, et l'écran lui-même t'indique où chercher. L'indice le plus important : si tu vois 16 carrés noirs uniquement sur la ligne du haut, l'alimentation et le contraste sont bons, mais la puce n'a jamais été initialisée. À la mise sous tension, le HD44780 démarre en mode une ligne et ne pilote que la première ; tant que le code n'arrive pas à initialiser l'écran, l'image ne change pas. Le problème vient alors presque toujours des fils RS, E ou D4–D7, ou de l'ordre des broches dans le constructeur. Si tu vois des carrés pâles sur les deux lignes, l'écran fonctionne et le contraste est simplement trop élevé.
| Symptôme | Cause probable | Solution |
|---|---|---|
| 16 carrés noirs sur la ligne du haut uniquement | Écran non initialisé : fils RS, E, D4–D7 ou ordre des broches dans le constructeur erronés, ou code non téléversé | Vérifie les fils avec le tableau et l'ordre LiquidCrystal lcd(RS, E, D4, D5, D6, D7) |
| Carrés pâles sur les deux lignes | Contraste trop élevé (V0 trop proche de GND) | Tourne le potentiomètre |
| Rétroéclairage allumé mais rien ne s'affiche | Contraste trop faible ou V0 non relié | Vérifie que le curseur du potentiomètre va sur V0 et tourne-le |
| Le rétroéclairage ne s'allume pas | Broches 15 et 16 non reliées, inversées ou sans résistance | Relie A au 5V via 220 Ω et K à GND |
| Caractères incohérents ou qui se décalent | Fil de données mal enfoncé, D4–D7 inversées, parasites de moteur ou de relais | Fixe les fils, ajoute 100 µF sur l'alimentation, réinitialise avec lcd.begin() si besoin |
| Le texte scintille | lcd.clear() utilisé dans la boucle | Réécris par-dessus avec setCursor() et efface les anciens chiffres par des espaces |
| Un ancien chiffre reste quand le nombre raccourcit | La nouvelle valeur est plus courte | Ajoute des espaces après la valeur |
| Aucun texte après un caractère personnalisé | createChar a déplacé le curseur dans la mémoire des caractères | Appelle setCursor() après createChar |
Faut-il passer à un module I2C ?

Grâce à la puce PCF8574 au dos, le module I2C transporte tous les signaux du LCD sur deux fils (SDA et SCL) ; le potentiomètre de contraste et le transistor du rétroéclairage sont aussi sur la carte. Quand ton projet grossit, ce confort compte : un Uno n'a que 20 broches numériques et analogiques, et un LCD parallèle en occupe six à lui seul. En revanche, la liaison parallèle est plus rapide, ne connaît pas de conflit d'adresse I2C et ne demande aucun module. Le tableau résume quand choisir l'une ou l'autre ; pour le montage avec module I2C, consulte l'article sur l'écran LCD I2C.
| Caractéristique | Parallèle (4 bits) | Avec module I2C |
|---|---|---|
| Broches Arduino utilisées | 6 | 2 (A4, A5) |
| Nombre de fils | 12 (alimentation et potentiomètre compris) | 4 |
| Rafraîchissement complet | Moins de 2 ms | Environ 20–30 ms à 100 kHz |
| Réglage du contraste | Potentiomètre externe | Potentiomètre ajustable sur le module |
| Extinction logicielle du rétroéclairage | Transistor supplémentaire nécessaire | lcd.noBacklight() |
| Bibliothèque | LiquidCrystal (fournie avec l'IDE) | LiquidCrystal I2C (à installer) |
| Ennuis typiques | Fouillis de fils, faux contacts | Adresse (0x27 / 0x3F) et résistances de tirage |
Idées de projets avec un LCD 16x2
- Thermomètre numérique : affiche en grand la température et l'humidité d'une CTN ou d'un DHT11, avec le symbole degré via lcd.write(223).
- Serrure à code : affiche en astérisques le code tapé sur un clavier matriciel et active un relais s'il est correct.
- Afficheur de distance : montre en même temps en centimètres et sous forme de barre la distance mesurée par un HC-SR04.
- Chronomètre et compte à rebours : démarre, arrête et remets à zéro avec deux boutons, en affichant minutes:secondes:centièmes.
- Mini-jeu : dessine un coureur et des obstacles avec des caractères personnalisés et fais-le sauter avec un bouton.
- Système de menus : crée un menu parcouru et réglé avec un encodeur rotatif et enregistre les choix en EEPROM.
Brancher un LCD 16x2 sans module I2C peut d'abord ressembler à un fouillis de fils, mais une fois que tu as compris comment l'écran reçoit ses commandes, tu peux utiliser n'importe quel LCD à caractères, le 20x4 et même d'autres microcontrôleurs avec la même logique. Dans l'application BlueGrays, les projets « Afficher un message sur un LCD 16x2 », « Texte rebondissant sur le LCD » et « Mesurer une distance avec un LCD » te guident pas à pas dans ce câblage avec schéma et code prêt à l'emploi.
Questions fréquentes
Pourquoi mon LCD 16x2 affiche-t-il des carrés noirs ?
Si les carrés n'apparaissent que sur la ligne du haut, l'alimentation et le contraste sont bons mais l'Arduino n'a pas réussi à initialiser l'écran ; vérifie les fils RS, E et D4–D7 ainsi que l'ordre des broches dans le constructeur LiquidCrystal. Si des carrés pâles apparaissent sur les deux lignes, le contraste est trop élevé et il suffit de tourner le potentiomètre.
Pourquoi mon LCD est-il éclairé mais sans texte ?
La cause la plus fréquente est un contraste trop faible : quand V0 reste proche de 5 V, les caractères sont invisibles. Vérifie que le curseur du potentiomètre est relié à V0 et tourne-le lentement. Si le contraste est bon et que des carrés apparaissent sur la ligne du haut, le problème vient des fils de données ou du code.
Peut-on utiliser un LCD 16x2 sans potentiomètre ?
Oui. Une résistance fixe de 1 à 2,2 kΩ entre V0 et GND donne un bon contraste sur la plupart des modules 5 V. Le plus fiable est de trouver la valeur une fois au potentiomètre, puis de le remplacer par une résistance fixe. On peut aussi relier V0 à une broche PWM via un filtre RC et régler le contraste par logiciel.
Où brancher la broche RW du LCD ?
Si tu ne fais qu'écrire sur l'écran, relie RW (broche 5) à GND : le LCD reste ainsi en permanence en mode écriture, ce qui correspond au fonctionnement de la bibliothèque LiquidCrystal. Si RW reste en l'air, l'écran peut passer au hasard en mode lecture, piloter les lignes de données et ne rien afficher. RW relié à GND protège aussi les broches des cartes 3,3 V.
Quelle différence entre LiquidCrystal et LiquidCrystal_I2C ?
LiquidCrystal pilote le LCD directement depuis les broches de l'Arduino et est fournie avec l'IDE Arduino ; elle sert au câblage parallèle. LiquidCrystal_I2C envoie les mêmes commandes via un module I2C à PCF8574 et doit être installée séparément. La plupart des commandes (print, setCursor, createChar) sont identiques ; la version I2C ajoute lcd.init() pour le démarrage et backlight() pour le rétroéclairage.
Mon code pour LCD 16x2 fonctionne-t-il sur un 20x4 ?
Oui, car le câblage et les commandes sont identiques ; il suffit de remplacer lcd.begin(16, 2) par lcd.begin(20, 4). Sur un écran 20x4, les lignes suivent en mémoire l'ordre 1, 3, 2, 4, le plus propre est donc de te placer sur chaque ligne avec setCursor(0, ligne). Le rétroéclairage consomme un peu plus.
Projets à réaliser après cet article
Voir tous les projets
Afficher un message sur un écran LCD 2x16
Ta première étape pour écrire du texte sur un écran. L'écran LCD à deux lignes affiche d'abord un message d'attente, puis écrit un bonjour sur la ligne du haut et tape un mot lettre par lettre sur…

Texte qui rebondit de gauche à droite sur un écran LCD
Sur la ligne du haut de l'écran LCD, le mot BLUEGRAYS glisse d'un bord à l'autre et rebondit comme une balle contre un mur, encore et encore sans fin.

Mesure de la distance à l'aide d'un écran LCD
Un appareil qui mesure les distances sans règle : avance et recule ta main devant le capteur et regarde le nombre changer.

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

Horloge RTC DS1302 avec écran LCD
Une petite horloge de bureau qui n'oublie pas l'heure, même en cas de coupure de courant.

Voltmètre numérique avec écran LCD
Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

Jeu Arduino LCD Runner
Jeu de course sans fin à défilement latéral fonctionnant sur un écran LCD de 16x2 caractères. Le héros court automatiquement, le joueur saute par-dessus les obstacles en appuyant sur le bouton. Des obstacles aléatoires apparaissent sur les rangées du haut et du bas. Un buzzer passif joue la mélodie d'ouverture, le son de saut, le son de célébration des 50 points et la mélodie de fin de partie. L'écran d'accueil "BlueGrays - Arduino Projects" s'affiche au démarrage.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

