Guides · 11 min de lecture

Types d'écrans pour Arduino : LCD, OLED, TFT, e-paper, 7 segments

Écrans pour Arduino comparés : LCD 16x2, OLED, TFT, e-paper, TM1637, MAX7219 et Nextion ; résolution, broches, mémoire, consommation et quel écran choisir.

Les types d'écrans pour Arduino déroutent au début : le même mot "écran" désigne un LCD de 16 caractères, un OLED grand comme un ongle, un TFT coloré comme un écran de téléphone et un e-paper qui garde son image même quand le courant est coupé. Résolution, couleur, mode de connexion, mémoire et consommation varient énormément de l'un à l'autre. Un mauvais choix se termine par un Uno à court de RAM, un afficheur illisible au soleil ou un capteur qui vide sa batterie en une journée.

Dans ce guide, nous passons en revue une à une les sept familles d'écrans les plus utilisées dans les projets Arduino : LCD à caractères (16x2 et 20x4), OLED (SSD1306 et SH1106), TFT couleur (ILI9341 et ST7789), e-paper, 7 segments et TM1637, matrices LED MAX7219 et écrans tactiles Nextion. D'abord un grand tableau comparatif, puis une courte présentation et un exemple de code fonctionnel pour chaque écran, et pour finir un tableau "quel écran pour quel projet" et les erreurs les plus fréquentes.

Écran LCD 16x2 avec adaptateur I2C
LCD à caractères 16x2 avec adaptateur I2C : l'écran Arduino le moins cher et le plus facile à lire, relié avec seulement deux fils de données.

Types d'écrans pour Arduino : tableau comparatif rapide

