Afficheur LCD / OLED

Un afficheur permet à un projet embarqué de présenter ses mesures, son état ou son menu sans passer par un PC. Deux familles cohabitent dans l’écosystème Arduino : LCD à caractères (16×2 ou 20×4 caractères, technologie historique) et OLED graphiques (128×64 pixels sur SSD1306, plus modernes). Cette fiche couvre les deux via leur version la plus pédagogique : branchées en I2C, qui n’occupe que deux broches.

À quoi ça sert ?

L’afficheur intervient au moment où un projet quitte le banc d’essai branché au PC pour devenir autonome :

• Démonstration — montrer les mesures du capteur en direct sur le boîtier, sans ordinateur.
• Interface utilisateur — menu, choix de mode, paramétrage.
• Indicateur d’état — heure, niveau de batterie, présence d’erreur.
• Datalogger embarqué — voir les dernières valeurs sans ouvrir un fichier.

Comparaison rapide :

Type	Lisibilité	Graphique	Consommation
LCD 16×2 I2C (HD44780 + PCF8574)	excellente même en plein soleil	aucun	~20-50 mA (rétroéclairage allumé)
OLED 0,96″ I2C SSD1306 (128×64)	très contrastée, faible angle	✅	~20 mA
TFT 2,4″ SPI (ILI9341)	couleur, angle large	✅	~80-150 mA
E-paper 2,9″ SPI	excellente en lumière ambiante	✅	nulle hors refresh (refresh lent ~2 s)

Procédure pas à pas

Quatre étapes : choisir l’afficheur, câbler en I2C, installer la bibliothèque, écrire le code.

1. Choisir l’afficheur

Pour un premier projet école : OLED SSD1306 128×64 I2C. Petit, lisible, graphique simple.

Pour de l’affichage texte robuste, avec lecture facile à distance : LCD I2C 16×2 (étiquette PCF8574 sur l’arrière). Pas de graphique mais texte parfait, et plus grand.

2. Câbler en I2C

Identique pour les deux types : 4 fils.

Module	Arduino Uno
VCC	5 V (ou 3,3 V pour certains OLED)
GND	GND
SDA	A4
SCL	A5

L’OLED SSD1306 grand public accepte 3,3 V et 5 V (régulateur intégré). Vérifier sur l’étiquette du module. Le LCD I2C est conçu pour 5 V uniquement.

3. Installer la bibliothèque

Pour OLED SSD1306 : Adafruit SSD1306 via le gestionnaire de bibliothèques. Installer également Adafruit GFX Library (dépendance, propose les primitives graphiques) et Adafruit BusIO (dépendance bus).

Pour LCD I2C : LiquidCrystal I2C (par Frank de Brabander) via le gestionnaire. Plusieurs forks existent. Celui-ci est fiable. Alternative : hd44780 (par Bill Perry), plus moderne mais à syntaxe légèrement différente.

4. Écrire le code

OLED SSD1306 :

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
 
const int LARGEUR = 128;
const int HAUTEUR = 64;
Adafruit_SSD1306 ecran(LARGEUR, HAUTEUR, &Wire, -1);  // -1 = pas de broche reset
 
void setup() {
  Serial.begin(115200);
  if (!ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  // 0x3C trouvé au scanner I2C
    Serial.println("OLED introuvable");
    while (1);
  }
  ecran.clearDisplay();
  ecran.setTextColor(SSD1306_WHITE);
  ecran.setTextSize(1);
  ecran.setCursor(0, 0);
  ecran.println("Hello !");
  ecran.println("Ligne 2");
  ecran.display();
}
 
void loop() {
  ecran.clearDisplay();
  ecran.setCursor(0, 0);
  ecran.print("Temps : ");
  ecran.print(millis() / 1000);
  ecran.println(" s");
  ecran.display();
  delay(500);
}

Comment lire ce code

ecran.display() est obligatoire : la bibliothèque Adafruit dessine dans un buffer interne (en RAM), et seul cet appel l’envoie réellement à l’écran. Les commandes print/setCursor/clearDisplay ne touchent que ce buffer. Tant qu’on n’appelle pas display(), l’écran reste tel quel. Oublier display() = écran qui semble vide alors que le code « tourne ».

LCD I2C 16×2 :

#include <Wire.h>                // bus I2C
#include <LiquidCrystal_I2C.h>    // pilote du LCD via l'extenseur PCF8574
 
// adresse I2C du module (0x27 ou 0x3F), puis nombre de colonnes et de lignes
LiquidCrystal_I2C lcd(0x27, 16, 2);
 
void setup() {
  lcd.init();              // initialise le LCD et le bus I2C
  lcd.backlight();         // allume le retroeclairage (sinon texte illisible)
  lcd.setCursor(0, 0);     // place le curseur colonne 0, ligne 0 (coin haut-gauche)
  lcd.print("Hello LCD !");
  lcd.setCursor(0, 1);     // colonne 0, ligne 1 (deuxieme ligne)
  lcd.print("Ligne 2");
}
 
void loop() {
  lcd.setCursor(0, 1);          // revenir au debut de la 2e ligne avant de reecrire
  lcd.print("Temps : ");
  lcd.print(millis() / 1000);   // secondes ecoulees depuis le demarrage
  lcd.print(" s   ");           // espaces de fin : effacent les chiffres de la valeur precedente
  delay(500);
}

Comment lire ce code

À l’inverse de l’OLED, le LCD n’a pas de buffer : chaque lcd.print() s’affiche immédiatement. Mais il n’efface pas ce qui était écrit avant. Afficher 42 puis 7 au même endroit laisse voir 72. Pour nettoyer, écrire des espaces après la valeur (comme le " s " ci-dessus) ou appeler lcd.clear() (lent, à utiliser parcimonieusement).

Exemple — Thermomètre OLED avec icône thermomètre

Cas complet : lire la température sur un BMP280 (voir I2C sur Arduino), l’afficher sur l’OLED en gros chiffres avec une icône.

Câblage : BMP280 + OLED tous deux en I2C sur A4/A5 (même bus qu’à l’étape 2 ; plusieurs devices à adresses différentes — BMP280 = 0x76, OLED = 0x3C).

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_BMP280.h>
 
const int LARGEUR = 128;
const int HAUTEUR = 64;
Adafruit_SSD1306 ecran(LARGEUR, HAUTEUR, &Wire, -1);
Adafruit_BMP280 bmp;
 
void setup() {
  Serial.begin(115200);
  ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  bmp.begin(0x76);
  ecran.setTextColor(SSD1306_WHITE);
}
 
void loop() {
  float t = bmp.readTemperature();
 
  ecran.clearDisplay();
  ecran.setTextSize(1);
  ecran.setCursor(0, 0);
  ecran.println("Temperature");
 
  ecran.setTextSize(3);  // gros caractères
  ecran.setCursor(10, 20);
  ecran.print(t, 1);  // 1 décimale
  ecran.print(" C");
 
  ecran.display();
  delay(500);
}

Souffler sur le BMP280 : la température affichée monte de 1-2 °C par seconde. Démo simple, visuellement satisfaisante, qui combine deux modules I2C sur un même bus.

Pièges

Adresse I2C incorrecte. Le SSD1306 est presque toujours en 0x3C, parfois en 0x3D. Le LCD est en 0x27 ou 0x3F selon le module. Toujours lancer un scanner I2C (voir I2C sur Arduino) avant de mettre une adresse en dur.

Bibliothèque obsolète ou incompatible. Les bibliothèques SSD1306 sont nombreuses (Adafruit, U8g2, SH1106 pour les variants). Si rien ne s’affiche, vérifier qu’on utilise bien la bibliothèque correspondant au contrôleur de l’écran (SSD1306 vs SH1106 : étiquette sur le module).

OLED sans appel à display(). La bibliothèque Adafruit dessine dans un buffer interne. Seul display() envoie au matériel. Oublier l’appel = écran blanc malgré le code qui semble correct.

LCD qui n’efface pas l’ancien contenu. Le LCD écrit caractère par caractère sans effacer le reste. Si on affiche "42" puis "7", on voit "72" : il faut écrire "7 " (avec espace) ou appeler lcd.clear().

Texte trop grand pour l’écran. Sur OLED 128×64 en setTextSize(3), un caractère fait ~18 pixels de large × 24 de haut, soit 7 caractères max par ligne. Au-delà, le texte sort à droite ou écrase l’affichage. Calibrer la taille selon la longueur attendue.

Plusieurs devices I2C avec mêmes pull-ups. Le LCD I2C et certains OLED intègrent leurs pull-ups SDA/SCL. Sur un bus avec plusieurs modules à pull-ups, la résistance équivalente devient trop faible : le bus arrête de fonctionner. Désactiver les pull-ups sur tous les modules sauf un.

Backlight LCD qui consomme trop. Le rétroéclairage d’un LCD I2C 16×2 tire ~50 mA. Sur un projet alimenté par batterie ou USB d’un PC déjà bien chargé, ça compte. lcd.noBacklight() éteint le rétroéclairage et économise.

Rafraîchissement lent qui scintille. Effacer tout l’écran à chaque frame (clearDisplay() + tout redessiner) à 50 Hz est OK. À plus, ça peut scintiller : préférer redessiner uniquement la zone qui a changé.

Cas particulier — Polices personnalisées et caractères accentués

Les caractères accentués (é, è, à, ç) ne sont pas dans la police par défaut de la bibliothèque Adafruit GFX. Trois options :

• Remplacer mentalement : "Temperature" à la place de "Température".
• Importer une police étendue (fonts/ dans Adafruit GFX, polices avec accents).
• Utiliser U8g2 — bibliothèque alternative qui supporte natively UTF-8 et propose des centaines de polices.

Pour un projet francophone qui doit afficher proprement les accents, U8g2 est l’option recommandée.

Raccrochage projet

• Étape 3 de la phase de preuve de concept — premier affichage embarqué pour observer les mesures sans PC.
• Étape 3 de la phase d’intégration et tests — l’afficheur intégré au démonstrateur sert d’IHM pour les tests pyramidaux (mode courant, valeurs réelles).

Un afficheur, même simple, transforme un projet du « regarder le moniteur série » en « voir l’état directement », un vrai saut qualitatif en démonstration.

Voir aussi

• Arduino — hub des tutoriels Arduino
• I2C sur Arduino — prérequis (câblage bus)
• Utiliser une bibliothèque — prérequis (Adafruit GFX, LiquidCrystal_I2C)
• SPI sur Arduino — pour écrans TFT et e-paper