ESP32: Guide pour DS3231 Module d’horloge en temps réel (RTC)

Ce tutoriel est un guide démarré pour le module d’horloge en temps réel DS3231 avec l’ESP32. Le module RTC DS3231 est un excellent module pour le chronomètre précis, il vous permet également de régler des alarmes, de sortir des ondes carrées avec différentes fréquences et d’obtenir des lectures de température.

Utilisation d’un module RTC DS1307? Suivez ce tutoriel à la place: ESP32: Guide du module d’horloge en temps réel DS1307 (RTC).

Table des matières

Dans ce tutoriel, nous couvrirons les sujets suivants:

Présentation des modules d’horloge en temps réel (RTC)

Les modules RTC, tels que les DS3231 et DS1307, ont leur propre petite horloge à l’intérieur pour garder le temps par eux-mêmes. Habituellement, ils sont livrés avec un support de batterie pour connecter une batterie afin qu’ils continuent de fonctionner même si l’ESP32 réinitialise ou perd l’énergie.

Le DS3231 et le DS1307 sont quelques-uns des choix les plus populaires à utiliser avec les microcontrôleurs. Les deux sont compatibles avec l’ESP32 et communiquent via le protocole de communication I2C. Le DS3231 est plus précis car il donne des résultats compensés par la température. De plus, il est également possible de définir des alarmes externes avec le DS3231, ce qui peut être extrêmement utile.

Présentation du module DS3231 RTC

L’image suivante montre le module RTC DS3231. Il utilise un oscillateur en cristal compensé à 32 kHz (TCXO) pour garder une trace du temps de manière précise (elle résiste aux changements de température). Pour cette raison, il vous permet également d’obtenir des données de température.

En plus de garder une trace de la date et de l’heure précisément, il a également une mémoire intégrée pour stocker jusqu’à deux alarmes et peut produire des ondes carrées à différentes fréquences: 1Hz, 4KHz, 8KHz et 32KHz.

Vous communiquez avec le module RTC à l’aide du protocole de communication I2C. Habituellement, c’est sur l’adresse 0x68.

Ce module est également livré avec un EEPROM de 32 octets 24c32 que vous pouvez utiliser pour stocker toutes les données non volatiles que vous souhaitez. Vous pouvez communiquer avec cette mémoire EEPROM via I2C en adressant la bonne adresse (0x57).

Porte-batterie DS3231

Le DS3231 est livré avec un support de batterie pour connecter une batterie pour maintenir un chronomètre précis. En cas de panne de courant, il peut toujours garder une trace du temps avec précision et garder toutes les alarmes.

Vous devez utiliser une batterie LIR2032, qui est rechargeable. N’utilisez pas un CR2032 (pas rechargeable).

Si vous souhaitez utiliser une batterie CR2032, qui n’est pas record, vous devez déconnecter le circuit de charge de la batterie en décollant et en supprimant la résistance (étiquetée R4 dans mon module) à côté de la diode.

Alarmes DS3231

Le DS3231 peut stocker jusqu’à deux alarmes: alarme 1 et alarme 2. Ces alarmes peuvent être configurées pour déclencher en fonction d’une heure et / ou d’une date spécifiques. Lorsqu’une alarme est déclenchée, la broche SQW du module sortira un signal faible.

Vous pouvez détecter ce signal avec l’ESP32 et déclencher des interruptions, ou même le réveiller du sommeil profond. Ainsi, cette fonctionnalité est extrêmement utile pour définir un réveil périodique de sommeil profond et d’autres tâches périodiques, une automatisation temporelle et également des alertes uniques (car vous pouvez effacer une alarme après son déclenchement).

Chaque alarme peut être configurée pour être déclenchée dans différents modes. Ces modes vous permettent de créer des alarmes qui se répètent à chaque seconde, minute, heure, quotidienne, hebdomadaire ou même une fois par mois.

Alarme 1:

• Chaque seconde
• Quand les secondes, les minutes, les heures, le jour ou la date correspondent

Alarme 2:

• Chaque minute
• Quand les minutes, les heures, le jour ou la date correspondent

Nous verrons comment définir des alarmes plus tard dans ce tutoriel.

Adresse du module I2C du module RTC DS3231

Par défaut, l’adresse du DS3231 RTC est 0x68 et l’EEPROM connecté au module est 0x57. Vous pouvez exécuter un croquis du scanner I2C pour revérifier les adresses.

