Horloge réveil avec la carte ESP32 et le module RTC DS1302

ESP32 23-02-26

18 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

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

4- Programmation de la carte ESP32

Présentation du projet

Objectif du projet

L’objectif de ce projet est de concevoir une horloge réveil numérique utilisant la carte ESP32, le module DS1302 RTC, un afficheur LCD I2C et un buzzer. Ce système permet d’afficher l’heure en temps réel sur l’écran LCD et de déclencher automatiquement une alarme sonore à une heure programmée, par exemple 07:00:00, accompagnée du message "Alarm 07:00 !!!". Ce projet permet d’apprendre à interfacer un module RTC, un écran LCD et un buzzer avec l’ESP32 afin de créer un système de réveil électronique fiable et automatisé.

Fonctionnement du projet

Le module RTC DS1302 est chargé de maintenir l’heure et la date exactes grâce à sa pile de sauvegarde, même lorsque l’alimentation principale est coupée. La carte ESP32 lit en permanence l’heure actuelle depuis le module RTC et l’affiche sur l’écran LCD I2C sous le format heures:minutes:secondes.

L’ESP32 compare continuellement l’heure actuelle avec l’heure de l’alarme programmée. Lorsque l’heure correspond à l’heure définie (par exemple 07:00:00), le système affiche le message "Alarm 07:00 !!!" sur l’écran LCD et active le buzzer pour produire un signal sonore afin d’alerter l’utilisateur.

Le système fonctionne en boucle continue, ce qui permet de mettre à jour l’affichage en temps réel et de surveiller automatiquement le déclenchement de l’alarme. Ce projet constitue une excellente application pratique pour comprendre la gestion du temps réel, l’affichage d’informations et le contrôle d’un dispositif sonore avec un microcontrôleur.

Matériel nécessaire

1- Carte ESP32

La carte ESP32 est le microcontrôleur principal du système. Elle exécute le programme qui lit l’heure depuis le module RTC, l’affiche sur l’écran LCD et active le buzzer lorsque l’heure de l’alarme est atteinte.

2. Module RTC DS1302

Le module RTC DS1302 est un composant électronique qui permet de garder et de fournir l’heure et la date en temps réel. Il est souvent utilisé avec des cartes programmables comme la Micro:bit, Arduino UNO ou ESP32 pour créer des horloges numériques, des réveils ou des systèmes automatisés.

3. Afficheur LCD I2C

L’afficheur LCD I2C permet d’afficher l’heure actuelle et les messages du système, comme le message d’alarme.

4. Buzzer

Le buzzer est un composant électronique qui produit un son lorsque l’alarme se déclenche.

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion assurent la liaison entre la carte ESP32, le module RTC DS1302, l’afficheur LCD et le Buzzer. 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 de l'horloge réveil

1- Connexion du module RTC DS1302 à la carte ESP32

RTC DS1302	Carte ESP32
CLK	GPIO 19
DAT	GPIO 18
RST	GPIO 5
GND	GND
VCC	5V

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

Afficheur LCD I2C	Carte ESP32
VCC	5V
GND	GND
SDA	GPIO 20
SCL	GPIO 19

3- Connexion du Buzzer à la carte ESP32

Buzzer	Carte ESP32
Broche (+)	GPIO 23
Broche (-)	GND

Programmation de la carte ESP32

Ce programme permet de réaliser une horloge réveil numérique utilisant la carte ESP32, le module DS1302 RTC, un afficheur LCD I2C et un buzzer. Il est développé en MicroPython et permet d’afficher l’heure en temps réel sur l’écran LCD et de déclencher automatiquement une alarme sonore à une heure précise.

On commence par l’importation de ces bibliothèques:

i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C

ds1302 → pour contrôler le module RTC DS1302

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

# Importer la classe Pin pour contrôler les broches GPIO
# et la classe I2C pour la communication I2C
from machine import Pin , I2C

# Importer la bibliothèque pour contrôler l'afficheur LCD I2C
from i2c_lcd import I2cLcd

# Importer la bibliothèque du module RTC DS1302
import ds1302

# Importer la bibliothèque time pour utiliser les délais
import time


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

