Discussion :

[cobra38]

Bonjour à Tous ,

Mille pardons pour cet "arrêt" momentané mais j'étais absent ...
j'ai remarqué que vous avez enrichi le programme par des corrections et surtout abordé le problème de la mesure de tension batterie
qui reste pour moi le point noir !
J'ai tenté d'utiliser une bibliothèque dédiée au ESP32 : #include "esp_adc_cal.h" // Pour pouvoir lire la tension de la batterie
mais il semble que cette bibliothèque soit obsolète ( voir exemple de code )
et le compilateur n’apprécie pas

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
 
uint32_t getBatteryVoltage(void)
{
    float v = 0.0;
    v = (readADC_Cal(analogRead(35))) * 2;
    CLOG(myLog1.add(), "getBatteryVoltage: %f", v);
    return v;
}
 
/**
 * @brief Obtenir la tension de la batterie via la broche de la batterie
 * 
 * @param adc_raw Tension brute de la batterie d'une lecture adc.
 * @return uint32_t Tension de la batterie, par exemple 3999.0
 */
static uint32_t readADC_Cal(const int adc_raw)
{
    esp_adc_cal_characteristics_t adc_chars;
    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 1100, &adc_chars);
    return (esp_adc_cal_raw_to_voltage(adc_raw, &adc_chars));
}
 
/**
 * @brief Calculer le pourcentage approximatif de vie restante de la batterie. Renvoie une valeur 
 * entre 0-100 % arrondie à l'entier le plus proche.
 * 
 * @param v Lecture de la tension de la batterie.
 * @return int Pourcentage restant
 */
 
int calculateBatteryPercentage(double v)
{
    // cette formule a été calculée en utilisant des échantillons collectés d'une batterie lipo
    double y = -  144.9390 * v * v * v
             + 1655.8629 * v * v
             - 6158.8520 * v
             + 7501.3202;
 
    // appliquer les limites, 0-100
    y = max(y, 0.0);
 
    y = min(y, 100.0);
 
    y = round(y);
 
    return static_cast<int>(y);
}

le programme ( voir ci-dessous) fonctionne dans sa globalité
il me reste 2 points :
- la mesure de % batterie ( au travers de 2 résistances de 100k )
- une inhibition de l'alarme sous forme de tempo afin de ne pas vider ma batterie lors d'un déclenchement

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
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
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
 
//----------------------------------------------------------------------
//                        ESP32 Wroom + E-papar 2.13'
//  
//                        ===============    
//                       -|             |- 23 SDA E-paper
//                       -|             |- 22 SCL
//                       -|             |- 
//                       -|             |-
//           VBAT     35 -|             |- 21 SDA
//         Alarme     32 -|             |-                                                   
//     SQW DS3231     33 -|             |- 18 SCL E-paper                                                    
//           BUSY     25 -|             |-                                                  
//           RES      26 -|             |-                                                  
//           DC       27 -|             |-                                                         
//       VL53L0X 1    14 -|             |-                                                      
//       VL53L0X 2    12 -|             |- 02 Panneau 1 ou 2 Led Built
//                    13 -|             |- 15 CS
//                   GND -|             |- GND
//                       -|             |- 3.3V
//                        ===============
//
// I2C device found at address 0x30  !
// I2C device found at address 0x31  !
//
// I2C device found at address 0x57  !
// I2C device found at address 0x68  !
//
//   Tension VBAT   35
//   VERANDA_V260703b : 
//-----------------------------------------------------------------------							
 
 
 
//##############################################################################
#include <SPI.h>
#include "RTClib.h"
#include "driver/rtc_io.h"
#include <Wire.h>
#include <time.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_VL53L0X.h"
#include <GxEPD2_BW.h>
#include <GxEPD2_3C.h>
#include <U8g2_for_Adafruit_GFX.h>
#include <Adafruit_NeoPixel.h>
#include "ephemeride.h"
#include "affichage.h"
 
 
//###### Branchements ##########################################################
#define pinAlarm             32                   //* Alarme */
#define pinPanneau            2                   //* Panneau 1 ou 2 
 
 
//####### NeoPixels ############################################################
#define NUMPIXELS 20 // Popular NeoPixel ring size
#define DELAYVAL 200 // Time (in milliseconds) to pause between pixels
Adafruit_NeoPixel pixels(NUMPIXELS, pinAlarm , NEO_GRB + NEO_KHZ800);
 