DS3231 RTC Module Pinout

Le tableau suivant décrit rapidement la broche du module RTC DS3231.

Voici une liste des pièces requises pour ce tutoriel:

Vous pouvez utiliser les liens précédents ou aller directement à makeradvisor.com/tools pour trouver toutes les pièces de vos projets au meilleur prix!

Tirez le DS3231 à l’ESP32. Vous pouvez utiliser le tableau suivant comme référence ou jeter un œil au schéma du schéma.

Vous pouvez également aimer: Guide pour la communication I2C avec l’ESP32

Travailler avec le RTC

L’utilisation d’un module RTC dans vos projets nécessite toujours deux étapes importantes.

1. Définition de l’heure actuelle: vous pouvez le faire manuellement en insérant l’heure actuelle (ou un temps souhaité différent) sur le code; l’heure locale du système; ou obtenez le temps d’un serveur NTP.
2. Conserver le temps: pour s’assurer que le RTC conserve le bon temps, même s’il perd l’énergie, il doit être connecté à une batterie. Les modules RTC sont livrés avec un support de batterie, généralement pour une cellule de pièces.

Installation de la bibliothèque RTCLIB

Il y a plusieurs bibliothèques pour s’interfacer avec le module RTC DS3231. Nous utiliserons le RTCLIB à partir d’AdaFruit qui est compatible avec les modules RTC DS1307, DS3231 et PCF8523. De plus, cette bibliothèque est également compatible avec les cartes ESP32 (même si cela n’est pas mentionné sur la page de la bibliothèque).

Dans le Arduino IDE, allez dans Sketch> Inclure la bibliothèque> Gérer les bibliothèques. Recherchez RTCLIB et installez la bibliothèque par AdaFruit. Nous utilisons la version 2.1.4.

ESP32 avec DS3231: définir et lire l’heure

L’exemple suivant définit l’heure sur l’horloge RTC, puis lit l’heure dans la boucle toutes les trois secondes. Nous lisons également la température. Ce code montre deux façons différentes de définir l’heure: la synchronisation du RTC avec l’heure du système (date et heure de l’esquisse a été compilée) et définir une date et une heure spécifiques manuellement en l’écrivant vous-même sur le code.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-ds3231-real-time-clock-arduino/
*********/

// Example based on the RTClib: implementation of an alarm using DS3231 https://github.com/adafruit/RTClib
#include 
RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

// the pin that is connected to SQW
#define CLOCK_INTERRUPT_PIN 4

// LED for visual indication
const int ledPin = 2;

// set the alarms
// (year, month, day, hour, minutes, seconds)
DateTime alarm1Time = DateTime(2024, 12, 18, 12, 49, 0);
DateTime alarm2Time = DateTime(2024, 12, 18, 11, 10, 0);

void printCurrentTime(){
  // Get the current time from the RTC
  DateTime now = rtc.now();
  
  // Getting each time field in individual variables
  // And adding a leading zero when needed;
  String yearStr = String(now.year(), DEC);
  String monthStr = (now.month() < 10 ? "0" : "") + String(now.month(), DEC);
  String dayStr = (now.day() < 10 ? "0" : "") + String(now.day(), DEC);
  String hourStr = (now.hour() < 10 ? "0" : "") + String(now.hour(), DEC); 
  String minuteStr = (now.minute() < 10 ? "0" : "") + String(now.minute(), DEC);
  String secondStr = (now.second() < 10 ? "0" : "") + String(now.second(), DEC);
  String dayOfWeek = daysOfTheWeek[now.dayOfTheWeek()];

  // Complete time string
  String formattedTime = dayOfWeek + ", " + yearStr + "-" + monthStr + "-" + dayStr + " " + hourStr + ":" + minuteStr + ":" + secondStr;

  // Print the complete formatted time
  Serial.println(formattedTime);
}

void onAlarm() {
  Serial.println("Alarm occured!");
  // toggle the current LED state
  int state = digitalRead(ledPin);
  digitalWrite(ledPin, !state);
}

void setup() {
  Serial.begin(115200);
  pinMode (ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  // initializing the rtc
  if(!rtc.begin()) {
    Serial.println("Couldn't find RTC!");
    Serial.flush();
    while (1) delay(10);
  }

  if(rtc.lostPower()) {
    // this will adjust to the date and time at compilation
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  // Uncomment if you need to adjust the time
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  //we don't need the 32K Pin, so disable it
  rtc.disable32K();

  // Trigger an interrupt when the alarm happens
  pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);

  // set alarm 1, 2 flag to false (so alarm 1, 2 didn't happen so far)
  // if not done, this easily leads to problems, as both register aren't reset on reboot/recompile
  rtc.clearAlarm(1);
  rtc.clearAlarm(2);

  // stop oscillating signals at SQW Pin, otherwise setAlarm1 will fail
  rtc.writeSqwPinMode(DS3231_OFF);

  // turn off alarm 2 (in case it isn't off already)
  // again, this isn't done at reboot, so a previously set alarm could easily go overlooked
  rtc.disableAlarm(2);

  // Schedule Alarm1 to fire when the minutes match
  if(!rtc.setAlarm1(alarm1Time, DS3231_A1_Minute)) {  // this mode triggers the alarm when the minutes match
    Serial.println("Error, alarm wasn't set!");
  }else {
    Serial.println("Alarm 1 will happen at specified time");
  }
}

void loop() {
  // print current date and time
  printCurrentTime();

  // Get Details about the alarm1
  DateTime alarm1 = rtc.getAlarm1();
  Ds3231Alarm1Mode alarm1mode = rtc.getAlarm1Mode();
  char alarm1Date[12] = "DD hh:mm:ss";
  alarm1.toString(alarm1Date);
  Serial.print("[Alarm1: ");
  Serial.print(alarm1Date);
  Serial.print(", Mode: ");
  switch (alarm1mode) {
    case DS3231_A1_PerSecond: Serial.print("PerSecond"); break;
    case DS3231_A1_Second: Serial.print("Second"); break;
    case DS3231_A1_Minute: Serial.print("Minute"); break;
    case DS3231_A1_Hour: Serial.print("Hour"); break;
    case DS3231_A1_Date: Serial.print("Date"); break;
    case DS3231_A1_Day: Serial.print("Day"); break;
  }
  // the value at SQW-Pin (because of pullup 1 means no alarm)
  Serial.print("] SQW: ");
  Serial.print(digitalRead(CLOCK_INTERRUPT_PIN));
  // whether a alarm fired
  Serial.print(" Fired: ");
  Serial.print(rtc.alarmFired(1));

  // Only one alarm can be set at a time, reset alarm 1 and activate alarm 2
  // resetting SQW and alarm 1 flag
  // the next alarm could now be configurated
  if (rtc.alarmFired(1)) {
      rtc.clearAlarm(1);
      Serial.println(" - Alarm cleared");
      
      // Set Alarm 2
      if(!rtc.setAlarm2(alarm2Time, DS3231_A2_Minute)) {  // this mode triggers the alarm when the minutes match
        Serial.println("Error, alarm wasn't set!");
      }else {
        Serial.println("Alarm 2 will happen at specified time");
      }

    // Get Details about the alarm2
    DateTime alarm1 = rtc.getAlarm2();
    Ds3231Alarm2Mode alarm2mode = rtc.getAlarm2Mode();
    char alarm2Date[12] = "DD hh:mm:ss";
    alarm1.toString(alarm2Date);
    Serial.print("[Alarm2: ");
    Serial.print(alarm2Date);
    Serial.print(", Mode: ");
    switch (alarm2mode) {
      case DS3231_A2_PerMinute: Serial.print("Every Minute"); break;
      case DS3231_A2_Minute: Serial.print("Minute"); break;
      case DS3231_A2_Hour: Serial.print("Hour"); break;
      case DS3231_A2_Date: Serial.print("Date"); break;
      case DS3231_A2_Day: Serial.print("Day"); break;
    }
    // the value at SQW-Pin (because of pullup 1 means no alarm)
    Serial.print("] SQW: ");
    Serial.print(digitalRead(CLOCK_INTERRUPT_PIN));
    // whether a alarm fired
    Serial.print(" Fired: ");
    Serial.print(rtc.alarmFired(1)); 
  }

  Serial.println();
  delay(2000);
}

Afficher le code brut

Comment fonctionne le code

Commencez par importer la bibliothèque RTCLIB.

#include "RTClib.h"

Ensuite, créez un objet RTC_DS3231 appelé RTC.

RTC_DS3231 rtc;

Ensuite, vous créez un réseau de char avec les jours de la semaine.

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

Vous pouvez accéder chaque jour par son index. Par exemple:

• jours-de-theweek[0] reviendra «Sunday».
• jours-de-theweek[1] reviendra «lundi».

Dans la configuration (), initialisez le moniteur série.

Serial.begin(115200);

Initialisez le module RTC comme suit:

if (! rtc.begin()) {
  Serial.println("Couldn't find RTC");
  Serial.flush();
  while (1) delay(10);
}

Vérification du statut RTC

Ensuite, vérifiez si le RTC a perdu la puissance avec la fonction LostPower (). S’il n’est pas en cours d’exécution, car il s’agit d’un nouvel appareil ou parce que la batterie a échoué, nous allons imprimer un message dans le moniteur en série et définir l’heure.

if (! rtc.lostPower()) {
  Serial.println("RTC lost power, let's set the time!");

Régler l’heure

Pour définir l’heure sur le RTC, nous pouvons utiliser la méthode Réglage () sur notre objet RTC. La ligne suivante définit la date et l’heure du RTC à la date et à l’heure actuelles où ce croquis a été compilé pour la dernière fois.

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

__Date__ et __time__ sont des macros qui fournissent la date et l’heure actuelles à la compilation.

Alternativement, vous pouvez définir la date et l’heure manuellement. Passez les champs d’heure dans cet ordre: année, mois, jour, heure, minute, deuxième. Cette ligne est commentée sur le code.

// January 21, 2014 at 3am you would call:
rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));

