Ecrire sur le clavier matriciel 4×4 contrôlé par Arduino UNO

Arduino UNO 11-11-24

74 0

Plan du tutoriel

1- Présenter le clavier matriciel 4x4

2- Comment saisir un texte avec le clavier matriciel et l'afficher sur l'afficheur LCD ?

3- Matériel nécessaire

4- Schéma des connexions

5- Programmer la carte Arduino

Présenter le clavier matriciel 4x4

Un clavier matriciel 4x4 est un périphérique d’entrée composé de 16 boutons disposés en une matrice de 4 rangées et 4 colonnes. Chaque bouton est placé à l’intersection d’une ligne et d’une colonne. Cela permet de réduire le nombre de connexions nécessaires pour détecter les boutons pressés : au lieu d’utiliser 16 fils pour 16 boutons, le clavier matriciel 4x4 n’utilise que 8 fils (4 pour les rangées et 4 pour les colonnes).

Description Physique

Le clavier est généralement composé de 16 boutons marqués de numéros ou de symboles, organisés de la manière suivante :

1 2 3 A

4 5 6 B

7 8 9 C

* 0 # D

Chaque ligne est reliée à un fil spécifique, tout comme chaque colonne. Les boutons correspondent donc à des coordonnées de rangée et de colonne.

Fonctionnement du Clavier Matriciel 4x4

Matrice de Connexions : Chaque bouton de ce clavier est placé à une intersection d'une ligne et d'une colonne. Lorsque l’utilisateur appuie sur un bouton, il établit une connexion électrique entre la ligne et la colonne correspondantes.

Lecture de l’État des Boutons :

Pour détecter quel bouton est pressé, le microcontrôleur (comme un Arduino) active tour à tour chaque ligne (en envoyant un signal HIGH ou LOW).

Ensuite, il vérifie quelles colonnes détectent ce signal. Si une colonne est active, cela indique que le bouton correspondant à cette ligne et colonne est pressé.

Applications

Le clavier matriciel 4x4 est utilisé dans de nombreuses applications, notamment :

Systèmes de sécurité : Pour entrer un code PIN sur un système de verrouillage électronique.

Calculatrices et téléphones : Interface pour saisir des nombres et des commandes.

Projets Arduino : Contrôle de menus ou de fonctions dans un projet Arduino.

Avantages du Clavier Matriciel

Efficacité : Permet de contrôler plusieurs boutons avec un nombre réduit de broches.

Économie de câblage : Réduit la complexité de câblage en regroupant les boutons en matrice.

Polyvalence : Peut être utilisé pour saisir des données alphanumériques dans de nombreuses applications.

Le clavier matriciel 4x4 est un outil pratique pour ajouter des entrées utilisateur simples et abordables dans les projets électroniques et les systèmes embarqués.

Comment saisir un texte avec le clavier matriciel et l'afficher sur l'afficheur LCD ?

Le clavier matriciel est connecté à l'Arduino qui détecte les pressions de touches. L'Arduino contrôle également un afficheur LCD 16x2 (16 caractères par ligne et 2 lignes) pour afficher le texte en temps réel.

Configuration des Connexions :

Les lignes et colonnes du clavier matriciel sont connectées à des pins numériques de l’Arduino (par exemple, pins 2 à 9).

Les pins de l’afficheur LCD sont connectées à d’autres pins numériques de l’Arduino pour gérer l'affichage.

Fonctionnement du Code :

Lorsque l’utilisateur appuie sur une touche, l'Arduino détecte la position de cette touche dans la matrice (en lisant la ligne et la colonne connectées).

Le caractère associé à la touche pressée est affiché sur l’afficheur LCD, permettant à l'utilisateur de visualiser la saisie en temps réel.

Matériel nécessaire

Arduino UNO

Arduino Uno

Clavier matriciel 4x4

Afficheur LCD 16x2 (écran de 16 caractères sur 2 lignes)

Fils de connexion

Fils de connexion

Schéma des connexions

Clavier Matriciel 4x4 :

Connectez les broches de ligne et de colonne du clavier matriciel aux pins numériques de l’Arduino (ex. pins 2 à 9).

Afficheur LCD 16x2 :

Connectez les broches de l’afficheur LCD comme suit :

- la broche SDA à la broche A4 de l’Arduino

- la broche SCL à la broche A5 de l’Arduino

- la broche GND à la broche GND de l’Arduino

- la broche VCC à la broche 5V de l’Arduino

Programmer la carte Arduino

Voici un exemple de code pour détecter les touches pressées sur le clavier matriciel et afficher les caractères correspondants sur l’afficheur LCD.

Remarque: importer la bibliothèque LiquidCrystal_I2C dédiées à l'afficheur LCD I2C et la bibliothèque Keypad pour le clavier matriciel 4x4.

#include <LiquidCrystal_I2C.h> 
#include <Keypad.h>
const int ROW_NUM = 4; //four rows
const int COLUMN_NUM = 4; //four columns
LiquidCrystal_I2C lcd(0x27, 20, 4);
char keys[ROW_NUM][COLUMN_NUM] = {
{'1','2','3', 'A'},
{'4','5','6', 'B'},
{'7','8','9', 'C'},
{'*','0','#', 'D'}
};

byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
byte pin_column[COLUMN_NUM] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );

void setup(){
 lcd.init(); // initialisation de l’afficheur
 lcd.clear();
 lcd.backlight(); // active le rétro-éclairage
 lcd.setCursor(0, 0); // se positionner à la première ligne
}

void loop(){
char key = keypad.getKey();
if(key) // On appuie sur une touche du clavier matriciel
{
lcd.print(key);  // Afficher le carctere saisie sur l'afficheur LCD
delay(100);
}
}

#include <LiquidCrystal_I2C.h>

#include <Keypad.h>

const int ROW_NUM = 4; //four rows

const int COLUMN_NUM = 4; //four columns

LiquidCrystal_I2C lcd(0x27, 20, 4);

char keys[ROW_NUM][COLUMN_NUM] = {

{'1','2','3', 'A'},

{'4','5','6', 'B'},

{'7','8','9', 'C'},

{'*','0','#', 'D'}

};

byte pin_rows[ROW_NUM] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad

byte pin_column[COLUMN_NUM] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );

void setup(){

lcd.init(); // initialisation de l’afficheur

lcd.clear();

lcd.backlight(); // active le rétro-éclairage

lcd.setCursor(0, 0); // se positionner à la première ligne

}

void loop(){

char key = keypad.getKey();

if(key) // On appuie sur une touche du clavier matriciel

{

lcd.print(key); // Afficher le carctere saisie sur l'afficheur LCD

delay(100);

}

Lorsque l’utilisateur appuie sur une touche, le caractère est immédiatement affiché sur le LCD.

Si la touche '*' est pressée, l’afficheur LCD est effacé, et le curseur revient à la position de départ.

Si la touche '#' est pressée, le curseur passe à la ligne suivante pour continuer la saisie en bas de l’écran.

Les touches pressées sont affichées sur le LCD en temps réel.

Le texte peut être saisi sans dépasser 16 caractères par ligne ; si le curseur arrive en fin de ligne, il peut être ajusté pour revenir au début ou passer à la ligne suivante selon les besoins.