//######## Capteurs VL50L0x#####################################################
#define pinLOX1  14                  //* Capteur 1           */
#define pinLOX2  12                  //* Capteur 2           */
#define LOX1_ADDRESS         0x31               //* Adresse I2C : 0x31  */
#define LOX2_ADDRESS         0x30               //* Adresse I2C : 0x30  */
#define maxDistance          100                //* distance max 100 mm */
Adafruit_VL53L0X LOX1      = Adafruit_VL53L0X();
Adafruit_VL53L0X LOX2      = Adafruit_VL53L0X();
VL53L0X_RangingMeasurementData_t measure1;
VL53L0X_RangingMeasurementData_t measure2;
 
//######### Mesure Batterie #####################################################
#define pinVb                35                  //* mesure BATT                                
#define VccMin               3.2                 //* Niveau minimum attendu de BAT, en Volts    
#define VccMax               4.2                 //* Niveau maximum attendu de BAT, en Volts    
const float voltage        = 0.0 ;
uint8_t percentage         = 0.0 ;
bool lowbatterie           = false ;
 
//########## DS3231 #############################################################
#define CLOCK_INTERRUPT_PIN   GPIO_NUM_33 // Définir la broche d'interruption du DS3231 (qui réveillera l'ESP32)
 
//########## Instance pour le RTC ###############################################
RTC_DS3231 rtc;
DateTime alarm1Time = DateTime(0, 0, 0, 0, 0, 0);
 
//########## Sauvegarde des variables ###########################################
RTC_DATA_ATTR bool premier_demarrage = true;
RTC_DATA_ATTR int bootCount = 0;
RTC_DATA_ATTR bool exP1 = 0;
RTC_DATA_ATTR bool exP2 = 0;
RTC_DATA_ATTR int  exjour = 0;
//########## Variables ###########################################
bool P1                    = 0;  // 0: ferme, 1: ouvert
bool P2                    = 0;  // 0: ferme, 1: ouvert
bool change                = 0;
bool activealarme          = 0;
volatile bool valarme      = 0;  
bool vVCC                  = false;
int jour;
int mois;
int annee;
int heure;
int minute;
int seconde;
int jj, hh, mm, ss;
 
char alarm1Date[12]     = "DD hh:mm:ss";
char nowDate[12]        = "DD hh:mm:ss";
char texte[80];
String(affichalarme);
String(affichmode);
 
