Calculatrice commandée par la carte ESP32

ESP32 12-02-26

28 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du système

4- Programmation de la carte ESP32

Présentation du projet

Ce projet a pour objectif de concevoir et programmer une calculatrice électronique basée sur la carte ESP32, en utilisant un afficheur LCD I2C 20x4 pour l’affichage et un clavier matriciel 4x4 pour la saisie des données, le tout programmé en MicroPython.

L’ESP32 assure la gestion des entrées du clavier, le traitement des opérations arithmétiques (addition, soustraction, multiplication et division) ainsi que l’affichage clair des nombres et des résultats sur l’écran LCD via la communication I2C.

Ce projet permet de comprendre l’interfaçage des composants électroniques, la lecture d’un clavier matriciel, la communication I2C et la programmation embarquée, tout en développant la logique algorithmique nécessaire à la réalisation d’un système interactif complet.

Matériel nécessaire

1- Carte ESP32

La carte ESP32 est une carte électronique programmable qui constitue le cœur du système.

2. Clavier matriciel 4×4

Le clavier matriciel 4×4 est utilisé pour la saisie des données.

3. Afficheur LCD I2C

L’afficheur LCD I2C sert à afficher les nombres saisis, les opérations choisies et le résultat final.

4. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion assurent la liaison entre la carte ESP32, le clavier et l’afficheur LCD. Ils permettent de relier les broches d’entrée/sortie et d’alimentation.

6- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

Schéma de câblage du système

1- Connexion du clavier matriciel 4×4 à la carte ESP32

Clavier 4×4	Carte ESP32
Ligne 1	GPIO 23
Ligne 2	GPIO 19
Ligne 3	GPIO 18
Ligne 4	GPIO 5
Colonne 1	GPIO 17
Colonne 2	GPIO 16
Colonne 3	GPIO 5
Colonne 4	GPIO 2

2- Connexion de l’afficheur LCD I2C à la carte ESP32

Afficheur LCD I2C	Carte ESP32
VCC	5V de la carte GPIO
GND	GND
SDA	GPIO 21
SCL	GPIO 22

Programmation de la carte ESP32

Le programme MicroPython permet à la carte ESP32 de piloter l’ensemble du système de la calculatrice. Il assure la lecture des touches du clavier matriciel, le traitement des opérations mathématiques et l’affichage des résultats sur l’écran LCD I2C.

On commence par l’importation de ces bibliothèques i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C

Voici le code en Micropython qui implémente le fonctionnement du système :

# Import des bibliothèques nécessaires
from machine import Pin, I2C      # Pour gérer les broches GPIO et la communication I2C
from i2c_lcd import I2cLcd        # Bibliothèque pour contrôler l'écran LCD I2C
import time                       # Pour gérer les temporisations

# ================= LCD I2C =================

# Adresse I2C du module LCD (souvent 0x27 ou 0x3F)
I2C_ADDR = 0x27

# Initialisation du bus I2C :
# I2C(0)  -> bus I2C numéro 0
# scl=Pin(22) -> broche SCL connectée à GPIO 22
# sda=Pin(21) -> broche SDA connectée à GPIO 21
# 4, 20 -> écran 4 lignes, 20 colonnes
lcd = I2cLcd(I2C(0, scl=Pin(22), sda=Pin(21)), I2C_ADDR, 4, 20)

# Effacer l'écran
lcd.clear()

# Afficher un message de démarrage
lcd.putstr("Calculatrice ESP32")


# ================= CLAVIER 4x4 =================

# Définition des 4 lignes du clavier comme sorties
lignes = [
    Pin(23, Pin.OUT),
    Pin(19, Pin.OUT),
    Pin(18, Pin.OUT),
    Pin(5, Pin.OUT)
]

# Définition des 4 colonnes du clavier comme entrées
# Pin.PULL_DOWN active la résistance interne pour éviter les faux signaux
colonnes = [
    Pin(17, Pin.IN, Pin.PULL_DOWN),
    Pin(16, Pin.IN, Pin.PULL_DOWN),
    Pin(4, Pin.IN, Pin.PULL_DOWN),
    Pin(2, Pin.IN, Pin.PULL_DOWN)
]

# Tableau représentant la disposition des touches du clavier
touches = [
    ['1', '2', '3', '+'],
    ['4', '5', '6', '-'],
    ['7', '8', '9', '*'],
    ['C', '0', '=', '/']
]

# Fonction pour détecter la touche appuyée
def lire_touche():
    # Parcours des lignes
    for i in range(4):
        lignes[i].on()  # Activer une ligne à la fois

        # Vérification des colonnes
        for j in range(4):
            if colonnes[j].value():   # Si une colonne détecte un signal
                lignes[i].off()       # Désactiver la ligne
                return touches[i][j]  # Retourner la touche correspondante

        lignes[i].off()  # Désactiver la ligne avant de passer à la suivante

    return None  # Aucune touche détectée


# ================= CALCULATRICE =================

# Variable pour stocker l'expression mathématique saisie
expression = ""

