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

ESP8266 21-02-26

25 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 ESP8266 NodeMCU

Présentation du projet

Objectif du projet

L’objectif de ce projet est de réaliser une horloge numérique précise et autonome en utilisant la carte ESP8266 NodeMCU, le module RTC DS1302 et un afficheur LCD I2C. Ce système permet d’afficher en temps réel l’heure et la date, même lorsque la carte ESP8266 est éteinte ou redémarrée. Le projet permet également d’apprendre à interfacer un module RTC avec un microcontrôleur et à afficher des informations sur un écran LCD en utilisant la communication I2C. Il constitue une excellente application pédagogique pour comprendre la gestion du temps réel et la communication entre différents modules électroniques.

Description du fonctionnement

Le fonctionnement de cette horloge numérique repose sur la communication entre trois éléments principaux : la carte ESP8266 NodeMCU, le module RTC DS1302 et l’afficheur LCD I2C.

Le module RTC DS1302 est responsable de la gestion de l’heure et de la date. Il possède une pile de sauvegarde qui lui permet de continuer à fonctionner même lorsque l’alimentation principale est coupée. Ainsi, l’heure reste toujours correcte.

La carte ESP8266 NodeMCU communique avec le module RTC DS1302 pour lire les informations de temps réel, telles que les heures, les minutes, les secondes, le jour, le mois et l’année. Elle traite ensuite ces données et les formate sous une forme lisible.

Enfin, l’ESP8266 envoie ces informations à l’afficheur LCD I2C. L’écran affiche clairement l’heure sur une ligne et la date sur une autre ligne. Ce processus se répète en continu, ce qui permet de mettre à jour l’affichage en temps réel.

Ce système permet donc d’obtenir une horloge numérique fiable, précise et facile à lire, basée sur des composants simples et largement utilisés dans les projets électroniques éducatifs.

Matériel nécessaire

1- Carte ESP8266 NodeMCU

La carte ESP8266 NodeMCU est le composant principal du projet. C’est un microcontrôleur qui permet de contrôler tous les autres composants. Elle lit les informations envoyées par le module RTC DS1302 et envoie les données de l’heure et de la date vers l’afficheur LCD I2C. Elle exécute le programme qui gère le fonctionnement de l’horloge.

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 sert à afficher les heures, minutes, secondes et la date

4. Câbles de Connexion (Jumper Wires)

Fils de connexion

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

Schéma de câblage de l'horloge

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 14)
GND	GND
VCC	3V ou 5V

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

Afficheur LCD I2C	ESP8266 NodeMCU
VCC	5V
GND	GND
SDA	D2 (GPIO4)
SCL	D1 (GPIO5)

Programmation de la carte ESP8266 NodeMCU

Le programme MicroPython permet de réaliser une horloge numérique en utilisant la carte ESP8266 NodeMCU, le module RTC DS1302 et un afficheur LCD I2C. Il permet d’afficher automatiquement l’heure, la date et le jour de la semaine sur l’écran LCD.

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
# Importer SoftI2C pour la communication I2C logicielle (ESP8266)
from machine import Pin , SoftI2C

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

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

# Importer la bibliothèque de gestion du temps
import time


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

# Adresse I2C de l'afficheur LCD (souvent 0x27 ou 0x3F)
I2C_ADDR = 0x27

# Nombre de lignes de l'écran LCD
totalRows = 4

# Nombre de colonnes de l'écran LCD
totalColumns = 20


# === Initialisation de la communication I2C ===

# Création de l'objet I2C logiciel
# scl connecté à la broche GPIO5
# sda connecté à la broche GPIO4
# freq = fréquence de communication I2C
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=10000)

# Création de l'objet LCD avec les paramètres I2C
lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
    

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


# ================= CONFIGURATION RTC DS1302 =================

# Définition des broches connectées au module RTC
clk = Pin(14)   # Broche CLK (horloge)
dat = Pin(12)   # Broche DAT (données)
rst = Pin(13)   # Broche RST (reset)

# Création de l'objet RTC
rtc = ds1302.DS1302(clk, dat, rst)


