LCD Shield avec 6 boutons

Le LCD Shield avec 6 boutons est une carte d’extension qui se clipse directement sur un Arduino Uno : elle apporte un écran LCD de 16 caractères sur 2 lignes et une rangée de boutons, sans un seul fil à câbler. On empile le shield, on téléverse le programme, l’interface est prête.

C’est le montage d’interface le plus économique qui existe pour un Arduino : l’écran occupe six broches, les cinq boutons de navigation n’en occupent qu’une seule, et il reste largement de quoi brancher capteurs et actionneurs à côté.

À quoi sert ce shield ?

• Afficher des mesures — température, distance, tension, compteur : tout ce qu’un Arduino calcule peut se lire sans ordinateur branché.
• Naviguer dans un menu — les boutons permettent de choisir une option, régler une valeur ou changer d’écran, comme sur un appareil du commerce.
• Faire une console de test — pendant la mise au point d’un montage, l’écran remplace le moniteur série quand la carte est autonome ou sur batterie.
• Construire un appareil complet — un régulateur, un minuteur, un compteur de passages, une borne interactive : l’interface est déjà là.
• Apprendre — c’est le support le plus simple pour comprendre un écran à caractères, un bus de données 4 bits et la lecture d’un clavier sur une entrée analogique.

Caractéristiques techniques

Brochage : ce que le shield occupe sur la carte

L’écran est câblé en 4 bits : quatre fils de données au lieu de huit, ce qui libère des broches. Correspondances imposées par le shield, à recopier telles quelles dans le programme :

Rien d’autre n’est câblé : les broches D2, D3, D11, D12, D13 et les entrées A1 à A5 restent entièrement libres. Évitez simplement D0 et D1 : ce sont les lignes du port série, celles qui servent aussi au téléversement du programme.

Les cinq boutons sur une seule entrée

C’est l’astuce du module. Les cinq boutons partagent la même broche A0 : chacun est relié à une résistance différente, si bien que la tension — et donc la valeur lue sur A0 — change selon le bouton pressé. Un seul fil pour cinq boutons.

Ces valeurs sont des repères, pas des certitudes : elles bougent légèrement d’une carte à l’autre et avec la température. Le programme ne les compare donc jamais à l’égalité — il teste des plages. Et si un bouton répond mal chez vous, la première chose à faire est d’afficher les valeurs d’A0 pour relever les vôtres, vous ajusterez les seuils ensuite.

Le potentiomètre de contraste

C’est la cause numéro un des « shields qui ne marchent pas ». Le potentiomètre bleu arrive vissé en butée : à la première mise sous tension, l’écran reste bleu, vide, parfois surmonté de rectangles sombres. L’écran n’est pas mort, le contraste est trop bas.

Tournez la vis d’un quart de tour puis affinez — il faut souvent dix tours complets avant que le texte apparaisse. Ce réglage se fait une fois : le contraste choisi reste sur la carte.

Mini-projet : un menu à cinq boutons

Un programme complet, à téléverser tel quel, sans un fil supplémentaire. Les boutons UP et DOWN parcourent un menu, SELECT valide l’option choisie, et la LED déjà présente sur la carte Arduino obéit au menu.

Ce qu’il faut

Si vous n’avez pas encore de matériel Arduino, le KIT Starter réunit déjà la carte Uno R3, la plaque d’essai, les fils, les LED et les résistances de 220 ohms : c’est un bon point de départ, et ce shield reste compatible avec tous les autres composants du kit.

Le montage

Aucun câblage : on empile le shield sur l’Arduino, les connecteurs femelles du shield venant sur les broches mâles de la carte. Vérifiez seulement que les deux rangées sont bien engagées sur toute leur longueur — un décalage d’un seul plot suffit à faire clignoter l’écran sans rien afficher. La LED utilisée par le programme est déjà soudée sur la carte Arduino.

Le programme

À copier dans l’IDE Arduino, puis à téléverser :