//######### Données géographiques ###########################################
double latitude_nord = 45.6590039;
double longitude_ouest = -5.278757777777778;
double lever, meridien, coucher;
 
 
/***************************************************************/
/*               SETUP                                         */
/***************************************************************/
void setup() 
{
 
   Serial.begin(115200);
   while (!Serial) {
      delay(1);
   }
 
   // I/O 
   pinMode(pinAlarm, OUTPUT);                    // Sortie Alarme
   pinMode(pinLOX1, OUTPUT);                     // Sortie LOX1  
   pinMode(pinLOX2, OUTPUT);                     // Sortie LOX2
   pinMode(pinPanneau, OUTPUT);                  // Sortie Panneau Ouvert
   pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);   // Entrée SQW 
 
  // Capteurs Proximités activés 
   Serial.println(F("Capteurs activés..."));
   digitalWrite(pinLOX1, LOW);
   digitalWrite(pinLOX2, LOW);
   setID();
 
  // Lecture Position des panneaux 
  ReadPanels();
 
   // Lecture Tension batterie 
  //tensionbatterie(); //<==========================
 
  // Initialiser le RTC
  if(!rtc.begin()) {
    Serial.println("Impossible de trouver RTC!");
    Serial.flush();
    while (1) delay(10);
  }else{
      Serial.println("\n-----------");
      Serial.println(F("RTC = OK"));
      Serial.println("\n-----------");
  } 
 
  //* --- Décommenter si besoin de définir l'heure du RTC --------------*/
  // Attention si MAJ recommenter la ligne après modification ----------*/
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Date et Heure du compilateur
  //rtc.adjust(DateTime(2026, 7, 3, 21, 28, 30));  // Date et Heure manuelles 
  //*-------------------------------------------------------------------*/
 
  // Init Date -------------------------------  
  DateTime maintenant = rtc.now();  // on lit la date actuelle
  //* -- L'alarme déclenche une interruption ------------*/
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);
 
 
   // Timer 
  esp_sleep_enable_timer_wakeup(5000000ULL); // 5 secondes
 
  print_wakeup_reason(); //Imprime le motif de réveil de l'ESP32
 
  // On calcule la Date du Jour 
  jour = maintenant.day();
  mois = maintenant.month();
  annee = maintenant.year();
  afficherDate(jour,mois,annee);  
  Serial.println("\n-----------");
  // On calcule l'heure
  heure  = maintenant.hour();
  minute = maintenant.minute();
  seconde = maintenant.second();
  char buf[9];
  sprintf(buf, "%02d:%02d:%02d", heure, minute,seconde );
  afficherHeure(heure,minute,seconde);  // affichage date du jour
  Serial.println("\n-----------");
 
  // Test du changment de jour 
  if ((exjour) < (jour)){
    change = 1 ;
    exjour = jour;
  }
 
  // Mise à Jour de la variable Change  
  change = change || premier_demarrage || (P1 != exP1) || (P2!= exP2) ;
  Serial.println("\n-----------");
  if(change) Serial.print(F("Changement- OK! ")); else Serial.print(F("Pas de Changement"));
  Serial.println("\n-----------");
 
  // Désactiver la broche 32K et Annexes 
  rtc.disable32K(); 
  rtc.writeSqwPinMode(DS3231_OFF);
  rtc.disableAlarm(2);
 
  // Mettre l'alarme 1 à jour en fonction de l'ephemeride 
  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 {
      calculerEphemeride(jour, mois, annee, longitude_ouest, latitude_nord, &lever, &meridien, &coucher);
  }
 
  // programmation Alarme 
  programmerAlarme(annee, mois, jour, coucher); 
  CheckAlarm();
 
 
  // s'il y a eu déclenchement d'alarme 
  if (rtc.alarmFired(1)==true) {
    valarme= 1;
    change = 1;
    rtc.clearAlarm(1);
    //maintenant = maintenant + TimeSpan(1,0,0,0); // On ajoute 1 jour à la date en cours
    Serial.println(" -- Crépuscule --");
  }  
 
  // Affichage  
  if (change) {
    exP1 = P1;
    exP2 = P2;  
    premier_demarrage = false;
    InitialiseDisplay();  //<====
    Draw_Heading_Section(); // <====== 
    DrawBattery(180, 12);  //  <====== 
    DrawPanneaux(3, 14);   //  <======
    DisplayAstronomySection(3, 87); // affichage E-Paper
  }
 
  // 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);
 
  // 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); 
 
 
  //S'endormir maintenant jusqu'à ce qu'une alarme se déclenche
  // Serial.println("Going to sleep now");
  if (!valarme) esp_deep_sleep_start();  
}
 
/***************************************************************/
/*               LOOP                                          */
/***************************************************************/
void loop() {
 
    ReadPanels();
    if(valarme){
      if((P1 || P2) & !lowbatterie){
          for(int i=0; i<NUMPIXELS; i++) // For each pixel...
          { 
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // ROUGE
          pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
          delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
          pixels.setPixelColor(i, pixels.Color(0, 0, 0));
          pixels.show(); 
          } 
 
      }else if(lowbatterie){
          //digitalWrite(pinAlarm,!digitalRead(pinAlarm)); //on inverse l'état actuel de pinAlarm
          //delay(500);
          /*
          for(int i=0; i<NUMPIXELS; i++) 
          { // For each pixel...
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // ROUGE
          pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
          delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
          pixels.setPixelColor(i, pixels.Color(0, 0, 0));
          pixels.show(); 
          } 
          */  
 
      }else{
        digitalWrite(pinAlarm,LOW); // état éteint (mettre LOW si logique inverse)
        esp_deep_sleep_start(); 
      }
    }  
}
 
//#########################################################################################
// 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 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;
  h= h + 2 ; // <=== correction UTC + 2
 
  DateTime alarme(annee, mois, jour, h, m, s); // puis on fabrique un DateTime avec ces infos
  rtc.setAlarm1(alarme, DS3231_A1_Date); // qu'on utilise pour armer l'alarme1 du DS3231 en mode date+heure exacte
 
}
 
