Réaliser une calculatrice commandée par la carte Micro:bit

Micro:bit 10-02-26

14 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 Micro:bit

Présentation du projet

Ce projet consiste à réaliser une calculatrice électronique commandée par la carte Micro:bit, permettant d’effectuer des opérations mathématiques de base telles que l’addition, la soustraction, la multiplication et la division.

La saisie des données est assurée par un clavier matriciel 4×4, qui permet à l’utilisateur d’entrer les nombres et de choisir l’opération souhaitée. Les résultats ainsi que les informations de saisie sont affichés sur un afficheur LCD I2C, offrant une interface claire et lisible.

La carte Micro:bit joue le rôle de unité de commande : elle lit les touches du clavier, traite les calculs à l’aide d’un programme, puis envoie les informations à l’écran LCD via le protocole de communication I2C.

Ce projet permet de :

- découvrir la programmation embarquée avec la Micro:bit,

- comprendre le fonctionnement d’un clavier matriciel,

- utiliser un afficheur LCD I2C pour l’affichage des données,

- appliquer des notions d’algorithmique et de logique mathématique.

Il constitue une excellente introduction aux projets d’électronique programmable et peut être facilement amélioré par l’ajout de nouvelles fonctionnalités.

Matériel nécessaire

1- Carte Micro:bit

Micro:bit board

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

2- Carte d'Extension GPIO pour Micro:bit

The GPIO expansion card for the Micro:bit card

La carte d'extension GPIO permet de connecter des composants qui nécessitent plus de broches d'entrée/sortie que celles offertes par la carte Micro:bit.

3. Clavier matriciel 4×4

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

4. Afficheur LCD I2C

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

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion assurent la liaison entre la Micro:bit, 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 Micro:bit

Clavier 4×4	Carte Micro:bit
Ligne 1	P0
Ligne 2	P1
Ligne 3	P2
Ligne 4	P8
Colonne 1	P12
Colonne 2	P13
Colonne 3	P14
Colonne 4	P15

2- Connexion de l’afficheur LCD I2C à la carte Micro:bit

Afficheur LCD I2C	Carte Micro:bit
VCC	5V de la carte GPIO
GND	GND
SDA	P20
SCL	P19

Programmation de la carte Micro:bit

Le programme MicroPython permet à la carte Micro:bit 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 cette bibliothèque i2c_lcd nécessaire à la communication I2C.

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

# Importation des fonctions de base de la carte Micro:bit
from microbit import *

# Importation de la bibliothèque pour l'afficheur LCD I2C
from i2c_lcd import I2cLcd


# =======================
#       AFFICHAGE LCD
# =======================

# Initialisation de l'afficheur LCD
# Adresse I2C : 0x27
# 4 lignes et 20 colonnes
lcd = I2cLcd(i2c, 0x27, 4, 20)

# Effacer l'écran LCD
lcd.clear()

# Afficher un message de démarrage
lcd.putstr("Microbit Calculator")

# Pause de 2 secondes
sleep(2000)

# Effacer l'écran après le message
lcd.clear()


# =======================
#    CLAVIER MATRICIEL
# =======================

# Définition des broches des lignes du clavier
lignes = [pin0, pin1, pin2, pin8]

# Définition des broches des colonnes du clavier
colonnes = [pin12, pin13, pin14, pin15]

# Tableau de correspondance des touches du clavier
touches = [
    ['1','2','3','+'],
    ['4','5','6','-'],
    ['7','8','9','*'],
    ['=','0','#','/']
]

# Configuration des lignes en sortie
# État de repos à 1
for l in lignes:
    l.write_digital(1)

# Configuration des colonnes en entrée avec résistance pull-up
for c in colonnes:
    c.set_pull(c.PULL_UP)


# =======================
#   LECTURE D’UNE TOUCHE
# =======================

def lire_touche():
    """
    Fonction qui détecte la touche appuyée sur le clavier matriciel
    et retourne le caractère correspondant.
    """
    for i in range(4):
        # Mettre une ligne à 0
        lignes[i].write_digital(0)

        for j in range(4):
            # Si une colonne passe à 0, une touche est pressée
            if colonnes[j].read_digital() == 0:
                sleep(300)   # Anti-rebond
                lignes[i].write_digital(1)
                return touches[i][j]

        # Remettre la ligne à 1
        lignes[i].write_digital(1)

    # Aucune touche détectée
    return None


# =======================
#      CALCUL MATHÉMATIQUE
# =======================

def calculer(expr):
    """
    Fonction qui calcule une expression mathématique
    contenant +, -, * et /
    """
    nombres = []   # Liste des nombres
    ops = []       # Liste des opérateurs
    temp = ""      # Stockage temporaire des chiffres

    # Découpage de l'expression
    for c in expr:
        if c.isdigit():
            temp += c
        else:
            nombres.append(float(temp))
            ops.append(c)
            temp = ""

    nombres.append(float(temp))

    # Traitement des opérations * et /
    i = 0
    while i < len(ops):
        if ops[i] == '*' or ops[i] == '/':
            if ops[i] == '*':
                res = nombres[i] * nombres[i+1]
            else:
                res = nombres[i] / nombres[i+1]

            nombres[i] = res
            nombres.pop(i+1)
            ops.pop(i)
        else:
            i += 1

    # Traitement des opérations + et -
    resultat = nombres[0]
    for i in range(len(ops)):
        if ops[i] == '+':
            resultat += nombres[i+1]
        elif ops[i] == '-':
            resultat -= nombres[i+1]

    return resultat


