Horloge temps réel DS1307

Le module horloge temps réel DS1307 donne une notion du temps à un montage : il tient l’heure, la date et le jour de la semaine, et il les conserve même lorsque l’Arduino est débranché, grâce à la pile bouton logée dans son support.

La carte livrée est le modèle Tiny RTC, la version la plus répandue du DS1307 : le circuit d’horloge, son quartz, ses résistances et son support de pile sont déjà soudés. Elle y ajoute une mémoire EEPROM 24C32 sur le même bus, utilisable pour enregistrer des réglages ou des relevés. Quatre fils suffisent à la faire fonctionner : alimentation, masse, et les deux lignes du bus I2C.

À quoi sert une horloge temps réel

Un microcontrôleur sait compter des millisecondes, pas des jours. Sans module RTC, il oublie tout au redémarrage et dérive de plusieurs minutes par jour. Le DS1307 comble exactement ce manque :

• Horodater des mesures — un enregistreur de température, un compteur d’impulsions ou un journal de démarrage qui note quand chaque événement s’est produit.
• Agir à une heure précise — allumer un arrosage à 6 h, couper une enseigne à minuit, faire sonner un réveil.
• Garder la date après une coupure — une machine qui perd son état mais pas son calendrier, même privée de courant plusieurs semaines.
• Programmer des scénarios hebdomadaires — le DS1307 suit aussi le jour de la semaine, la logique « seulement le lundi » s’écrit sans calendrier embarqué.

Caractéristiques techniques

Brochage : quatre fils suffisent

La carte porte deux rangées de broches mâles. Les broches qui portent le même nom sont reliées entre elles : vous pouvez donc câbler le module par la rangée qui arrange votre montage.

Deux adresses cohabitent sur le même bus : 0x68 pour l’horloge et 0x50 pour la mémoire. Un scanner I2C qui affiche les deux a donc parfaitement raison — ce n’est pas un doublon, ce sont les deux circuits de la carte.

La pile : ce qu’il faut savoir avant d’en monter une

Le module est livré sans pile. Le support situé au dos accepte une pile bouton de 12 mm de diamètre. Sans elle, tout fonctionne encore, mais l’heure repart de zéro à chaque coupure d’alimentation et il faut la régler de nouveau.

Deux points méritent votre attention avant de choisir la pile :

• La carte est prévue pour l’heure, pas pour le temps réel absolu. Elle dérive de quelques minutes par mois. Pour une horloge qui doit rester juste à la seconde sur plusieurs mois, il faut un modèle compensé en température — ce n’est pas ce que propose le DS1307, et il vaut mieux le savoir avant de comparer.
• Certaines cartes Tiny RTC comportent un petit circuit de charge (une diode et une résistance près du support) prévu pour une pile rechargeable. Une pile bouton non rechargeable n’est pas conçue pour être rechargée. Avant d’en monter une, regardez si la carte comporte une diode et une résistance de charge : si c’est le cas, utilisez une pile rechargeable ou alimentez le module en permanence — la question se tranche en dix secondes en lisant les composants soudés autour du support.

Dans tous les cas, l’heure se règle une fois, et la pile se contente de la maintenir ensuite.

Mini-projet : lire la date et l’heure sur le moniteur série

Le montage le plus court pour prendre en main le module : quatre fils, un programme d’une trentaine de lignes, et l’heure s’affiche chaque seconde dans le moniteur série.

Ce qu’il faut

Le câblage

Quatre fils, aucune résistance, aucun condensateur : le module embarque déjà tout ce dont il a besoin.

Le programme

La bibliothèque RTClib gère le DS1307 et traduit les registres internes en date et heure lisibles. Installez-la depuis le gestionnaire de bibliothèques de l’IDE Arduino (Croquis, puis Inclure une bibliothèque, puis Gérer les bibliothèques), puis téléversez :