//#########################################################################################
void CheckAlarm()
{
    DateTime alarm1Time = rtc.getAlarm1();
    Ds3231Alarm1Mode alarm1mode = rtc.getAlarm1Mode();
    alarm1Time.toString(alarm1Date);
    //char alarm1Date[12]     = "DD hh:mm:ss";
    jj = (alarm1Date[0] - '0') * 10 + (alarm1Date[1] - '0');
    hh = (alarm1Date[3] - '0') * 10 + (alarm1Date[4] - '0');
    mm = (alarm1Date[6] - '0') * 10 + (alarm1Date[7] - '0');
    ss = (alarm1Date[9] - '0') * 10 + (alarm1Date[10] - '0');
    Serial.print("[ Alarme 1: ");
    Serial.print(alarm1Date);
    Serial.print(", Mode: ");
    switch (alarm1mode) {
      case DS3231_A1_PerSecond:
        Serial.println("PerSecond ]");
        affichmode = "Par Seconde";
        break;
      case DS3231_A1_Second:
        Serial.println("Second ]");
        affichmode = "Seconde";
        break;
      case DS3231_A1_Minute:
        Serial.println("Minute ]");
        affichmode = "Minute";
        break;
      case DS3231_A1_Hour:
        Serial.println("Hour ]");
         affichmode = "Heure";
        break;
      case DS3231_A1_Date:
        Serial.println("Date ]");
         affichmode = "Date";
        break;
      case DS3231_A1_Day:
        Serial.println("Day ]");
         affichmode = "Jour";
        break;
    }
 
    DateTime maintenant = rtc.now();
    maintenant.toString(nowDate);
    jour = (nowDate[0] - '0') * 10 + (nowDate[1] - '0');
    if (String(nowDate) > String(alarm1Date)) {
      if (String(jj) == String(jour)) {
        activealarme = 1 ;
      }
    }else{
      activealarme = 0 ;
    }
 
    Serial.print("");
}
 
//#########################################################################################
void onAlarm(){
}
 
//#########################################################################################
void tensionbatterie() {
  float v_mes = analogRead(pinVb); // à partir d'un pont de resistances 100kOhms
  delay(200);
  voltage = ((v_mes / 4096.0) * 3.3 ) ; 
  Serial.println("Voltage = " + String(voltage));
  if (voltage >= VccMax) percentage = 100;
  if (voltage <= VccMin) percentage = 0 ;
 
  if (voltage <= 3.62)
    percentage = 75 * pow((voltage - 3.2), 2.);
  else if (voltage <= 4.19)
    percentage = 2836.9625 * pow(voltage, 4) - 43987.4889 * pow(voltage, 3) + 255233.8134 * pow(voltage, 2) - 656689.7123 * voltage + 632041.7303;
   else
    percentage = 100;
 
  if (voltage <= 3.5)
  {
    valarme= 1;
    change = 1;
    lowbatterie = true;
    Serial.println("Batterie faible !");
  }
}
 
//######### Initialiser les capteurs VL53L0X ##############################################
void setID() {
  // tout est remis à zéro
   digitalWrite(pinLOX1, LOW);                   
   digitalWrite(pinLOX2, LOW);
   delay(20);
 
   // initialisation LOX1........................
   digitalWrite(pinLOX1, HIGH);
   delay(30);
 
   if(! LOX1.begin(LOX1_ADDRESS)) {
      Serial.println(F("Echec init VL53L0X 1"));
      while(1);
    }else{
      Serial.println(F("VL53L0X 1 = OK"));
    }
 
    // initialisation LOX2........................
   digitalWrite(pinLOX2, HIGH);
   delay(30);
   if(! LOX2.begin(LOX2_ADDRESS)) {
      Serial.println(F("Echec init VL53L0X 2"));
      while(1);
   }else{
      Serial.println(F("VL53L0X 2 = OK"));
   }
}
 