# Boucle principale (fonctionnement continu)
while True:

    # Lire la touche appuyée
    touche = lire_touche()

    # Si une touche est détectée
    if touche:

        # Petite temporisation pour éviter les doubles lectures (anti-rebond)
        time.sleep(0.3)

        # Si la touche est "C" → effacer
        if touche == 'C':
            expression = ""     # Réinitialiser l'expression
            lcd.clear()         # Effacer l'écran

        # Si la touche est "=" → calculer le résultat
        elif touche == '=':
            try:
                # Évaluer l'expression mathématique
                resultat = str(eval(expression))

                # Afficher le résultat
                lcd.clear()
                lcd.putstr("Resultat :")
                lcd.move_to(0, 1)  # Aller à la deuxième ligne
                lcd.putstr(resultat)

                # Permet de continuer le calcul avec le résultat
                expression = resultat

            except:
                # En cas d'erreur (ex: division par zéro)
                lcd.clear()
                lcd.putstr("Erreur")
                expression = ""

        # Sinon → ajouter la touche à l'expression
        else:
            expression += touche  # Ajouter le caractère
            lcd.clear()
            lcd.putstr(expression)

    # Petite pause pour stabiliser la lecture
    time.sleep(0.1)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

# Import des bibliothèques nécessaires

from machine import Pin, I2C # Pour gérer les broches GPIO et la communication I2C

from i2c_lcd import I2cLcd # Bibliothèque pour contrôler l'écran LCD I2C

import time # Pour gérer les temporisations

# ================= LCD I2C =================

# Adresse I2C du module LCD (souvent 0x27 ou 0x3F)

I2C_ADDR = 0x27

# Initialisation du bus I2C :

# I2C(0) -> bus I2C numéro 0

# scl=Pin(22) -> broche SCL connectée à GPIO 22

# sda=Pin(21) -> broche SDA connectée à GPIO 21

# 4, 20 -> écran 4 lignes, 20 colonnes

lcd = I2cLcd(I2C(0, scl=Pin(22), sda=Pin(21)), I2C_ADDR, 4, 20)

# Effacer l'écran

lcd.clear()

# Afficher un message de démarrage

lcd.putstr("Calculatrice ESP32")

# ================= CLAVIER 4x4 =================

# Définition des 4 lignes du clavier comme sorties

lignes = [

Pin(23, Pin.OUT),

Pin(19, Pin.OUT),

Pin(18, Pin.OUT),

Pin(5, Pin.OUT)

]

# Définition des 4 colonnes du clavier comme entrées

# Pin.PULL_DOWN active la résistance interne pour éviter les faux signaux

colonnes = [

Pin(17, Pin.IN, Pin.PULL_DOWN),

Pin(16, Pin.IN, Pin.PULL_DOWN),

Pin(4, Pin.IN, Pin.PULL_DOWN),

Pin(2, Pin.IN, Pin.PULL_DOWN)

]

# Tableau représentant la disposition des touches du clavier

touches = [

['1', '2', '3', '+'],

['4', '5', '6', '-'],

['7', '8', '9', '*'],

['C', '0', '=', '/']

]

# Fonction pour détecter la touche appuyée

def lire_touche():

# Parcours des lignes

for i in range(4):

lignes[i].on() # Activer une ligne à la fois

# Vérification des colonnes

for j in range(4):

if colonnes[j].value(): # Si une colonne détecte un signal

lignes[i].off() # Désactiver la ligne

return touches[i][j] # Retourner la touche correspondante

lignes[i].off() # Désactiver la ligne avant de passer à la suivante

return None # Aucune touche détectée

# ================= CALCULATRICE =================

# Variable pour stocker l'expression mathématique saisie

expression = ""

# Boucle principale (fonctionnement continu)

while True:

# Lire la touche appuyée

touche = lire_touche()

# Si une touche est détectée

if touche:

# Petite temporisation pour éviter les doubles lectures (anti-rebond)

time.sleep(0.3)

# Si la touche est "C" → effacer

if touche == 'C':

expression = "" # Réinitialiser l'expression

lcd.clear() # Effacer l'écran

# Si la touche est "=" → calculer le résultat

elif touche == '=':

try:

# Évaluer l'expression mathématique

resultat = str(eval(expression))

# Afficher le résultat

lcd.clear()

lcd.putstr("Resultat :")

lcd.move_to(0, 1) # Aller à la deuxième ligne

lcd.putstr(resultat)

# Permet de continuer le calcul avec le résultat

expression = resultat

except:

# En cas d'erreur (ex: division par zéro)

lcd.clear()

lcd.putstr("Erreur")

expression = ""

# Sinon → ajouter la touche à l'expression

else:

expression += touche # Ajouter le caractère

lcd.clear()

lcd.putstr(expression)

# Petite pause pour stabiliser la lecture

time.sleep(0.1)

Grâce à ce programme MicroPython, la carte ESP32 devient une calculatrice fonctionnelle, capable d’interagir avec l’utilisateur via un clavier matriciel et un écran LCD I2C.