ESP8266 NODEMCU: DS3231 Module d’horloge en temps réel (RTC)

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

Utilisation d’un module RTC DS1307? Suivez ce didacticiel à la place: ESP8266 NODEMCU: Guide du module d’horloge 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 une petite horloge à l’intérieur pour garder le temps indépendamment sans être connecté à un microcontrôleur. Ils sont livrés avec un support de batterie pour connecter une batterie, ils continuent de fonctionner même si l’ESP8266 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 les cartes ESP8266 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, qui peut être extrêmement utile dans les projets d’automatisation et de datalog.

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 (il s’agit d’une broche basse active).

Vous pouvez détecter ce signal avec l’ESP8266 pour déclencher des interruptions. 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 ponctuelles (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. Alarm1 et Alarm2 sont différents.

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.

32k	Sortie de l’oscillateur de 32 kHz – peut être utilisée comme référence d’horloge
SQW	Sortie d’onde carrée / interruption
SCL	Pin SCL pour I2C
SDA	PIN SDA pour I2C
VCC	Fournit de la puissance au module (3,3 V ou 5V)
GND	GND

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’ESP8266. Vous pouvez utiliser le tableau suivant comme référence ou jeter un œil au schéma du schéma. Nous utilisons les broches par défaut I2C.

Module DS3231 RTC	ESP8266
SQW	GPIO 14 (ou toute autre broche numérique)
SCL	GPIO 5 (D1)
SDA	GPIO 4 (D2)
VCC	3V3
GND	GND

Vous aimerez peut-être aussi: ESP8266 Référence de broche: quelles broches GPIO devriez-vous utiliser?

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

Nous programmerons l’ESP8266 Nodemcu à l’aide d’Arduino IDE. Assurez-vous que les planches ESP8266 sont installées en suivant ce guide: Installation de la carte ESP8266 dans Arduino IDE 2 (Windows, Mac OS X, Linux)

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

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.

ESP8266 Nodemcu avec DS3231: définir et lire l’heure

L’exemple suivant définit l’heure sur le module 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/esp8266-nodemcu-ds3231-real-time-clock-arduino/
*********/
// Based on the RTCLib Library examples: 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

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 ne fonctionne pas, car il s’agit d’un nouvel appareil, ou parce que la sauvegarde de 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 de l’énergie (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:

maintenant.year ()	Obtient l’année en cours (par exemple, 2024)
maintenant Month ()	Obtient le mois en cours (1–12)
maintenant.Day ()	Obtient le jour en cours du mois (1–31)
maintenant.Dayoftheweek ()	Obtient le jour de la semaine (0-6), où 0 est dimanche, et 6 est samedi
maintenant.hour ()	Obtient l’heure en cours (0–23)
maintenant.Minute ()	Obtient la minute actuelle (0–59)
maintenant.second ()	Obtient la seconde actuelle (0–59)

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()];

Enfin, 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é à la carte ESP8266 et téléchargez le code sur votre carte.

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

DS3231 avec l’ESP8266: 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:

Alarme	Mode	Signification (déclenchez l’alarme…)
Alarme 1	DS3231_A1_PERSECOND	chaque seconde
Alarme 1	Ds3231_a1_second	Quand les secondes correspondent
Alarme 1	DS3231_A1_MINUTE	Quand les minutes correspondent
Alarme 1	Ds3231_a1_hour	Quand l’heure correspond
Alarme 1	Ds3231_a1_date	Lorsque la date correspond
Alarme 1	Ds3231_a1_day	Quand la journée correspond
Alarme 2	Ds3231_a2_perminute	chaque minute
Alarme 2	DS3231_A2_MINUTE	Quand les minutes correspondent
Alarme 2	Ds3231_a2_hour	Quand l’heure correspond
Alarme 2	DS3231_A2_DATE	Lorsque la date correspond
Alarme 2	Ds3231_a2_day	Quand la journée correspond

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

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp8266-nodemcu-ds3231-real-time-clock-arduino/
*********/
// Example based on the library: implementation of an alarm using DS3231
#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 14

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

// set the alarms
// (year, month, day, hour, minutes, seconds)
DateTime alarm1Time = DateTime(2025, 01, 03, 18, 42, 0);
DateTime alarm2Time = DateTime(2025, 01, 03, 18, 48, 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);
}

ICACHE_RAM_ATTR 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_Second)) {  // 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

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’ESP8266;
• Vous devez désactiver une alarme avant d’activer l’autre.

Comment fonctionne le code?

Nous avons déjà couvert comment initialiser le RTC, et 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 14, vous pouvez utiliser tout autre GPIO numérique approprié.

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

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(2025, 01, 03, 18, 42, 0);
DateTime alarm2Time = DateTime(2025, 01, 03, 18, 48, 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 ESP8266 à bord).

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

Remarque: La fonction à appeler lorsque l’interruption est déclenchée doit avoir l’icache_ram_attr avant la définition de la fonction pour exécuter le code d’interruption dans RAM.

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 qui montre 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 projets d’automatisation et IoT.

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 ESP8266 basculera chaque fois qu’une alarme est tirée.

Emballage

Dans ce didacticiel, vous avez appris à interfacer le module RTC DS3231 avec l’ESP8266 pour obtenir les alarmes d’heure et de déclenchement. Ce module peut être utile pour les tâches périodiques, la données de données, l’automatisation, etc. Vous pouvez également ajouter un écran OLED ou un écran LCD pour créer une horloge numérique.

Nous avons des guides pour d’autres modules avec l’ESP8266 que vous pouvez trouver utile.

En savoir plus sur l’ESP8266 avec nos ressources:

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :