Adaptateur I2C pour afficheur LCD

L’adaptateur I2C pour afficheur LCD est la petite carte que l’on fixe au dos d’un afficheur à caractères. Elle remplace le faisceau de seize fils du mode parallèle par quatre fils seulement, et ramène le câblage d’un écran au niveau de celui d’un simple capteur.

Sans elle, un afficheur 16×02 demande une douzaine de liaisons vers l’Arduino, dont une résistance pour le contraste. Avec elle, tout le travail de traduction est confié à un expandeur d’entrées-sorties posé sur la carte : le microcontrôleur n’envoie plus que deux fils, et le contraste se règle sur place avec un petit tournevis.

À quoi sert l’adaptateur I2C ?

• Réduire le câblage — quatre fils au lieu de seize : alimentation, masse, SDA et SCL.
• Libérer des broches — un afficheur en parallèle occupe six broches de l’Arduino ; en I2C, il n’en occupe aucune de plus, puisque le bus est déjà là.
• Régler le contraste sans résistance — le potentiomètre est soudé sur l’adaptateur.
• Multiplier les écrans — jusqu’à huit modules sur le même bus, chacun avec son adresse.
• Gérer le rétroéclairage — la carte porte la commande du rétroéclairage et son cavalier d’activation.

Caractéristiques techniques

Brochage : quatre fils, dans un seul sens

Le connecteur d’entrée est sérigraphié sur la carte, à côté des broches. Le branchement ne souffre aucune improvisation : une inversion d’alimentation peut détruire le module et l’afficheur.

Les autres broches du module ne se câblent pas : la rangée de seize broches sur le bord opposé se fixe directement au dos de l’afficheur.

L’adresse I2C et les cavaliers A0, A1 et A2

Sur un bus I2C, chaque participant porte une adresse. L’expandeur en propose huit, obtenues en combinant les trois pastilles A0, A1 et A2 : une pastille laissée en l’état compte pour 1, une pastille reliée à la masse compte pour 0. Les trois à 1 donnent l’adresse d’usine la plus répandue, 0x27 — et 0x3F lorsque la carte est équipée d’un PCF8574A.

Cette distinction a son importance, et c’est la première cause d’un écran qui reste muet : la puce d’un module ne se lit pas toujours sur la photo du vendeur, et une adresse fausse ne provoque aucune erreur — simplement aucun affichage. Le programme du mini-projet commence donc par balayer le bus et afficher les adresses réellement présentes : c’est la réponse la plus fiable, et elle prend deux secondes.

Relier une pastille à la masse retire sa valeur de l’adresse. C’est le seul réglage à faire si vous voulez poser deux afficheurs sur un même Arduino.

La seule étape délicate : la fixation au dos de l’afficheur

Le module se fixe à l’afficheur par une rangée de seize broches. Si votre afficheur porte déjà un peigne mâle, l’adaptateur s’embroche dessus en une seconde. Sinon il faut souder seize points, et deux précautions suffisent : présenter le module bien aligné, à plat contre le circuit imprimé, puis souder deux broches opposées d’abord pour figer la position avant de faire les autres.

Une soudure faite à la hâte sur une seule broche de travers est la deuxième cause d’écran muet : le contact se fait sur certaines broches et pas sur d’autres, et l’ensemble devient impossible à diagnostiquer. Prenez le temps de l’alignement.

Mini-projet : le premier texte affiché en I2C

Le montage tient en quatre fils et le programme en trente lignes. Il relève l’adresse du module, puis écrit deux lignes de texte et un compteur de secondes.

Ce qu’il faut

L’afficheur et son adaptateur se branchent sur le 5 V de l’Arduino : aucun bloc d’alimentation supplémentaire n’est nécessaire pour ce montage.

Le câblage

C’est tout. Quatre fils, et l’afficheur est en place.

Le programme

À copier dans l’IDE Arduino, puis à téléverser. La bibliothèque LiquidCrystal I2C s’installe depuis le gestionnaire de bibliothèques de l’IDE.