/*
 * Menu a cinq boutons - LCD Keypad Shield 1602
 * Carte : Arduino Uno R3
 * Montage : le shield s'empile sur la carte, aucun fil supplementaire
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "LiquidCrystal.h"

// Brochage impose par le shield : RS, E, D4, D5, D6, D7
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

const byte PIN_BOUTONS = A0;   // les cinq boutons sont sur cette seule entree
const byte PIN_RETRO   = 10;   // retroeclairage de l'ecran
const byte PIN_LED     = 13;   // LED deja presente sur la carte Arduino

const char* OPTIONS[] = {"LED allumee", "LED clignotante", "LED eteinte"};
const byte NB_OPTIONS = 3;

byte choix    = 0;   // option survolee dans le menu
byte applique = 2;   // option validee : 2 = LED eteinte
int  valides  = 0;   // nombre de validations depuis le demarrage

// Lecture du clavier : chaque bouton renvoie une valeur differente sur A0.
// On teste des plages, jamais une egalite : les valeurs varient d'une carte
// a l'autre, il faut donc laisser de la marge de chaque cote.
byte lireBouton() {
  int v = analogRead(PIN_BOUTONS);
  if (v < 50)  return 0;   // RIGHT
  if (v < 150) return 1;   // UP
  if (v < 350) return 2;   // DOWN
  if (v < 500) return 3;   // LEFT
  if (v < 750) return 4;   // SELECT
  return 5;                // aucun bouton presse
}

void afficherMenu() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Choisir :");
  lcd.setCursor(0, 1);
  lcd.print(OPTIONS[choix]);
}

void setup() {
  pinMode(PIN_LED, OUTPUT);
  pinMode(PIN_RETRO, OUTPUT);
  digitalWrite(PIN_RETRO, HIGH);   // allume le retroeclairage

  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("LCD Keypad");
  lcd.setCursor(0, 1);
  lcd.print("Shield 1602");
  delay(1500);

  afficherMenu();
}

void loop() {
  byte bouton = lireBouton();

  if (bouton == 1) {                              // UP : option precedente
    choix = (choix + NB_OPTIONS - 1) % NB_OPTIONS;
    afficherMenu();
  }

  if (bouton == 2) {                              // DOWN : option suivante
    choix = (choix + 1) % NB_OPTIONS;
    afficherMenu();
  }

  if (bouton == 4) {                              // SELECT : on valide
    applique = choix;
    valides++;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Valide ");
    lcd.print(valides);
    lcd.setCursor(0, 1);
    lcd.print(OPTIONS[applique]);
    delay(800);
    afficherMenu();
  }

  // La LED suit l'option validee : allumee, clignotante ou eteinte.
  bool allumee;
  if (applique == 0) {
    allumee = true;                           // LED allumee en permanence
  } else if (applique == 1) {
    allumee = (millis() / 300) % 2 == 0;      // LED clignotante
  } else {
    allumee = false;                          // LED eteinte
  }
  digitalWrite(PIN_LED, allumee ? HIGH : LOW);

  delay(80);   // laisse le contact se stabiliser et evite les doubles appuis
}

Comment ça marche

• LiquidCrystal lcd(8, 9, 4, 5, 6, 7) déclare les broches que le shield a câblées. Les changer reviendrait à déclarer un écran qui n’existe pas.
• lcd.begin(16, 2) annonce la taille de l’écran : 16 colonnes, 2 lignes. C’est ce qui permet à la bibliothèque de placer correctement le curseur.
• % NB_OPTIONS fait tourner le menu : arrivé après la dernière option, UP revient à la première. Une seule ligne pour gérer le bouclage.
• La temporisation de 80 ms en fin de boucle sert au contact : sans elle, un appui un peu long se lit comme plusieurs appuis et le menu défile trop vite.
• La condition sur millis() fait clignoter la LED sans jamais bloquer le programme avec un delay() : pendant le clignotement, les boutons restent réactifs.

Pour aller plus loin

• Afficher une mesure — la deuxième ligne est libre : faites-y défiler la valeur d’un capteur branché sur A1 ou D2, tout en gardant le menu.
• Régler une valeur au lieu de choisir — remplacez les trois options par un seuil, augmenté avec UP et diminué avec DOWN : c’est le principe d’un thermostat ou d’un minuteur.
• Un retour en arrière — ajoutez le test de LEFT (bouton == 3) pour revenir à l’écran précédent, comme sur un vrai appareil.

Variante : en faire un petit terminal de mesure

Le shield n’occupe que A0 et les broches 4 à 10. Pour l’utiliser en afficheur autonome, il suffit d’un capteur de température LM35 sur l’entrée A1, qui reste libre :

Le LM35 délivre 10 mV par degré Celsius : analogRead(A1) * 0.48828125 donne directement la température en degrés, à afficher sur la ligne du bas. Le menu du shield garde toute sa place sur la ligne du haut, et l’appareil devient un thermomètre autonome qu’on règle sans ordinateur.

Questions fréquentes

L’écran reste bleu et vide, ou montre deux rangées de rectangles noirs

C’est le contraste, dans la quasi-totalité des cas — le potentiomètre bleu est livré vissé à fond et demande souvent une dizaine de tours. Vérifiez ensuite que le shield est bien enfoncé sur toute la longueur des deux rangées de connecteurs. Un vrai problème d’écran est rare : quand il survient, c’est un écran mort dès la sortie d’usine, ce qui se voit à l’absence totale d’affichage même contraste réglé.

Mon programme affiche des caractères bizarres

Deux causes, presque toujours dans cet ordre : la bibliothèque employée et l’ordre des broches. Ce shield porte un écran en parallèle classique, alimenté par la bibliothèque LiquidCrystal — et non LiquidCrystal_I2C, qui sert aux modules équipés d’un petit adaptateur soudé au dos, dont ce shield n’a pas besoin. Vérifiez également que la déclaration est bien LiquidCrystal lcd(8, 9, 4, 5, 6, 7) et que lcd.begin(16, 2) est appelé avant tout affichage.

Mes boutons répondent mal ou pas du tout

Les seuils de lecture sont des repères : selon la carte Arduino et la tolérance des résistances, les valeurs peuvent se décaler. Affichez les valeurs lues sur A0 (sur l’écran ou le moniteur série), relevez celles de vos cinq boutons, puis élargissez ou déplacez les plages du programme en conséquence. Un décalage de quelques dizaines d’unités suffit à régler le problème.

Puis-je brancher un capteur sur A0 ?

Non : A0 est déjà pris par le clavier. C’est la seule entrée analogique immobilisée — A1 à A5 restent libres, ainsi que D2, D3 et D11 à D13 pour les entrées numériques et les sorties.

Fonctionne-t-il sur une Mega, une Nano ou un ESP32 ?

Le bouclier est au format Uno. Sur une Mega 2560 les broches 4 à 10 et A0 existent au même emplacement : le programme tourne à l’identique, mais les broches supplémentaires de la Mega ne sont plus accessibles tant que le shield est dessus. Sur une Nano, un Pro Mini ou un ESP32, le format ne correspond pas : prenez alors un afficheur LCD 16 × 02 et, pour ne garder que deux fils, son adaptateur I2C — c’est le même écran, sans le bouclier autour.

Peut-on l’alimenter en 3,3 V ?

Non. L’écran à caractères et son rétroéclairage sont prévus pour 5 V, et le shield est conçu pour se servir directement sur l’alimentation de la carte. Il fonctionne sur un Uno, une Mega ou toute carte qui fournit du 5 V sur ses connecteurs au format Uno.

Les boutons sont-ils utilisables avec l’écran en même temps ?

Oui, et sans partage : le clavier n’utilise que A0, alors que l’écran occupe six broches numériques. C’est justement l’intérêt du module — cinq boutons sur une seule entrée analogique.

À combiner avec

Pour démarrer sans matériel, le KIT Starter fournit la carte Uno R3, la plaque d’essai, les fils et les composants de base ; le Kit Arduino Uno maroc ajoute des capteurs et ouvre davantage de projets. Si vous cherchez une autre façon de piloter une interface sans écran à caractères, regardez le joystick analogique et l’afficheur TM1637, plus compacts. Et si votre montage demande finalement plus de place pour souder, le shield de prototypage Uno laisse la même zone de pastilles, sans écran ni boutons.