Horloge réveil avec ESP8266 NodeMCU 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 ESP8266 NodeMCU
Présentation du projet
Objectif du projet
L’objectif de ce projet est de concevoir une horloge réveil numérique intelligente basée sur la carte ESP8266 NodeMCU développée par Espressif Systems, le module RTC DS1302 de Maxim Integrated et un afficheur LCD I2C. Ce système permet d’afficher l’heure en temps réel, de programmer une alarme (par exemple 07:00:00), et d’alerter l’utilisateur à l’aide d’un buzzer lorsque l’heure programmée est atteinte. Ce projet permet de créer une horloge autonome, fiable et précise, utile dans la vie quotidienne comme réveil électronique.
Fonctionnement du projet
Le module RTC DS1302 est utilisé pour maintenir l’heure et la date exactes, même lorsque l’alimentation principale est coupée, grâce à sa pile de sauvegarde. La carte ESP8266 NodeMCU communique avec le module RTC pour lire en permanence l’heure actuelle (heures, minutes et secondes).
Ces informations sont ensuite affichées sur l’écran LCD I2C, ce qui permet une visualisation claire et facile de l’heure. Une heure d’alarme est programmée dans le code, par exemple 07:00:00.
Lorsque l’heure actuelle devient égale à l’heure programmée :
1- l’écran LCD affiche le message : "Alarm 07:00 !!!",
2- le buzzer est activé pour produire un signal sonore,
3- ce signal avertit l’utilisateur que l’heure de l’alarme est atteinte.
Le système fonctionne en boucle continue :
1- il lit l’heure depuis le module RTC,
2- il met à jour l’affichage sur le LCD,
3- il compare l’heure actuelle avec l’heure de l’alarme pour déclencher le buzzer au moment approprié.
Ce projet est idéal pour apprendre la gestion du temps réel, l’utilisation d’un module RTC, le contrôle d’un afficheur LCD I2C et l’intégration d’un buzzer avec la carte ESP8266 NodeMCU.
Matériel nécessaire
1- Carte ESP8266 NodeMCU
La carte ESP8266 NodeMCU est le microcontrôleur principal du projet. Elle exécute le programme qui lit l’heure depuis le module RTC DS1302, affiche l’heure sur l’écran LCD I2C 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 carte ESP8266 NodeMCU 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)
Les fils de connexion assurent la liaison entre la carte ESP8266 NodeMCU, 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) :
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 ESP8266 NodeMCU
| RTC DS1302 | ESP8266 NodeMCU |
|---|---|
| CLK | D5 (GPIO 14) |
| DAT | D6 (GPIO 12) |
| RST | D7 (GPIO 13) |
| GND | GND |
| VCC | VIN |
2- Connexion de l’afficheur LCD I2C à la carte ESP8266 NodeMCU
| Afficheur LCD I2C | ESP8266 NodeMCU |
|---|---|
| VCC | 5V |
| GND | GND |
| SDA | D2 (GPIO 4) |
| SCL | D1 (GPIO 5) |
3- Connexion du Buzzer à la carte ESP8266 NodeMCU
| Buzzer | ESP8266 NodeMCU |
|---|---|
| Broche (+) | D0 (GPIO 0) |
| Broche (-) | GND |
Programmation de la carte ESP8266 NodeMCU
Ce programme permet de réaliser une horloge réveil numérique utilisant la carte ESP8266 NodeMCU, 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 :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
from machine import Pin , SoftI2C from i2c_lcd import I2cLcd import ds1302 import time # ================= LCD I2C ================= I2C_ADDR = 0x27 # I2C address of the LCD display totalRows = 4 # Number of rows of the LCD totalColumns = 20 # Number of columns of the LCD # === Initialize the I2C communication for ESP8266 === i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=10000) # scl -> Serial Clock pin # sda -> Serial Data pin # freq -> I2C communication frequency # Create LCD object lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns) # Initialize buzzer pin as output buzzer = Pin(0, Pin.OUT) # The buzzer is connected to GPIO0 and configured as output # Clear the LCD screen lcd.clear() # ================= RTC DS1302 Configuration ================= # Define the pins connected to the DS1302 RTC module clk = Pin(14) # Clock pin dat = Pin(12) # Data pin rst = Pin(13) # Reset pin # Create RTC object rtc = ds1302.DS1302(clk, dat, rst) # ⚠️ Run this line ONLY ONCE, then comment it # It sets the initial date and time in the RTC module rtc.date_time([2026, 2, 6, 5, 6, 59, 55]) # Format: # [year, month, day, day_of_week, hour, minute, second] # ================= Main Loop ================= while True: # Read current date and time from RTC t = rtc.date_time() # Display project title on first row lcd.move_to(0, 0) lcd.putstr("ESP8266 Clock") # Display current time on second row lcd.move_to(0, 1) lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6])) # ================= Alarm condition ================= # Check if the time is exactly 07:00:00 if (t[4] == 7) and (t[5] == 0) and (t[6] == 0): lcd.move_to(0, 1) # Repeat alarm ON/OFF 10 times for i in range(10): # Read updated time t = rtc.date_time() # Display current time lcd.move_to(0, 1) lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6])) # Display alarm message lcd.move_to(0, 2) lcd.putstr('Alarm 07:00 !!!') # Turn buzzer ON buzzer.value(1) # Wait 1 second time.sleep(1) # Read updated time again t = rtc.date_time() # Display current time lcd.move_to(0, 1) lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6])) # Clear alarm message lcd.move_to(0, 2) lcd.putstr(' ') # Turn buzzer OFF buzzer.value(0) # Wait 1 second time.sleep(1) |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
