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
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
|
#include "RTClib.h"
#include "driver/rtc_io.h"
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Preferences.h>
#include <Wire.h>
#include <time.h>
#include <math.h>
// 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 initialiserAffichage()
{
Serial.begin(115200);
}
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];
initialiserAffichage();
//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, 7, 29, 15, 16, 0));
// 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);
// Programmation d'une alarme
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 {
// Lat : 45.6590039 & Long : 5.278757777777778 => Lat : N 45 39 32.414 & Long : E 5 16 43
testerEphemeride(30, 07, 2025, 1, -5, 16, 43, 45, 39, 32);
Serial.println("L'alarme se déclenchera à l'heure spécifiée");
checkAlarms();
}
// 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);
DateTime now = rtc.now();
// 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();
}
//****************************************//
// 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 calculerEphemeride(int jour, int mois, int annee, double longitude_ouest, double latitude_nord, double *lever, double *meridien, double *coucher)
{
int nbjours;
const double radians = M_PI / 180.0;
double d, x, sinlat, coslat;
//calcul nb jours écoulés depuis le 01/01/2000
if (annee > 2000) annee -= 2000;
nbjours = (annee*365) + ((annee+3)>>2) + jour - 1;
switch (mois)
{
case 2 : nbjours += 31; break;
case 3 : nbjours += 59; break;
case 4 : nbjours += 90; break;
case 5 : nbjours += 120; break;
case 6 : nbjours += 151; break;
case 7 : nbjours += 181; break;
case 8 : nbjours += 212; break;
case 9 : nbjours += 243; break;
case 10 : nbjours += 273; break;
case 11 : nbjours += 304; break;
case 12 : nbjours += 334; break;
}
if ((mois > 2) && (annee&3 == 0)) nbjours++;
d = nbjours;
//calcul initial meridien & lever & coucher
x = radians * latitude_nord;
sinlat = sin(x);
coslat = cos(x);
calculerCentreEtVariation(longitude_ouest, sinlat, coslat, d + longitude_ouest/360.0, meridien, &x);
*lever = *meridien - x;
*coucher = *meridien + x;
//seconde itération pour une meilleure précision de calcul du lever
calculerCentreEtVariation(longitude_ouest, sinlat, coslat, d + *lever, lever, &x);
*lever = *lever - x;
//seconde itération pour une meilleure précision de calcul du coucher
calculerCentreEtVariation(longitude_ouest, sinlat, coslat, d + *coucher, coucher, &x);
*coucher = *coucher + x;
}
//********************************************//
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);
}
//********************************************//
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 avancerDate(int *jour, int *mois, int *annee)
{
(*jour)++;
if ((*jour>31)
|| ((*jour==31) && (*mois==2 || *mois==4 || *mois==6 || *mois==9 || *mois==11))
|| ((*jour==30) && (*mois==2))
|| ((*jour==29) && (*mois==2) && (((*annee)&3) != 0)))
{
*jour = 1;
(*mois)++;
if (*mois > 12)
{
*mois = 1;
(*annee)++;
}
}
}
int nb_calculs = 0;
unsigned long int duree_calculs = 0;
//********************************************//
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");
avancerDate(&jour, &mois, &annee);
/*------------------------------------*/
int Aannee = annee;
int Amois = mois;
int Ajour = jour;
double AheureJulienne = coucher; // exemple : 18h00 UTC le 30 juillet 2025
programmerAlarme(Aannee, Amois, Ajour, AheureJulienne);
}
}
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+2, m, s);
// qu'on utilise pour armer l'alarme1 en mode date+heure exacte
rtc.setAlarm1(alarme, DS3231_A1_Date);
//rtc.enableAlarm(DS3231_ALARM_1);
}
void calculerCentreEtVariation(double longitude_ouest, double sinlat, double coslat, double d, double *centre, double *variation)
{
//constantes précalculées par le compilateur
const double M_2PI = 2.0 * M_PI;
const double degres = 180.0 / M_PI;
const double radians = M_PI / 180.0;
const double radians2 = M_PI / 90.0;
const double m0 = 357.5291;
const double m1 = 0.98560028;
const double l0 = 280.4665;
const double l1 = 0.98564736;
const double c0 = 0.01671;
const double c1 = degres * (2.0*c0 - c0*c0*c0/4.0);
const double c2 = degres * c0*c0 * 5.0 / 4.0;
const double c3 = degres * c0*c0*c0 * 13.0 / 12.0;
const double r1 = 0.207447644182976; // = tan(23.43929 / 180.0 * M_PI / 2.0)
const double r2 = r1*r1;
const double d0 = 0.397777138139599; // = sin(23.43929 / 180.0 * M_PI)
const double o0 = -0.0106463073113138; // = sin(-36.6 / 60.0 * M_PI / 180.0)
double M,C,L,R,dec,omega,x;
//deux ou trois petites formules de calcul
M = radians * fmod(m0 + m1 * d, 360.0);
C = c1*sin(M) + c2*sin(2.0*M) + c3*sin(3.0*M);
L = fmod(l0 + l1 * d + C, 360.0);
x = radians2 * L;
R = -degres * atan((r2*sin(x))/(1+r2*cos(x)));
*centre = (C + R + longitude_ouest)/360.0;
dec = asin(d0*sin(radians*L));
omega = (o0 - sin(dec)*sinlat)/(cos(dec)*coslat);
if ((omega > -1.0) && (omega < 1.0))
*variation = acos(omega) / M_2PI;
else
*variation = 0.0;
} |
Convertir une date en une alarme RTC
Répondre avec citation
Envoyé par cobra38
Partager