ÉcranRésolutionCouleurInterfaceBroches de donnéesCourant typiquePrix
LCD à caractères 16x2 / 20x416×2 ou 20×4 caractèresMonochrome, rétroéclairéParallèle ou adaptateur I2C6 (parallèle) / 2 (I2C)20–40 mATrès bon marché
OLED SSD1306 / SH1106128×64 (0,96" et 1,3")Monochrome (blanc, bleu, jaune-bleu)I2C ou SPI2 (I2C) / 5 (SPI)10–25 mABon marché
TFT ILI9341240×320 (2,4–3,2")65 000 couleursSPI ou parallèle 8 bits5 (SPI)50–100 mAMoyen
TFT ST7789240×240, 240×320, 135×24065 000 couleursSPI4–530–80 mAMoyen
E-paper (e-ink)200×200, 296×128, 250×122Noir et blanc (certains rouge/jaune)SPI6 (BUSY compris)5–20 mA seulement au rafraîchissementMoyen à cher
7 segments / TM16371 à 8 chiffresLED d'une couleurDirect ou 2 fils (TM1637)8–12 / 220–80 mATrès bon marché
Matrice LED MAX72198×8, chaînée en 32×8 et plusLED d'une couleur3 fils (type SPI)320–300 mA selon la luminositéBon marché
Nextion HMIDe 320×240 à 800×48065 000 couleurs, tactileUART (TX/RX)290–500 mACher

Le nombre de "broches de données" du tableau n'inclut pas l'alimentation (VCC et GND). Les courants varient beaucoup selon le rétroéclairage et la luminosité ; l'e-paper ne consomme que pendant que l'image change, puis presque rien. Les prix sont classés les uns par rapport aux autres : pour le prix d'un Nextion, tu peux acheter une dizaine de LCD 16x2.

Que regarder pour choisir un écran ?

  • Que vas-tu afficher ? Des chiffres seulement : 7 segments ; quelques lignes de texte : LCD à caractères ; graphiques et icônes : OLED ; interface couleur ou photos : TFT.
  • Où sera-t-il lu ? L'e-paper et le LCD se lisent bien au soleil ; l'OLED et le TFT peinent en pleine lumière. Dans le noir en revanche, le noir d'un OLED est vraiment noir et ne fatigue pas les yeux.
  • Combien de broches te restent-il ? Les écrans I2C se contentent de deux fils ; un LCD parallèle en demande six, un TFT SPI cinq et un e-paper six. Pour le calcul des broches, consulte les articles I2C et SPI.
  • La mémoire de ta carte suffit-elle ? Les 2 Ko de RAM de l'Uno contiennent à peine le tampon d'un OLED et jamais celui d'un TFT couleur. Sur l'ESP32 et le Pico, ce n'est presque jamais un problème.
  • Fonctionnera-t-il sur piles ? L'e-paper, qui garde son image sans consommer, est imbattable pour les capteurs qui tournent des mois.
  • Niveau de tension : la plupart des modules TFT et e-paper fonctionnent en logique 3,3 V ; avec un Uno, un convertisseur de niveau peut être nécessaire.
  • Prise en charge par les bibliothèques : les écrans compatibles avec des bibliothèques répandues comme Adafruit GFX, U8g2, TFT_eSPI et LiquidCrystal_I2C facilitent énormément la recherche d'exemples et le dépannage.

LCD à caractères : 16x2 et 20x4

Les LCD à caractères à contrôleur HD44780 sont l'écran classique de l'Arduino. Chaque caractère est formé de 5×8 points ; le modèle 16x2 affiche 2 lignes de 16 caractères et le 20x4, 4 lignes de 20. Comme le contrôleur de l'écran conserve lui-même l'image, il n'utilise presque pas de RAM sur l'Arduino. En liaison directe, il faut 6 broches (RS, E et D4–D7) et un potentiomètre pour le contraste ; nous avons expliqué cette méthode dans l'article Câblage parallèle du LCD 16x2. Avec un adaptateur I2C à base de PCF8574 soudé au dos, SDA et SCL suffisent. Tu peux définir jusqu'à 8 caractères personnalisés pour dessiner un symbole degré, une icône de pile ou des lettres accentuées. L'utilisation détaillée est dans l'article Écran LCD I2C.

C++ (Arduino IDE)
1// I2C 16x2 LCD: sıcaklık gibi bir değeri göstermek / I2C 16x2 LCD: showing a value such as temperature
2// SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2);    // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8byte degree[8] = {                      // kendi karakterin: derece işareti / custom character: degree sign
9  0b00110, 0b01001, 0b01001, 0b00110,
10  0b00000, 0b00000, 0b00000, 0b00000
11};
12
13void setup() {
14  lcd.init();
15  lcd.backlight();
16  lcd.createChar(0, degree);            // 8 özel karakterden ilki / first of 8 custom characters
17  lcd.setCursor(0, 0);
18  lcd.print("BlueGrays LCD");
19}
20
21void loop() {
22  int raw = analogRead(A0);             // A0'a bağlı bir sensör / a sensor on A0
23  float value = raw * 100.0 / 1023.0;
24  lcd.setCursor(0, 1);
25  lcd.print("Deger: ");
26  lcd.print(value, 1);
27  lcd.write(byte(0));                   // derece işaretini yaz / print the degree sign
28  lcd.print("   ");                     // eski karakterleri sil / clear leftover characters
29  delay(500);
30}
Si un LCD I2C n'affiche rien, tourne d'abord le potentiomètre bleu de contraste au dos de l'adaptateur ; il est souvent mal réglé en sortie d'usine. S'il reste vide, l'adresse est peut-être 0x3F au lieu de 0x27 ; un sketch scanner I2C te donne la bonne adresse en quelques secondes.

OLED : SSD1306 et SH1106

Écran OLED I2C 0,96 pouce
OLED I2C 0,96 pouce : 128×64 pixels qui produisent leur propre lumière et seulement 4 broches de connexion.

