Afficheur LCD 20 04

Quatre lignes de vingt caractères, soit quatre-vingts signes affichés en permanence : c’est le plus grand format de la famille des afficheurs à caractères pilotés par le contrôleur HD44780. Le LCD 20 × 04 se câble exactement comme un 16 × 02 — mêmes seize broches, même bibliothèque — mais il permet d’afficher une mesure, son unité, un état et un message d’erreur en même temps, sans faire défiler quoi que ce soit.

Le module de cette page est un 2004A à fond bleu et texte clair, connecteur parallèle de seize broches au pas de 2,54 mm. Aucun adaptateur n’est soudé au dos : les broches vont directement au contrôleur, et c’est la carte de commande qui décide du mode de transmission, 8 bits ou 4 bits.

Caractéristiques techniques

Brochage des seize broches

La numérotation est gravée sur la carte, côté connecteur, et suit le brochage standard de toute la famille à caractères. Un module d’une autre marque se branche donc de la même façon.

Ce que change la quatrième ligne

Un afficheur à caractères n’est pas une grille continue : il possède 80 adresses de mémoire d’affichage, et sur un 20 × 04 elles ne se suivent pas dans l’ordre où on les lit. La première ligne commence à l’adresse 0, la deuxième à 64, la troisième à 20 et la quatrième à 84. Rien de tout cela n’apparaît à l’écran, mais c’est la raison pour laquelle lcd.setCursor(0, 2) tombe bien sur le début de la troisième ligne alors que la mémoire fait un saut à cet endroit.

L’écriture d’un programme reste donc simple : on donne un numéro de colonne et un numéro de ligne, et la bibliothèque se charge de traduire. La seule chose à retenir est que la largeur vaut 20 colonnes, indexées de 0 à 19, et la hauteur 4 lignes, indexées de 0 à 3. Un lcd.begin(20, 4) déclaré par erreur en 16 × 02 ne casse pas le module : il décale simplement le découpage des lignes et le texte apparaît à des endroits inattendus.

Cette mémoire explique aussi pourquoi un afficheur de ce format est apprécié sur un montage fixe : chaque ligne peut être réservée à une information précise, mise à jour indépendamment des autres. On redessine la ligne qui change, pas tout l’écran — un lcd.clear() redessine les 80 caractères et fait clignoter l’ensemble.

Applications

• Tableau de bord de mesure — une ligne par grandeur : température, humidité, tension, avec l’unité écrite en toutes lettres.
• Chronomètre ou minuterie — temps courant, dernier tour, meilleur tour et état sur quatre lignes, comme dans le montage de cette page.
• Automate pédagogique — étape en cours, consigne, message d’erreur et état des entrées visibles simultanément.
• Station météo — la mesure et l’heure sur deux lignes, l’état d’une horloge temps réel DS3231 sur une troisième.
• Supervision d’un montage fixe — quatre informations lues d’un coup d’œil, sans écran d’ordinateur ni console série.

Mini-projet : un chronomètre à trois affichages

Le programme n’utilise que la bibliothèque LiquidCrystal et deux boutons : le premier démarre et arrête le chrono, le second enregistre un tour pendant la course et remet tout à zéro à l’arrêt. Les quatre lignes servent à quelque chose de différent, ce qui est justement la raison d’être de ce format.

Ce qu’il faut

Le câblage

L’afficheur travaille en mode 4 bits : quatre fils de données et deux lignes de commande, c’est le montage qui laisse le plus de broches libres. RW part directement à la masse. Les deux boutons, eux, se contentent des résistances internes de la carte : un côté à la broche numérique, l’autre à la masse, et le code active le rappel interne.

Le programme

À copier dans l’IDE Arduino et à téléverser sur la carte :