Si vous devez réinitialiser l’heure sur un appareil précédemment configuré, vous pouvez appeler l’une des deux lignes précédentes pour définir l’heure sans vérifier si elle a perdu la puissance ou non (ceci est commenté sur le code).

// When time needs to be re-set on a previously configured device, the
// following line sets the RTC to the date & time this sketch was compiled
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
//rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));

Obtenir la date et l’heure

Dans la boucle (), nous obtenons la date et l’heure toutes les trois secondes, et nous l’imprimons dans le moniteur série.

Nous appelons rtc.Now () pour obtenir la date et l’heure actuelles du module RTC.

DateTime now = rtc.now();

Il renvoie un objet DateTime contenant les valeurs pour l’année en cours, mois, jour, heure, minute et seconde.

Pour accéder à chaque champ de la date et de l’heure, nous pouvons utiliser les méthodes suivantes:

Pour convertir le résultat en une chaîne, nous pouvons utiliser la méthode String (). Nous passons également Dec en deuxième argument à la méthode String () pour obtenir un numéro décimal.

String yearStr = String(now.year(), DEC);

Dans le cas du mois, du jour, de l’heure, de la minute et du deuxième, nous ajoutons un zéro leader lorsque le nombre est inférieur à 10. Donc, au lieu d’avoir, par exemple: 3: 5: 6 (ce qui est bizarre pour un format de temps), vous obtiendrez 03:05:06.

String monthStr = (now.month() < 10 ? "0" : "") + String(now.month(), DEC);
String dayStr = (now.day() < 10 ? "0" : "") + String(now.day(), DEC);
String hourStr = (now.hour() < 10 ? "0" : "") + String(now.hour(), DEC); 
String minuteStr = (now.minute() < 10 ? "0" : "") + String(now.minute(), DEC);
String secondStr = (now.second() < 10 ? "0" : "") + String(now.second(), DEC);

Pour obtenir le nom du jour de la semaine, nous utilisons le tableau DaysoStheweek que nous avons créé au début du code.

String dayOfWeek = daysOfTheWeek[now.dayOfTheWeek()];

En fin de compte, nous concatenons tous les champs de temps dans une variable et l’avons affiché dans le moniteur série.

// Complete time string
String formattedTime = dayOfWeek + ", " + yearStr + "-" + monthStr + "-" + dayStr + " " + hourStr + ":" + minuteStr + ":" + secondStr;

// Print the complete formatted time
Serial.println(formattedTime);

Le DS3231 donne des résultats compensés par température. Nous pouvons obtenir la température qu’il mesure en utilisant la méthode getTemperature () sur l’objet RTC. Cela renvoie la température dans les degrés Celsius.

 // Getting temperature
 Serial.print(rtc.getTemperature());
 Serial.println("ºC");

Tester l’exemple

Avec le RTC connecté à l’ESP32, téléchargez le code sur votre carte.