Sur un écran OLED, chaque pixel produit sa propre lumière ; il n'y a pas de rétroéclairage, le contraste est très élevé et l'image est nette sous tous les angles. Les modèles de 0,96 pouce utilisent généralement le contrôleur SSD1306, ceux de 1,3 pouce le plus souvent le SH1106. Vus de l'extérieur, ils sont identiques, mais la mémoire interne du SH1106 compte 132 colonnes ; un SH1106 piloté avec une bibliothèque SSD1306 affiche une image décalée de deux pixels et une bande parasitée sur le bord. La solution est de choisir la bibliothèque ou le constructeur adapté au contrôleur. La bibliothèque U8g2 gère les deux et, grâce au mode page, fonctionne sur l'Uno avec un tampon de seulement 128 octets. Tu trouveras les bases du SSD1306 dans l'article Écran OLED (SSD1306).

C++ (Arduino IDE)
1// U8g2 ile 1,3" SH1106 OLED (sayfa modu, Uno'da az RAM) / 1.3" SH1106 OLED with U8g2 (page mode, low RAM on the Uno)
2// SDA -> A4, SCL -> A5. 0,96" SSD1306 için yorumdaki satırı kullan / for a 0.96" SSD1306 use the commented line
3#include <U8g2lib.h>
4#include <Wire.h>
5
6U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
7// U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
8
9void setup() {
10  oled.begin();
11}
12
13void loop() {
14  int level = map(analogRead(A0), 0, 1023, 0, 120);   // A0'daki potansiyometre / potentiometer on A0
15  oled.firstPage();
16  do {                                                 // her sayfa için aynı çizim tekrarlanır / the same drawing repeats per page
17    oled.setFont(u8g2_font_ncenB08_tr);
18    oled.drawStr(0, 12, "BlueGrays OLED");
19    oled.drawFrame(0, 40, 124, 14);                    // çubuk çerçevesi / bar frame
20    oled.drawBox(2, 42, level, 10);                    // dolu çubuk / filled bar
21  } while (oled.nextPage());
22  delay(100);
23}

Le _1_ dans le nom du constructeur signifie que l'écran est dessiné par pages de 8 lignes : la boucle firstPage() / nextPage() répète le même dessin huit fois et envoie une bande de l'écran à chaque passage. C'est un peu plus lent, mais cela utilise 128 octets de RAM au lieu de 1 Ko. Sur l'ESP32 et le Pico, où la mémoire ne manque pas, tu peux choisir la version _F_ à tampon complet pour des animations plus fluides.

TFT couleur : ILI9341 et ST7789

Module d'écran TFT couleur ILI9341
TFT couleur 2,8 pouces à contrôleur ILI9341 : 240×320 pixels, 65 000 couleurs et liaison SPI ; certains modèles ont aussi une dalle tactile et un lecteur de carte SD.

Si tu veux des graphiques, des menus, des icônes et des indicateurs en couleur, tu passes aux écrans TFT. Chaque pixel porte une couleur sur 16 bits (RGB565), soit environ 65 000 couleurs. Les deux contrôleurs les plus courants sont l'ILI9341 et le ST7789. L'ILI9341 équipe des écrans 240×320 de 2,4 à 3,2 pouces, souvent avec un contrôleur tactile XPT2046. Le ST7789 se trouve sur des écrans carrés de 1,3 et 1,54 pouce (240×240) et sur les écrans 135×240 de cartes comme la TTGO T-Display. Ils fonctionnent avec l'Uno, mais lentement : même remplir tout l'écran une fois prend un temps visible. Sur l'ESP32, un SPI à 40 MHz et des bibliothèques optimisées comme TFT_eSPI permettent des interfaces fluides. Pour les détails, consulte les articles Écran TFT ILI9341 et Écran TFT ST7789.

