Horloge digitale avec alarme utilisant Arduino UNO et DS1302

Arduino 23-02-26

12 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du système de l'horloge avec alarme

4- Programmation de la carte Arduino UNO

Présentation du projet

Objectif du projet

L’objectif de ce projet est de concevoir et réaliser une horloge digitale avec fonction réveil en utilisant la carte Arduino UNO, le module RTC DS1302, un afficheur LCD I2C et un buzzer. Ce système permet d’afficher l’heure en temps réel et de déclencher une alarme sonore à une heure prédéfinie, comme 07:00:00. Ce projet constitue une application pratique des systèmes embarqués combinant la gestion du temps, l’affichage et les alertes sonores.

Fonctionnement du système

Le fonctionnement du système repose sur le module RTC DS1302, qui assure la gestion et la conservation de l’heure et de la date. Grâce à sa pile de sauvegarde, le module continue de fonctionner même lorsque la carte Arduino UNO est éteinte.

La carte Arduino UNO communique avec le module RTC pour lire en permanence l’heure actuelle (heures, minutes et secondes). Ensuite, elle envoie ces informations à l’afficheur LCD I2C, qui affiche clairement l’heure au format numérique, par exemple : Hour: 07:00:00

Le programme compare continuellement l’heure actuelle avec l’heure d’alarme prédéfinie. Lorsque l’heure atteint exactement 07:00:00, la carte Arduino active le buzzer pour produire un signal sonore et affiche un message d’alerte sur l’écran LCD : Alarm 07:00 !!!

Le buzzer s’active et se désactive de manière répétée pour attirer l’attention de l’utilisateur, tandis que le message d’alarme reste affiché sur l’écran. Après la fin de la séquence d’alarme, le buzzer s’arrête et le système continue de fonctionner normalement en affichant l’heure et en surveillant la prochaine occurrence de l’alarme.

Matériel nécessaire

1- Carte Arduino UNO

Arduino Uno

L’Arduino UNO est la carte microcontrôleur principale du projet. Elle contrôle tous les autres composants et exécute le programme de l’horloge et de l’alarme.

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. Buzzer

Le buzzer est un dispositif sonore qui émet un signal lorsque l’alarme est déclenchée.

4. Afficheur LCD I2C

L’afficheur LCD permet de visualiser l’heure et les messages d’alarme.

5. Câbles de Connexion (Jumper Wires)

Fils de connexion

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

Schéma de câblage du système de l'horloge avec alarme

1- Connexion du module RTC DS1302 à la carte Arduino UNO

RTC DS1302	Arduino UNO
CLK	pin 5
DAT	pin 6
RST	pin 7
GND	GND
VCC	5V

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

Afficheur LCD I2C	Arduino UNO
VCC	5V
GND	GND
SDA	pin A4
SCL	pin A5

3- Connexion du Buzzer à la carte Arduino UNO

Buzzer	Arduino UNO
Broche +	Pin 3
Broche -	GND

Programmation de la carte Arduino UNO

Ce programme implémente une horloge digitale avec fonction réveil. Il est écrit en Arduino C/C++ et permet d’afficher l’heure actuelle sur le LCD tout en déclenchant un buzzer lorsque l’heure correspond à un moment prédéfini (07:00:00 dans ce cas).

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

LiquidCrystal_I2C → pour afficher les informations sur l’écran LCD I2C

ErriezDS1302-master → pour contrôler le module RTC DS1302

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

#include <ErriezDS1302.h>       // Bibliothèque pour le module RTC DS1302
#include <LiquidCrystal_I2C.h>  // Bibliothèque pour l'afficheur LCD I2C

// ===============================
// Configuration RTC DS1302
// ===============================
#define CLK_PIN 5   // Broche CLK du module RTC → connectée à D5 de l'Arduino
#define IO_PIN  6   // Broche DAT/IO du module RTC → connectée à D6
#define CE_PIN  7   // Broche CE (Chip Enable) du module RTC → connectée à D7

ErriezDS1302 rtc(CLK_PIN, IO_PIN, CE_PIN); // Création de l'objet RTC

// ===============================
// Configuration LCD I2C 20x4
// ===============================
LiquidCrystal_I2C lcd(0x27, 20, 4); // Adresse I2C 0x27, écran 20 colonnes x 4 lignes