/*
 * Horloge temps reel DS1307 - lecture de la date et de l'heure
 * Carte : Arduino Uno R3
 * Montage : module Tiny RTC DS1307 sur le bus I2C
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "Wire.h"
#include "RTClib.h"

RTC_DS1307 horloge;

// A mettre sur true UNE SEULE FOIS, pour regler le module a l'heure
// de l'ordinateur au moment du televersement. Remettre ensuite sur false.
const bool REGLER_AU_DEMARRAGE = true;

// Ecrit un nombre sur deux chiffres : 7 devient 07, 12 reste 12.
void afficherDeuxChiffres(int valeur) {
  if (valeur / 10 == 0) {
    Serial.print('0');
  }
  Serial.print(valeur);
}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  delay(2000);              // laisse le temps d'ouvrir le moniteur serie

  if (horloge.begin() == false) {
    Serial.println("DS1307 introuvable : verifiez SDA, SCL, VCC et GND.");
    while (1) {
      delay(1000);          // on reste ici tant que le module ne repond pas
    }
  }

  if (REGLER_AU_DEMARRAGE == true) {
    horloge.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("Heure du module reglee sur celle de l'ordinateur.");
  }

  if (horloge.isrunning() == false) {
    Serial.println("Le DS1307 etait arrete : une pile neuve a-t-elle ete posee ?");
    horloge.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
}

void loop() {
  DateTime maintenant = horloge.now();

  Serial.print(maintenant.day());
  Serial.print('/');
  Serial.print(maintenant.month());
  Serial.print('/');
  Serial.print(maintenant.year());
  Serial.print("  ");
  afficherDeuxChiffres(maintenant.hour());
  Serial.print(':');
  afficherDeuxChiffres(maintenant.minute());
  Serial.print(':');
  afficherDeuxChiffres(maintenant.second());
  Serial.println();

  delay(1000);              // une lecture par seconde suffit largement
}

Comment ça marche

• horloge.begin() vérifie que le module répond sur le bus I2C. Le programme s’arrête avec un message clair si le câblage est en défaut : c’est plus rapide à comprendre qu’un affichage de date absurde.
• horloge.adjust(DateTime(F(__DATE__), F(__TIME__))) écrit dans le module la date et l’heure de la compilation, pas celles du moment où vous ouvrez le moniteur série. D’où la remise de REGLER_AU_DEMARRAGE sur false juste après le premier réglage : sans cela, l’heure serait réécrite à chaque redémarrage, et la pile ne servirait à rien.
• horloge.isrunning() indique si l’horloge tourne réellement. Après une longue coupure sans pile, elle est arrêtée : le programme la remet en marche plutôt que d’afficher une date figée.
• F(__DATE__) range la chaîne en mémoire programme, comme la bibliothèque l’attend. Aucun réglage manuel de la date dans le code : elle vient de l’ordinateur.

Pour aller plus loin

Le module se branche aussi bien sur une autre carte : le câblage change deux numéros de broches seulement. Et comme l’I2C accepte plusieurs circuits sur les mêmes deux fils, l’heure s’affiche sur un afficheur LCD 16×02 I2C branché en parallèle, sans consommer une seule broche supplémentaire de l’Arduino.

Questions fréquentes

L’heure revient à zéro dès que je débranche l’Arduino

Le module est livré sans pile : c’est le comportement normal. Posez une pile bouton de 12 mm dans le support au dos, réglez l’heure une nouvelle fois, et elle tiendra ensuite les coupures d’alimentation.

Pourquoi mon scanner I2C trouve-t-il deux périphériques ?

Parce que la carte en contient deux : l’horloge DS1307 (0x68) et l’EEPROM 24C32 (0x50). Les deux répondent sur le même bus, et c’est une bonne nouvelle : la mémoire est utilisable pour vos propres données sans ajouter de composant.

À quoi servent les broches SQ et DS ?

À rien dans un montage courant. SQ sort un signal carré à 1 Hz, 4 kHz, 8 kHz ou 32 kHz selon un registre interne — utile pour faire clignoter une LED à la seconde sans occuper le programme. DS est la ligne d’un capteur de température one-wire optionnel, non fourni : elle n’a d’intérêt que si vous soudez ce capteur sur les pastilles prévues à cet effet.

Faut-il re téléverser le programme pour régler l’heure ?

Une seule fois, avec REGLER_AU_DEMARRAGE sur true. Ensuite, le module garde l’heure par lui-même : c’est tout l’intérêt du composant. Pour la corriger plus tard, un simple bouton poussoir et deux lignes de programme suffisent — mais le cas est rare, la dérive étant de quelques minutes par mois.

Combien de temps une pile tient-elle ?

Elle dépend du modèle et de la consommation du circuit en veille, de l’ordre de plusieurs mois à quelques années. Le signe qu’il faut la changer est simple : l’heure se remet à zéro à chaque coupure de courant.

À combiner avec

Le KIT Starter contient déjà la carte Uno, la plaque d’essai, les fils et les composants de base : en y ajoutant ce module d’horloge, vous avez de quoi construire un enregistreur ou un réveil sans rien commander d’autre. Le DS1307 se marie particulièrement bien avec un afficheur pour composer une horloge autonome, et avec les capteurs du catalogue pour horodater leurs relevés.