CaractéristiqueILI9341ST7789
Tailles courantes2,4", 2,8", 3,2"1,14", 1,3", 1,54", 2,0"
Résolution240×320135×240, 240×240, 240×320
InterfaceSPI (les versions shield pour Uno sont en parallèle 8 bits)SPI (certains modèles sans broche CS)
TactileTactile résistif XPT2046 sur la plupart des modèlesGénéralement aucun
BibliothèqueAdafruit_ILI9341, TFT_eSPIAdafruit_ST7789, TFT_eSPI
Taille d'un tampon plein écran153 600 octets115 200 octets (240×240)
C++ (Arduino IDE)
1// ESP32 + 2,8" ILI9341 TFT: renkli sıcaklık göstergesi / colour temperature gauge
2// SCK 18, MOSI 23, MISO 19 (isteğe bağlı / optional), CS 5, DC 16, RST 17, VCC 3V3, LED 3V3
3#include <SPI.h>
4#include <Adafruit_GFX.h>
5#include <Adafruit_ILI9341.h>
6
7const int TFT_CS = 5;
8const int TFT_DC = 16;
9const int TFT_RST = 17;
10
11Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);    // donanım SPI (VSPI) / hardware SPI (VSPI)
12
13void setup() {
14  tft.begin(40000000);                 // 40 MHz SPI
15  tft.setRotation(1);                  // yatay 320x240 / landscape 320x240
16  tft.fillScreen(ILI9341_BLACK);
17  tft.setTextColor(ILI9341_WHITE);
18  tft.setTextSize(2);
19  tft.setCursor(10, 10);
20  tft.print("BlueGrays TFT");
21  tft.drawRect(10, 180, 300, 30, ILI9341_WHITE);  // çubuk çerçevesi / bar frame
22}
23
24void loop() {
25  float temp = 20.0 + (analogReadMilliVolts(34) / 3300.0) * 20.0;   // örnek değer / example value
26  uint16_t color = temp < 26 ? ILI9341_GREEN : (temp < 33 ? ILI9341_YELLOW : ILI9341_RED);
27
28  tft.fillRect(10, 60, 300, 80, ILI9341_BLACK);   // yalnız değişen alanı sil / clear only the changing area
29  tft.setTextSize(6);
30  tft.setTextColor(color);
31  tft.setCursor(20, 70);
32  tft.print(temp, 1);
33  tft.print(" C");
34
35  int w = (int)((temp - 20.0) / 20.0 * 296);
36  tft.fillRect(12, 182, w, 26, color);
37  tft.fillRect(12 + w, 182, 296 - w, 26, ILI9341_BLACK);
38  delay(500);
39}
La plupart des modules TFT SPI fonctionnent en logique 3,3 V et n'ont pas de convertisseur de niveau intégré. Relier directement les broches 5 V de l'Uno peut abîmer l'écran à la longue ; place des résistances série ou un convertisseur de niveau entre les deux. Les shields TFT de 2,4 pouces qui s'enfichent directement sur l'Uno occupent presque toutes les broches et ne laissent aucune place à d'autres modules. L'ESP32 et le Pico fonctionnent nativement en 3,3 V et n'ont pas ce problème.

Écrans e-paper (e-ink)

L'e-paper est la technologie d'affichage des liseuses. L'image se forme en déplaçant de minuscules capsules de pigment noir et blanc avec un champ électrique ; une fois dessinée, elle reste à l'écran même si le courant est coupé. Associé au mode deep sleep de l'ESP32, il est donc idéal pour des stations qui se réveillent une fois par heure, mettent à jour la météo et tiennent des mois sur piles. Comme il ressemble à du papier, il se lit parfaitement au soleil. Son point faible est la vitesse : un rafraîchissement complet prend environ 2 secondes et l'écran clignote plusieurs fois ; sur les modèles à rafraîchissement partiel, on descend sous la demi-seconde, mais des rafraîchissements partiels fréquents peuvent laisser des traces fantômes. Il se relie en SPI et demande MOSI, SCK, CS, DC, RST et une broche BUSY qui signale que l'écran est occupé. La bibliothèque la plus répandue est GxEPD2.

CaractéristiqueValeur
Tailles courantes1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300)
CouleurNoir et blanc ; les modèles trois couleurs ajoutent le rouge ou le jaune (rafraîchissement de 10 à 15 secondes)
Rafraîchissement completEnviron 1 à 3 secondes
Rafraîchissement partiel0,3 à 0,5 seconde sur les modèles compatibles
Courant au reposQuasi nul pendant que l'image est conservée
Alimentation3,3 V (la plupart des modules acceptent 5 V grâce à un régulateur)

Afficheurs 7 segments et TM1637

Module afficheur 7 segments TM1637 à 4 chiffres
Module TM1637 à 4 chiffres : un afficheur d'horloge avec deux-points au centre, relié uniquement par les fils CLK et DIO.

Si tu n'as que des chiffres à afficher, les afficheurs 7 segments restent l'option la plus lisible : grands, lumineux et visibles à plusieurs mètres. Un afficheur d'un chiffre demande 8 broches pour les 7 segments et le point, plus une résistance par segment ; un afficheur multiplexé à 4 chiffres utilise 12 broches. Nous avons expliqué ce câblage et la différence entre anode commune et cathode commune dans l'article Afficheur 7 segments. Le moyen le plus simple d'échapper au problème des broches est le module TM1637 : tu relies l'afficheur à 4 chiffres, qui a son propre pilote, avec seulement CLK et DIO, et tu règles la luminosité en 8 niveaux par logiciel. Même si le protocole du TM1637 ressemble à l'I2C, il n'utilise pas d'adresse ; il peut donc aller sur deux broches numériques quelconques et chaque module demande sa propre paire de broches.

C++ (Arduino IDE)
1// TM1637 4 haneli gösterge ile sayaç ve saat / Counter and clock with a TM1637 4-digit display
2// CLK -> D2, DIO -> D3, VCC -> 5V, GND -> GND
3#include <TM1637Display.h>
4
5TM1637Display display(2, 3);           // CLK, DIO
6unsigned long lastTick = 0;
7int seconds = 0;
8
9void setup() {
10  display.setBrightness(4);            // 0 (sönük) - 7 (en parlak) / 0 (dim) - 7 (brightest)
11  display.clear();
12}
13
14void loop() {
15  if (millis() - lastTick >= 1000) {
16    lastTick = millis();
17    seconds++;
18    int mm = (seconds / 60) % 100;
19    int ss = seconds % 60;
20    // 0b01000000: ortadaki iki nokta / the colon in the middle
21    display.showNumberDecEx(mm * 100 + ss, 0b01000000, true);
22  }
23}

Matrice LED MAX7219

Module matrice de points LED MAX7219 8x32
Module MAX7219 8×32 formé de quatre matrices 8×8 : chaîné sur une seule ligne CS pour du texte défilant, des horloges et des animations simples.

Le MAX7219 est un circuit qui pilote à lui seul 64 LED (une matrice 8×8 ou un afficheur 7 segments à 8 chiffres) et communique par trois fils, DIN, CLK et CS, avec un protocole proche du SPI. Les modules se chaînent ; avec les modules 4 en 1 courants, on réalise des panneaux de texte défilant de 32×8, et avec deux rangées de 32×16. Sa luminosité et sa lisibilité à distance en font l'idéal pour les panneaux de messages, les tableaux de score et les horloges. Sur Arduino, on utilise surtout les bibliothèques MD_Parola et MD_MAX72XX ; les détails sont dans l'article Matrice LED MAX7219. Ci-dessous, nous pilotons une seule matrice 8×8 avec un Raspberry Pi Pico sans bibliothèque, en écrivant directement dans les registres :