# ⚠️ À exécuter UNE SEULE FOIS puis commenter
# Cette ligne permet de régler la date et l'heure du RTC
rtc.date_time([2026, 2, 6, 5, 9, 6, 0])

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


# ================= FONCTION POUR CONVERTIR LE JOUR =================

# Cette fonction convertit le numéro du jour en nom du jour
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 afficher l'heure en temps réel
while True:
    
    # Lire la date et l'heure depuis le module RTC
    t = rtc.date_time()
    
    # Positionner le curseur à la colonne 0, ligne 0
    lcd.move_to(0, 0)
    
    # Afficher le titre
    lcd.putstr("ESP8266 Clock")
    
    # Positionner le curseur à la ligne 1
    lcd.move_to(0, 1)
    
    # Afficher le jour de la semaine
    lcd.putstr("Day: "+get_day(t[3]))
    
    # Positionner le curseur à la ligne 2
    lcd.move_to(0, 2)
    
    # Afficher la date (jour/mois/année)
    lcd.putstr("Date: {}/{}/{}".format(t[2], t[1], t[0]))
    
    # Positionner le curseur à la ligne 3
    lcd.move_to(0, 3)
    
    # Afficher l'heure (heure:minute:seconde)
    lcd.putstr("Hour: {:02d}:{:02d}:{:02d}".format(t[4], t[5], t[6]))

100

101

102

103

104

105

106

107

108

109

110

111

112

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

# Importer SoftI2C pour la communication I2C logicielle (ESP8266)

from machine import Pin , SoftI2C

# Importer la bibliothèque de l'afficheur LCD I2C

from i2c_lcd import I2cLcd

# Importer la bibliothèque du module RTC DS1302

import ds1302

# Importer la bibliothèque de gestion du temps

import time

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

# Adresse I2C de l'afficheur LCD (souvent 0x27 ou 0x3F)

I2C_ADDR = 0x27

# Nombre de lignes de l'écran LCD

totalRows = 4

# Nombre de colonnes de l'écran LCD

totalColumns = 20

# === Initialisation de la communication I2C ===

# Création de l'objet I2C logiciel

# scl connecté à la broche GPIO5

# sda connecté à la broche GPIO4

# freq = fréquence de communication I2C

i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=10000)

# Création de l'objet LCD avec les paramètres I2C

lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

# Effacer l'écran LCD au démarrage

lcd.clear()

# ================= CONFIGURATION RTC DS1302 =================

# Définition des broches connectées au module RTC

clk = Pin(14) # Broche CLK (horloge)

dat = Pin(12) # Broche DAT (données)

rst = Pin(13) # Broche RST (reset)

# Création de l'objet RTC

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

# ⚠️ À exécuter UNE SEULE FOIS puis commenter

# Cette ligne permet de régler la date et l'heure du RTC

rtc.date_time([2026, 2, 6, 5, 9, 6, 0])

# Format :

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

# ================= FONCTION POUR CONVERTIR LE JOUR =================

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

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 afficher l'heure en temps réel

while True:

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

t = rtc.date_time()

# Positionner le curseur à la colonne 0, ligne 0

lcd.move_to(0, 0)

# Afficher le titre

lcd.putstr("ESP8266 Clock")

# Positionner le curseur à la ligne 1

lcd.move_to(0, 1)

# Afficher le jour de la semaine

lcd.putstr("Day: "+get_day(t[3]))

# Positionner le curseur à la ligne 2

lcd.move_to(0, 2)

# Afficher la date (jour/mois/année)

lcd.putstr("Date: {}/{}/{}".format(t[2], t[1], t[0]))

# Positionner le curseur à la ligne 3

lcd.move_to(0, 3)

# Afficher l'heure (heure:minute:seconde)

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

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

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

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

Micro:bit 15-02-26

Calculatrice commandée par la carte Arduino UNO

Arduino 14-02-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11448vues

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

Arduino 11023vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9694vues

Allumer une LED par la carte ESP32

ESP32 9301vues

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

Arduino 9296vues

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

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

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 ESP8266 NodeMCU

Présentation du projet

Matériel nécessaire

Schéma de câblage de l'horloge

Programmation de la carte ESP8266 NodeMCU

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