Ecrire sur le clavier matriciel 4×4 en utilisant la carte ESP32

ESP32 10-02-25

49 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 ESP32 avec le Micropython

Présenter le clavier matriciel 4x4

Un clavier matriciel 4x4 est un pavé numérique composé de 16 touches disposées en 4 lignes et 4 colonnes. Il est couramment utilisé pour les entrées utilisateur dans des projets électroniques, notamment avec des microcontrôleurs comme l'ESP32.

Principe de fonctionnement :

- Chaque bouton est à l'intersection d'une ligne et d'une colonne.

- Lorsque vous appuyez sur une touche, cela établit un contact entre une ligne et une colonne.

- Le microcontrôleur "balaye" les lignes et détecte quelle colonne reçoit le signal, identifiant ainsi la touche pressée.

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

1. Lecture des touches du clavier :

Balayage des lignes : L'ESP32 active chaque ligne à tour de rôle.

Détection des colonnes : Si une touche est pressée, un contact est établi entre une ligne et une colonne.

Identification de la touche : L'intersection ligne/colonne permet de savoir quelle touche a été pressée (par ex. 1, 2, A, etc.).

2. Gestion de la saisie de texte :

Chaque caractère saisi est stocké dans une chaîne de texte.

La touche * peut servir de touche d'effacement (backspace).

La touche # peut être utilisée pour valider ou passer à la ligne suivante.

3. Affichage sur l’écran SSD1306 :

Le texte est affiché en temps réel sur l’écran OLED.

Possibilité de gérer des retours à la ligne si le texte dépasse la largeur de l’écran.

Le curseur peut être déplacé pour indiquer la position d’écriture actuelle.

Matériel nécessaire

Carte ESP32 (Microcontrôleur principal)

La carte ESP32 contrôle la logique du système, lire les entrées du clavier et gérer l'affichage sur l’écran LCD.

Clavier Matriciel 4x4

Le clavier matriciel permet la saisie de caractères (lettres, chiffres, symboles).

Afficheur SSD1306

L'afficheur SSD1306 affiche en temps réel les caractères saisis depuis le clavier.

Fils de Connexion (Dupont)

Fils de connexion

Ces fils connectent les broches du clavier et de l’écran LCD aux GPIO de l’ESP32.

Breadboard (ou plaque d'essai sans soudure)

Breadboard

Une breadboard est un composant essentiel pour les prototypes électroniques. Elle permet de réaliser des montages facilement sans avoir à souder les composants.

Schéma des connexions

Clavier Matriciel 4x4 → ESP32 :

On connecte les 8 sorties du clavier aux 8 broches de la carte ESP32 suivant cet ordre: D2, D4, D5, D18, D19, D16, D15 et D23.

Écran OLED SSD1306 (I2C) → ESP32 :

VCC → 3.3V

GND → GND

SDA → GPIO21 (par défaut pour l’I2C sur l’ESP32)

SCL → GPIO22 (par défaut pour l’I2C sur l’ESP32)

Programmer la carte ESP32 avec le Micropython

Voici le programme micropython qui permet de saisir des caractères du clavier matriciel 4×4 et l’afficher sur l’afficheur SSD1306.

Remarque: il faut importer la bibliothèque suivante: ssd1306.py .

from machine import Pin,I2C
import ssd1306
from time import sleep
import utime
import machine

WIDTH  = 128                                            
HEIGHT = 64                                             

i2c = I2C(scl=Pin(22), sda=Pin(21)) #Init i2c
oled=ssd1306.SSD1306_I2C(128,64,i2c,0x3c)
# CONSTANTS
KEY_UP   = const(0)
KEY_DOWN = const(1)

keys = [['1', '2', '3', 'A'], ['4', '5', '6', 'B'], ['7', '8', '9', 'C'], ['*', '0', '#', 'D']]

# Pin names for Pico
cols = [19,16,15,23]
rows = [2,4,5,18]

# set pins for rows as outputs
row_pins = [Pin(pin_name, mode=Pin.OUT) for pin_name in rows]

# set pins for cols as inputs
col_pins = [Pin(pin_name, mode=Pin.IN, pull=Pin.PULL_DOWN) for pin_name in cols]

def init():
    for row in range(0,4):
        for col in range(0,4):
            row_pins[row].value(0)

def scan(row, col):
    """ scan the keypad """

    # set the current column to high
    row_pins[row].value(1)
    key = None

    # check for keypressed events
    if col_pins[col].value() == KEY_DOWN:
        key = KEY_DOWN
    if col_pins[col].value() == KEY_UP:
        key = KEY_UP
    row_pins[row].value(0)

    # return the key state
    return key

print("starting")

# set all the columns to low
init()

while True:
    oled.fill(0) 
    for row in range(4):
        for col in range(4):
            key = scan(row, col)
            if key == KEY_DOWN:
                oled.text("Key Pressed: ",10,0)
                print("Key Pressed", keys[row][col])
                oled.text(keys[row][col], 55, 30) # afficher le caractère associe au touche presse
                oled.show()
                last_key_press = keys[row][col]