MicroPython
1# Raspberry Pi Pico: kütüphanesiz MAX7219 8x8 matris / MAX7219 8x8 matrix without a library
2# GP18 -> CLK, GP19 -> DIN, GP17 -> CS, VCC -> VBUS (5 V), GND -> GND
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7cs = Pin(17, Pin.OUT, value=1)
8
9def write_reg(reg, value):
10    cs.value(0)
11    spi.write(bytearray([reg, value]))     # önce yazmaç, sonra değer / register first, then value
12    cs.value(1)
13
14def init():
15    write_reg(0x0F, 0x00)    # test modu kapalı / display test off
16    write_reg(0x09, 0x00)    # kod çözme yok (matris) / no decode (matrix)
17    write_reg(0x0B, 0x07)    # 8 satırın hepsi / scan all 8 rows
18    write_reg(0x0A, 0x03)    # parlaklık 0-15 / brightness 0-15
19    write_reg(0x0C, 0x01)    # uyku modundan çık / leave shutdown mode
20
21SMILE = [0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C]
22HEART = [0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18]
23
24def show(image):
25    for row in range(8):
26        write_reg(row + 1, image[row])     # satır yazmaçları 1-8 / row registers 1-8
27
28init()
29while True:
30    show(SMILE)
31    time.sleep(1)
32    show(HEART)
33    time.sleep(1)

Pour que ses LED brillent fort, le MAX7219 doit être alimenté en 5 V ; c'est pourquoi le VCC du module va sur la broche VBUS du Pico. D'après la fiche technique, avec une alimentation de 5 V, les entrées doivent recevoir au moins 3,5 V pour être vues à HIGH ; les signaux 3,3 V du Pico fonctionnent sans souci sur la plupart des modules, mais en cas d'instabilité, ajoute un convertisseur de niveau sur les lignes DIN, CLK et CS. Le courant augmente avec la luminosité et le nombre de LED allumées : avec les quatre modules entièrement allumés à pleine luminosité, on peut tirer des centaines de milliampères.

Écrans tactiles HMI Nextion

Le Nextion est un écran tactile intelligent doté de son propre processeur et de sa propre mémoire. Tu conçois l'interface avec boutons, curseurs et jauges sur ton ordinateur dans Nextion Editor par glisser-déposer, puis tu la charges dans l'écran ; l'Arduino se contente d'envoyer par le port série (UART) de courtes commandes comme t0.txt="25" et de lire les événements tactiles. Tout le travail de dessin est donc assuré par l'écran, et même une petite carte comme l'Uno peut gérer une interface couleur de 7 pouces. La vitesse par défaut est de 9600 bauds. Les inconvénients sont le prix, une consommation de 90 mA même sur le modèle de 2,4 pouces et jusqu'à 500 mA sur le 7 pouces, et la conception dans un logiciel séparé. Sur l'Uno, le port série matériel est partagé avec l'USB ; utiliser SoftwareSerial ou des cartes à plusieurs ports série comme le Mega et l'ESP32 simplifie les choses.

Besoin en mémoire : quel écran tient sur un Uno ?

La plupart des bibliothèques d'écrans graphiques dessinent d'abord l'image dans un tampon en RAM, puis l'envoient entièrement à l'écran. Taille du tampon = largeur × hauteur × bits par pixel / 8. Quand on sait que l'Arduino Uno n'a que 2 Ko de RAM, dont une partie part dans les variables, le port série et les bibliothèques, la limite saute aux yeux. Nous avons réuni les solutions générales aux problèmes de mémoire dans l'article Arduino à court de mémoire.