# =======================
#   PROGRAMME PRINCIPAL
# =======================

# Variable pour stocker l'expression saisie
expression = ""

while True:
    # Lecture d'une touche
    touche = lire_touche()

    if touche:
        # Effacement (si touche C existait)
        if touche == 'C':
            expression = ""
            lcd.clear()

        # Calcul lorsque la touche = est pressée
        elif touche == '=':
            if expression != "":
                try:
                    res = calculer(expression)
                    lcd.move_to(0, 2)
                    lcd.putstr("= " + str(res))
                    sleep(4000)
                    lcd.clear()
                except:
                    lcd.clear()
                    lcd.putstr("Erreur")
                expression = ""

        # Ajout de la touche à l'expression
        else:
            expression += touche
            lcd.move_to(0, 0)
            lcd.putstr(" " * 20)   # Effacer la ligne
            lcd.move_to(0, 0)
            lcd.putstr(expression)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

# Importation des fonctions de base de la carte Micro:bit

from microbit import *

# Importation de la bibliothèque pour l'afficheur LCD I2C

from i2c_lcd import I2cLcd

# =======================

# AFFICHAGE LCD

# =======================

# Initialisation de l'afficheur LCD

# Adresse I2C : 0x27

# 4 lignes et 20 colonnes

lcd = I2cLcd(i2c, 0x27, 4, 20)

# Effacer l'écran LCD

lcd.clear()

# Afficher un message de démarrage

lcd.putstr("Microbit Calculator")

# Pause de 2 secondes

sleep(2000)

# Effacer l'écran après le message

lcd.clear()

# =======================

# CLAVIER MATRICIEL

# =======================

# Définition des broches des lignes du clavier

lignes = [pin0, pin1, pin2, pin8]

# Définition des broches des colonnes du clavier

colonnes = [pin12, pin13, pin14, pin15]

# Tableau de correspondance des touches du clavier

touches = [

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

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

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

['=','0','#','/']

]

# Configuration des lignes en sortie

# État de repos à 1

for l in lignes:

l.write_digital(1)

# Configuration des colonnes en entrée avec résistance pull-up

for c in colonnes:

c.set_pull(c.PULL_UP)

# =======================

# LECTURE D’UNE TOUCHE

# =======================

def lire_touche():

"""

Fonction qui détecte la touche appuyée sur le clavier matriciel

et retourne le caractère correspondant.

"""

for i in range(4):

# Mettre une ligne à 0

lignes[i].write_digital(0)

for j in range(4):

# Si une colonne passe à 0, une touche est pressée

if colonnes[j].read_digital() == 0:

sleep(300) # Anti-rebond

lignes[i].write_digital(1)

return touches[i][j]

# Remettre la ligne à 1

lignes[i].write_digital(1)

# Aucune touche détectée

return None

# =======================

# CALCUL MATHÉMATIQUE

# =======================

def calculer(expr):

"""

Fonction qui calcule une expression mathématique

contenant +, -, * et /

"""

nombres = [] # Liste des nombres

ops = [] # Liste des opérateurs

temp = "" # Stockage temporaire des chiffres

# Découpage de l'expression

for c in expr:

if c.isdigit():

temp += c

else:

nombres.append(float(temp))

ops.append(c)

temp = ""

nombres.append(float(temp))

# Traitement des opérations * et /

i = 0

while i < len(ops):

if ops[i] == '*' or ops[i] == '/':

if ops[i] == '*':

res = nombres[i] * nombres[i+1]

else:

res = nombres[i] / nombres[i+1]

nombres[i] = res

nombres.pop(i+1)

ops.pop(i)

else:

i += 1

# Traitement des opérations + et -

resultat = nombres[0]

for i in range(len(ops)):

if ops[i] == '+':

resultat += nombres[i+1]

elif ops[i] == '-':

resultat -= nombres[i+1]

return resultat

# =======================

# PROGRAMME PRINCIPAL

# =======================

# Variable pour stocker l'expression saisie

expression = ""

while True:

# Lecture d'une touche

touche = lire_touche()

if touche:

# Effacement (si touche C existait)

if touche == 'C':

expression = ""

lcd.clear()

# Calcul lorsque la touche = est pressée

elif touche == '=':

if expression != "":

try:

res = calculer(expression)

lcd.move_to(0, 2)

lcd.putstr("= " + str(res))

sleep(4000)

lcd.clear()

except:

lcd.clear()

lcd.putstr("Erreur")

expression = ""

# Ajout de la touche à l'expression

else:

expression += touche

lcd.move_to(0, 0)

lcd.putstr(" " * 20) # Effacer la ligne

lcd.move_to(0, 0)

lcd.putstr(expression)

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