int buzzerPin = 3; // Broche de connexion du buzzer (D3)

void setup() {
  pinMode(buzzerPin, OUTPUT); // Définir le buzzer comme sortie
  Serial.begin(9600);         // Initialisation du port série (facultatif pour debug)

  // Initialisation de l'écran LCD
  lcd.init();
  lcd.backlight();  // Allume le rétroéclairage
  lcd.clear();      // Efface l'écran

  // Initialisation du module RTC
  if (!rtc.begin()) {           // Vérifie la présence du RTC
    lcd.setCursor(0, 0);
    lcd.print("RTC not detected"); // Message d'erreur si RTC non détecté
    while (1);                     // Boucle infinie si le RTC n'est pas détecté
  }

  rtc.clockEnable(true); // Active l'horloge du module RTC

  // ⚠️ Régler UNE SEULE FOIS puis commenter
  // Format : h, m, s, j, mois, annee, jour_semaine
  rtc.setDateTime(6, 59, 55, 8, 2, 2026, 1); // Lundi 6 février 2026, 06:59:55

  lcd.clear(); // Efface l'écran après réglage
}

void loop() {
  uint8_t hour, min, sec, day, mon, wday; // Variables pour stocker la date/heure
  uint16_t year;                           // Année sur 16 bits

  // Lecture des données du RTC
  if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {

    // ================= AFFICHAGE DE L'HEURE =================
    lcd.setCursor(0, 0);
    lcd.print("Arduino Clock"); // Affiche le titre

    lcd.setCursor(0, 1);
    lcd.print("Hour: ");
    if (hour < 10) lcd.print("0"); // Ajoute un 0 pour l'affichage à deux chiffres
    lcd.print(hour);
    lcd.print(":");
    if (min < 10) lcd.print("0");
    lcd.print(min);
    lcd.print(":");
    if (sec < 10) lcd.print("0");
    lcd.print(sec);

    // ================= ALARME =================
    // Vérifie si l'heure correspond à 07:00:00
    if ((hour == 7) && (min == 0) && (sec == 0)) {
      for (int i = 1; i <= 10; i++) { // Répéter l'alarme 10 fois
        if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {
          // Affiche l'heure pendant l'alarme
          lcd.setCursor(0, 1);
          lcd.print("Hour: ");
          if (hour < 10) lcd.print("0");
          lcd.print(hour);
          lcd.print(":");
          if (min < 10) lcd.print("0");
          lcd.print(min);
          lcd.print(":");
          if (sec < 10) lcd.print("0");
          lcd.print(sec);
        }

        // Affiche le message d'alarme
        lcd.setCursor(0, 2);
        lcd.print("Alarm 07:00 !!!");

        digitalWrite(buzzerPin, HIGH); // Active le buzzer (alarme ON)
        delay(1000);                    // Attend 1 seconde

        // Met à jour l'heure et efface le message d'alarme
        if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {
          lcd.setCursor(0, 1);
          lcd.print("Hour: ");
          if (hour < 10) lcd.print("0");
          lcd.print(hour);
          lcd.print(":");
          if (min < 10) lcd.print("0");
          lcd.print(min);
          lcd.print(":");
          if (sec < 10) lcd.print("0");
          lcd.print(sec);
        }

        lcd.setCursor(0, 2);
        lcd.print("               ");  // Efface le message d'alarme
        digitalWrite(buzzerPin, LOW); // Désactive le buzzer (alarme OFF)
        delay(1000);                   // Attend 1 seconde
      }
    }
  } else { // Si lecture du RTC échoue
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Error RTC"); // Message d'erreur
  }

  delay(1000); // Attente 1 seconde avant la prochaine lecture
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

#include <ErriezDS1302.h> // Bibliothèque pour le module RTC DS1302

#include <LiquidCrystal_I2C.h> // Bibliothèque pour l'afficheur LCD I2C

// ===============================

// Configuration RTC DS1302

// ===============================

#define CLK_PIN 5 // Broche CLK du module RTC → connectée à D5 de l'Arduino

#define IO_PIN 6 // Broche DAT/IO du module RTC → connectée à D6

#define CE_PIN 7 // Broche CE (Chip Enable) du module RTC → connectée à D7

ErriezDS1302 rtc(CLK_PIN, IO_PIN, CE_PIN); // Création de l'objet RTC

// ===============================

// Configuration LCD I2C 20x4

// ===============================

LiquidCrystal_I2C lcd(0x27, 20, 4); // Adresse I2C 0x27, écran 20 colonnes x 4 lignes

int buzzerPin = 3; // Broche de connexion du buzzer (D3)

void setup() {

pinMode(buzzerPin, OUTPUT); // Définir le buzzer comme sortie

Serial.begin(9600); // Initialisation du port série (facultatif pour debug)

// Initialisation de l'écran LCD

lcd.init();

lcd.backlight(); // Allume le rétroéclairage

lcd.clear(); // Efface l'écran

// Initialisation du module RTC

if (!rtc.begin()) { // Vérifie la présence du RTC

lcd.setCursor(0, 0);

lcd.print("RTC not detected"); // Message d'erreur si RTC non détecté

while (1); // Boucle infinie si le RTC n'est pas détecté

}

rtc.clockEnable(true); // Active l'horloge du module RTC

// ⚠️ Régler UNE SEULE FOIS puis commenter

// Format : h, m, s, j, mois, annee, jour_semaine

rtc.setDateTime(6, 59, 55, 8, 2, 2026, 1); // Lundi 6 février 2026, 06:59:55

lcd.clear(); // Efface l'écran après réglage

}

void loop() {

uint8_t hour, min, sec, day, mon, wday; // Variables pour stocker la date/heure

uint16_t year; // Année sur 16 bits

// Lecture des données du RTC

if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {

// ================= AFFICHAGE DE L'HEURE =================

lcd.setCursor(0, 0);

lcd.print("Arduino Clock"); // Affiche le titre

lcd.setCursor(0, 1);

lcd.print("Hour: ");

if (hour < 10) lcd.print("0"); // Ajoute un 0 pour l'affichage à deux chiffres

lcd.print(hour);

lcd.print(":");

if (min < 10) lcd.print("0");

lcd.print(min);

lcd.print(":");

if (sec < 10) lcd.print("0");

lcd.print(sec);

// ================= ALARME =================

// Vérifie si l'heure correspond à 07:00:00

if ((hour == 7) && (min == 0) && (sec == 0)) {

for (int i = 1; i <= 10; i++) { // Répéter l'alarme 10 fois

if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {

// Affiche l'heure pendant l'alarme

lcd.setCursor(0, 1);

lcd.print("Hour: ");

if (hour < 10) lcd.print("0");

lcd.print(hour);

lcd.print(":");

if (min < 10) lcd.print("0");

lcd.print(min);

lcd.print(":");

if (sec < 10) lcd.print("0");

lcd.print(sec);

}

// Affiche le message d'alarme

lcd.setCursor(0, 2);

lcd.print("Alarm 07:00 !!!");

digitalWrite(buzzerPin, HIGH); // Active le buzzer (alarme ON)

delay(1000); // Attend 1 seconde

// Met à jour l'heure et efface le message d'alarme

if (rtc.getDateTime(&hour, &min, &sec, &day, &mon, &year, &wday)) {

lcd.setCursor(0, 1);

lcd.print("Hour: ");

if (hour < 10) lcd.print("0");

lcd.print(hour);

lcd.print(":");

if (min < 10) lcd.print("0");

lcd.print(min);

lcd.print(":");

if (sec < 10) lcd.print("0");

lcd.print(sec);

}

lcd.setCursor(0, 2);

lcd.print(" "); // Efface le message d'alarme

digitalWrite(buzzerPin, LOW); // Désactive le buzzer (alarme OFF)

delay(1000); // Attend 1 seconde

}

} else { // Si lecture du RTC échoue

lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Error RTC"); // Message d'erreur

}

delay(1000); // Attente 1 seconde avant la prochaine lecture

}

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 digitale avec alarme utilisant Arduino UNO et DS1302

Arduino 23-02-26

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

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11476vues

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

Arduino 11052vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9717vues

Allumer une LED par la carte ESP32

ESP32 9321vues

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

Arduino 9312vues

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 digitale avec alarme utilisant Arduino UNO et DS1302

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du système de l'horloge avec alarme

4- Programmation de la carte Arduino UNO

Présentation du projet

Matériel nécessaire

Schéma de câblage du système de l'horloge avec alarme

Programmation de la carte Arduino UNO

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