ÉcranTampon completArduino Uno (2 Ko)ESP32 (520 Ko) / Pico (264 Ko)
LCD 16x2Inutile (l'écran le conserve)Sans problèmeSans problème
OLED 128×641 024 octetsLimite ; mode page (128 octets) conseilléSans problème
OLED 128×32512 octetsSans problèmeSans problème
E-paper 296×1284 736 octetsSeulement en dessinant page par pageSans problème
TFT ST7789 240×240115 200 octetsImpossible ; on dessine directement à l'écranPossible sur l'ESP32, la moitié de la RAM sur le Pico
TFT ILI9341 240×320153 600 octetsImpossible ; on dessine directement à l'écranPossible, mais on préfère souvent de petits sprites

Consommation et utilisation sur piles

Dans un projet sur piles, l'écran consomme souvent plus d'énergie que le microcontrôleur. Le seul rétroéclairage d'un LCD 16x2 peut dépasser 20 mA ; si tu l'éteins (lcd.noBacklight()), l'écran reste lisible au soleil mais plus dans le noir. Le courant d'un OLED est proportionnel au nombre de pixels allumés : un texte blanc fin sur fond noir consomme plusieurs fois moins qu'un fond blanc. Sur les TFT, les LED de rétroéclairage sont toujours allumées ; commander la broche de rétroéclairage par un transistor ou en PWM fait gagner beaucoup. L'e-paper ne consomme presque rien tant que tu ne changes pas l'image. Pour calculer l'autonomie, tu peux reprendre la méthode de l'article sur les mAh.

Quel écran pour quel projet ?

ProjetÉcran conseilléPourquoi ?
Afficheur de température et d'humiditéLCD 16x2 I2C ou OLED 0,96"Bon marché, deux fils, quelques lignes de texte suffisent
Horloge numérique et compte à reboursTM1637 ou MAX7219Grands chiffres lumineux ; lisibles de loin
Jeu de poche (Pong, serpent, T-Rex)OLED 128×64 ou matrice 8×8Rafraîchissement rapide, dessin au pixel près
Station météo (sur piles)E-paper + deep sleep de l'ESP32L'image reste sans consommer, lisible au soleil
Tableau de commande et menu en couleurILI9341 avec tactile, ou NextionCouleur, icônes et saisie tactile
Texte défilant et panneau de messagesModules MAX7219 chaînésVisible à plusieurs mètres, s'agrandit sur un seul CS
Appareil compact à ESP32ST7789 1,14" ou 1,3"Petit, coloré et rapide en SPI

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Le LCD n'affiche que des pavés pleinsContraste non réglé ou écran non initialiséTourne le potentiomètre de contraste, vérifie l'adresse et l'appel à lcd.init()
Image décalée et parasites sur le bord d'un OLED 1,3"Un écran SH1106 piloté avec une bibliothèque SSD1306Utilise le constructeur SH1106 d'U8g2 ou la bibliothèque Adafruit SH110X
Le sketch OLED se téléverse mais l'Uno se figeLe tampon d'écran a épuisé la RAMUtilise le mode page d'U8g2, place les textes dans F()
Le TFT reste tout blancMauvais contrôleur, mauvaises broches ou signal 5 VVérifie le contrôleur (ILI9341, ST7789), contrôle les broches DC et CS, respecte le niveau 3,3 V
L'e-paper ne change jamaisBroche BUSY non reliée ou mauvais modèle choisiRelie BUSY, choisis dans GxEPD2 la classe exacte de ton écran
Certains segments de l'afficheur 7 segments sont pâlesAnode et cathode communes confondues ou résistance manquanteVérifie le type d'afficheur, mets une résistance sur chaque segment
Le MAX7219 allume des LED au hasardFil desserré, alimentation faible ou signal 3,3 V à la limiteRaccourcis les fils, renforce l'alimentation 5 V, ajoute un convertisseur de niveau si besoin
Avant d'intégrer un écran à ton projet, lance l'exemple fourni avec la bibliothèque. Si l'exemple fonctionne et pas ton code, le problème est dans ton code ; si l'exemple ne marche pas non plus, concentre-toi sur le câblage, l'adresse ou le choix du contrôleur. Cette seule étape transforme des heures de tâtonnements en quelques minutes.

Le bon écran dépend de ce que ton projet affiche, de l'endroit où il sera lu et de son alimentation : un LCD pour le texte, un OLED pour de petits graphiques, un TFT ou un Nextion pour une interface couleur, l'e-paper pour les appareils sur piles, les 7 segments et le MAX7219 pour de grands chiffres. Dans l'application BlueGrays, tu trouveras des projets avec LCD I2C, des jeux et un écran météo sur OLED, une horloge TM1637 et une matrice de points MAX7219, pas à pas avec schémas de câblage et code.

Questions fréquentes

Quel est le meilleur écran pour Arduino ?

Il n'y a pas un meilleur écran unique ; le choix dépend du projet. Pour quelques lignes de texte, un LCD 16x2 I2C convient, pour de petits graphiques un OLED de 0,96 pouce, pour une interface couleur un TFT ILI9341 et pour les appareils sur piles un e-paper.

OLED ou LCD : lequel est le meilleur ?

L'OLED est plus net, très contrasté, peut dessiner des graphiques et se lit parfaitement dans le noir. Le LCD à caractères est moins cher, plus lisible au soleil et n'utilise presque pas de RAM sur l'Arduino.

Un Arduino Uno peut-il piloter un écran TFT couleur ?

Oui, les TFT SPI comme l'ILI9341 ou le ST7789 fonctionnent avec l'Uno, mais faute de RAM pour un tampon plein écran, le dessin se fait directement à l'écran et lentement. Pour des interfaces couleur fluides, un ESP32 ou un Raspberry Pi Pico est un meilleur choix.

Quelle différence entre le SSD1306 et le SH1106 ?

Ce sont deux contrôleurs d'OLED 128×64 ; le SSD1306 équipe surtout les écrans de 0,96 pouce et le SH1106 ceux de 1,3 pouce. Comme la mémoire du SH1106 compte 132 colonnes, l'image se décale avec une bibliothèque SSD1306 ; il faut une bibliothèque adaptée comme U8g2 ou Adafruit SH110X.

Un écran e-paper garde-t-il son image sans courant ?

Oui. L'e-paper forme l'image en déplaçant des capsules de pigment et, une fois dessinée, l'image reste à l'écran sans aucune énergie. C'est pourquoi il est idéal pour les appareils sur piles mis à jour une fois par heure.

Le TM1637 est-il un composant I2C ?

Non. Le protocole à deux fils du TM1637 ressemble à l'I2C, mais il n'utilise pas d'adresse et ne se branche pas sur un bus I2C. Il se relie à deux broches numériques quelconques et se pilote avec sa propre bibliothèque (par ex. TM1637Display) ; plusieurs modules demandent chacun leur propre paire de broches.

Voir tous les projets
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
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
Jeu de Raquettes - SSD1306
AR-86Intermédiaire
Premium

Jeu de Raquettes - SSD1306

Une balle, deux raquettes et toi : tu joues au tennis de table, l'un des tout premiers jeux vidéo, sur un petit écran OLED.

4.5(47)
65
OLED T-Rex Run : Jeu de dinosaures Arduino
AR-87Avancé
Premium

OLED T-Rex Run : Jeu de dinosaures Arduino

Le jeu du dinosaure qui apparaît quand internet est coupé, maintenant sur ton bureau : le dinosaure court sur le petit écran OLED, les cactus foncent sur lui et tu sautes avec un seul bouton.

4.7(33)
53
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
ES-32Avancé
Premium

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)

L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

4.3(10)
22
ESP32 TM1637 Affichage à 7 segments à 4 chiffres
ES-23Intermédiaire
Premium

ESP32 TM1637 Affichage à 7 segments à 4 chiffres

Nous contrôlons un module d'affichage à 7 segments à 4 chiffres équipé d'un pilote TM1637 à l'aide d'un ESP32. En utilisant seulement 2 GPIO (CLK et DIO), nous faisons fonctionner un compteur de 0 à 9999, réglons le niveau de luminosité et affichons le caractère « : » au milieu sous forme d'horloge. Grâce à la bibliothèque TM1637Display, le contrôle des nombres, des valeurs hexadécimales, des segments et des chaînes de caractères est très simple.

4.7(20)
32
Horloge et calendrier matriciel (MAX7219, DS1307)
AR-84Intermédiaire
Premium

Horloge et calendrier matriciel (MAX7219, DS1307)

Un panneau lumineux pour ton bureau ou ton mur, qui affiche l'heure et la date en texte défilant.

5.0(37)
59
Horloge numérique avec afficheur 7 segments à 4 chiffres
AR-48Intermédiaire
Premium

Horloge numérique avec afficheur 7 segments à 4 chiffres

Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

4.8(56)
73