/*
 * Premier affichage sur un LCD en I2C
 * Carte : Arduino Uno R3
 * Montage : adaptateur I2C + afficheur LCD 16x02
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

const byte ADRESSE_LCD = 0x27;   // a corriger si le balayage annonce autre chose
const byte COLONNES    = 16;
const byte LIGNES      = 2;

LiquidCrystal_I2C lcd(ADRESSE_LCD, COLONNES, LIGNES);

byte pret = 0;

// Un module I2C repond en acquittant son adresse : endTransmission()
// renvoie 0 quand quelqu'un a repondu, et un code d'erreur sinon.
byte moduleTrouve(byte adresse) {
  Wire.beginTransmission(adresse);
  return Wire.endTransmission() == 0;
}

void setup() {
  Serial.begin(9600);
  Wire.begin();

  Serial.println("Balayage du bus I2C...");
  byte nombre = 0;

  for (byte adresse = 1; adresse != 127; adresse++) {
    if (moduleTrouve(adresse)) {
      Serial.print("  module a l'adresse 0x");
      Serial.println(adresse, HEX);
      nombre++;
    }
  }

  Serial.print(nombre);
  Serial.println(" module(s) sur le bus.");

  if (!moduleTrouve(ADRESSE_LCD)) {
    Serial.println("L'adaptateur ne repond pas a l'adresse choisie.");
    Serial.println("Corrigez ADRESSE_LCD avec une adresse listee ci-dessus.");
    return;
  }

  lcd.init();              // lcd.begin(COLONNES, LIGNES) selon la bibliotheque
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("Maroc Produits");
  lcd.setCursor(0, 1);
  lcd.print("LCD en I2C");

  pret = 1;
}

void loop() {
  static unsigned long dernier = 0;
  unsigned long secondes = millis() / 1000;

  if (!pret) return;
  if (secondes == dernier) return;

  dernier = secondes;

  lcd.setCursor(11, 1);
  lcd.print("     ");        // on efface le compteur precedent
  lcd.setCursor(11, 1);
  lcd.print(secondes);
}

Comment ça marche

• Wire.beginTransmission(adresse) ouvre une conversation avec une adresse et Wire.endTransmission() la referme en rendant compte : la valeur 0 signifie qu’un composant a acquitté. Le balayage consiste donc à poser la question aux 126 adresses possibles et à noter celles qui répondent.
• Le rôle de l’expandeur se limite à cela : recevoir deux fils et les répartir sur les huit lignes qui pilotent l’afficheur, en suivant les ordres reçus sur le bus.
• Le mode 4 bits double chaque octet à transmettre ; c’est un détail de la bibliothèque, mais il explique pourquoi six fils suffisent côté afficheur là où le brochage du HD44780 en annonce davantage.
• Un Wire.begin() oublié laisse le bus inactif : rien ne s’affiche et le balayage ne trouve personne, même quand tout est correctement câblé.
• Le compteur est comparé à sa valeur précédente (secondes == dernier) pour n’écrire sur l’afficheur qu’une fois par seconde : réécrire seize caractères en boucle sature le bus pour rien et fait scintiller l’écran.

Variante : deux afficheurs sur le même Arduino

Sur un bus I2C, tout se partage : les deux afficheurs se branchent en parallèle sur les mêmes broches VCC, GND, SDA et SCL, et c’est l’adresse qui désigne celui à qui l’on parle. Il suffit donc de relier une pastille d’adresse à la masse sur l’un des deux modules pour lui donner une adresse distincte — l’autre garde son adresse d’usine.

Le programme de balayage annonce alors deux modules, et le reste du code ne change qu’en déclarant un second objet, avec l’autre adresse. C’est un moyen peu coûteux d’afficher beaucoup d’informations : un écran pour les mesures, un écran pour l’état du système.

Questions fréquentes

L’afficheur s’allume mais n’affiche rien, ou une rangée de rectangles noirs

C’est le contraste, dans neuf cas sur dix. Tournez lentement la vis du potentiomètre sur la carte, sur un demi-tour complet : le texte apparaît en général quelque part dans cette plage. Une rangée de rectangles noirs est le signe que l’afficheur est alimenté et initialisé, mais que le contraste est poussé trop loin. Si rien n’apparaît du tout, vérifiez que le rétroéclairage s’allume : sans lui, le texte reste lisible en pleine lumière, ce qui permet de distinguer un problème de contraste d’un problème d’alimentation.

Le balayage I2C ne trouve aucun module

Quatre causes, à vérifier dans cet ordre : les fils SDA et SCL inversés — c’est la plus fréquente, et elle n’abîme rien ; le 5 V non relié ; un module soudé de travers sur l’afficheur ; une bibliothèque installée mais un Wire.begin() absent. Un module qui ne répond pas au balayage ne répondra à aucun programme : inutile de chercher ailleurs avant que le balayage l’ait vu.

Quelle bibliothèque installer ?

La bibliothèque LiquidCrystal I2C, disponible dans le gestionnaire de bibliothèques de l’IDE Arduino. Attention : plusieurs versions circulent sous des noms proches, et elles ne s’initialisent pas de la même façon. Si la compilation refuse lcd.init(), remplacez cette ligne par lcd.begin(COLONNES, LIGNES) — le reste du programme ne change pas.

Peut-on l’utiliser avec un ESP32 ou un ESP8266 ?

Oui. Le circuit du module fonctionne sous 5 V et se contente très bien des 3,3 V de ces cartes, qui restent dans sa plage d’alimentation. Deux points d’attention : les broches du bus I2C ne sont pas les broches A4 et A5, il faut les indiquer dans le programme ; et le rétroéclairage, qui consomme le plus, mérite d’être éteint par son cavalier pour un montage sur batterie.

Peut-on alimenter l’afficheur sans l’Arduino ?

Avec une alimentation 5 V stabilisée, oui, à condition de relier les masses ensemble. L’afficheur avec son rétroéclairage consomme l’essentiel du courant du montage : sur un projet autonome, il vaut mieux ne pas le faire alimenter par le régulateur de la carte Arduino.

Faut-il retirer le cavalier LED ?

Uniquement si vous voulez éteindre le rétroéclairage. Le cavalier ne sert qu’à cela : il coupe l’alimentation des diodes du fond. Retirez-le pour un montage sur pile ou batterie, laissez-le en place pour un montage sur secteur, où le confort de lecture prime.

À combiner avec

Si votre afficheur n’est pas encore équipé, l’afficheur LCD 16×02 déjà soudé sur son adaptateur évite complètement l’étape de soudure. Pour démarrer proprement, le KIT Starter réunit la carte Uno R3, la plaque d’essai et les fils nécessaires à ce montage. Et si l’affichage de texte vous entraîne plus loin, un module TM1637 affichera des chiffres là où la place manque.