/*
 * Chronometre sur afficheur LCD 20 x 04, en mode 4 bits
 * Carte : Arduino Uno -- D8 : marche/arret, D9 : tour et remise a zero
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "LiquidCrystal.h"

const byte RS = 12;                      // selection registre ou donnee
const byte EN = 11;                      // validation
const byte D4 = 5;
const byte D5 = 4;
const byte D6 = 3;
const byte D7 = 2;

const byte BOUTON_MARCHE = 8;
const byte BOUTON_TOUR   = 9;

LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);

bool enMarche = false;
unsigned long depart = 0;                // millis() au demarrage
unsigned long cumul = 0;                 // temps couru avant la pause
unsigned long referenceTour = 0;         // temps au dernier tour
unsigned long dernierTour = 0;
unsigned long meilleurTour = 0;

void deuxChiffres(byte valeur) {
  if (valeur / 10 == 0) lcd.print('0');  // zero de tete pour garder la largeur
  lcd.print(valeur);
}

void afficherTemps(byte ligne, unsigned long ms) {
  unsigned long centiemes = ms / 10;
  byte c = centiemes % 100;
  unsigned long secondes = centiemes / 100;
  byte s = secondes % 60;
  byte m = (secondes / 60) % 100;

  lcd.setCursor(12, ligne);
  deuxChiffres(m);
  lcd.print(':');
  deuxChiffres(s);
  lcd.print('.');
  deuxChiffres(c);
}

unsigned long ecoule() {
  if (enMarche) return cumul + (millis() - depart);
  return cumul;
}

bool appui(byte broche) {
  if (digitalRead(broche) == LOW) {
    delay(30);                                 // anti-rebond
    if (digitalRead(broche) == LOW) {
      while (digitalRead(broche) == LOW) {}     // attendre le relachement
      return true;
    }
  }
  return false;
}

void remiseAZero() {
  enMarche = false;
  cumul = 0;
  depart = 0;
  referenceTour = 0;
  dernierTour = 0;
  meilleurTour = 0;
}

void setup() {
  lcd.begin(20, 4);
  pinMode(BOUTON_MARCHE, INPUT_PULLUP);
  pinMode(BOUTON_TOUR, INPUT_PULLUP);

  lcd.setCursor(0, 1);
  lcd.print("Temps");
  lcd.setCursor(0, 2);
  lcd.print("Dernier tour");
  lcd.setCursor(0, 3);
  lcd.print("Meilleur tour");
}

void loop() {
  if (appui(BOUTON_MARCHE)) {
    if (enMarche) {
      cumul = ecoule();                        // figer le temps couru
      enMarche = false;
    } else {
      depart = millis();                       // repartir de l instant present
      enMarche = true;
    }
  }

  if (appui(BOUTON_TOUR)) {
    if (enMarche) {
      dernierTour = ecoule() - referenceTour;
      referenceTour = ecoule();
      if (meilleurTour == 0) {
        meilleurTour = dernierTour;            // premier tour de reference
      } else {
        meilleurTour = min(meilleurTour, dernierTour);
      }
    } else {
      remiseAZero();
    }
  }

  lcd.setCursor(7, 0);
  lcd.print(enMarche ? "EN MARCHE" : "A L ARRET");

  afficherTemps(1, ecoule());
  afficherTemps(2, dernierTour);
  afficherTemps(3, meilleurTour);

  delay(100);
}

Comment ça marche

• Le temps n’est jamais compté en incrémentant une variable : millis() donne le nombre de millisecondes écoulées depuis la mise sous tension, et le chrono n’est que la différence entre l’instant présent et l’instant de départ. L’affichage ne peut donc pas dériver, même si une boucle prend du retard.
• La variable cumul conserve le temps déjà couru pendant les pauses : appuyer sur le bouton d’arrêt n’efface rien, cela fige simplement le total.
• deuxChiffres() ajoute un zéro devant les valeurs à un seul chiffre. Sans elle, l’affichage sauterait de largeur à chaque changement et les caractères voisins resteraient collés à l’écran.
• Chaque ligne est réécrite à la même colonne, avec le même nombre de caractères : c’est ce qui évite le scintillement. Un lcd.clear() dans la boucle redessinerait les 80 caractères cent fois par seconde et l’écran paraîtrait clignoter.
• Le chrono occupe les colonnes 12 à 19 de sa ligne, sous la forme MM:SS.CC, et les libellés restent à gauche. Les quatre informations sont donc lisibles d’un seul coup d’œil.
• appui() attend le relâchement du bouton avant de rendre la main. Sans cette attente, un appui d’un dixième de seconde serait compté plusieurs fois, puisque la boucle repasse toutes les cent millisecondes.
• Le meilleur tour se met à jour avec min() : le premier tour sert de référence, les suivants ne sont retenus que s’ils sont plus courts. Le zéro initial est traité à part, sinon il serait pris pour un temps imbattable.

Variante : quatre fils au lieu de six

Un adaptateur I2C pour afficheur LCD soudé au dos du module ramène le câblage à quatre fils : alimentation, masse, SDA et SCL, et le contraste se règle avec le petit potentiomètre du module. Le programme change de bibliothèque — LiquidCrystal_I2C — et lcd.begin(20, 4) devient lcd.init() suivi d’un lcd.backlight(). L’adresse du module est à vérifier au préalable : la plupart des cartes d’adaptation répondent en 0x27, certaines en 0x3F.

Si le besoin est d’afficher des valeurs chiffrées plutôt que du texte, l’afficheur quatre chiffres TM1637 se contente de deux fils et se lit à plusieurs mètres, tandis que l’afficheur TM1638 ajoute des boutons et des diodes sur la même carte. Pour un affichage graphique — courbes, jauges, texte de toute taille — c’est le écran LCD 128 × 64 qu’il faut viser : il ne partage ni le contrôleur ni le brochage de cette famille.

Questions fréquentes

L’écran affiche une ligne de cases sombres, ou rien du tout

C’est presque toujours le contraste. V0 doit recevoir une tension intermédiaire : vérifiez que le curseur du potentiomètre arrive bien sur la broche 3 et que les deux pattes extérieures vont, l’une au 5 V, l’autre à la masse. Si le réglage ne donne rien, la cause suivante est la masse commune entre l’afficheur et la carte, puis un fil de données décalé d’une position.

Peut-on brancher cet afficheur en 8 bits ?

Oui : le contrôleur accepte les deux modes, et le mode 8 bits envoie un octet entier par écriture au lieu de deux moitiés. Le résultat affiché est identique, mais huit fils de données occupent la carte au lieu de quatre. Sur un montage où il reste des capteurs à raccorder, le mode 4 bits est le choix raisonnable ; le constructeur LiquidCrystal déduit le mode du nombre de broches qu’on lui donne.

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 le latin non accentué, les chiffres et la ponctuation. La parade prévue par le contrôleur est ailleurs : huit emplacements de caractères sont libres, et on y dessine les symboles utiles — un « é », un pictogramme, une flèche — en envoyant la suite de points de chaque ligne. Une fois définis au démarrage, ces caractères s’affichent comme les autres.

Faut-il une résistance pour le rétroéclairage ?

Si le module n’embarque pas sa propre résistance de limitation, oui : une 220 Ω entre le 5 V et la broche 15 (A), la broche 16 (K) allant à la masse. Si votre module porte déjà cette résistance, il s’alimente directement en 5 V. Dans le doute, partez de la résistance : l’écran est un peu moins lumineux, mais il ne s’abîme pas.

Pourquoi le texte apparaît-il au mauvais endroit sur la troisième et la quatrième ligne ?

Presque toujours parce que le format déclaré ne correspond pas au module. Un lcd.begin(16, 2) sur un 20 × 04 fait écrire le programme avec la mauvaise largeur de ligne, et le texte se décale à partir de la seizième colonne. Vérifiez également la bibliothèque utilisée : celles écrites pour un 16 × 02 ne calculent pas le saut d’adresse de la troisième ligne, et c’est l’erreur qui produit un affichage cohérent sur deux lignes puis incohérent en dessous.

Combien de temps prend un effacement complet de l’écran ?

Quelques millisecondes, pendant lesquelles le contrôleur est occupé. C’est peu, mais appelé dans une boucle qui tourne cent fois par seconde, cela suffit à faire clignoter l’affichage et à ralentir le reste du programme. La bonne pratique avec quatre lignes est justement de ne réécrire que la ligne dont la valeur a changé.

À combiner avec

Le Kit Arduino Uno maroc réunit la carte, la plaque d’essai, les fils et des composants : avec l’afficheur en plus, le chronomè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, avec un potentiomètre 10 kΩ pour le contraste et deux mini boutons poussoir pour la commande. Pour afficher des mesures plutôt qu’un temps, un capteur DHT11 ou une horloge temps réel DS3231 remplit les lignes disponibles. Si le texte compte plus que le nombre de lignes, l’afficheur LCD 16 × 02 ou sa version 16 × 02 en I2C offre un affichage plus compact pour le même programme, et un buzzer actif ajoute un signal sonore au moment du départ ou de l’arrivée.