//#########################################################################################
void ReadPanels() {  
    // Capteur1 en lecture........P1 = 1 si panneau n°1 ouvert................
   Serial.println("\n-----------");
   Serial.print(F("Panneau N°1 => "));
   LOX1.rangingTest(&measure1, false);    // 'true' pour avoir les données de débogage
   P1 = (measure1.RangeMilliMeter >  maxDistance); 
   if(P1) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println();
 
   // Capteur2 en lecture...P2 = 1 si panneau n°2 ouvert.....................
   Serial.print(F("Panneau N°2 => "));
   LOX2.rangingTest(&measure2, false);  // 'true' pour avoir les données de débogage
   P2 = (measure2.RangeMilliMeter >  maxDistance);
   if(P2) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println("\n-----------");
 
   // Affichage LEDS 
     if ((P1 != 0) || (P2 != 0)) digitalWrite(pinPanneau , HIGH); else digitalWrite(pinPanneau , LOW);
 
}

[Guesset]

Bonjour,

Un schéma de montage serait certainement utile.

Les deux résistance de 100 k certainement en pont diviseur m'inquiètent un peu. Je comprends que le but est d'éviter une surconsommation, mais présenter une source présentant une impédance de 50 k à une entrée capacitive peut amener des mesures un peu aléatoires (mais je n'ai pas vérifié les caractéristiques de l'entrée analogique de l'ESP).

Il y a au moins 2 techniques pour éviter ce problème.

La première consiste à mettre une capacité sur l'entrée (donc en // avec le point milieu du pont et la masse). Cela diminuera l'impédance d'entrée. La valeur de la capacité peut être assez importante, car les lectures ont lieu une fois par réveil. Il suffit donc que RC avec R = 50k soit relativement petite devant 5 s (par exemple 0.5 s).

La seconde solution mange une broche du MPU. Elle consiste à mettre le pied du pont, constitué de deux résistances de 15 k par exemple, non pas à la masse, mais sur une broche en haute impédance dans 99% du temps et à 0 un peu avant la mesure et pendant celle-ci.

J'ai vu qu'il y avait une variable SleepHour à 23 h (+1 GMT je présume), mais il n'y a pas de réveil semble-t-il. Je ne sais pas si cette variable est toujours d'actualité. Si c'est le cas, toutes nos discussions sur la détection du début du jour d'après sont un peu caduques.

Salutations

[cobra38]

Salut Guesset

Un schéma de montage serait certainement utile.

voici le schéma

Les deux résistance de 100 k certainement en pont diviseur m'inquiètent un peu. Je comprends que le but est d'éviter une surconsommation, mais présenter une source présentant une impédance de 50 k à une entrée capacitive peut amener des mesures un peu aléatoires (mais je n'ai pas vérifié les caractéristiques de l'entrée analogique de l'ESP).

en fait, pour le schéma actuel j'ai repris le schéma du Liligo T5 E-paper


à l'origine je voulais faire ceci :

[cobra38]

Bonjour à Tous

J'ai résolu le petit problème :
- une inhibition de l'alarme sous forme de tempo afin de ne pas vider ma batterie lors d'un déclenchement

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
 
/***************************************************************/
/*               LOOP                                          */
/***************************************************************/
void loop() {
 
    ReadPanels();
    if(valarme){
     digitalWrite(pinPanneau , LOW);
      // Inversion de l'état toutes les minutes
     if (millis() - changementEtat >= dureeCycle) {
        changementEtat = millis();
        AlarmeActive = !AlarmeActive;
 
        if (!AlarmeActive) {
           digitalWrite(pinAlarm, LOW);
           pixels.clear();
           pixels.show();
        }
      }
 
      if((P1 || P2) & !lowbatterie){
        if (AlarmeActive) {
          for(int i=0; i<NUMPIXELS; i++) // For each pixel...
          { 
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // ROUGE
          pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
          delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
          pixels.setPixelColor(i, pixels.Color(0, 0, 0));
          pixels.show(); 
          } 
        } else {
          digitalWrite(pinAlarm, LOW);
          pixels.clear();
          pixels.show();
        } 
 
      }else if(lowbatterie){
        if (AlarmeActive) {
          for(int i=0; i<NUMPIXELS; i++) 
            { // For each pixel...
            pixels.setPixelColor(i, pixels.Color(127, 0, 255)); // VIOLET
            pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
            delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
            pixels.setPixelColor(i, pixels.Color(0, 0, 0));
            pixels.show(); 
            } 
        } else {
          digitalWrite(pinAlarm, LOW);
          pixels.clear();
          pixels.show();
        }   
 
      }else{
        valarme = 0;
        changementEtat = 0;
        AlarmeActive = true;
        digitalWrite(pinAlarm,LOW); // état éteint (mettre LOW si logique inverse)
        pixels.clear();
        pixels.show();
        esp_deep_sleep_start(); 
      }
    }  
}

Séquence :
Ouverture → 1 min de alarme
Puis 1 min éteint
Puis 1 min Alarme.
Puis 1 min éteint
Et ainsi de suite tant qu'un panneau reste ouvert ou que j'intervienne pour recharger la batterie

votre avis ?

[umfred]

Pour commencer, je ne sais plus si tu l'avais précisé, mais quel type de batterie tu utilises? ici les paramètres, comme indiqués en commentaires, sont ceux d'une batterie lipo
De même quand tu dis que le compilateur n'aime pas, ça serait bien de donner son message d'erreur

[cobra38]

Salut umfred

Pour commencer, je ne sais plus si tu l'avais précisé, mais quel type de batterie tu utilises?

c'est une batterie 18650

De même quand tu dis que le compilateur n'aime pas, ça serait bien de donner son message d'erreur

Voici ce que la console renvoie mais çà compile quand même

Code :

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

1
2
3
4
5
 
In file included from ...VERANDA_V260705b.ino:48:
C:\Users\Utilisateur\AppData\Local\Arduino15\packages\esp32\tools\esp32-libs\3.3.8/include/esp_adc/deprecated/include/esp_adc_cal.h:17:2: warning: #warning "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h" [-Wcpp]
   17 | #warning "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h"
      |  ^~~~~~~

[cobra38]

J'ai fait quelques mesures de consommation

Je trouve une consommation de 10mA lorsque l'UC est au repos ( panneaux fermés )
il y a quelque chose qui cloche ....

[umfred]

ta batterie est Li-ion, c'est il me semble un peu différent d'une LiPo (après je ne suis pas expert non plus)
J'ai trouvé isi un tableau donnant le pourcentage de charge en fonction de la tension mesurée https://cmbatteries.com/fr/comprendr...soc-of-battery (ça peut peut-être aidé)

Le message d'erreur est un warning qui signale que ta bibliothèque n'est plus d'actualité (bien que fonctionnelle (donc attention aux mises à jour des librairies de ton projet)

Pour les 10mA, vérifie par exemple que tu ne commandes plus la fermeture des portes (bien que fermées), que tu n'as plus de voyants d'allumés, etc

[cobra38]

Salut umfred

pour le traitement du niveau de tension batterie , j'ai fait ceci :

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
 
 
//######### Mesure Batterie #####################################################
#define pinVb                35                  //* mesure BATT                                
#define VccMin               3.2                 //* Niveau minimum attendu de BAT, en Volts    
#define VccMax               4.2                 //* Niveau maximum attendu de BAT, en Volts    
 
struct BatteryPoint {
  float voltage;
  uint8_t percent;
};
 
const BatteryPoint batteryTable[] = {
  {4.20,100},
  {4.15,95},
  {4.11,90},
  {4.08,85},
  {4.02,80},
  {3.98,75},
  {3.95,70},
  {3.91,65},
  {3.87,60},
  {3.85,55},
  {3.84,50},
  {3.82,45},
  {3.80,40},
  {3.79,35},
  {3.77,30},
  {3.75,25},
  {3.73,20},
  {3.71,15},
  {3.69,10},
  {3.61,5},
  {3.50,0}
};
 
const int tableSize = sizeof(batteryTable) / sizeof(batteryTable[0]);
 
int batteryPercent(float voltage)
{
  if (voltage >= batteryTable[0].voltage)
    return 100;
 
  if (voltage <= batteryTable[tableSize-1].voltage)
    return 0;
 
  for (int i = 0; i < tableSize - 1; i++)
  {
    if (voltage <= batteryTable[i].voltage &&
        voltage > batteryTable[i + 1].voltage)
    {
      float v1 = batteryTable[i].voltage;
      float v2 = batteryTable[i + 1].voltage;
      int p1 = batteryTable[i].percent;
      int p2 = batteryTable[i + 1].percent;
 
      return p1 + (voltage - v1) * (p2 - p1) / (v2 - v1);
    }
  }
 
  return 0;
}  
 
uint16_t lireADCmoyenne(byte pin, uint8_t nbMesures = 64)
{ uint32_t somme = 0;
  for (uint8_t i = 0; i < nbMesures; i++) 
  {
    somme += analogRead(pin);
  } return somme / nbMesures;
}
 
//const float voltage        = 0.0 ;
uint8_t percentage         = 0.0 ;
bool lowbatterie           = false ;
 
 
****/*****
 
//#########################################################################################
void tensionbatterie() {
  float v_mes = lireADCmoyenne(pinVb, 100); // à partir d'un pont de resistances 100kOhms
  float tensionBatterie = ((v_mes * 3.30f / 4095.0f) * 2 * 1.04 ) ;
  int charge = batteryPercent(tensionBatterie);
  percentage = charge; 
  Serial.print("Tension : ");
  Serial.print(tensionBatterie, 2);
  Serial.print(" V  Charge : ");
  Serial.print(charge);
  Serial.println(" %"); 
 
   
  if (tensionBatterie <= 3.5)
  {
    valarme= 1;
    change = 1;
    lowbatterie = true;
    Serial.println("Batterie faible !");
  }else{
    valarme= 0;
    change = 0;
    lowbatterie = false;
  }
  
}

Qu'en penses-tu ? pour l'instant çà a l'air de fonctionner

Pour les 10mA, vérifie par exemple que tu ne commandes plus la fermeture des portes (bien que fermées), que tu n'as plus de voyants d'allumés, etc

Je n'ai pas de voyant externe à l'UC, seul le E-paer m'affiche la position des panneaux toutes les 5s si besoin
j'ai enlevé la Led Power de l'UC et du DS3231 , j'ai changé aussi l'adresse GPIO12 en GPIO13 selon la recommandation suivante :

Par exemple, sur le module ESP32-WROVER, la broche GPIO12 est reliée à un niveau haut par une résistance externe et à un niveau bas par une résistance interne au sein de la puce ESP32. Cela signifie qu'en mode veille profonde, un courant circule à travers ces résistances externes et internes, augmentant ainsi le courant de veille profonde au-delà de sa valeur minimale.

mais cela ne change rien ...
y-a-t-il une commande à mettre avant le deep-sleep pour inhiber les entrées ?

je remets le schéma , si quelqu'un a une idée


EDIT : lorsqu'on alimente l'UC en 5V via l'entrée Vin , lorsque l'on passe en Deep-Sleep le régulateur 5V => 3.3V est toujours actif , ne serait-pas là le problème ?

[cobra38]

Bonjour à tous

Mon problème reste sans solution quoique je fasse j'aurai toujours env 10mA de consommation
car j'utilise une carte ESP32 devKit et il semblerait que le convertisseur ( CP2102 ou CH340 ) reste alimenté,
j'ai fait ce test en enlevant les périphériques :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <Arduino.h>
 
void setup()
{
    delay(1000);
 
    esp_deep_sleep_start();
}
 
void loop()
{
}

j'obtiens :
- avec le CP2102 => 10.2 mA
- avec le CH340 => 6 mA

si quelqu'un a une solution pour couper en software l'alimentation des convertisseurs en Deep-Sleep je suis preneur

[umfred]

est-ce que tu as besoin qu'il soit relié au PC dans son fonctionnement normal? parce que je suppose que tu as regardé ta consommation avec la carte connectée au PC ?

[cobra38]

Salut umfred

est-ce que tu as besoin qu'il soit relié au PC dans son fonctionnement normal? parce que je suppose que tu as regardé ta consommation avec la carte connectée au PC ?

Non, j'ai pris la précaution d'alimenter mon montage hors PC
et j'ai fait l'expérience similaire avec uPesy ESP32 low power basic
je mesure 16µA en deep sleep
ce qui démontre qu'un ESP32 devKit en deep Sleep ne peut pas descendre < 10mA
seul un ESP32 nu peut le faire mais çà ce n'est pas précisé

[Guesset]

Bonjour Cobra,

...à l'origine je voulais faire ceci :

Ton montage me paraît mieux, mais il consomme plus : Vcc/(R1+R2). La capacité fait baisser l'impédance du pont tout en filtrant les parasites. Elle peut s'appliquer avec bonheur au montage proposé initialement.

Salut

[cobra38]

merci Guesset