Clavier matriciel 16 touches

Le clavier matriciel 16 touches est le pavé d’entrée le plus simple à intégrer dans un projet : 16 touches, une nappe souple, aucun circuit imprimé ni soudure. Il sert à saisir un code, choisir un menu, régler une valeur ou piloter un appareil sans ordinateur à côté.

C’est un clavier à membrane 4 × 4 au format le plus répandu : les touches 0 à 9 et les symboles * et # comme sur un téléphone, plus les quatre touches A, B, C et D réservées à ce que vous voulez. Sa nappe se termine par un connecteur femelle à 8 broches : huit fils suffisent pour lire les seize touches, et le tout se branche directement sur une plaque d’essai.

À quoi sert un clavier matriciel ?

• Cadenas à code — une combinaison de touches ouvre un relais, une serrure ou une porte de garage.
• Menu de configuration — régler un seuil, une heure, une température sur un appareil autonome.
• Distributeur et borne — choisir un article, saisir un montant, valider une opération.
• Jeu électronique — diriger un personnage avec les quatre touches de direction, valider avec une autre.
• Pupitre de commande — remplacer une rangée de boutons poussoirs par un seul pavé fin et étanche à la poussière.
• Alarme — armer et désarmer avec un code, sans clé ni badge.

Caractéristiques techniques

Pourquoi « matriciel » : 8 broches pour 16 touches

Un bouton poussoir ordinaire occupe une broche : seize boutons prendraient seize entrées. Un clavier matriciel relie les touches en grille — quatre lignes et quatre colonnes — si bien que chaque touche se trouve à l’intersection d’une ligne et d’une colonne. Huit broches suffisent donc pour seize touches, et le principe tient jusqu’à 64 touches avec huit lignes et huit colonnes.

La lecture se fait par balayage : le microcontrôleur met une ligne à un niveau bas, puis regarde lesquelles des quatre colonnes suivent ce niveau. C’est la bibliothèque Keypad qui s’en charge dans le programme de cette page ; vous n’avez pas à écrire le balayage vous-même.

Brochage du connecteur

En présentant le clavier face avant, nappe vers le bas, les huit broches de l’embout femelle se lisent de gauche à droite :

Les quatre premières broches sont les lignes, les quatre dernières les colonnes : c’est la convention de la quasi-totalité des claviers de ce format. Si un montage ne réagit pas comme prévu, inutile de chercher une panne : permutez les groupes. Un multimètre en position continuité, posé entre une broche de ligne et une broche de colonne, sonne lorsque vous appuyez sur la touche qui les croise — c’est la façon la plus rapide de relever le brochage réel d’un clavier inconnu.

Notez que le brochage n’a rien d’une alimentation : il n’y a ni VCC ni GND sur ces huit broches. Le clavier est un ensemble de contacts secs, il ne consomme rien, et les lignes sont portées par les broches du microcontrôleur.

Mini-projet : un lecteur de touches avec affichage sur écran LCD

Le montage tient en une quinzaine de minutes : on branche le clavier, on affiche la dernière touche appuyée sur un écran LCD 16 × 02, et le moniteur série garde une trace de tout ce qui a été tapé.

Ce qu’il faut

Pourquoi des fils mâle-mâle ? L’embout du clavier est femelle et la plaque d’essai n’accepte que des broches mâles : une extrémité se pique dans le connecteur du clavier, l’autre dans la plaque. Aucune soudure, aucun outil.

Le câblage

Le brochage du clavier se recopie tel quel dans le programme, dans l’ordre des broches 1 à 8 : ce sont les seules lignes à modifier si vous câblez autrement.

Le programme

Installez d’abord la bibliothèque Keypad et la bibliothèque LiquidCrystal I2C par le gestionnaire de bibliothèques de l’IDE Arduino, puis copiez le programme et téléversez-le :

/*
 * Clavier matriciel 4x4 sur Arduino Uno - lecture des touches
 * Ecran : LCD 16x02 avec module I2C
 * Bibliotheques : Keypad et LiquidCrystal_I2C
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
#include "Wire.h"
#include "LiquidCrystal_I2C.h"
#include "Keypad.h"
// Les huit broches du clavier, dans l'ordre 1 a 8 du connecteur
byte brochesLignes[4]   = {9, 8, 7, 6};
byte brochesColonnes[4] = {5, 4, 3, 2};
// Etiquette imprimee sur chaque touche : 4 lignes puis 4 colonnes
char touches[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
Keypad clavier = Keypad(makeKeymap(touches), brochesLignes, brochesColonnes, 4, 4);
LiquidCrystal_I2C ecran(0x27, 16, 2);
void setup() {
  Serial.begin(9600);
  ecran.init();
  ecran.backlight();
  ecran.setCursor(0, 0);
  ecran.print("Appuyez sur une touche");
}
void loop() {
  char touche = clavier.getKey();
  if (touche != NO_KEY) {
    Serial.print("Touche : ");
    Serial.println(touche);
    ecran.setCursor(0, 1);
    ecran.print("Touche : ");
    ecran.print(touche);
  }
}

Comment ça marche

• clavier.getKey() renvoie le caractère de la touche appuyée, ou la constante NO_KEY quand aucune touche n’est pressée. Le test if (touche != NO_KEY) évite d’afficher seize fois par seconde une touche qui n’existe pas.
• La bibliothèque Keypad gère elle-même le balayage des lignes et les rebonds de contact. C’est pour cette raison qu’un même appui n’apparaît jamais deux fois : sans ce filtrage, une touche appuyée un dixième de seconde produirait plusieurs lectures.
• Le tableau touches associe à chaque croisement ligne-colonne l’étiquette imprimée sur la membrane. Un clavier câblé dans un autre ordre se corrige ici, sans toucher au reste du programme.
• L’écran s’adresse en 0x27, l’adresse du module I2C soudé au dos de la plupart des afficheurs 16 × 02. Si l’écran reste noir malgré un rétroéclairage allumé, l’adresse est probablement 0x3F — c’est la seule ligne à changer.

Pour aller plus loin

• Mémoriser une saisie — rangez chaque touche dans un tableau de caractères et affichez la suite complète sur l’écran, plutôt que la dernière touche seule.
• Un bip de confirmation — ajoutez un buzzer actif sur une broche libre : chaque appui produit un clic sonore, ce qui rend le clavier utilisable à l’aveugle.
• Des menus hiérarchiques — les touches A, B, C et D sont faites pour cela : entrez, validez, montez, redescendez, sans glisser de chiffre dans la saisie.

Variante : un cadenas à code

Le même montage, sans écran, mais avec un relais à la place de l’affichage : quatre touches correctement saisies dans l’ordre, et le relais se colle. C’est le principe d’un contrôle d’accès.

Remplacez l’écran par un Module 1 relais 5 V — VCC sur le 5 V de l’Arduino, GND sur la masse, IN sur une broche libre — et comparez la saisie à une suite de quatre caractères au lieu de l’afficher. Deux points de méthode valent la peine d’être connus avant de se lancer :

• Ne vérifiez pas les touches une à une. Comparez la suite complète quand la quatrième est saisie : une vérification touche par touche laisse le code se deviner par essais successifs.
• Prévoyez une remise à zéro. Une touche efface la saisie en cours, sinon une faute de frappe bloque le clavier jusqu’à la remise sous tension.

Deux limites à garder en tête : un code tapé sur un pavé visible n’est pas un secret bien gardé, et la sécurité réelle est assurée par le relais et l’installation qu’il commande, pas par le clavier. Pour une porte qui compte, ajoutez une temporisation qui interdit plusieurs essais d’affilée, et alimentez l’ensemble par une source stable — une coupure d’alimentation efface le code saisi en cours.

Questions fréquentes

Faut-il souder quelque chose ?

Non. L’embout femelle du clavier accueille directement des fils mâle-mâle : le clavier se clipse sur les fils, les fils se piquent dans la plaque d’essai, et le montage fonctionne sans fer à souder. Pour une version définitive, les huit conducteurs se brasent sur un circuit imprimé ou se logent dans un connecteur serti.

Aucune touche n’est détectée, par où commencer ?

Dans l’ordre : vérifiez que la nappe est insérée jusqu’au fond dans l’embout, vérifiez que les huit fils sont bien sur huit broches distinctes et non deux sur la même, puis que le tableau touches du programme décrit exactement les huit broches utilisées. Le contrôle le plus utile reste le multimètre en continuité entre une ligne et une colonne : s’il sonne à l’appui d’une touche, le clavier est bon et le problème est dans le câblage ou le programme.

Le clavier peut-il rester à l’extérieur ?

La membrane résiste aux projections et à la poussière, et elle se nettoie d’un chiffon humide. Elle n’est pas conçue pour une immersion ni pour une exposition prolongée en plein soleil, qui finit par jaunir et craqueler la couche supérieure. Pour un usage extérieur durable, logez-la derrière une facade découpée et prévoyez une évacuation d’eau vers le bas.

Une touche reste « collée » et déclenche en boucle ?

C’est presque toujours mécanique : une membrane pincée au montage, une nappe tendue qui tire sur une ligne, ou une poussière coincée entre les deux couches. Sortez le clavier de son logement, vérifiez que la nappe n’est pas en traction, et testez de nouveau. Si elle reste active sans appui, c’est un contact interne abîmé par un appui trop violent — la membrane accepte un doigt, pas un objet pointu.

Peut-on l’utiliser avec un ESP32 ou un Raspberry Pi ?

Oui, il n’y a rien à adapter : c’est un ensemble de contacts secs, sans alimentation ni niveau logique propre. Sur un ESP32, la bibliothèque Keypad fonctionne à l’identique et seules les broches du tableau changent. Sur un Raspberry Pi, l’équivalent s’appelle matrix keypad dans les bibliothèques de GPIO.

À combiner avec

Le KIT Starter contient déjà la carte Uno R3, la plaque d’essai et les fils nécessaires : en y ajoutant ce clavier et un afficheur LCD 16 × 02 I2C, vous avez le montage complet de cette page. Si votre écran n’a pas de module I2C soudé au dos, l’adaptateur I2C se soude dessous et ramène le câblage de seize fils à quatre.