# Définir l'adresse I2C de l'écran LCD (souvent 0x27 ou 0x3F)
I2C_ADDR = 0x27

# Initialiser l'écran LCD
# 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 → nombre de lignes
# 20 → nombre de colonnes
lcd = I2cLcd(I2C(0, scl=Pin(22), sda=Pin(21)), I2C_ADDR, 4, 20)

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


# ================= CONFIGURATION DU MODULE RTC DS1302 =================

# Définir les broches connectées au module RTC
clk = Pin(19)  # Broche CLK du RTC connectée à GPIO 19
dat = Pin(18)  # Broche DAT du RTC connectée à GPIO 18
rst = Pin(5)   # Broche RST du RTC connectée à GPIO 5

# Créer un objet rtc pour contrôler le module DS1302
rtc = ds1302.DS1302(clk, dat, rst)


# ================= REGLAGE DE L'HEURE =================
# ⚠️ Cette instruction doit être exécutée UNE SEULE FOIS
# ensuite elle doit être commentée pour éviter de réinitialiser l'heure à chaque démarrage

rtc.date_time([2026, 2, 6, 5, 6, 59, 55])

# Format :
# [année, mois, jour, jour_semaine, heure, minute, seconde]
# jour_semaine : 1=Lundi, 2=Mardi, ..., 7=Dimanche


# ================= CONFIGURATION DU BUZZER =================

# Définir la broche GPIO 23 comme sortie pour contrôler le buzzer
buzzer=Pin(23,Pin.OUT)

# buzzer.value(0) → buzzer OFF
# buzzer.value(1) → buzzer ON


# ================= FONCTION POUR OBTENIR LE JOUR =================

# Cette fonction convertit le numéro du jour en texte
def get_day(d):

    if d==1 :
        return "Monday"

    if d==2 :
        return "Tuesday"

    if d==3 :
        return "Wednesday"

    if d==4 :
        return "Thursday"

    if d==5 :
        return "Friday"

    if d==6 :
        return "Saturday"

    if d==7 :
        return "Sunday"


# ================= BOUCLE PRINCIPALE =================

# Boucle infinie pour faire fonctionner l'horloge en continu
while True:
   
    # Lire la date et l'heure actuelles depuis le RTC
    t = rtc.date_time()

    # Afficher le titre sur la première ligne
    lcd.move_to(0, 0)
    lcd.putstr("ESP32 Clock")

    # Afficher l'heure au format HH:MM:SS sur la deuxième ligne
    lcd.move_to(0, 1)
    lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))


    # ================= VERIFICATION DE L'ALARME =================

    # Vérifier si l'heure est exactement 07:00:00
    if (t[4]==7) and (t[5]==0) and (t[6]==0) :

        lcd.move_to(0, 1)

        # Faire sonner l'alarme 10 fois
        for i in range(10) :

            # Lire l'heure actuelle
            t = rtc.date_time()

            # Afficher l'heure
            lcd.move_to(0, 1)
            lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

            # Afficher le message d'alarme
            lcd.move_to(0, 2)
            lcd.putstr('Alarm 07:00 !!!')

            # Activer le buzzer
            buzzer.value(1)

            # Attendre 1 seconde
            time.sleep(1)


            # Lire l'heure à nouveau
            t = rtc.date_time()

            # Afficher l'heure
            lcd.move_to(0, 1)
            lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

            # Effacer le message d'alarme
            lcd.move_to(0, 2)
            lcd.putstr('               ')

            # Désactiver le buzzer
            buzzer.value(0)

            # Attendre 1 seconde
            time.sleep(1)


    # Petite pause possible (optionnel)
    # time.sleep(3)

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

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

# Importer la classe Pin pour contrôler les broches GPIO

# et la classe I2C pour la communication I2C

from machine import Pin , I2C

# Importer la bibliothèque pour contrôler l'afficheur LCD I2C

from i2c_lcd import I2cLcd

# Importer la bibliothèque du module RTC DS1302

import ds1302

# Importer la bibliothèque time pour utiliser les délais

import time

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

# Définir l'adresse I2C de l'écran LCD (souvent 0x27 ou 0x3F)

I2C_ADDR = 0x27

# Initialiser l'écran LCD

# 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 → nombre de lignes