Ouvrez le moniteur en série à un taux en bauds de 115200. L’ESP32 définira le temps RTC et affichera l’heure et la température actuelles toutes les trois secondes.

DS3231 avec l’ESP32: réglage des alarmes

Le module RTC DS3231 vous permet de configurer jusqu’à deux alarmes: alarme 1 et alarme 2. Lorsque vous utilisez la bibliothèque RTCLIB, ce sont les modes acceptés pour les alarmes:

L’exemple suivant montre comment configurer deux alarmes et comment les utiliser pour déclencher une interruption sur l’ESP32 (en savoir plus sur les interruptions avec l’ESP32 ici).

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-ds3231-real-time-clock-arduino/
*********/

// Based on the RTCLib Library examples: https://github.com/adafruit/RTClib
// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include "RTClib.h"

RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {
  Serial.begin(115200);

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    while (1) delay(10);
  }

  if (! rtc.lostPower()) {
    Serial.println("RTC lost power, let's set the time!");
    // When time needs to be set on a new device, or after a power loss, the
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }

  // When time needs to be re-set on a previously configured device, the
  // following line sets the RTC to the date & time this sketch was compiled
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // This line sets the RTC with an explicit date & time, for example to set
  // January 21, 2014 at 3am you would call:
  //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}

void loop () {
  // Get the current time from the RTC
  DateTime now = rtc.now();
  
  // Getting each time field in individual variables
  // And adding a leading zero when needed;
  String yearStr = String(now.year(), DEC);
  String monthStr = (now.month() < 10 ? "0" : "") + String(now.month(), DEC);
  String dayStr = (now.day() < 10 ? "0" : "") + String(now.day(), DEC);
  String hourStr = (now.hour() < 10 ? "0" : "") + String(now.hour(), DEC); 
  String minuteStr = (now.minute() < 10 ? "0" : "") + String(now.minute(), DEC);
  String secondStr = (now.second() < 10 ? "0" : "") + String(now.second(), DEC);
  String dayOfWeek = daysOfTheWeek[now.dayOfTheWeek()];

  // Complete time string
  String formattedTime = dayOfWeek + ", " + yearStr + "-" + monthStr + "-" + dayStr + " " + hourStr + ":" + minuteStr + ":" + secondStr;

  // Print the complete formatted time
  Serial.println(formattedTime);

  // Getting temperature
  Serial.print(rtc.getTemperature());
  Serial.println("ºC");

  Serial.println();
  delay(3000);
}

Afficher le code brut

Notes importantes sur les alarmes:

• Le RTC vous permet d’économiser jusqu’à deux alarmes;
• Vous ne pouvez avoir qu’une seule alarme active à la fois;
• Une fois qu’une alarme a été déclenchée, vous devez effacer son drapeau pour éviter de déclencher et de planter l’ESP32;
• Vous devez désactiver une alarme avant d’activer l’autre.

Comment fonctionne le code?

Nous avons déjà couvert comment initialiser le RTC, définir et obtenir l’heure du module DS3231. Nous allons simplement expliquer les parties pertinentes liées aux alarmes.

Définissez le GPIO connecté à la broche SQW. Dans notre cas, nous utilisons GPIO 4, vous pouvez utiliser tout autre GPIO approprié.

// the pin that is connected to SQW
#define CLOCK_INTERRUPT_PIN 4

Tout d’abord, nous créons deux objets DateTime pour définir l’heure de l’alarme 1 et de l’alarme 2.

DateTime alarm1Time = DateTime(2024, 12, 18, 12, 05, 0);
DateTime alarm2Time = DateTime(2024, 12, 18, 11, 10, 0);

Ensuite, nous devons désactiver la broche 32k car nous ne l’utiliserons pas.

 rtc.disable32K();

Définissez la broche SQW en tant qu’interruption afin que nous puissions déclencher une fonction lorsqu’une alarme est tirée. Le SQW est actif bas, ce qui signifie que son état est normalement élevé et se transforme en bas lorsqu’une alarme est tirée. Lorsque l’alarme sera déclenchée, nous appellerons la fonction onalarm.

// Trigger an interrupt when the alarm happens
pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);

La fonction onalarm (), définie précédemment dans le code, imprime un message dans le moniteur série et inverse l’état actuel de GPIO 2 (connecté à la LED embarquée ESP32).

