Composants · 11 min de lecture

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.

Écran LCD 16x2 à caractères
LCD 16x2 : caractères de 5 × 8 pixels sur 16 colonnes et 2 lignes. Les 16 broches du bord supérieur se branchent directement, sans 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éristiqueValeur
ContrôleurHD44780 ou compatible (KS0066, SPLC780)
Affichage16 colonnes × 2 lignes, caractères de 5 × 8 pixels
Alimentation4,5–5,5 V (il existe aussi des versions spéciales 3,3 V)
Courant logiqueEnviron 1–2 mA
Courant du rétroéclairageEnviron 15–30 mA (LED, selon le modèle)
Bus de donnéesParallèle 8 bits ou 4 bits
Caractères personnalisés8 (CGRAM)
Durée des commandesLa plupart 37 µs, clear() et home() environ 1,5 ms

Le rôle des 16 broches

BrocheNomRôleConnexion
1VSSMasseGND
2VDDAlimentation logique5V
3V0 (VO, VEE)Réglage du contrasteCurseur d'un potentiomètre de 10 kΩ
4RSSélection commande (LOW) ou caractère (HIGH)Arduino D12
5RWLecture (HIGH) ou écriture (LOW)GND (on ne fait qu'écrire)
6EImpulsion de donnée valideArduino D11
7–10D0–D3Bits de données basNon connectées en mode 4 bits
11D4Bit de données 4Arduino D5
12D5Bit de données 5Arduino D4
13D6Bit de données 6Arduino D3
14D7Bit de données 7Arduino D2
15A (LED+)Anode du rétroéclairage5V via 220 Ω
16K (LED−)Cathode du rétroéclairageGND
Sur certains LCD, l'ordre des broches est différent, ou les broches 15 et 16 du rétroéclairage se trouvent au début. Vérifie les marquages de la carte et le repère de la broche 1 avant de brancher. Ne relie pas le rétroéclairage directement au 5 V sans résistance : si le module n'a pas de résistance série, la LED consomme trop et s'use. Il y a généralement au dos une résistance d'environ 100 Ω marquée R8 ou R9 ; dans le doute, ajoute quand même la résistance de 220 Ω. Tu peux trouver la bonne valeur avec le calculateur de résistance pour LED.

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

Potentiomètre de 10 kΩ
Un potentiomètre de 10 kΩ suffit pour le contraste : broches extérieures sur 5V et GND, broche centrale sur V0 du LCD.

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

  1. 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é.
  2. 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.
  3. 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.
  4. Relie la broche 5 (RW) à GND. Puis RS à D12, E à D11, et D4–D7 respectivement à D5, D4, D3 et D2.
  5. 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.
  6. Quand les carrés disparaissent et que le texte apparaît, ajuste une dernière fois le contraste au potentiomètre.
C++ (Arduino IDE)
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.

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

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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ômeCause probableSolution
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 lignesContraste trop élevé (V0 trop proche de GND)Tourne le potentiomètre
Rétroéclairage allumé mais rien ne s'afficheContraste 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 pasBroches 15 et 16 non reliées, inversées ou sans résistanceRelie A au 5V via 220 Ω et K à GND
Caractères incohérents ou qui se décalentFil de données mal enfoncé, D4–D7 inversées, parasites de moteur ou de relaisFixe les fils, ajoute 100 µF sur l'alimentation, réinitialise avec lcd.begin() si besoin
Le texte scintillelcd.clear() utilisé dans la boucleRéécris par-dessus avec setCursor() et efface les anciens chiffres par des espaces
Un ancien chiffre reste quand le nombre raccourcitLa nouvelle valeur est plus courteAjoute 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èresAppelle setCursor() après createChar
Dans les projets avec moteurs, relais ou servos, le LCD affiche parfois n'importe quoi au bout de quelques heures : une baisse de tension a placé la puce dans un état indéfini. Appeler lcd.begin(16, 2) à intervalles réguliers, par exemple une fois par minute, puis redessiner l'écran règle le problème sans que l'utilisateur s'en aperçoive.

Faut-il passer à un module I2C ?

Module I2C pour LCD (PCF8574)
Le module I2C à base de PCF8574 se soude au dos du LCD et réduit les 16 broches à quatre fils seulement.

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éristiqueParallèle (4 bits)Avec module I2C
Broches Arduino utilisées62 (A4, A5)
Nombre de fils12 (alimentation et potentiomètre compris)4
Rafraîchissement completMoins de 2 msEnviron 20–30 ms à 100 kHz
Réglage du contrastePotentiomètre externePotentiomètre ajustable sur le module
Extinction logicielle du rétroéclairageTransistor supplémentaire nécessairelcd.noBacklight()
BibliothèqueLiquidCrystal (fournie avec l'IDE)LiquidCrystal I2C (à installer)
Ennuis typiquesFouillis de fils, faux contactsAdresse (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.

Voir tous les projets
Afficher un message sur un écran LCD 2x16
AR-29Avancé
Premium

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…

4.6(37)
51
Texte qui rebondit de gauche à droite sur un écran LCD
AR-30Avancé
Premium

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.

4.5(29)
40
Mesure de la distance à l'aide d'un écran LCD
AR-31Avancé
Premium

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.

4.6(45)
59
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Horloge RTC DS1302 avec écran LCD
AR-46Intermédiaire
Premium

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.

4.7(41)
51
Voltmètre numérique avec écran LCD
AR-56Intermédiaire
Premium

Voltmètre numérique avec écran LCD

Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

4.5(27)
36
Serrure à code avec clavier 4x4 et écran LCD
AR-64Avancé
Premium

Serrure à code avec clavier 4x4 et écran LCD

Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

4.8(59)
75
Jeu Arduino LCD Runner
AR-96Intermédiaire
Premium

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.

4.6(32)
56