# 20 → nombre de colonnes

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

# Effacer l'écran LCD au démarrage

lcd.clear()

# ================= CONFIGURATION DU MODULE RTC DS1302 =================

# Définir les broches connectées au module RTC

clk = Pin(19) # Broche CLK du RTC connectée à GPIO 19

dat = Pin(18) # Broche DAT du RTC connectée à GPIO 18

rst = Pin(5) # Broche RST du RTC connectée à GPIO 5

# Créer un objet rtc pour contrôler le module DS1302

rtc = ds1302.DS1302(clk, dat, rst)

# ================= REGLAGE DE L'HEURE =================

# ⚠️ Cette instruction doit être exécutée UNE SEULE FOIS

# ensuite elle doit être commentée pour éviter de réinitialiser l'heure à chaque démarrage

rtc.date_time([2026, 2, 6, 5, 6, 59, 55])

# Format :

# [année, mois, jour, jour_semaine, heure, minute, seconde]

# jour_semaine : 1=Lundi, 2=Mardi, ..., 7=Dimanche

# ================= CONFIGURATION DU BUZZER =================

# Définir la broche GPIO 23 comme sortie pour contrôler le buzzer

buzzer=Pin(23,Pin.OUT)

# buzzer.value(0) → buzzer OFF

# buzzer.value(1) → buzzer ON

# ================= FONCTION POUR OBTENIR LE JOUR =================

# Cette fonction convertit le numéro du jour en texte

def get_day(d):

if d==1 :

return "Monday"

if d==2 :

return "Tuesday"

if d==3 :

return "Wednesday"

if d==4 :

return "Thursday"

if d==5 :

return "Friday"

if d==6 :

return "Saturday"

if d==7 :

return "Sunday"

# ================= BOUCLE PRINCIPALE =================

# Boucle infinie pour faire fonctionner l'horloge en continu

while True:

# Lire la date et l'heure actuelles depuis le RTC

t = rtc.date_time()

# Afficher le titre sur la première ligne

lcd.move_to(0, 0)

lcd.putstr("ESP32 Clock")

# Afficher l'heure au format HH:MM:SS sur la deuxième ligne

lcd.move_to(0, 1)

lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

# ================= VERIFICATION DE L'ALARME =================

# Vérifier si l'heure est exactement 07:00:00

if (t[4]==7) and (t[5]==0) and (t[6]==0) :

lcd.move_to(0, 1)

# Faire sonner l'alarme 10 fois

for i in range(10) :

# Lire l'heure actuelle

t = rtc.date_time()

# Afficher l'heure

lcd.move_to(0, 1)

lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

# Afficher le message d'alarme

lcd.move_to(0, 2)

lcd.putstr('Alarm 07:00 !!!')

# Activer le buzzer

buzzer.value(1)

# Attendre 1 seconde

time.sleep(1)

# Lire l'heure à nouveau

t = rtc.date_time()

# Afficher l'heure

lcd.move_to(0, 1)

lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

# Effacer le message d'alarme

lcd.move_to(0, 2)

lcd.putstr(' ')

# Désactiver le buzzer

buzzer.value(0)

# Attendre 1 seconde

time.sleep(1)

# Petite pause possible (optionnel)

# time.sleep(3)

# Effacer l'écran (optionnel)

# lcd.clear()

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Horloge réveil avec la carte ESP32 et le module RTC DS1302

ESP32 23-02-26

Projet Micro:bit : Horloge réveil avec affichage LCD et module RTC DS1302

Micro:bit 21-02-26

Créer une horloge numérique avec ESP8266 NodeMCU et RTC DS1302

ESP8266 21-02-26

Créer une horloge numérique avec Arduino UNO et RTC DS1302

Arduino 19-02-26

Créer une horloge numérique avec la carte ESP32 et le module RTC DS1302

ESP32 17-02-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11475vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 11051vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9716vues

Allumer une LED par la carte ESP32

ESP32 9320vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 9310vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 27 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Horloge réveil avec la carte ESP32 et le module RTC DS1302

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

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

4- Programmation de la carte ESP32

Présentation du projet

Matériel nécessaire

Schéma de câblage de l'horloge réveil

Programmation de la carte ESP32

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles