Convertir une date en une alarme RTC

**cobra38** · 02/08/2025, 15h31

Bonjour Jay M

vous pouvez profiter du réveil lors du coucher du soleil pour planifier celui du lendemain. Vous avez la DateTime du jour, vous ajouter un TimeSpan de 24h, ça vous donne le lendemain et vous calculer le coucher du soleil et l'enregistrez dans la RTC. Comme ça votre ESP ne se réveille qu'une seule fois au coucher du soleil.

j'ai réfléchi à votre proposition et j'ai fait cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
 if (rtc.alarmFired(1)==true) {
    rtc.clearAlarm(1);
    Serial.print(" - Alarm cleared");
    DateTime now = rtc.now()+ TimeSpan(1, 0, 0,0); // On ajoute 1 jour à la date en cours
    jour = now.day();
    mois = now.month();
    annee = now.year();
    testerEphemeride(jour,mois,annee, 1, -5, 16, 43, 45, 39, 32); 
  }

l'ennui c'est que le programme ne passe jamais par là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
15:01:50.647 -> Date            Lever         Meridien      Coucher
15:01:50.647 -> 02/08/2025      04:25:04      11:45:10      19:04:30
15:01:50.686 -> [ Alarme 1: 02 19:04:30, Mode: Date ]
15:01:50.686 -> --------------------
15:01:50.686 -> Boot number: 7
15:01:50.686 -> --------------------
15:01:50.686 -> 🕒 Heure actuelle DS3231 : 19:03:30
15:01:50.686 -> Going to sleep now

**Jay M** · 03/08/2025, 08h48

sans le code complet, difficile de dire ce qu'il se passe... Vous avez mis cela où?

**cobra38** · 03/08/2025, 11h17

sans le code complet, difficile de dire ce qu'il se passe... Vous avez mis cela où?

c'est juste ...

le voici ( juste le fichier .ino ):
pour l'instant j'essaie de comprendre pourquoi je n'ai pas "- Alarm cleared"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
 
#include "RTClib.h"
#include "driver/rtc_io.h"
#include <ArduinoJson.h>
//#include <Preferences.h>
#include <Wire.h>
#include <time.h>
#include <math.h>
#include "ephemeride.h"
 
int nb_calculs = 0;
unsigned long int duree_calculs = 0;
 
int jour;
int mois;
int annee;
 
// Définir la broche d'interruption du DS3231 (qui réveillera l'ESP32 - doit être un GPIO RTC)
#define CLOCK_INTERRUPT_PIN   GPIO_NUM_33  // Only RTC IO are allowed
 
// LED pour l'indication visuelle
const int ledPin = 32;
 
// Enregistre le nombre de fois où l'ESP32 s'est réveillé
RTC_DATA_ATTR int bootCount = 0;
 
// Instance pour le RTC
RTC_DS3231 rtc;
DateTime alarm1Time = DateTime(0, 0, 0, 0, 0, 0);
 
void onAlarm(){
  Serial.print("Une alarme s'est produite!");
}
 
void afficherTexte(char texte[])
{
  Serial.print(texte);
}
/*
unsigned long int millis()
  {
      return (unsigned long int) clock() * 1000 / CLOCKS_PER_SEC;
  }
*/
//****************************************//
//              SETUP                      //  
//****************************************//
void setup() {
  Serial.begin(115200);
  pinMode (ledPin, OUTPUT);
 
  char texte[80];
 
  //Imprime le motif de réveil de l'ESP32
  print_wakeup_reason();
 
  // Clignotement de la LED lorsque l'ESP32 se réveille
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
 
  // Initialiser le RTC
  if(!rtc.begin()) {
    Serial.println("Couldn't find RTC!");
    Serial.flush();
    while (1) delay(10);
  }
 
  if(rtc.lostPower()) {
      // ceci s'ajustera à la date et à l'heure de la compilation
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
 
  // Décommenter si vous avez besoin de définir l'heure du RTC
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  //rtc.adjust(DateTime(2025, 8, 2,15, 25, 0)); // ajuste à l'heure UTC
 
 
  // Nous n'avons pas besoin de la broche 32K, il faut donc la désactiver.
  rtc.disable32K();
 
  // L'alarme déclenche une interruption
  pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);
 
  // Mettre l'alarme 1, 2 à false (donc l'alarme 1, 2 ne s'est pas produite jusqu'à présent)
  // si ce n'est pas fait, cela conduit facilement à des problèmes, car les deux registres ne sont pas réinitialisés au redémarrage/recompilation.
  rtc.clearAlarm(1);
  rtc.clearAlarm(2);
 
  // Arrêter les signaux oscillants sur la broche SQW, sinon setAlarm1 échouera.
  rtc.writeSqwPinMode(DS3231_OFF);
 
  // Désactiver l'alarme 2 (au cas où elle ne le serait pas déjà)
 // encore une fois, cela n'est pas fait au redémarrage, de sorte qu'une alarme précédemment réglée pourrait facilement être ignorée.
  rtc.disableAlarm(2);
  DateTime now = rtc.now(); 
 
  jour = now.day();
  mois = now.month();
  annee = now.year();
 
  afficherDate(jour,mois,annee);
  if(!rtc.setAlarm1(alarm1Time, DS3231_A1_Date)) {  // ce mode déclenche l'alarme lorsque la date et heure correspondantes
        Serial.println("Erreur, l'alarme n'a pas été réglée!");
  }else {
      testerEphemeride(jour,mois,annee, 1, -5, 16, 43, 45, 39, 32); // Lat : 45.6590039 & Long : 5.278757777777778  => Lat : N 45 39 32.414 & Long : E 5 16 43
  }
 
  // Incrémente le numéro de démarrage et l'imprime à chaque redémarrage
  ++bootCount;
  Serial.println("--------------------");
  Serial.println("Boot number: " + String(bootCount));
  Serial.println("--------------------");
 
  // Configuration du réveil externe
  esp_sleep_enable_ext0_wakeup(CLOCK_INTERRUPT_PIN, 0);  //1 = Haut, 0 = Bas
  // Configurer le pullup/down via RTCIO pour lier les broches de réveil à un niveau inactif pendant le sommeil profond.
  // La broche SQW du RTC est active à un niveau bas.
  rtc_gpio_pulldown_dis(CLOCK_INTERRUPT_PIN);
  rtc_gpio_pullup_en(CLOCK_INTERRUPT_PIN);
 
 
  // Heure actuelle du DS3231
  char buf[9];
  sprintf(buf, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  Serial.print("🕒 Heure actuelle DS3231 : ");
  Serial.println(buf);
 
  if (rtc.alarmFired(1)) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm cleared");
  }   
 
  //S'endormir maintenant jusqu'à ce qu'une alarme se déclenche
  Serial.println("Going to sleep now");
  esp_deep_sleep_start();
}
 
//****************************************//
//              LOOP                      //  
//****************************************//
void loop() {
  // Le code n'atteint jamais la boucle, car l'ESP32 se met en veille à la fin de l'installation.
  Serial.print("Ce document ne sera jamais imprimé!");
}
 
// Méthode permettant d'imprimer la raison pour laquelle l'ESP32 a été réveillé de son sommeil
void print_wakeup_reason() {
  esp_sleep_wakeup_cause_t wakeup_reason;
  wakeup_reason = esp_sleep_get_wakeup_cause();
  switch (wakeup_reason) {
    case ESP_SLEEP_WAKEUP_EXT0:     Serial.println("Réveil causé par un signal externe utilisant RTC_IO"); break;
    case ESP_SLEEP_WAKEUP_EXT1:     Serial.println("Réveil provoqué par un signal externe utilisant RTC_CNTL"); break;
    case ESP_SLEEP_WAKEUP_TIMER:    Serial.println("Réveil provoqué par la minuterie"); break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println("Réveil provoqué par le pavé tactile"); break;
    case ESP_SLEEP_WAKEUP_ULP:      Serial.println("Réveil causé par le programme ULP"); break;
    default:                        Serial.printf("Le réveil n'a pas été causé par un sommeil profond : %d\n", wakeup_reason); break;
  }
}
 
//********************************************//
void checkAlarms()
{
    DateTime alarm1Time = rtc.getAlarm1();
    Ds3231Alarm1Mode alarm1mode = rtc.getAlarm1Mode();
    char alarm1Date[12] = "DD hh:mm:ss";
    alarm1Time.toString(alarm1Date);
    Serial.print("[ Alarme 1: ");
    Serial.print(alarm1Date);
    Serial.print(", Mode: ");
    switch (alarm1mode) {
      case DS3231_A1_PerSecond: Serial.println("PerSecond ]"); break;
      case DS3231_A1_Second: Serial.println("Second ]"); break;
      case DS3231_A1_Minute: Serial.println("Minute ]"); break;
      case DS3231_A1_Hour: Serial.println("Hour ]"); break;
      case DS3231_A1_Date: Serial.println("Date ]"); break;
      case DS3231_A1_Day: Serial.println("Day ]"); break;
    }
    Serial.print("");
}
 
 
//********************************************//
void afficherDate(int jour, int mois, int annee)
{
  char texte[20];
  sprintf(texte, "%02d/%02d/%04d", jour, mois, annee);
  afficherTexte(texte);
}
 
//********************************************//
void afficherCoordonnee(int degre, int minute, int seconde, char c)
{
  char texte[20];
  if (degre < 0)
  {
    degre = -degre;
    if (c == 'W') c = 'E';
    if (c == 'N') c = 'S';
  }
  sprintf(texte,"%dd%d'%d''%c", degre, minute, seconde, c);
  afficherTexte(texte);
}
 
//********************************************//
void afficherHeure(double d)
{
  int h,m,s;
  char texte[20];
 
  d = d + 0.5;
 
  if (d < 0.0)
  {
    afficherTexte("(J-1)");
    d = d + 1.0;
  }
  else
  {
    if (d > 1.0)
    {
      afficherTexte("(J+1)");
      d = d - 1.0;
    }
    else
    {
      afficherTexte("     ");
    }
  }
 
  h = d * 24.0;
  d = d - (double) h / 24.0;
  m = d * 1440.0;
  d = d - (double) m / 1440.0;
  s = d * 86400.0 + 0.5;
 
  sprintf(texte,"%02d:%02d:%02d",h,m,s);
  afficherTexte(texte);
}
 
 
 
//********************************************//
void testerEphemeride(int jour, int mois, int annee, int nbjours,
                      int longitude_ouest_degres, int longitude_ouest_minutes, int longitude_ouest_secondes,
                      int latitude_nord_degres, int latitude_nord_minutes, int latitude_nord_secondes)
{
  double longitude_ouest, latitude_nord;
  double lever, meridien, coucher;
  int i;
  unsigned long int duree;
 
  afficherTexte("\nCalcul ephemeride au lieu ");
  afficherCoordonnee(longitude_ouest_degres, longitude_ouest_minutes, longitude_ouest_secondes, 'W');
  afficherTexte(" - ");
  afficherCoordonnee(latitude_nord_degres, latitude_nord_minutes, latitude_nord_secondes, 'N');
  afficherTexte("\n\nDate            Lever         Meridien      Coucher\n");
 
  longitude_ouest = calculerCoordonneeDecimale(longitude_ouest_degres, longitude_ouest_minutes, longitude_ouest_secondes);
  latitude_nord = calculerCoordonneeDecimale(latitude_nord_degres, latitude_nord_minutes, latitude_nord_secondes);
 
  //for (i=0; i<nbjours; i++)
  //{
    afficherDate(jour, mois, annee);
    afficherTexte(" ");
 
    duree = millis();
    calculerEphemeride(jour, mois, annee, longitude_ouest, latitude_nord, &lever, &meridien, &coucher);
    duree = millis() - duree;
    duree_calculs += duree;
    nb_calculs++;
 
    afficherHeure(lever);
    afficherTexte(" ");
    afficherHeure(meridien);
    afficherTexte(" ");
    afficherHeure(coucher);
    afficherTexte("\n");
 
  /*------------------------------------*/  
  int Aannee = annee; // année de l'alarme
  int Amois = mois;   // mois de l'alarme
  int Ajour = jour;   // jour de l'alarme
  double AheureJulienne = coucher;  // heure du coucher du soleil 
  programmerAlarme(Aannee, Amois, Ajour, AheureJulienne); 
 
}
 
//********************************************//
double calculerCoordonneeDecimale(int degre, int minute, int seconde)
{
  if (degre > 0)
  {
    return (double) degre + minute / 60.0 + seconde / 3600.0;
  }
  else
  {
    return (double) degre - minute / 60.0 - seconde / 3600.0;
  }
}
 
void programmerAlarme(int annee, int mois, int jour, double heureJulienne) {
 
  // on calcule l'heure, minute et seconde comme dans le code de bricoleau
  // dans sa fonction afficherHeure() en modifiant éventuellement le jour
  int h, m, s;
  double d = heureJulienne + 0.5;
 
  if (d < 0.0) {
    jour -= 1;
    d += 1.0;
  } else if (d >= 1.0) {
    jour += 1;
    d -= 1.0;
  }
 
  h = d * 24.0;
  d -= (double) h / 24.0;
  m = d * 1440.0;
  d -= (double) m / 1440.0;
  s = d * 86400.0 + 0.5;
 
  // puis on fabrique un DateTime avec ces infos
  DateTime alarme(annee, mois, jour, h, m, s);
 
  // qu'on utilise pour armer l'alarme1 en mode date+heure exacte
  rtc.setAlarm1(alarme, DS3231_A1_Date);
  checkAlarms();
  //rtc.enableAlarm(DS3231_ALARM_1);
}

Pour information , j'ai gardé la fonction

void testerEphemeride(int jour, int mois, int annee, int nbjours,
int longitude_ouest_degres, int longitude_ouest_minutes, int longitude_ouest_secondes,
int latitude_nord_degres, int latitude_nord_minutes, int latitude_nord_secondes)
{

dans le programme principal et non pas dans le sous-programme "ephemeride.h" et "ephemeride.cpp" , la cause étant le report des variables (jour, mois et année) qui je n'arrivait à maitriser

Dans le code je n'ai mis que la fonction pour test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
if (rtc.alarmFired(1)) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm cleared");
  }

**Jay M** · 03/08/2025, 18h41

Envoyé par cobra38

Dans le code je n'ai mis que la fonction pour test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
if (rtc.alarmFired(1)) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm cleared");
  }

oui mais vous la mettez tout en bas... après avoir fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
  // Mettre l'alarme 1, 2 à false (donc l'alarme 1, 2 ne s'est pas produite jusqu'à présent)
  // si ce n'est pas fait, cela conduit facilement à des problèmes, car les deux registres ne sont pas réinitialisés au redémarrage/recompilation.
  rtc.clearAlarm(1);
  rtc.clearAlarm(2);

au début du setup....

**cobra38** · 04/08/2025, 11h55

Désolé mais j'ai essayé çà dans le "setup"
mais çà ne fonctionne toujours pas

11:49:51.152 -> Le réveil n'a pas été causé par un sommeil profond : 0
11:49:52.147 -> 04/08/2025
11:49:52.147 -> Calcul ephemeride au lieu 5d16'43''E - 45d39'32''N
11:49:52.147 ->
11:49:52.147 -> Date Lever Meridien Coucher
11:49:52.147 -> 04/08/2025 04:27:25 11:44:59 19:01:47
11:49:52.186 -> [ Alarme 1: 04 19:01:47, Mode: Date ]
11:49:52.186 -> --------------------
11:49:52.186 -> Boot number: 1
11:49:52.186 -> --------------------
11:49:52.186 -> 🕒 Heure actuelle DS3231 : 19:01:00 <== initialisation RTC
11:49:52.186 -> Going to sleep now
11:50:38.825 ->
11:50:38.862 -> Réveil causé par un signal externe utilisant RTC_IO
11:50:39.861 -> - Alarm Fired 04/08/2025 <=== malgré TimeSpan(1, 0, 0,0) la date reste au 04/08/2025 ????
11:50:39.899 -> Calcul ephemeride au lieu 5d16'43''E - 45d39'32''N
11:50:39.899 ->
11:50:39.899 -> Date Lever Meridien Coucher
11:50:39.899 -> 04/08/2025 04:27:25 11:44:59 19:01:47
11:50:39.899 -> [ Alarme 1: 04 19:01:47, Mode: Date ]

voici le setup

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
//****************************************//
//              SETUP                      //  
//****************************************//
void setup() {
  Serial.begin(115200);
  pinMode (ledPin, OUTPUT);
 
  char texte[80];
 
  //Imprime le motif de réveil de l'ESP32
  print_wakeup_reason();
 
  // Clignotement de la LED lorsque l'ESP32 se réveille
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
 
  // Initialiser le RTC
  if(!rtc.begin()) {
    Serial.println("Couldn't find RTC!");
    Serial.flush();
    while (1) delay(10);
  }
  // Mettre l'alarme 1, 2 à false (donc l'alarme 1, 2 ne s'est pas produite jusqu'à présent)
  // si ce n'est pas fait, cela conduit facilement à des problèmes, car les deux registres ne sont pas réinitialisés au redémarrage/recompilation.
 
 
  if(rtc.lostPower()) {
      // ceci s'ajustera à la date et à l'heure de la compilation
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
 
  DateTime now = rtc.now();   
  if (rtc.alarmFired(1)==true) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm Fired");
    DateTime now = rtc.now() + TimeSpan(1, 0, 0,0); // On ajoute 1 jour à la date en cours
  } 
 
  // Décommenter si vous avez besoin de définir l'heure du RTC
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // rtc.adjust(DateTime(2025, 8, 4,19, 00, 00)); // ajuster à l'heure UTC
 
  // Nous n'avons pas besoin de la broche 32K, il faut donc la désactiver.
  rtc.disable32K();
 
  // L'alarme déclenche une interruption
  pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);
 
  // Arrêter les signaux oscillants sur la broche SQW, sinon setAlarm1 échouera.
  rtc.writeSqwPinMode(DS3231_OFF);
 
  // Désactiver l'alarme 2 (au cas où elle ne le serait pas déjà)
 // encore une fois, cela n'est pas fait au redémarrage, de sorte qu'une alarme précédemment réglée pourrait facilement être ignorée.
  rtc.disableAlarm(2);
 
  jour = now.day();
  mois = now.month();
  annee = now.year();  
  afficherDate(jour,mois,annee);
  if(!rtc.setAlarm1(alarm1Time, DS3231_A1_Date)) {  // ce mode déclenche l'alarme lorsque la date et heure correspondantes
        Serial.println("Erreur, l'alarme n'a pas été réglée!");
  }else {
      testerEphemeride(jour,mois,annee, 1, -5, 16, 43, 45, 39, 32); // Lat : 45.6590039 & Long : 5.278757777777778  => Lat : N 45 39 32.414 & Long : E 5 16 43
  }
 
  rtc.clearAlarm(1);
  rtc.clearAlarm(2);
 
  // Incrémente le numéro de démarrage et l'imprime à chaque redémarrage
  ++bootCount;
  Serial.println("--------------------");
  Serial.println("Boot number: " + String(bootCount));
  Serial.println("--------------------");
 
  // Configuration du réveil externe
  esp_sleep_enable_ext0_wakeup(CLOCK_INTERRUPT_PIN, 0);  //1 = Haut, 0 = Bas
  // Configurer le pullup/down via RTCIO pour lier les broches de réveil à un niveau inactif pendant le sommeil profond.
  // La broche SQW du RTC est active à un niveau bas.
  rtc_gpio_pulldown_dis(CLOCK_INTERRUPT_PIN);
  rtc_gpio_pullup_en(CLOCK_INTERRUPT_PIN);
 
 
  // Heure actuelle du DS3231
  char buf[9];
  sprintf(buf, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  Serial.print("🕒 Heure actuelle DS3231 : ");
  Serial.println(buf);
 
 
  //S'endormir maintenant jusqu'à ce qu'une alarme se déclenche
  Serial.println("Going to sleep now");
  esp_deep_sleep_start();
}

