Afficheur LCD 16 02 I2C

Un afficheur 16 × 02 se câble d’ordinaire avec une nappe de seize fils, dont deux seulement pour l’alimentation. Sur ce modèle, l’adaptateur I2C est déjà en place, soudé au dos de l’écran : quatre fils suffisent, et il n’y a rien à souder ni à visser soi-même.

Le module réunit deux cartes. Devant, un afficheur à caractères 16 × 02 avec son contrôleur compatible HD44780, celui que toutes les bibliothèques Arduino savent piloter. Derrière, un circuit noir qui porte un expandeur PCF8574 : il reçoit deux fils du bus I2C et reconstruit à lui seul le bus parallèle de l’écran, données et signaux de commande compris. Le contraste se règle avec le petit potentiomètre posé sur cette carte, et le rétroéclairage se commande par logiciel.

L’intérêt se mesure en broches. Un afficheur classique en mode 4 bits consomme six fils de la carte, ce module en consomme deux. Sur une Uno, ces quatre broches rendues à l’utilisateur font souvent la différence entre un montage qui tient sur la plaque d’essai et un montage qui réclame un port d’extension.

Caractéristiques techniques

Brochage du connecteur

Quatre broches seulement, et leur nom est écrit sur la carte côté connecteur. Le tableau donne la correspondance pour les cartes les plus courantes : sur une Uno comme sur une Nano, le bus I2C est en bout de carte sur A4 et A5 ; sur une Mega, il dispose de ses propres broches, doublées en D20 et D21.

L’adresse I2C : la seule chose à connaître avant d’écrire

Un bus I2C met plusieurs circuits en parallèle sur les deux mêmes fils, et chacun répond à une adresse. L’adaptateur fabrique la sienne à partir des cavaliers A0, A1 et A2 : pontés ou laissés ouverts, ils changent les bits de poids faible de l’adresse. Le réglage d’usine est l’adresse 0x27, valable pour un PCF8574T dont les trois cavaliers sont ouverts. Un adaptateur à PCF8574AT répond en revanche à 0x3F, et seule la sérigraphie de la carte ou un balayage du bus permet de trancher.

Quand rien ne s’affiche, cette adresse est la première chose à vérifier, avant le câblage. L’IDE ne contient pas de balayeur de bus : on en écrit un en une quinzaine de lignes avec la bibliothèque Wire, en interrogeant tour à tour les adresses possibles et en affichant celles qui répondent. Le programme de cette page utilise la constante ADRESSE_I2C : c’est la seule valeur à changer si vous lisez autre chose que 0x27 sur le moniteur série.

Applications

• Banc de mesure — température, tension, distance, poids, avec l’unité écrite en toutes lettres à côté de la valeur.
• Afficheur d’état d’un automate — étape en cours, message d’erreur et consigne courante d’un montage fixe, sur quatre fils seulement.
• Station météo — deux lignes suffisent pour la température et l’humidité, ou pour la mesure et l’heure d’une horloge temps réel DS3231, elle aussi sur le bus I2C.
• Minuterie ou compte-tours — la valeur d’un côté, l’état ou le cumul de l’autre.
• Interface d’un projet pédagogique — les messages remplacent les clignotements de LED quand il faut expliquer ce que fait le programme.
• Montages déjà chargés en capteurs — c’est là que les deux fils économisés pèsent le plus : sur un montage qui réclame déjà une dizaine de broches, l’afficheur ne prend plus que le bus.

Mini-projet : un thermomètre sur le bus I2C

Le capteur de température LM35 sort une tension proportionnelle à la température, que l’Arduino lit sur une entrée analogique : aucune bibliothèque de capteur à installer. L’afficheur, lui, occupe A4 et A5. Le montage tient donc sur trois fils de liaison et laisse toutes les autres broches numériques libres. Le programme affiche la mesure sur la première ligne, et la température la plus basse et la plus haute relevées depuis la mise sous tension sur la seconde.

Ce qu’il faut

Le câblage

Quatre fils pour l’afficheur, trois pour le capteur, dont deux déjà présents sur les lignes d’alimentation.

Le LM35 se présente comme un petit transistor à trois pattes, la face plate tournée vers soi : l’alimentation à gauche, la sortie au milieu, la masse à droite. Une inversion d’alimentation le détruit, contrairement à beaucoup d’autres capteurs du même genre — c’est le seul geste à ne pas se tromper sur ce montage.

Le programme

À copier dans l’IDE Arduino, après avoir installé la bibliothèque LiquidCrystal_I2C depuis « Inclure une bibliothèque » puis « Gérer les bibliothèques » :

/*
 * Thermometre LM35 sur afficheur LCD 16 x 02 en I2C
 * Carte : Arduino Uno -- LM35 sur A0, afficheur sur SDA (A4) et SCL (A5)
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

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

const uint8_t ADRESSE_I2C = 0x27;   // 0x3F sur certains adaptateurs
const uint8_t LM35 = A0;            // sortie analogique du capteur

LiquidCrystal_I2C lcd(ADRESSE_I2C, 16, 2);

float tMini = 999.0;
float tMaxi = -999.0;

float lireTemperature() {
  int brut = analogRead(LM35);
  return brut * 5.0 / 1024.0 * 100.0;   // 10 mV par degre Celsius
}

void afficher(float t) {
  lcd.setCursor(0, 0);
  lcd.print("Temp : ");
  lcd.print(t, 1);
  lcd.print(" C ");

  lcd.setCursor(0, 1);
  lcd.print("mn");
  lcd.print(tMini, 1);
  lcd.print(" mx");
  lcd.print(tMaxi, 1);
}

void setup() {
  lcd.init();                 // lcd.begin(16, 2) avec la bibliotheque de Marco Schwartz
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Thermometre pret");
  delay(1200);
  lcd.clear();
}

void loop() {
  float t = lireTemperature();

  tMaxi = max(tMaxi, t);
  tMini = min(tMini, t);

  afficher(t);
  delay(500);
}

Comment ça marche

• Le constructeur LiquidCrystal_I2C lcd(ADRESSE_I2C, 16, 2) reçoit l’adresse du module et le format de l’écran. Adresse fausse, l’écran reste vide et l’Arduino, lui, continue de tourner : le programme n’affiche aucune erreur, ce qui explique bien des recherches inutiles.
• lcd.init() puis lcd.backlight() : la première initialise l’écran par le bus I2C, la seconde allume le rétroéclairage. Avec la bibliothèque LiquidCrystal_I2C de Frank de Brabander, ce sont ces deux appels ; la bibliothèque LiquidCrystal I2C de Marco Schwartz, plus récente dans le gestionnaire, demande à la place lcd.begin(16, 2). Un message d’erreur du type « no member named init » signale simplement l’autre bibliothèque.
• analogRead() renvoie un nombre de 0 à 1023 pour une tension de 0 à 5 V, soit environ 4,88 mV par pas. Le LM35 délivre 10 mV par degré, donc 25 °C donnent 250 mV, lus comme 51 pas. La multiplication par 5,0 puis par 100 reconstitue directement des degrés Celsius.
• min() et max() conservent les extrêmes sans condition à écrire : la valeur la plus basse et la plus haute depuis la mise sous tension restent en mémoire tant que l’Arduino est alimenté.
• lcd.setCursor(0, 1) place le curseur en début de deuxième ligne. Sans ce repositionnement, la suite du texte s’écrirait à la queue du précédent et la seconde ligne ne serait jamais atteinte.
• Le delay(500) borne la cadence. Chaque caractère affiché traverse le bus I2C, bien plus lent que le bus parallèle d’origine : sans temporisation, l’écran scintillerait pendant que les mesures se succèdent.
• Le LM35 est un capteur de précision mais lent : posé sur une plaque d’essai à l’air libre, il met plusieurs dizaines de secondes à rejoindre la température ambiante. Les deux valeurs extrêmes de la deuxième ligne demandent donc quelques minutes avant d’être représentatives.

Variante : plusieurs circuits sur le même bus

L’afficheur n’occupe que deux broches, et le bus accepte plusieurs circuits à condition que leurs adresses diffèrent. Une horloge temps réel DS3231 pour garder l’heure, un convertisseur numérique-analogique MCP4725 pour sortir une tension réglable ou un pilote de servo PCA9685 se branchent sur les deux mêmes fils, et le programme les distingue par leur adresse. C’est la vraie raison de choisir cette version plutôt que la version parallèle : plus le montage se charge, plus l’économie de quatre broches compte.

Un deuxième afficheur se branche de la même façon, à condition de déplacer le cavalier A1 ou A2 de l’un des adaptateurs pour lui donner une autre adresse. Et si c’est la place qui manque plutôt que les broches, le afficheur LCD 20 × 04 offre quatre lignes de vingt caractères avec le même adaptateur et la même bibliothèque, en changeant la seule ligne LiquidCrystal_I2C lcd(ADRESSE_I2C, 20, 4).

Questions fréquentes

L’écran reste vide, ou n’affiche qu’une ligne de cases sombres

Deux causes, dans cet ordre. Le contraste d’abord : le potentiomètre de l’adaptateur se tourne sur environ vingt tours, et un module neuf est souvent vissé à une extrémité de sa course — il faut tourner franchement. L’adresse ensuite : si le module répond à 0x3F, un programme réglé sur 0x27 n’affiche rien du tout. Vient enfin la masse commune entre l’afficheur et la carte, puis un fil SDA et SCL inversés.

Comment savoir à quelle adresse répond mon module ?

Par un balayage du bus : un petit croquis avec la bibliothèque Wire interroge tour à tour les adresses possibles et affiche sur le moniteur série celles qui répondent. C’est l’outil qui sert aussi à repérer l’adresse d’un autre circuit du montage, et il tient en une quinzaine de lignes. Ne cherchez pas l’adresse dans la documentation d’un adaptateur générique : elles se ressemblent toutes mais ne se comportent pas pareil.

Ce module et l’afficheur 16 × 02 à seize broches sont-ils interchangeables ?

L’écran, oui : c’est le même afficheur, même contrôleur, même jeu de caractères. Le LCD 16 × 02 à seize broches et celui-ci affichent exactement la même chose. Ce qui change, c’est le nombre de fils — six contre quatre — et la bibliothèque : LiquidCrystal d’un côté, LiquidCrystal_I2C de l’autre. L’adaptateur I2C seul existe aussi pour transformer un afficheur parallèle déjà en votre possession.

Peut-on l’utiliser sur une carte en 3,3 V ?

Avec un convertisseur de niveau logique entre les deux : l’afficheur et son adaptateur tiennent sur 5 V, alors que beaucoup de cartes récentes travaillent en 3,3 V. Le bus I2C, avec ses deux lignes à collecteur ouvert, n’apprécie pas d’être tiré vers deux tensions différentes, et c’est l’afficheur qui cède en premier.

Le rétroéclairage peut-il rester éteint ?

Oui, de deux façons. Par logiciel, en n’appelant pas lcd.backlight(), ou en appelant lcd.noBacklight() pour l’éteindre en cours d’exécution — l’écran reste lisible à la lumière du jour et la consommation baisse. Par matériel, en retirant le cavalier marqué LED sur l’adaptateur. N’appeler ni l’un ni l’autre ne suffit pas toujours : selon la bibliothèque, le rétroéclairage peut s’allumer à l’initialisation.

Peut-on afficher des lettres accentuées ou de l’arabe ?

Pas directement. Le jeu de caractères gravé dans un afficheur de cette famille couvre l’alphabet latin non accentué, les chiffres et la ponctuation, sans les lettres accentuées du français ni les lettres arabes. Le contrôleur prévoit huit emplacements libres, dans lesquels on dessine les symboles dont on a besoin — un « é », un pictogramme — en envoyant la suite de points de chaque ligne. Une fois définis au démarrage, ces caractères s’affichent comme les autres.

Les fils entre la carte et l’afficheur peuvent-ils être longs ?

Non, et c’est une limite du bus, pas du module. I2C n’a pas été conçu pour les longues distances : au-delà de quelques dizaines de centimètres, la capacité des câbles déforme les fronts d’horloge et l’affichage devient erratique, sans erreur franche. Pour éloigner un afficheur de sa carte, mieux vaut allonger l’alimentation et refaire le montage près de l’écran.

À combiner avec

Le Kit Arduino Uno maroc réunit la carte, la plaque d’essai, les fils et des composants : avec l’afficheur et le capteur LM35 en plus, le thermomètre de cette page se monte tel quel. Si vous partez de zéro, le trio Uno R3 + cable usb, plaque d’essai 400 points et fils mâle-mâle suffit. Pour lui ajouter un second facteur, le capteur DHT22 apporte l’humidité à côté de la température, et pour transformer l’affichage en interface, un mini bouton poussoir suffit à changer de page.