Utiliser un clavier matriciel (keypad) : serrure à code 4x4 avec Arduino

Un keypad (clavier matriciel) est un organe de saisie bon marché, semblable aux touches d'un téléphone, qui te permet d'entrer des chiffres ou des lettres dans ton projet. Serrures de porte à code, coffres-forts, calculatrices, centrales d'alarme et systèmes de menus se font avec un keypad. Les modèles les plus courants sont des claviers à membrane fins, au dos adhésif, au format 4x4 (16 touches) et 3x4 (12 touches).

Comment fonctionne un keypad ? La matrice lignes-colonnes

Si chacune des 16 touches avait sa propre broche, il en faudrait 16. Le keypad organise plutôt ses touches en matrice : 4 lignes et 4 colonnes ; chaque touche se trouve au croisement d'une ligne et d'une colonne et, quand on appuie, elle relie cette ligne à cette colonne. L'Arduino met les lignes à LOW une par une et lit les colonnes ; la colonne qui lit LOW pendant qu'une ligne donnée est à LOW indique la touche appuyée. Comme ce balayage a lieu des centaines de fois par seconde, 16 touches se lisent avec seulement 8 broches.

Brochage et câblage du keypad

Touches face à toi, les broches de la nappe sont généralement, de gauche à droite, R1, R2, R3, R4, C1, C2, C3, C4 : les quatre premières sont les lignes, les quatre dernières les colonnes. Aucune résistance n'est nécessaire : la bibliothèque utilise les résistances de tirage internes de l'Arduino pour les colonnes.

Lire les touches avec la bibliothèque Keypad

Dans le gestionnaire de bibliothèques, cherche Keypad et installe la bibliothèque de Mark Stanley et Alexander Brevig. Le code ci-dessous affiche dans le moniteur série chaque touche appuyée :

1#include <Keypad.h>
2
3const byte ROWS = 4, COLS = 4;
4char keys[ROWS][COLS] = {
5  {'1', '2', '3', 'A'},
6  {'4', '5', '6', 'B'},
7  {'7', '8', '9', 'C'},
8  {'*', '0', '#', 'D'}
9};
10byte rowPins[ROWS] = {9, 8, 7, 6};     // R1–R4
11byte colPins[COLS] = {5, 4, 3, 2};     // C1–C4
12Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
13
14void setup() {
15  Serial.begin(9600);
16}
17
18void loop() {
19  char key = keypad.getKey();          // tuş yoksa 0 döner / returns 0 if no key
20  if (key) {
21    Serial.println(key);
22  }
23}

getKey() ne bloque pas le programme : si aucune touche n'est appuyée à cet instant, elle renvoie 0 tout de suite, ce qui te permet de faire autre chose dans loop(). La bibliothèque gère elle-même les rebonds et ne signale chaque appui qu'une fois. Pour attendre l'appui d'une touche, utilise waitForKey().

Réaliser une serrure à code

Rassemblons maintenant les touches appuyées dans un texte et comparons-le à un code enregistré. La touche * efface la saisie, la touche # la valide. Si le code est bon, un servomoteur ouvre la serrure pendant 3 secondes. Pour le câblage du servo, vois Qu'est-ce qu'un servomoteur ?

1#include <Keypad.h>
2#include <Servo.h>
3
4const byte ROWS = 4, COLS = 4;
5char keys[ROWS][COLS] = {
6  {'1', '2', '3', 'A'},
7  {'4', '5', '6', 'B'},
8  {'7', '8', '9', 'C'},
9  {'*', '0', '#', 'D'}
10};
11byte rowPins[ROWS] = {9, 8, 7, 6};
12byte colPins[COLS] = {5, 4, 3, 2};
13Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
14
15Servo lock;
16const String PASSWORD = "1234";
17String input = "";
18
19void setup() {
20  Serial.begin(9600);
21  lock.attach(10);
22  lock.write(0);                        // kilitli / locked
23}
24
25void loop() {
26  char key = keypad.getKey();
27  if (!key) return;
28  if (key == '*') {                     // temizle / clear
29    input = "";
30  } else if (key == '#') {              // onayla / confirm
31    if (input == PASSWORD) {
32      Serial.println("Doğru, açılıyor / correct, opening");
33      lock.write(90);
34      delay(3000);
35      lock.write(0);
36    } else {
37      Serial.println("Yanlış şifre / wrong code");
38    }
39    input = "";
40  } else if (input.length() < 8) {
41    input += key;
42    Serial.print('*');                  // tuşu gizle / hide the key
43  }
44}

