Réaliser une horloge numérique avec Micro:bit et RTC DS1302

Micro:bit 15-02-26

6 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage de l'horloge

4- Programmation de la carte Micro:bit

Présentation du projet

Le but de ce projet est de concevoir et réaliser une horloge numérique en utilisant la carte Micro:bit, un module RTC DS1302 et un afficheur LCD I2C.

L’horloge pourra afficher l’heure et la date en temps réel sur l’écran LCD, offrant ainsi une introduction pratique aux concepts de programmation électronique, de lecture de l’heure réelle et d’interfaçage de composants électroniques.

Le projet consiste à :

1- utiliser la carte Micro:bit comme microcontrôleur principal pour traiter les données et contrôler l’affichage.

2- connecter le module RTC DS1302 (Real Time Clock) à la Micro:bit pour obtenir l’heure et la date précises, même lorsque l’alimentation est coupée grâce à sa pile de sauvegarde.

3- afficher les informations sur un écran LCD I2C, permettant une lecture facile de l’heure (heures, minutes, secondes) et de la date (jour, mois, année).

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.

Elle traite les informations reçues du module RTC DS1302 et envoie les données à afficher sur l’écran LCD I2C

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 heures, minutes, secondes et la date

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion assurent la liaison entre la carte 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.