**Jay M** · 04/08/2025, 16h25

quand vous faites

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  DateTime now = rtc.now();   
  if (rtc.alarmFired(1)==true) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm Fired");
    DateTime now = rtc.now() + TimeSpan(1, 0, 0,0); // On ajoute 1 jour à la date en cours
  }

la variable now qui est créée locale dans le if disparaît à la fin du if. Elle masque la variable du dessus mais ce n'est pas la même.. donc une fois sortie du if, vous revenez à la valeur d'avant le if...

===> essayez un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  DateTime now = rtc.now();   
  if (rtc.alarmFired(1)==true) {
    //rtc.clearAlarm(1);
    Serial.print(" - Alarm Fired");
    now += TimeSpan(1, 0, 0,0); // On ajoute 1 jour à la date en cours
  }

**cobra38** · 04/08/2025, 17h10

En fait , j'ai essayé ceci ( messages croisés ..)
je pense que çà fonctionne à peu près mais je dois tester en réel

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
//****************************************//
//              SETUP                      //  
//****************************************//
void setup() {
  Serial.begin(115200);
  pinMode (ledPin, OUTPUT);
 
  char texte[80];
 
  //Imprime le motif de réveil de l'ESP32
  print_wakeup_reason();
 
  // Clignotement de la LED lorsque l'ESP32 se réveille
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
 
  // Initialiser le RTC
  if(!rtc.begin()) {
    Serial.println("Couldn't find RTC!");
    Serial.flush();
    while (1) delay(10);
  }
  // Mettre l'alarme 1, 2 à false (donc l'alarme 1, 2 ne s'est pas produite jusqu'à présent)
  // si ce n'est pas fait, cela conduit facilement à des problèmes, car les deux registres ne sont pas réinitialisés au redémarrage/recompilation.
 
 
  if(rtc.lostPower()) {
      // ceci s'ajustera à la date et à l'heure de la compilation
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
 
  DateTime now = rtc.now();     <======
  jour = now.day();
  mois = now.month();
  annee = now.year();  
  if (rtc.alarmFired(1)==true) {
    rtc.clearAlarm(1);
    Serial.print(" - Alarm Fired");
    DateTime futur = rtc.now() + TimeSpan(1,0,0,0); // On ajoute 1 jour à la date en cours
    jour = futur.day();
    mois = futur.month();
    annee = futur.year(); 
  } 
 
  // Décommenter si vous avez besoin de définir l'heure du RTC
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  //rtc.adjust(DateTime(2025, 8, 4,15, 05, 00)); // ajuster à l'heure UTC
 
  // Nous n'avons pas besoin de la broche 32K, il faut donc la désactiver.
  rtc.disable32K();
 
  // L'alarme déclenche une interruption
  pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);
 
  // Arrêter les signaux oscillants sur la broche SQW, sinon setAlarm1 échouera.
  rtc.writeSqwPinMode(DS3231_OFF);
 
  // Désactiver l'alarme 2 (au cas où elle ne le serait pas déjà)
 // encore une fois, cela n'est pas fait au redémarrage, de sorte qu'une alarme précédemment réglée pourrait facilement être ignorée.
  rtc.disableAlarm(2);
 
 
  afficherDate(jour,mois,annee);
  if(!rtc.setAlarm1(alarm1Time, DS3231_A1_Date)) {  // ce mode déclenche l'alarme lorsque la date et heure correspondantes
        Serial.println("Erreur, l'alarme n'a pas été réglée!");
  }else {
      testerEphemeride(jour,mois,annee, 1, -5, 16, 43, 45, 39, 32); // Lat : 45.6590039 & Long : 5.278757777777778  => Lat : N 45 39 32.414 & Long : E 5 16 43
  }
 
  rtc.clearAlarm(1);
  rtc.clearAlarm(2);
 
  // Incrémente le numéro de démarrage et l'imprime à chaque redémarrage
  ++bootCount;
  Serial.println("--------------------");
  Serial.println("Boot number: " + String(bootCount));
  Serial.println("--------------------");
 
  // Configuration du réveil externe
  esp_sleep_enable_ext0_wakeup(CLOCK_INTERRUPT_PIN, 0);  //1 = Haut, 0 = Bas
  // Configurer le pullup/down via RTCIO pour lier les broches de réveil à un niveau inactif pendant le sommeil profond.
  // La broche SQW du RTC est active à un niveau bas.
  rtc_gpio_pulldown_dis(CLOCK_INTERRUPT_PIN);
  rtc_gpio_pullup_en(CLOCK_INTERRUPT_PIN);
 
 
  // Heure actuelle du DS3231
  char buf[9];
  sprintf(buf, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  Serial.print("🕒 Heure actuelle DS3231 : ");
  Serial.println(buf);
 
 
  //S'endormir maintenant jusqu'à ce qu'une alarme se déclenche
  Serial.println("Going to sleep now");
  esp_deep_sleep_start();
}

**Jay M** · 04/08/2025, 17h14

c'est un peu lourd en terme d'écriture puisque vous calculez deux fois

faites plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
  // on prend la date actuelle
  DateTime maintenant = rtc.now();
 
  // s'il y a eu déclenchement d'alarme on ajoute 1 jour à la date en cours et enlève l'alarme
  if (rtc.alarmFired(1)==true) {
    maintenant += TimeSpan(1,0,0,0); 
    rtc.clearAlarm(1);
    Serial.print(" - Alarm Fired");
  } 
 
  // On calcule maintenant le jour, le mois et l'année.
  jour = maintenant.day();
  mois = maintenant.month();
  annee = maintenant.year();

attention à cette partie du code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
  if(rtc.lostPower()) {
      // ceci s'ajustera à la date et à l'heure de la compilation
      rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

si votre horloge perd l'heure dans 1 mois par exemple, au prochain reboot vous allez remettre l'heure de la compilation et votre RTC ne sera plus à jour...

**cobra38** · 04/08/2025, 17h32

Ok merci bien Jay M

EDIT :
j'ai testé mais je ne dois avoir de chance car cela ne fonctionne pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
maintenant += TimeSpan(1,0,0,0);   <===== erreur compil : Compilation error: no match for 'operator+=' (operand types are 'DateTime' and 'TimeSpan')

j'ai donc essayé cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
DateTime maintenant = maintenant + TimeSpan(1,0,0,0); // On ajoute 1 jour à la date en cours

mais sans succès ....desolé

**Jay M** · 05/08/2025, 09h24

ah le += n'est pas implémenté

il faut faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
maintenant = maintenant + TimeSpan(1,0,0,0);

Envoyé par cobra38

j'ai donc essayé cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
DateTime maintenant = maintenant + TimeSpan(1,0,0,0); // On ajoute 1 jour à la date en cours

mais sans succès ....desolé

Attention, vous répétez à nouveau la faute sur la portée des variables. Lisez la doc arduino sur scope si ce concept est nouveau pour vous.

Quand vous mettez le type devant un nom de variable, vous (RE)DECLAREZ la variable. Si c'est dans un bloc séparé (le if par exemple ici) alors la durée de vie de cette variable n'est que celle du bloc, et ensuite cette variable disparait.

**Jay M** · 05/08/2025, 16h28

Vous êtes sur la bonne voie !

Convertir une date en une alarme RTC [Arduino ESP32]

Arduino

Vue hybride

Discussions similaires

Partager

Partager