L'utiliser avec un écran LCD

Un écran rend la saisie d'un code bien plus confortable. Un LCD I2C n'utilise que les broches A4 et A5 : il ne touche donc pas aux 8 broches numériques du keypad. À chaque appui, affiche une étoile sur la ligne du bas du LCD, puis « Ouvert » ou « Erreur » sur la ligne du haut après validation. Le câblage et les commandes de l'écran sont expliqués dans Utiliser un écran LCD I2C.

Moins de broches : keypads I2C et analogiques

Le keypad occupe à lui seul 8 des 20 broches de l'Uno. Quand les broches manquent, il y a deux solutions : un adaptateur I2C pour keypad à base de PCF8574 ramène le clavier à deux fils et partage le bus avec le LCD. Sur les keypads analogiques, chaque touche crée une résistance différente et tout le clavier se lit sur une seule broche analogique ; cela demande moins de fils, mais ne détecte pas deux touches appuyées en même temps.

Le keypad avec l'ESP32 et le Raspberry Pi Pico

La bibliothèque Keypad fonctionne aussi sur l'ESP32. Comme les broches de ligne servent de sorties et les broches de colonne d'entrées avec tirage, évite les GPIO 34 à 39, qui ne peuvent pas servir de sortie et n'ont pas de tirage ; prends par exemple 13, 12, 14 et 27 pour les lignes et 26, 25, 33 et 32 pour les colonnes. Sur le Pico en MicroPython, tu peux écrire toi-même le balayage en quelques lignes :

1from machine import Pin
2import time
3
4KEYS = ["123A", "456B", "789C", "*0#D"]
5rows = [Pin(n, Pin.OUT, value=1) for n in (2, 3, 4, 5)]        # R1–R4
6cols = [Pin(n, Pin.IN, Pin.PULL_UP) for n in (6, 7, 8, 9)]     # C1–C4
7
8def scan():
9    for r, row in enumerate(rows):
10        row.value(0)                         # bu satırı etkinleştir / activate this row
11        for c, col in enumerate(cols):
12            if col.value() == 0:             # tuş basılı / key pressed
13                row.value(1)
14                return KEYS[r][c]
15        row.value(1)
16    return None
17
18last = None
19while True:
20    key = scan()
21    if key and key != last:                  # her basışı bir kez yaz / print each press once
22        print(key)
23    last = key
24    time.sleep_ms(50)

Idées de projets avec un keypad

• Coffre à code : une boîte qui s'ouvre après saisie du code, avec servomoteur, écran LCD et buzzer.
• Calculatrice : utilise les touches A à D pour les quatre opérations et affiche le résultat sur un LCD.
• Sélecteur de couleur : change la couleur d'une LED RGB selon le nombre saisi.
• Centrale d'alarme : active et désactive avec un code une alarme à capteur PIR.
• Jeu du nombre mystère : trouve le nombre choisi par l'Arduino grâce aux indices « plus » et « moins ».
• Clavier de raccourcis : transforme chaque touche en raccourci clavier pour l'ordinateur avec un Arduino Leonardo.

Erreurs fréquentes et solutions

• Une autre touche que celle appuyée est lue : l'ordre des lignes et des colonnes est inversé ; inverse l'ordre des tableaux rowPins et colPins.
• Aucune touche n'est lue : la nappe est branchée décalée d'une broche, ou les broches de lignes et colonnes ne correspondent pas au code.
• Certaines touches ne marchent jamais : un fil de ligne ou de colonne fait un mauvais contact ; si toutes les touches d'une ligne ou d'une colonne sont muettes, c'est le signe.
• Utiliser les broches 0 et 1 : elles servent à la liaison série USB ; téléverser avec le keypad branché peut échouer.
• Sur l'ESP32, certaines colonnes semblent toujours appuyées : les GPIO 34 à 39, sans tirage, sont utilisées ; passe sur d'autres broches.
• Attendre une répétition en appui long : getKey() signale chaque appui une fois ; pour détecter une touche maintenue, utilise l'état HOLD de la bibliothèque.

Un keypad n'est finalement qu'un ensemble de boutons disposés en matrice ; tu trouveras le principe des boutons dans Comment brancher un bouton-poussoir sur Arduino. Dans l'application BlueGrays, tu trouveras des projets d'utilisation de keypads 3x4 et 4x4, une application de code avec LCD, un coffre électronique intelligent, une calculatrice I2C et le pilotage d'une LED RGB au keypad, avec schémas et code.