void onAlarm() {
  Serial.println("Alarm occured!");
  int state = digitalRead(ledPin);
  digitalWrite(ledPin, !state);
}

Effacer à la fois l’alarme 1 et l’alarme 2 avant de définir une alarme.

rtc.clearAlarm(1);
rtc.clearAlarm(2);

Nous utiliserons la broche SQW pour déclencher les alarmes. Nous n’utiliserons pas ses fonctionnalités pour générer des vagues carrées. Nous devons donc arrêter cela.

rtc.writeSqwPinMode(DS3231_OFF);

Nous ne pouvons avoir qu’une seule alarme à la fois. Désactivez donc l’alarme 2 avant de configurer l’alarme 1.

rtc.disableAlarm(2);

Configurez l’alarme 1 à l’aide de la fonction setalarm1 () sur l’objet RTC. Passer comme arguments le temps de l’alarme 1 et le mode d’alarme. Nous avons déjà vu les options de mode d’alarme pour l’alarme 1 et l’alarme 2 avant. Dans ce cas, nous le définissons sur DS3231_A1_MINUTE, ce qui signifie que l’alarme se déclenchera lorsque les minutes correspondent.

// Schedule Alarm1 to fire when the minutes match
if(!rtc.setAlarm1(alarm1Time, DS3231_A1_Minute)) {  // this mode triggers the alarm when the minutes match
  Serial.println("Error, alarm wasn't set!");
}else {
  Serial.println("Alarm 1 will happen at specified time");
}

Dans la boucle (), nous imprimons les détails de l’alarme actuelle.

// Get Details about the alarm1
DateTime alarm1 = rtc.getAlarm1();
Ds3231Alarm1Mode alarm1mode = rtc.getAlarm1Mode();
char alarm1Date[12] = "DD hh:mm:ss";
alarm1.toString(alarm1Date);
Serial.print("[Alarm1: ");
Serial.print(alarm1Date);
Serial.print(", Mode: ");
switch (alarm1mode) {
  case DS3231_A1_PerSecond: Serial.print("PerSecond"); break;
  case DS3231_A1_Second: Serial.print("Second"); break;
  case DS3231_A1_Minute: Serial.print("Minute"); break;
  case DS3231_A1_Hour: Serial.print("Hour"); break;
  case DS3231_A1_Date: Serial.print("Date"); break;
  case DS3231_A1_Day: Serial.print("Day"); break;
}
// the value at SQW-Pin (because of pullup 1 means no alarm)
Serial.print("] SQW: ");
Serial.print(digitalRead(CLOCK_INTERRUPT_PIN));
// whether a alarm fired
Serial.print(" Fired: ");
Serial.print(rtc.alarmFired(1));

Nous pouvons vérifier si l’alarme 1 a tiré en utilisant la ligne suivante:

if (rtc.alarmFired(1)) {

Lorsqu’il tire, nous effacons cette alarme et commençons à configurer l’alarme 2.

// Set Alarm 2
if(!rtc.setAlarm2(alarm2Time, DS3231_A2_Minute)) {  // this mode triggers the alarm when the minutes match
  Serial.println("Error, alarm wasn't set!");
}else {
  Serial.println("Alarm 2 will happen at specified time");
}

Ce n’est qu’un exemple rapide vous montrant les détails de la configuration des alarmes avec le module RTC DS3231. Maintenant, vous devriez être en mesure de modifier cet exemple pour utiliser des alarmes dans vos propres projets. Cette fonction d’alarme peut être spécialement utile pour réveiller l’ESP32 depuis un sommeil profond à un moment désigné ou pour planifier des tâches périodiques qui doivent fonctionner à un moment précis.

Après avoir téléchargé le code, vous devez obtenir des informations sur le moniteur en série sur les alarmes. La LED à bord ESP32 basculera chaque fois qu’une alarme est tirée.

Emballage

Dans ce tutoriel, vous avez appris à utiliser le module RTC DS3231 avec l’ESP32 pour définir et obtenir le temps, définir des alarmes et obtenir des lectures de température.

Dans un prochain tutoriel, nous vous montrerons comment configurer des alarmes pour réveiller l’ESP32 depuis un sommeil profond à un moment précis.

Nous espérons que vous trouverez ce tutoriel utile. Autres tutoriels que vous pouvez trouver utiles:

En savoir plus sur l’ESP32 avec nos ressources:

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :