// =====================================================
// BOUTONS MEGA (50 boutons)
// =====================================================
 
#define BUTTON1   2
#define BUTTON2   3
#define BUTTON3   4
#define BUTTON4   5
#define BUTTON5   6
#define BUTTON6   7
#define BUTTON7   8
#define BUTTON8   9
#define BUTTON9   10
#define BUTTON10  11
#define BUTTON11  12
#define BUTTON12  13
 
#define BUTTON13  22
#define BUTTON14  23
#define BUTTON15  24
#define BUTTON16  25
#define BUTTON17  26
#define BUTTON18  27
 
// 28 = ENCODEUR A
// 30 = ENCODEUR B
 
#define BUTTON19  29
#define BUTTON20  31
#define BUTTON21  32
#define BUTTON22  33
#define BUTTON23  34
#define BUTTON24  35
#define BUTTON25  36
#define BUTTON26  37
#define BUTTON27  38
#define BUTTON28  39
#define BUTTON29  40
#define BUTTON30  41
#define BUTTON31  42
#define BUTTON32  43
#define BUTTON33  44
#define BUTTON34  45
#define BUTTON35  46
#define BUTTON36  47
#define BUTTON37  48
#define BUTTON38  49
#define BUTTON39  50
#define BUTTON40  51
#define BUTTON41  52
#define BUTTON42  53
#define BUTTON43  A0
#define BUTTON44  A1
#define BUTTON45  A2
#define BUTTON46  A3
#define BUTTON47  A4
#define BUTTON48  A5
#define BUTTON49  A6
#define BUTTON50  A7
 
// =====================================================
// TABLEAU DES PINS BOUTONS
// =====================================================
 
const byte NUM_BUTTONS = 50;
 
const byte buttonPins[NUM_BUTTONS] = {
  BUTTON1,  BUTTON2,  BUTTON3,  BUTTON4,
  BUTTON5,  BUTTON6,  BUTTON7,  BUTTON8,
  BUTTON9,  BUTTON10, BUTTON11, BUTTON12,
 
  BUTTON13, BUTTON14, BUTTON15, BUTTON16,
  BUTTON17, BUTTON18, BUTTON19, BUTTON20,
  BUTTON21, BUTTON22, BUTTON23, BUTTON24,
  BUTTON25, BUTTON26, BUTTON27, BUTTON28,
  BUTTON29, BUTTON30, BUTTON31, BUTTON32,
  BUTTON33, BUTTON34, BUTTON35, BUTTON36,
  BUTTON37, BUTTON38, BUTTON39, BUTTON40,
  BUTTON41, BUTTON42, BUTTON43, BUTTON44,
  BUTTON45, BUTTON46, BUTTON47, BUTTON48,
  BUTTON49, BUTTON50
};
 
// =====================================================
// ENCODEUR KY-040 (méthode simple)
// =====================================================
 
#define ENCODER_A 28
#define ENCODER_B 30
 
int lastCLK;
 
// =====================================================
// DONNÉES DES BOUTONS
// =====================================================
 
byte buttons[7] = {0};
 
// =====================================================
// SETUP
// =====================================================
 
void setup() {
 
  Serial.begin(115200);     // Debug
  Serial1.begin(115200);    // Vers Pro Micro
 
  // Configuration des boutons
  for (byte i = 0; i < NUM_BUTTONS; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP);
  }
 
  // Encodeur
  pinMode(ENCODER_A, INPUT_PULLUP);
  pinMode(ENCODER_B, INPUT_PULLUP);
 
  lastCLK = digitalRead(ENCODER_A);
 
  Serial.println("=== MEGA OK ===");
}
 
// =====================================================
// ENCODEUR SIMPLE
// =====================================================
 
byte readEncoderSimple() {
 
  int currentCLK = digitalRead(ENCODER_A);
 
  if (currentCLK != lastCLK) {
 
    int currentDT = digitalRead(ENCODER_B);
 
    lastCLK = currentCLK;
 
    if (currentDT != currentCLK) {
      return 1;   // droite
    } else {
      return 2;   // gauche
    }
  }
 
  return 0;
}
 
// =====================================================
// LOOP
// =====================================================
 
void loop() {
 
  // ---------------------------------------------------
  // Lecture des boutons
  // ---------------------------------------------------
 
  for (byte i = 0; i < 7; i++) buttons[i] = 0;
 
  for (byte i = 0; i < NUM_BUTTONS; i++) {
    if (!digitalRead(buttonPins[i])) {
      buttons[i / 8] |= (1 << (i % 8));
    }
  }
 
  // ---------------------------------------------------
  // Lecture encodeur
  // ---------------------------------------------------
 
  byte encoderEvent = readEncoderSimple();
 
  if (encoderEvent != 0) {
    Serial.print("ENCODEUR = ");
    Serial.println(encoderEvent);
  }
 
  // ---------------------------------------------------
  // Envoi du paquet
  // ---------------------------------------------------
 
  Serial1.write(0xAA);
  Serial1.write(buttons, 7);
  Serial1.write(encoderEvent);
 
  delay(1);
}

#include "Joystick.h"
 
// =====================================================
// BOUTONS LOCAUX
// =====================================================
 
#define joyButton1  2
#define joyButton2  3
#define joyButton3  4
#define joyButton4  5
#define joyButton5  6
#define joyButton6  7
#define joyButton7  8
#define joyButton8  9
#define joyButton9  A2
#define joyButton10 A1
#define joyButton11 A0
#define joyButton12 15
 
// =====================================================
// AXES
// =====================================================
 
#define joyRZ       A3
#define joyThrottle A3
 
// =====================================================
// TABLEAU DES BOUTONS LOCAUX
// =====================================================
 
const byte unoButtonPins[12] = {
 
joyButton1,
joyButton2,
joyButton3,
joyButton4,
joyButton5,
joyButton6,
joyButton7,
joyButton8,
joyButton9,
joyButton10,
joyButton11,
joyButton12
};
 
// =====================================================
// JOYSTICK USB
// =====================================================
//
// 12 boutons locaux
// 50 boutons Mega
// 2 boutons encodeur
//
// TOTAL = 64 boutons
//
// 0 à 11  = boutons locaux
// 12 à 61 = boutons Mega
// 62      = encodeur droite
// 63      = encodeur gauche
// =====================================================
 
Joystick_ Joystick(
  0x15,
  JOYSTICK_TYPE_JOYSTICK,
  32,
  0,
  true, true, false, false, false, true,
  false, true, false, false, false
);
 
 
// =====================================================
// DONNÉES REÇUES DE LA MEGA
// =====================================================
 
// 50 boutons = 7 octets
 
byte megaButtons[7] = {
0
};
 
// =====================================================
// ÉVÉNEMENT ENCODEUR
// =====================================================
//
// 0 = aucun mouvement
// 1 = rotation droite
// 2 = rotation gauche
// =====================================================
 
byte megaEncoderEvent = 0;
 
// =====================================================
// RÉCEPTION DES DONNÉES DE LA MEGA
// =====================================================
//
// Trame reçue :
//
// 0xAA
// + 7 octets boutons
// + 1 octet encodeur
//
// TOTAL = 9 octets
// =====================================================
 
void receiveMegaData() {
 
static byte state = 0;
 
while (Serial1.available()) {
 
 
byte data = Serial1.read();
 
 
// -------------------------------------------------
// ATTENTE DU HEADER
// -------------------------------------------------
 
if (state == 0) {
 
 
  if (data == 0xAA) {
 
    state = 1;
  }
}
 
 
// -------------------------------------------------
// RÉCEPTION DES 7 OCTETS DE BOUTONS
// -------------------------------------------------
 
else if (state >= 1 && state <= 7) {
 
 
  megaButtons[state - 1] = data;
 
  state++;
}
 
 
// -------------------------------------------------
// RÉCEPTION DE L'ÉVÉNEMENT ENCODEUR
// -------------------------------------------------
 
else if (state == 8) {
 
 
  megaEncoderEvent = data;
 
  state = 0;
}
 
 
}
}
 
// =====================================================
// SETUP
// =====================================================
 
void setup() {
 
// ---------------------------------------------------
// CONFIGURATION DES BOUTONS LOCAUX
// ---------------------------------------------------
 
for (byte i = 0; i < 12; i++) {
 
 
pinMode(
 
  unoButtonPins[i],
 
  INPUT_PULLUP
);
 
 
}
 
// ---------------------------------------------------
// LIAISON SÉRIE AVEC LA MEGA
// ---------------------------------------------------
 
Serial1.begin(115200);
 
// ---------------------------------------------------
// INITIALISATION DU JOYSTICK USB
// ---------------------------------------------------
 
Joystick.begin();
}
 
// =====================================================
// LOOP
// =====================================================
 
void loop() {
 
// ---------------------------------------------------
// RÉCEPTION DES DONNÉES DE LA MEGA
// ---------------------------------------------------
 
receiveMegaData();
 
// ---------------------------------------------------
// AXES
// ---------------------------------------------------
 
Joystick.setRzAxis(
 
 
analogRead(joyRZ)
 
 
);
 
Joystick.setThrottle(
 
 
analogRead(joyThrottle)
 
 
);
 
// ---------------------------------------------------
// BOUTONS LOCAUX
// ---------------------------------------------------
//
// Boutons joystick 0 à 11
// ---------------------------------------------------
 
for (byte i = 0; i < 12; i++) {
 
 
Joystick.setButton(
 
  i,
 
  !digitalRead(unoButtonPins[i])
);
 
 
}
 
// ---------------------------------------------------
// BOUTONS DE LA MEGA
// ---------------------------------------------------
//
// Boutons joystick 12 à 61
// ---------------------------------------------------
 
for (byte i = 0; i < 50; i++) {
 
 
byte byteNumber = i / 8;
 
 
byte bitNumber = i % 8;
 
 
bool buttonState =
 
  megaButtons[byteNumber]
  &
  (1 << bitNumber);
 
 
Joystick.setButton(
 
  12 + i,
 
  buttonState
);
 
 
}
 
// ---------------------------------------------------
// ENCODEUR ROTATIF
// ---------------------------------------------------
//
// Bouton 62 = rotation droite
// Bouton 63 = rotation gauche
//
// Chaque rotation génère une courte impulsion.
// ---------------------------------------------------
 
if (megaEncoderEvent == 1) {
  Joystick.setButton(30, true);
  delay(20);
  Joystick.setButton(30, false);
  megaEncoderEvent = 0;
}
 
else if (megaEncoderEvent == 2) {
  Joystick.setButton(31, true);
  delay(20);
  Joystick.setButton(31, false);
  megaEncoderEvent = 0;
}
 
// ---------------------------------------------------
// PETITE PAUSE
// ---------------------------------------------------
 
delay(5);
}

#include <Adafruit_LiquidCrystal.h>
Adafruit_LiquidCrystal lcd(10, 11, 5 , 4, 3, 2);  //  sur lcd => RS, E, D4, D5, D6, D7
 
int bip = 6;
const byte mosfet = 9;
const byte led = 13;
 
unsigned long currentTime = 0;
unsigned long previousTime = 0;
 
long hh = 0, mm = 0, ss = 0;
long countdown_time = (hh * 3600) + (mm * 60) + ss;
 
#define batterie 0
int tensionLue = 0;
int valeurLue = 0;
 
#define minuterie 1
int chrono_lu = 0;
int valeur_chrono = 0;
 
void setup() {
  lcd.begin(16, 2);
 
  analogReference(INTERNAL);
 
  pinMode(mosfet, OUTPUT);
  pinMode (bip, OUTPUT);
  pinMode (led, OUTPUT);
 
  pinMode(batterie, INPUT);
  digitalWrite (mosfet, HIGH);
  digitalWrite (led, LOW);
 
  lcd.setCursor( 0, 0);
  lcd.print ("Batterie>");
  lcd.setCursor (15 , 0);
  lcd.print ("V");
 
  lcd.setCursor( 0, 1);
  lcd.print ("Duree");
  lcd.setCursor (8, 1);
  lcd.print ("mn");
 
  tone(bip, 2000, 200);
  delay(150);
  tone(bip, 2800, 250);
}
 
void loop() {
 
 
  int valeur_chrono = analogRead(minuterie);
  chrono_lu = (valeur_chrono * 31 / 1023);
 
  long countdowntime_ss = countdown_time + (millis() / 1000);
 
  if (countdowntime_ss >= 0) {
 
    long countdown_hh = countdowntime_ss / 3600;
    long countdown_mm = ((countdowntime_ss / 60) % 60);
    long countdown_sec = countdowntime_ss % 60;
 
    char buffer[3];
    sprintf(buffer, "%2d", chrono_lu);
    lcd.setCursor (6, 1);
    lcd.print (buffer);   //en minutes
 
    /*char minuterie[6];
    sprintf(minuterie, "%02d:%02d", countdown_mm, countdown_sec);
    lcd.setCursor (11, 1);
    lcd.print (minuterie);*/ 
 
    sprintf(buffer, "%02d", countdown_sec);
      lcd.setCursor (14, 1);
      lcd.print (buffer);
 
      sprintf(buffer, "%02d", countdown_mm);
      lcd.setCursor (11, 1);
      lcd.print (buffer);
 
    lcd.setCursor (13, 1);
    lcd.print(":");
 
    int valeurLue = analogRead (batterie);
    float tensionLue = (valeurLue * 14.0 / 10 * 1.023);
    lcd.setCursor (11, 0);
    lcd.print (tensionLue / 100.0);
    delay(50);
 
    if (countdown_mm == 1 && chrono_lu == 1 || countdown_mm == 2 && chrono_lu  == 2 || countdown_mm == 3 && chrono_lu == 3 || countdown_mm == 4 && chrono_lu == 4
        || countdown_mm == 5 && chrono_lu == 5 || countdown_mm == 6 && chrono_lu == 6 || countdown_mm == 7 && chrono_lu == 7 || countdown_mm == 7 && chrono_lu == 7
        || countdown_mm == 8 && chrono_lu == 8 || countdown_mm == 9 && chrono_lu == 9 || countdown_mm == 10 && chrono_lu == 10 || countdown_mm == 11 && chrono_lu == 11
        || countdown_mm == 12 && chrono_lu == 12 || countdown_mm == 13 && chrono_lu == 13 || countdown_mm == 14 && chrono_lu == 14 || countdown_mm == 15 && chrono_lu == 15
        || countdown_mm == 16 && chrono_lu == 16 || countdown_mm == 17 && chrono_lu == 17 || countdown_mm == 18 && chrono_lu == 18 || countdown_mm == 19 && chrono_lu == 19
        || countdown_mm == 20 && chrono_lu == 20 || countdown_mm == 21 && chrono_lu == 21 || countdown_mm == 22 && chrono_lu == 22 || countdown_mm == 23 && chrono_lu == 23
        || countdown_mm == 24 && chrono_lu == 24 || countdown_mm == 25 && chrono_lu == 25 || countdown_mm == 26 && chrono_lu == 26 || countdown_mm == 27 && chrono_lu == 27
        || countdown_mm == 28 && chrono_lu == 28 || countdown_mm == 29 && chrono_lu == 29 || countdown_mm == 30 && chrono_lu == 30) {
 
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(300);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(300);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2800, 200);
      delay(300);
      tone(bip, 2800, 200);
      delay(900);
      tone(bip, 2000, 800);
      delay(900);
      digitalWrite (mosfet, LOW);
      digitalWrite (led, HIGH);
 
    }
  }
}

16:11:51.333 -> Capteurs activées...
16:11:51.607 -> VL53L0X 1 = OK
16:11:52.170 -> VL53L0X 2 = OK
16:11:52.170 ->  RTC = OK
16:11:52.170 -> Réveil provoqué par la minuterie
16:11:52.170 -> 08/06/2026
16:11:52.208 -> -----------
16:11:52.208 -> 16:09:56
16:11:52.208 -> -----------
16:11:52.208 -> Panneau N°1 => - Ouvert
16:11:52.208 -> Panneau N°2 => - Fermé
16:11:52.254 -> 
16:11:52.254 -> -----------
16:11:52.254 -> Pas de Changement
16:11:52.254 -> -----------
16:11:52.432 -> Voltage = 4.02
16:11:52.471 -> Lever : 03:51:34
16:11:52.471 -> Meridien : 11:37:58
16:11:52.471 -> Coucher : 19:24:42
16:12:02.509 -> Busy Timeout!  <===================
16:12:12.484 -> Busy Timeout!  <===================
16:12:22.507 -> Busy Timeout!  <===================
16:12:32.487 -> Busy Timeout!  <===================
16:12:32.487 -> [ Alarme 1: 08 21:24:42, Mode: Date ]
16:12:32.487 -> --------------------
16:12:32.487 -> Boot number: 56
16:12:32.532 -> --------------------

 
//----------------------------------------------------------------------
//                        Lilygo T5 ESP32 E-paper
//  
//                        ===============    
//                  3.3V -|             |- 
//                  GND -|             |- 
//             SDA  21 -|             |- 
//                         -|             |-
//                         -|             |- 3.3V
//             SCL  22 -|             |- 32  Alarme
//                         -|             |- 33  SQW DS3231
//  VL53L0X 1   14 -|             |- 25  Panneau 2
//                         -|             |- 26  Panneau 1
//  VL53L0X 2   15 -|             |- 27  LDR
//                         -|             |- 
//                    5V -|             |- 
//                VBAT -|             |- GND
//                        ===============
//
// I2C device found at address 0x30  !
// I2C device found at address 0x31  !
// I2C device found at address 0x38  !
// I2C device found at address 0x57  !
// I2C device found at address 0x68  !
//
//   Tension VBAT   35
//   VERANDA_V260608a : 
//-----------------------------------------------------------------------							
 
/**** Branchements *****************************************************/ 
#define pinAlarm             32                   //* Alarme */
#define pinP1                25                   //* Panneau 1 ouvert */
#define pinP2                26                   //* Panneau 2 ouvert /*
 
/********************************************************************/
#include <SPI.h>
#include "RTClib.h"
#include "driver/rtc_io.h"
#include <Wire.h>
#include <time.h>
#include <Adafruit_AHTX0.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_VL53L0X.h"
#include <GxEPD2_BW.h>
#include <U8g2_for_Adafruit_GFX.h>
#include <Adafruit_NeoPixel.h>
#include "ephemeride.h"
#include "affichage.h"
/*********************************************************************/
 
/******* Declarations ************************************************/
 
//------------------ AHT10  ---------------------------
Adafruit_AHTX0 aht; // I2C device found at address 0x38
//------------------ NeoPixel  ---------------------------
#define NUMPIXELS 10 // Popular NeoPixel ring size
#define DELAYVAL 200 // Time (in milliseconds) to pause between pixels
Adafruit_NeoPixel pixels(NUMPIXELS, pinAlarm , NEO_GRB + NEO_KHZ800);
// ------------Capteurs vl53l0x..............................
#define pinLOX1  14                  //* Capteur 1           */
#define pinLOX2  15                  //* 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 ;
//---------------- DS3231 ---------------------------------------
// Définir la broche d'interruption du DS3231 (qui réveillera l'ESP32)
#define CLOCK_INTERRUPT_PIN   GPIO_NUM_33 
// --------------sauvegarde 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;
// -----Instance pour le RTC -----------------------------------
RTC_DS3231 rtc;
DateTime alarm1Time = DateTime(0, 0, 0, 0, 0, 0);
// -----Variables ----------------------------------------------
bool P1                    = 0;  // 0: ferme, 1: ouvert
bool P2                    = 0;  // 0: ferme, 1: ouvert
bool change                = 0;
int pp                     = 0;
int tt                     = 0;
int hh                     = 0;
bool n1                    = 0;
bool n2                    = 0;
int  valarme               = 0;
bool vVCC                  = false;
 
float AHT_Temp = 0 ;
float AHT_Humidite = 0;
int jour;
int mois;
int annee;
int heure;
int minute;
int seconde;
char alarm1Date[12] = "DD hh:mm:ss";
String(affichalarme);
String(affichmode);
 
// ------- Données Géographiques --------------------------------
double latitude_nord = 45.6590039;
double longitude_ouest = -5.278757777777778;
double lever, meridien, coucher;
 
/*************************************************/
long SleepDuration = 10; // Temps de sommeil en minutes, aligné sur la limite de la minute la plus proche, donc si 30, la mise à jour se fera toujours à 00 ou 30 heures passées.
int  WakeupHour    = 7;  // Ne pas se réveiller avant 07h00 pour économiser la batterie
int  SleepHour     = 23; // Mise en veille après (23+1) 00:00 pour économiser la batterie
int  CurrentHour = 0, CurrentMin = 0, CurrentSec = 0;
long StartTime = 0;
/*************************************************/
 
/***************************************************************/
/*               SETUP                                         */
/***************************************************************/
void setup() 
{
   StartTime = millis();
   Serial.begin(115200);
   delay(500);
   pinMode(pinAlarm, OUTPUT);                    // Sortie Alarme
   pinMode(pinLOX1, OUTPUT);                     // Sortie LOX1  
   pinMode(pinLOX2, OUTPUT);                     // Sortie LOX2
   pinMode(pinP1, OUTPUT);                       // Sortie Panneau 1 Ouvert
   pinMode(pinP2, OUTPUT);                       // Sortie Panneau 2 Ouvert
 
  // Capteurs Proximités activés 
   Serial.println(F("Capteurs activées..."));
   digitalWrite(pinLOX1, LOW);
   digitalWrite(pinLOX2, LOW);
   setID();
 
  esp_sleep_enable_timer_wakeup(5000000ULL); // 5 secondes
 
  // Initialiser le RTC
  if(!rtc.begin()) {
    Serial.println("Impossible de trouver RTC!");
    Serial.flush();
    while (1) delay(10);
  }else{
      Serial.println(F(" RTC = OK"));
  }  
  // Initialiser le AHT10
  /*
  if (! aht.begin()) {
    Serial.println("Impossible de trouver l'AHT ? Vérifier le câblage");
    while (1) delay(10);
  }else{
    Serial.println(F(" AHT10 = OK"));
  }	
  */
 
   char texte[80];
   print_wakeup_reason(); //Imprime le motif de réveil de l'ESP32
 
  // Clignotement de la LED lorsque l'ESP32 se réveille
  //pinMode (pinAlarm, OUTPUT);
  //digitalWrite(pinAlarm, HIGH);
  //delay(1000);
  //digitalWrite(pinAlarm, LOW);
 
 
 
  // Init Date -------------------------------  
  DateTime maintenant = rtc.now();  // on lit la date actuelle
  // 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) {
    rtc.clearAlarm(1);
    maintenant = maintenant + TimeSpan(1,0,0,0); // On ajoute 1 jour à la date en cours
    Serial.println(" -Alarme réactualisée-");
  }
 
  // On calcule la Date du Jour -------------
  double lever, meridien, coucher;
  jour = maintenant.day();
  mois = maintenant.month();
  annee = maintenant.year();
  afficherDate(jour,mois,annee);  
  Serial.println("\n-----------");
   // On calcule l'heure UTC 
  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-----------");
 
  // Lecture Position des panneaux
  ReadPanels();
  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-----------");
  // Lecture Tension batterie
  tensionbatterie();
  // Lecture AHT10
  //Temp_Hum_Section();
 
  /* --- Décommenter si besoin de définir l'heure du RTC ----*/
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  //rtc.adjust(DateTime(2026, 6, 8,13, 07, 00)); // Attention mettre à l'heure UTC
  /*-------------------------------------------------------------------*/
 
  rtc.disable32K();   // Désactiver la broche 32K
  rtc.writeSqwPinMode(DS3231_OFF);
  rtc.disableAlarm(2);
 
   // L'alarme déclenche une interruption
  pinMode(CLOCK_INTERRUPT_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLOCK_INTERRUPT_PIN), onAlarm, FALLING);
 
 
 
  /* 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 {
      //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
      //calculerEphemeride(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
      calculerEphemeride(jour, mois, annee, longitude_ouest, latitude_nord, &lever, &meridien, &coucher);
      Serial.print("Lever : ");
      afficherHeureJulienne(lever);
      Serial.print("Meridien : ");
      afficherHeureJulienne(meridien);
      Serial.print("Coucher : ");
      afficherHeureJulienne(coucher); 
      full_sreeen();
      //display.display(false); // Full screen update mode 
  }
 
  programmerAlarme(annee, mois, jour, coucher); 
  checkDate(); 
 
 
  // Affichage  
  if (change) {
    exP1 = P1;
    exP2 = P2;  
    premier_demarrage = false;
    InitialiseDisplay();  //<====
    Draw_Heading_Section(); // <====== 
    DrawBattery(190, 12);  //  <====== 
    DrawPanneaux(5, 15);   //  <======
    Draw_Temp_Hum_Section(192,15); // <====== 
    DisplayAstronomySection(10, 10); // 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");
  esp_deep_sleep_start();  
  //BeginSleep();
}
 
/***************************************************************/
/*               LOOP                                          */
/***************************************************************/
void loop() {}
 
//#########################################################################################
void BeginSleep() {
  powerOff();
  long SleepTimer = (SleepDuration * 60 - ((CurrentMin % SleepDuration) * 60 + CurrentSec)); //Certaines ESP32 sont trop rapides pour maintenir une heure précise
  esp_sleep_enable_timer_wakeup((SleepTimer + 20) * 1000000LL); // Ajout de +20 secondes pour couvrir les imprécisions de la source du timer RTC de l'ESP32
 
  Serial.println("Entering " + String(SleepTimer) + "-secs of sleep time");
  Serial.println("Awake for : " + String((millis() - StartTime) / 1000.0, 3) + "-secs");
  Serial.println("Starting deep-sleep period...");
  esp_deep_sleep_start();  // Sleep for e.g. 30 minutes
}
 
//#########################################################################################
// 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
  //rtc.enableAlarm(DS3231_ALARM_1);
}
 
 
//#########################################################################################
void checkDate()
{
    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 ]");
        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;
    }
    //affichalarme = alarm1Date;
    affichalarme = "Alarme => ";
    affichalarme += alarm1Date;
    affichalarme += " - En Mode: ";
    affichalarme += affichmode;
    affichalarme +=  " ";
    Serial.print("");
}
 
 
//#########################################################################################
void onAlarm(){
  Serial.print("Une alarme s'est produite!");
 
}
 
/*****************************************************************/
void tensionbatterie() {
  float v_mes = analogRead(pinVb);
  delay(200);
  //float voltage = 1.435*(v_mes/4095)*3.3;
  float voltage = 2*(v_mes/4095)*3.3;
  Serial.println("Voltage = " + String(voltage));
  percentage = 2836.9625 * pow(voltage, 4) - 43987.4889 * pow(voltage, 3) + 255233.8134 * pow(voltage, 2) - 656689.7123 * voltage + 632041.7303;
  if (voltage >= 4.20) percentage = 100;
  if (voltage <= 3.20) percentage = 0 ;
 
}
 
/*******************************************************************/
void Temp_Hum_Section() {
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data
  AHT_Temp = temp.temperature;
  AHT_Humidite = humidity.relative_humidity;
  Serial.print("Temperature: "); Serial.print(temp.temperature,1); Serial.println(" degrees C");
  Serial.print("Humidity: "); Serial.print(humidity.relative_humidity,0); Serial.println("% rH");
 
} 
 
/*****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"));
   }
}
 
 
 
/***************** PANNEAUX ********************************/
void ReadPanels() {  
 
   // Capteur1 en lecture........P1 = 1 si panneau n°1 ouvert................
   Serial.print(F("Panneau N°1 => "));
   LOX1.rangingTest(&measure1, false);    // 'true' pour avoir les données de débogage
   P1 = (measure1.RangeMilliMeter >  maxDistance); 
   //Serial.print(P1);
   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();
 
   // Affichage LEDS 
     if (P1 != 0) digitalWrite(pinP1 , HIGH); else digitalWrite(pinP1 , LOW);
     if (P2 != 0) digitalWrite(pinP2 , HIGH); else digitalWrite(pinP2 , LOW);
 
}
 
/******** Traitement Alarme ******************************/
void alarme() { 
 
   Serial.print(F("Alarme: "));    Serial.print(valarme);      Serial.println();
 
   /*
   for(int i=0; i<NUMPIXELS; i++) 
	 { // For each pixel...
       
       if (valarme==1){
          pixels.setPixelColor(i, pixels.Color(255, 0, 255)); // Sombre = VIOLET
       }
       if (valarme==2){
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // Pluie = ROUGE
       }   
       if (valarme==3){
          pixels.setPixelColor(i, pixels.Color(0, 255, 0)); // Batterie = VERT
       }
        
        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(); 
   }
   */
}
 
/*** Alarme OFF *****************************************/
void alarmeOFF() { 
    /*
    pixels.clear();
	  pixels.show(); 
    digitalWrite(pinP1 , LOW);
    digitalWrite(pinP2 , LOW);
	  valarme = 0;
    */
}

 
#ifndef TFT_DRIVER_H
#define TFT_DRIVER_H
 
#include <Arduino.h>
#include <SPI.h>
#include "hw_config.h"
 
#define TFT_SWRESET   0x01
#define TFT_SLPOUT    0x11
#define TFT_COLMOD    0x3A
#define TFT_MADCTL    0x36
#define TFT_CASET     0x2A
#define TFT_RASET     0x2B
#define TFT_RAMWR     0x2C
#define TFT_DISPON    0x29
#define TFT_DISPOFF   0x28
#define TFT_INVON     0x21
#define TFT_INVOFF    0x20
 
#define DISPLAY_WIDTH  280  
#define DISPLAY_HEIGHT 240
 
#define ST7789_COL_OFFSET 20  <====( affichage prévu initialement pour un ST7789 )
 
#define TFT_BLACK   0x0000
#define TFT_WHITE   0xFFFF
#define TFT_RED     0xF800
#define TFT_GREEN   0x07E0
#define TFT_BLUE    0x001F
 
static const uint8_t font_5x7[] PROGMEM = {
    0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ' '
    0x00, 0x00, 0x5F, 0x00, 0x00, // 0x21 '!'
    0x00, 0x07, 0x00, 0x07, 0x00, // 0x22 '"'
    0x14, 0x7F, 0x14, 0x7F, 0x14, // 0x23 '#'
    0x24, 0x2A, 0x7F, 0x2A, 0x12, // 0x24 '$'
    0x23, 0x13, 0x08, 0x64, 0x62, // 0x25 '%'
    0x36, 0x49, 0x55, 0x22, 0x50, // 0x26 '&'
    0x00, 0x05, 0x03, 0x00, 0x00, // 0x27 '''
    0x00, 0x1C, 0x22, 0x41, 0x00, // 0x28 '('
    0x00, 0x41, 0x22, 0x1C, 0x00, // 0x29 ')'
    0x14, 0x08, 0x3E, 0x08, 0x14, // 0x2A '*'
    0x08, 0x08, 0x3E, 0x08, 0x08, // 0x2B '+'
    0x00, 0x50, 0x30, 0x00, 0x00, // 0x2C ','
    0x08, 0x08, 0x08, 0x08, 0x08, // 0x2D '-'
    0x00, 0x60, 0x60, 0x00, 0x00, // 0x2E '.'
    0x20, 0x10, 0x08, 0x04, 0x02, // 0x2F '/'
    0x3E, 0x51, 0x49, 0x45, 0x3E, // 0x30 '0'
    0x00, 0x42, 0x7F, 0x40, 0x00, // 0x31 '1'
    0x42, 0x61, 0x51, 0x49, 0x46, // 0x32 '2'
    0x21, 0x41, 0x45, 0x4B, 0x31, // 0x33 '3'
    0x18, 0x14, 0x12, 0x7F, 0x10, // 0x34 '4'
    0x27, 0x45, 0x45, 0x45, 0x39, // 0x35 '5'
    0x3C, 0x4A, 0x49, 0x49, 0x30, // 0x36 '6'
    0x01, 0x71, 0x09, 0x05, 0x03, // 0x37 '7'
    0x36, 0x49, 0x49, 0x49, 0x36, // 0x38 '8'
    0x06, 0x49, 0x49, 0x29, 0x1E, // 0x39 '9'
    0x00, 0x36, 0x36, 0x00, 0x00, // 0x3A ':'
    0x00, 0x56, 0x36, 0x00, 0x00, // 0x3B ';'
    0x08, 0x14, 0x22, 0x41, 0x00, // 0x3C '<'
    0x14, 0x14, 0x14, 0x14, 0x14, // 0x3D '='
    0x00, 0x41, 0x22, 0x14, 0x08, // 0x3E '>'
    0x02, 0x01, 0x51, 0x09, 0x06, // 0x3F '?'
    0x32, 0x49, 0x79, 0x41, 0x3E, // 0x40 '@'
    0x7E, 0x11, 0x11, 0x11, 0x7E, // 0x41 'A'
    0x7F, 0x49, 0x49, 0x49, 0x36, // 0x42 'B'
    0x3E, 0x41, 0x41, 0x41, 0x22, // 0x43 'C'
    0x7F, 0x41, 0x41, 0x22, 0x1C, // 0x44 'D'
    0x7F, 0x49, 0x49, 0x49, 0x41, // 0x45 'E'
    0x7F, 0x09, 0x09, 0x09, 0x01, // 0x46 'F'
    0x3E, 0x41, 0x49, 0x49, 0x7A, // 0x47 'G'
    0x7F, 0x08, 0x08, 0x08, 0x7F, // 0x48 'H'
    0x00, 0x41, 0x7F, 0x41, 0x00, // 0x49 'I'
    0x20, 0x40, 0x41, 0x3F, 0x01, // 0x4A 'J'
    0x7F, 0x08, 0x14, 0x22, 0x41, // 0x4B 'K'
    0x7F, 0x40, 0x40, 0x40, 0x40, // 0x4C 'L'
    0x7F, 0x02, 0x0C, 0x02, 0x7F, // 0x4D 'M'
    0x7F, 0x04, 0x08, 0x10, 0x7F, // 0x4E 'N'
    0x3E, 0x41, 0x41, 0x41, 0x3E, // 0x4F 'O'
    0x7F, 0x09, 0x09, 0x09, 0x06, // 0x50 'P'
    0x3E, 0x41, 0x51, 0x21, 0x5E, // 0x51 'Q'
    0x7F, 0x09, 0x19, 0x29, 0x46, // 0x52 'R'
    0x46, 0x49, 0x49, 0x49, 0x31, // 0x53 'S'
    0x01, 0x01, 0x7F, 0x01, 0x01, // 0x54 'T'
    0x3F, 0x40, 0x40, 0x40, 0x3F, // 0x55 'U'
    0x1F, 0x20, 0x40, 0x20, 0x1F, // 0x56 'V'
    0x7F, 0x20, 0x18, 0x20, 0x7F, // 0x57 'W'
    0x63, 0x14, 0x08, 0x14, 0x63, // 0x58 'X'
    0x03, 0x04, 0x78, 0x04, 0x03, // 0x59 'Y'
    0x61, 0x51, 0x49, 0x45, 0x43, // 0x5A 'Z'
    0x00, 0x7F, 0x41, 0x41, 0x00, // 0x5B '['
    0x02, 0x04, 0x08, 0x10, 0x20, // 0x5C '\'
    0x00, 0x41, 0x41, 0x7F, 0x00, // 0x5D ']'
    0x04, 0x02, 0x01, 0x02, 0x04, // 0x5E '^'
    0x40, 0x40, 0x40, 0x40, 0x40, // 0x5F '_'
    0x00, 0x01, 0x02, 0x04, 0x00, // 0x60 '`'
    0x20, 0x54, 0x54, 0x54, 0x78, // 0x61 'a'
    0x7F, 0x48, 0x44, 0x44, 0x38, // 0x62 'b'
    0x38, 0x44, 0x44, 0x44, 0x20, // 0x63 'c'
    0x38, 0x44, 0x44, 0x48, 0x7F, // 0x64 'd'
    0x38, 0x54, 0x54, 0x54, 0x18, // 0x65 'e'
    0x08, 0x7E, 0x09, 0x01, 0x02, // 0x66 'f'
    0x0C, 0x52, 0x52, 0x52, 0x3E, // 0x67 'g'
    0x7F, 0x08, 0x04, 0x04, 0x78, // 0x68 'h'
    0x00, 0x44, 0x7D, 0x40, 0x00, // 0x69 'i'
    0x20, 0x40, 0x44, 0x3D, 0x00, // 0x6A 'j'
    0x7F, 0x10, 0x28, 0x44, 0x00, // 0x6B 'k'
    0x00, 0x41, 0x7F, 0x40, 0x00, // 0x6C 'l'
    0x7C, 0x04, 0x18, 0x04, 0x78, // 0x6D 'm'
    0x7C, 0x08, 0x04, 0x04, 0x78, // 0x6E 'n'
    0x38, 0x44, 0x44, 0x44, 0x38, // 0x6F 'o'
    0x7C, 0x14, 0x14, 0x14, 0x08, // 0x70 'p'
    0x08, 0x14, 0x14, 0x18, 0x7C, // 0x71 'q'
    0x7C, 0x08, 0x04, 0x04, 0x08, // 0x72 'r'
    0x48, 0x54, 0x54, 0x54, 0x20, // 0x73 's'
    0x04, 0x3F, 0x44, 0x40, 0x20, // 0x74 't'
    0x3C, 0x40, 0x40, 0x20, 0x7C, // 0x75 'u'
    0x1C, 0x20, 0x40, 0x20, 0x1C, // 0x76 'v'
    0x3C, 0x40, 0x30, 0x40, 0x3C, // 0x77 'w'
    0x44, 0x28, 0x10, 0x28, 0x44, // 0x78 'x'
    0x0C, 0x50, 0x50, 0x50, 0x3C, // 0x79 'y'
    0x44, 0x64, 0x54, 0x4C, 0x44, // 0x7A 'z'
    0x00, 0x08, 0x36, 0x41, 0x00, // 0x7B '{'
    0x00, 0x00, 0x7F, 0x00, 0x00, // 0x7C '|'
    0x00, 0x41, 0x36, 0x08, 0x00, // 0x7D '}'
    0x10, 0x08, 0x08, 0x10, 0x08, // 0x7E '~'
    0x00, 0x00, 0x00, 0x00, 0x00  // 0x7F DEL
};
 
class TFTDriver {
private:
    static constexpr int TFT_DC = 15;
    static constexpr int TFT_RST = 9;
    static constexpr int TFT_CS = 10;
    static constexpr int TFT_SCK = 12;
    static constexpr int TFT_MOSI = 11;
    static constexpr int TFT_MISO = -1;
 
    void spi_write_cmd(uint8_t cmd) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, LOW);  
        SPI.write(cmd);
        digitalWrite(TFT_DC, HIGH);
        digitalWrite(TFT_CS, HIGH);
    }
 
    void spi_write_byte(uint8_t data) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
        SPI.write(data);
        digitalWrite(TFT_CS, HIGH);
    }
 
    void spi_write_word(uint16_t data) {
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH); 
        SPI.write16(data);
        digitalWrite(TFT_CS, HIGH);
    }
  public:
    TFTDriver() {}
 
    void init() {
        pinMode(TFT_DC, OUTPUT);
        pinMode(TFT_RST, OUTPUT);
        pinMode(TFT_CS, OUTPUT);
 
        digitalWrite(TFT_CS, HIGH);
        digitalWrite(TFT_DC, HIGH);
 
        SPI.begin(TFT_SCK, TFT_MISO, TFT_MOSI, TFT_CS);
        SPI.setFrequency(80000000);
	//SPI.setFrequency(40000000);
        SPI.setDataMode(SPI_MODE0);
        SPI.setBitOrder(MSBFIRST);
 
        digitalWrite(TFT_RST, HIGH);
        delay(30);
        digitalWrite(TFT_RST, LOW);
        delay(30);
        digitalWrite(TFT_RST, HIGH);
        delay(30);
 
        spi_write_cmd(TFT_SWRESET);
        delay(30);
 
        spi_write_cmd(TFT_SLPOUT);
        delay(50);
 
        spi_write_cmd(TFT_COLMOD);
        spi_write_byte(0x55);  
 
        delay(5);
 
        spi_write_cmd(TFT_MADCTL);
        //spi_write_byte(0x60);  // Landscape: rotate 90°        <====== valeur d'origine 
	spi_write_byte(0x70);  // <==== test 
        delay(5);
 
        spi_write_cmd(TFT_CASET);
        spi_write_cmd(TFT_RASET);
        delay(5);
 
        fillScreen(TFT_BLACK);
        delay(20);
 
        spi_write_cmd(TFT_DISPON);
        delay(50);
 
        spi_write_cmd(TFT_INVOFF);
        delay(10);
 
    }
 
    void fillScreen(uint16_t color) {
        spi_write_cmd(TFT_CASET);
        spi_write_word(ST7789_COL_OFFSET);
        spi_write_word(ST7789_COL_OFFSET + DISPLAY_WIDTH - 1);
 
        spi_write_cmd(TFT_RASET);
        spi_write_word(0);
        spi_write_word(DISPLAY_HEIGHT - 1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
 
        uint32_t pixel_count = (uint32_t)DISPLAY_WIDTH * DISPLAY_HEIGHT;
        static uint8_t buffer[512];  
 
        uint8_t high = color >> 8;
        uint8_t low = color & 0xFF;
        for (int i = 0; i < 512; i += 2) {
            buffer[i] = high;
            buffer[i + 1] = low;
        }
 
        for (uint32_t i = 0; i < pixel_count; i += 256) {
            uint32_t chunk_size = (pixel_count - i > 256) ? 256 : (pixel_count - i);
            SPI.writeBytes(buffer, chunk_size * 2);
        }
 
        digitalWrite(TFT_CS, HIGH);
    }
 
    void pushImage(int x, int y, int w, int h, const uint16_t *data, bool preswapped = false) {
 
        spi_write_cmd(TFT_CASET);
        spi_write_word(x + ST7789_COL_OFFSET);
        spi_write_word(x + w - 1 + ST7789_COL_OFFSET);
 
        spi_write_cmd(TFT_RASET);
        spi_write_word(y);
        spi_write_word(y + h - 1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);  
 
        uint32_t pixel_count = (uint32_t)w * h;
 
        static uint8_t buffer[1024];  
 
        for (uint32_t i = 0; i < pixel_count; i += 512) {
            uint32_t chunk_size = (pixel_count - i > 512) ? 512 : (pixel_count - i);
            if (preswapped) { 
                SPI.writeBytes((const uint8_t *)&data[i], chunk_size * 2);
            } else {
                for (uint32_t j = 0; j < chunk_size; j++) {
                    uint16_t pixel = data[i + j];
                    buffer[j * 2] = pixel >> 8;      
                    buffer[j * 2 + 1] = pixel & 0xFF;  
                }
                SPI.writeBytes(buffer, chunk_size * 2);
            }
        }
 
        digitalWrite(TFT_CS, HIGH);
    } 
    void drawChar(int x, int y, char c, uint16_t fg, uint16_t bg, int scale = 1) {
        if (scale < 1) {
            scale = 1;
        }
 
        uint8_t idx = (c >= 0x20 && c <= 0x7F) ? static_cast<uint8_t>(c - 0x20) : static_cast<uint8_t>('?' - 0x20);
        const uint8_t *glyph = &font_5x7[idx * 5];
 
        for (int cy = 0; cy < 7; cy++) {
            for (int cx = 0; cx < 5; cx++) {
                uint8_t line = pgm_read_byte(&glyph[cx]);
                if (line & (1 << cy)) {
                    drawFilledRect(x + cx * scale, y + cy * scale, scale, scale, fg);
                } else {
                    drawFilledRect(x + cx * scale, y + cy * scale, scale, scale, bg);
                }
            }
        }
    }
 
    void drawFilledRect(int x, int y, int w, int h, uint16_t color) {
        if (w <= 0 || h <= 0) {
            return;
        }
 
        int x0 = max(0, x);
        int y0 = max(0, y);
        int x1 = min(DISPLAY_WIDTH - 1, x + w - 1);
        int y1 = min(DISPLAY_HEIGHT - 1, y + h - 1);
 
        if (x1 < x0 || y1 < y0) {
            return;
        }
 
        int clipped_w = x1 - x0 + 1;
        int clipped_h = y1 - y0 + 1;
 
        spi_write_cmd(TFT_CASET);
        spi_write_word(x0 + ST7789_COL_OFFSET);
        spi_write_word(x1 + ST7789_COL_OFFSET);
 
        spi_write_cmd(TFT_RASET);
 
        spi_write_word(y0);
        spi_write_word(y1);
 
        spi_write_cmd(TFT_RAMWR);
 
        digitalWrite(TFT_CS, LOW);
        digitalWrite(TFT_DC, HIGH);
 
        uint32_t pixels = (uint32_t)clipped_w * clipped_h;
 
        for (uint32_t i = 0; i < pixels; i++) {
             SPI.write16(color);
        }
 
         digitalWrite(TFT_CS, HIGH);
    }
 
    void drawNumber(int x, int y, int num, uint16_t fg, uint16_t bg, int scale = 1) {
        if (num < 0) num = 0;
        char buf[10];
        sprintf(buf, "%d", num);
 
        int px = x;
        for (int i = 0; buf[i] != '\0'; i++) {
            drawChar(px, y, buf[i], fg, bg, scale);
            px += (5 + 1) * scale; 
        }
    }
 
    void drawString(int x, int y, const char *str, uint16_t fg, uint16_t bg, int scale = 1) {
        int px = x;
        for (int i = 0; str[i] != '\0'; i++) {
            drawChar(px, y, str[i], fg, bg, scale);
            px += (5 + 1) * scale;  
            }
        }
 
        static uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
        return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
        }
   };
#endif

 
spi_write_cmd(TFT_MADCTL);
        //spi_write_byte(0x60);  // Landscape: rotate 90°
	spi_write_byte(0x70);  //
        delay(5);

 
/***************************************
          ESP32C3 Mini
          adresse IP:192.168.1.150
          Version : Test_V20260422a
          
                         _____
                   |----|     |-----|
                   |    |_____|     |
           GPIO5   | 5           5V | 
    E-SDA  GPIO6   | 6            G | 
       CS  GPIO7   | 7          3V3 |    
  AHT-SDA  GPIO8   | 8            4 | GPIO4     E-SCL
  AHT-SCL  GPIO9   | 9            3 | GPIO3     BUSY
   DS18B20 GPIO10  | 10           2 | GPIO2     RES
           GPIO20  | 20           1 | GPIO1     DC
           GPIO21  | 21           0 | GPIO0     VBat
                   \------------- --/
                           
*************************************/
 
#include <WiFi.h>
#include <Wire.h>
#include <ArduinoOTA.h>
#include <Arduino.h>
#include <PubSubClient.h>
#include "BitmapGraphics.h"
#include "Batteriefaible.h"
#include <functional>
#include <Wire.h>
#include <AHT20.h>  //<=======================
 
#include <OneWire.h>
#include <DallasTemperature.h>
#include "config.h"
 
 
#include <MQTT.h>
 
char server[] = "mqtt3.thingspeak.com";
 
//  E-paper *********************************************
#include <GxEPD2_BW.h>
#include <GxEPD2_GFX.h>
#include <Fonts/FreeMonoBold9pt7b.h>
#include "FreeSerifBold30pt7b.h"
// 2.9" EPD Module
//#define ENABLE_GxEPD2_display 0
#define SCREEN_WIDTH   296
#define SCREEN_HEIGHT  128
#define Large 7    // For best results use odd numbers
#define Small 3    // For best results use odd numbers
static const uint8_t EPD_SCL = 4; // Master-In Slave-Out not used, as no data from display
static const uint8_t EPD_SDA = 6; // to EPD DIN
GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> display(GxEPD2_290_BS(/*CS=7*/ SS, /*DC=*/ 1, /*RES=*/ 2, /*BUSY=*/ 3)); // DEPG0290BS 128x296, SSD1680
 
//*******************************************************
#define aht10 0x38 //adresse 0x38 ou 0x39
//*******************************************************
#if DEBUG
#define D_SerialBegin(...) Serial.begin(__VA_ARGS__)
#define D_print(...) Serial.print(__VA_ARGS__)
#define D_write(...) Serial.write(__VA_ARGS__)
#define D_println(...) Serial.println(__VA_ARGS__)
#define D_printf(...) Serial.printf(__VA_ARGS__)
#define D_flush(...) Serial.flush(__VA_ARGS__)
#define D_timestamp() Serial.printf("[%lu] ", millis())
#else
#define D_SerialBegin(bauds)
#define D_print(...)
#define D_write(...)
#define D_println(...)
#define D_printf(...)
#define D_flush(...)
#define D_timestamp()
#endif
 
#ifndef DEBUG
#define DEBUG 0 /**< Régler à 1 pour déboguer en série */
#endif
 
//*******************************************************
const byte oneWireBus = 10;  // DS18B20 pin used for Temperature sensor bus GIPO10
float humidity;
float temperature;
char temp[10];
char bat[10];
float piscine;
const gpio_num_t vbatPin = GPIO_NUM_0;
uint_fast16_t Vbatt ;
float batteryVoltage;
int8_t batteryPercentage;
uint_fast16_t adcValue;
char error[15];
uint8_t wifiRetries = 0;
 
bool isWifiStarted = false;
bool isWifiReady = false;
bool isRegularWifi = false;
bool isMQTTStarted = false;
bool isMQTTReady = false;
bool isRtcValid = false;
 
 
//*********** Init **************************
WiFiClient  wifiClient;
WiFiServer serverAP(80);
PubSubClient pubSubclient(wifiClient);
OneWire oneWire(oneWireBus);
DallasTemperature sensors(&oneWire);
 
//****    AHT20 ******************************
AHT20 aht; //<=========================
bool status_aht = false;
 
 
//******************************************************** 
struct __attribute__((packed, aligned(1))) WiFiRapide {
  uint8_t channel;
  uint8_t ap_mac[6];
  uint32_t crc32;
};
 
RTC_DATA_ATTR WiFiRapide rtcData = {0, {0, 0, 0, 0, 0, 0}, 0xDEADBEEF}; 
uint32_t calculateCRC32MPGE2(const uint8_t *data, size_t length) {
  uint32_t crc = 0xffffffff;
  while (length--) {
    uint8_t c = *data++;
    for (uint32_t i = 0x80; i > 0; i >>= 1) {
      bool bit = crc & 0x80000000;
      if (c & i) bit = !bit;
      crc <<= 1;
      if (bit) crc ^= 0x04c11db7;
    }
  }
  return crc;
}
 
void printByte(uint8_t b) {
  Serial.print("0x");
  if (b < 0x10) Serial.write('0');
  Serial.print(b, HEX);
}
 
void printStructure(WiFiRapide& s) {
  Serial.print("channel = "); Serial.println(s.channel);
  Serial.print("ap_mac[] = ");
  for (uint8_t i = 0; i < sizeof(s.ap_mac); i++) {
    printByte(s.ap_mac[i]);
    Serial.write(' ');
  }
  Serial.println();
  Serial.print("CRC32-MPEG2 = 0x"); Serial.println(s.crc32, HEX);
}
unsigned long startMillis;
 
//*****************************************
// SETUP
//****************************************
 
void setup()
{  	
	delay(1000); // il sert surtout au premier boot pour qu'on le voit sur le moniteur série
	D_SerialBegin(115200);
	while (!Serial) yield();
	//Serial.print("Taille de la structure = "); Serial.print(sizeof rtcData); Serial.println(" octets.");
 
	esp_reset_reason_t resetReason = esp_reset_reason();
	if (resetReason != ESP_RST_DEEPSLEEP) {
		Serial.println("Premier boot");
	} else {
		Serial.println("Reboot sur timer");
	}
 
	// on vérifie si ce qu'on avait dans la mémoire était correct (ce ne sera pas le cas au boot)
	uint32_t crcAttendu = calculateCRC32MPGE2((uint8_t*)&rtcData, sizeof rtcData - sizeof(uint32_t));
	bool isRtcValid = (rtcData.crc32 == crcAttendu);
 
	//Serial.print("crcAttendu = 0x"); Serial.println(crcAttendu, HEX);
	//Serial.print("crc en mémoire RTC = 0x"); Serial.println(rtcData.crc32, HEX);
 
 
    //**** INIT Ecran E-paper**********
    display.init(115200,true,50,false);
    display.setRotation(3);
    display.setFullWindow();
    display.fillScreen(GxEPD_BLACK);
    display.drawBitmap(0, 0, gImage_gui, 296, 128, GxEPD_WHITE);
    while (display.nextPage()); 
    delay(500) ;     
 
    //********** VBAT ********************
	  pinMode(0, INPUT); // Pin Entree VBAT
    // *** DS18B20 Temperature sensor ****
    sensors.begin(); 
    // **** AHT20 *************
     Wire.begin();
    if (aht.begin() == false)
    {
      Serial.println("AHT20 not detected. Please check wiring. Freezing.");
      while(true);
    }
 
    // Wait minimum sampling period
    startMillis = millis();
 
    //---------------------------------------------
    // Step 0:
    // Lecture DS18B20
    //---------------------------------------------
 
       sensors.requestTemperatures(); 
       float raw_temp = sensors.getTempCByIndex(0);
       piscine = sensors.getTempCByIndex(0);
       Serial.printf("Temperature = %8.4f°C\r\n", (float)raw_temp);
       snprintf(temp, sizeof temp, "%.1f",(float)raw_temp);
       updatePiscine();
 
    //---------------------------------------------
    // Step 1: Lecture de la température et de l'humidité à partir de AHT20
    //---------------------------------------------
 
        temperature = aht.getTemperature();
        humidity = aht.getHumidity();
        D_timestamp();
        D_println("AHT20 Reading ready");
        D_timestamp();
        D_printf("Temperature: %.1f, Humidity: %.1f ", temperature, humidity);
        D_println();
 
    //---------------------------------------------
    // Step 2: Lecture Batterie ADC GPIO0
    //---------------------------------------------
 
        adcValue =  analogReadMilliVolts(vbatPin); //<============
        uint_fast16_t Vbatt = 0;
        for(int i = 0; i < 16; i++) {
         Vbatt = Vbatt + adcValue ;// ADC with correction   
        }
        batteryVoltage = 2 * Vbatt / 16 / 1000.00;     // attenuation ratio 1/2, mV --> V
        batteryPercentage = ((batteryVoltage-3.20)*100.0); // 
 
 
        int tensionBrute = adcValue ; 
        constexpr int seuilTensionBruteBasse = 1600; // 3.2V ==> calculé par (3.2V / 2) 
        if  (tensionBrute <= seuilTensionBruteBasse)
        {
            if (batteryPercentage < 0){
              (batteryPercentage = 0) ;
            } 
            D_timestamp();
            D_println("Batterie faible. Sommeil profond.");
            D_printf("Battery Percentage: %i", batteryPercentage);
            batteriefaible();
            //esp_sleep_enable_timer_wakeup(120000000ULL); // on programme un réveil pour dans 120s (en µs)
        }
 
 
          D_timestamp();
          D_printf("Vbat: %.2f",batteryVoltage);
          D_println();
          sprintf(bat, "%3d%s", batteryPercentage, "%");
          updateBattery() ;
 
 
    //---------------------------------------------
    // Step 3: Demarrage Connection WIFI
    //---------------------------------------------
 
      D_timestamp();
      D_println("Démarrage du WiFi");
      WiFi.mode(WIFI_STA);
 
 
      if (isRtcValid) {
        Serial.print("Connexion RAPIDE au Wi-Fi en cours...");
        WiFi.begin(WLAN_SSID, WLAN_PASSWD, rtcData.channel, rtcData.ap_mac, true);
      } else {
        Serial.print("Connexion LENTE au Wi-Fi en cours...");
        WiFi.begin(WLAN_SSID, WLAN_PASSWD);
      }
 
      isWifiStarted = true;
 
 
    //---------------------------------------------
    // Step 4: Si le WiFi est prêt : Initialiser le client MQTT
    //---------------------------------------------
 
    if (isWifiStarted)
    {
 
  		while (WiFi.status() != WL_CONNECTED) 
  		{
  		Serial.write('.');
  		delay(500);
      }
 
  	  Serial.println(" => Connecté");
  	  Serial.print("adresse IP:");   Serial.println(WiFi.localIP());
      isWifiReady = true;
 
      if (isWifiReady) 
      {	
        /*  
        pubSubclient.setServer(server, 1883);
        D_timestamp();
        pubSubclient.connect(MQTT_CLIENT, MQTT_USER, MQTT_PASSWORD);
        delay(10);
        D_timestamp();
        D_println("MQTT connected");
        pubSubclient.loop();
        D_print("MQTT Publish: ");
        D_println(MQTT_TOPIC);
        String topicString ="channels/" + String(MQTT_TOPIC) + "/publish";
        String dataString = String("field1=" + String(temperature) + "&field2=" + String(humidity) + "&field3=" + String(batteryPercentage) + "&field4=" + String(piscine)+"&timezone=Europe/Paris");
        pubSubclient.publish(topicString.c_str(),dataString.c_str());
        delay(100);
  
          // si la mémoire RTC n'était pas valide, on la met à jour pour le prochain réveil
        if (!isRtcValid) {
            rtcData.channel = WiFi.channel();
            memcpy(rtcData.ap_mac, WiFi.BSSID(), 6); // les 6 octets de l'adresse mac
            // puis on met à jour le CRC dans la structure
            rtcData.crc32 = calculateCRC32MPGE2((uint8_t*)&rtcData, sizeof rtcData - sizeof(uint32_t));
            Serial.println(" Sauv config pour la prochaine fois en mémoire RTC. ");
            printStructure(rtcData);
        }
        */
 
	      if  (tensionBrute > seuilTensionBruteBasse)
        {	
          D_timestamp();
          D_println("Batterie OK. Dormir....");
          D_printf("Battery Percentage: %i", batteryPercentage);	
		      Serial.flush();
 		      esp_sleep_enable_timer_wakeup(60000000ull); // on programme un réveil pour dans 1mn (en µs) pour test
          //esp_sleep_enable_timer_wakeup(18000000000ull); // on programme un réveil pour dans 30mn (en µs)
		    } else{
			    D_timestamp();
          D_println("Batterie faible. Sommeil profond.");
          D_printf("Battery Percentage: %i", batteryPercentage);
          Serial.flush();
          //esp_sleep_enable_timer_wakeup(60000000ull); // on programme un réveil pour dans 1mn (en µs) pour test
 		      //esp_sleep_enable_timer_wakeup(3600000000ull); // on programme un réveil pour dans 1h (en µs)
		    }	
      }  
	  }
 
   esp_deep_sleep_start();  
 
}
 
 
//**************************************
//  LOOP
//**************************************
void loop() {}
 
 
//*******************************************************
void updateBattery() 
{
  int16_t tbx, tPar;
  uint16_t tbw, tbh;
  display.setRotation(3);
  display.setFont(&FreeMonoBold9pt7b);
  display.setTextColor(GxEPD_BLACK);
  uint16_t x = 225;
  uint16_t y = 120;
  display.getTextBounds(bat, x, y, &tbx, &tPar, &tbw, &tbh);
  display.setPartialWindow(tbx, tPar, tbw, tbh);
  display.firstPage();
  do {
    //display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.print(bat);
  } while (display.nextPage());
  delay(500);
 
}
 
 
//*******************************************************
void updatePiscine() 
{
  int16_t tbx, tPar;
  uint16_t tbw, tbh;
  display.setRotation(3);
  display.setFont(&FreeSerifBold30pt7b);
  display.setTextColor(GxEPD_BLACK);
  uint16_t x = 120;
  uint16_t y = 80;
  display.getTextBounds(temp, x, y, &tbx, &tPar, &tbw, &tbh);
  display.setPartialWindow(tbx, tPar, tbw, tbh);
  display.firstPage();
  do {
    display.fillScreen(GxEPD_WHITE);
    display.setCursor(x, y);
    display.print(temp);
  } while (display.nextPage());
   delay(500);
}
 
 
void batteriefaible() {
 display.setRotation(3);
    display.setFullWindow();
    display.fillScreen(GxEPD_BLACK);
    display.drawBitmap(0, 0, myBitmapbatterie_faible, 296, 128, GxEPD_WHITE);
    while (display.nextPage()); 
    delay(500) ;     
 
}

#include "HX710B.h"
 
const int DOUT = 2;
const int CLK_PIN = 3;
 
HX710B sensor;
 
void setup() {
  Serial.begin(115200);
  sensor.begin(DOUT, CLK_PIN);
}
 
void loop() {
  if (sensor.is_ready()) {
    Serial.print("mmHg: ");
    Serial.print(sensor.mmHg());
 
    Serial.print(" | PSI: ");
    Serial.println(sensor.psi());
  } else {
    Serial.println("Sensor not ready");
  }
 
  delay(1000);
}

 
   if (TEMPS==10.00)digitalWrite(A1, HIGH);
   if (A2, HIGH) digitalWrite(A2, LOW);
   if (A3, HIGH)digitalWrite(A3, LOW);
   if (A4, HIGH)digitalWrite(A4, LOW);   
 
 
   if (TEMPS==15.00)digitalWrite(A2, HIGH);
   if (A1,HIGH)digitalWrite(A1, LOW);
   if (A3,HIGH)digitalWrite(A3, LOW);
   if (A4,HIGH)digitalWrite(A4, LOW);  
 
 
  if (TEMP==20.00) digitalWrite(A3, HIGH);
  if (A1, HIGH)digitalWrite(A1, LOW);
  if (A2, HIGH)digitalWrite(A2, LOW);
  if (A4, HIGH)digitalWrite(A4, LOW);
 
 
  if (TEMP==25.00) digitalWrite(A4, HIGH);
  if (A1, HIGH)digitalWrite(A1, LOW);
  if (A2, HIGH)digitalWrite(A2, LOW);
  if (A3, HIGH)digitalWrite(A3, LOW);

 
 
const char* jours[] = {
  "Dim","Lun","Mar","Mer",
  "Jeu","Ven","Sam"
};
 
const char* mois[] = {
  "Janv","Fev","Mars","Avr","Mai","Jun",
  "Jul","Aout","Sept","Oct","Nov","Dec"
};
 
.../...
 
void drawClock() {
  setlocale(LC_TIME,""); 
  struct tm t;
 
  if (!getLocalTime(&t)) {
    display.setFont(NULL);
    display.setCursor(30, 30);
    display.print("Synchro en cours...");
    return;
  }
 
  int h12 = t.tm_hour ;
  display.setTextColor(SSD1306_WHITE);
  display.setFont(NULL);
  display.setTextSize(1);
  display.setCursor(114, 0);
  //display.print(ampm);
  display.setFont(&FreeSansBold18pt7b);
  char timeStr[6];
  sprintf(timeStr, "%02d:%02d", h12, t.tm_min);
  int16_t x1, y1;
  uint16_t w, h;
  display.getTextBounds(timeStr, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 42);
  display.print(timeStr);
  display.setFont(&FreeSans9pt7b);
  const char* j =jours[t.tm_wday];  
  const char* m =mois[t.tm_mon];
  char dateStr[20];
  strftime(dateStr, 20, "%j %d %m", &t);
  display.getTextBounds(dateStr, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - w) / 2, 62);
  display.print(dateStr);
}

 
/01d32.jpg
../..
/alarm.txt
/config.txt  <=====================
/ik.txt
/i_stat.txt
/wind_2.jpg
/wind_4.jpg
/wind_6.jpg
/wind_8.jpg
[SPIFFS] upload  : C:\Users\UTILIS~1\AppData\Local\Temp\arduino_build_795945/meteoV12.spiffs.bin
[SPIFFS] address  : 0x200000
[SPIFFS] reset    : nodemcu
[SPIFFS] port     : COM4
[SPIFFS] speed    : 921600
 
Uploading 2076672 bytes from C:\Users\UTILIS~1\AppData\Local\Temp\arduino_build_795945/meteoV12.spiffs.bin to flash at 0x00200000
................................................................................ [  3% ]
................................................................................ [  7% ]
................................................................................ [ 11% ]
................................................................................ [ 15% ]
................................................................................ [ 19% ]
................................................................................ [ 23% ]
................................................................................ [ 27% ]
................................................................................ [ 31% ]
................................................................................ [ 35% ]
................................................................................ [ 39% ]
................................................................................ [ 43% ]
................................................................................ [ 47% ]
................................................................................ [ 51% ]
................................................................................ [ 55% ]
................................................................................ [ 59% ]
................................................................................ [ 63% ]
................................................................................ [ 67% ]
................................................................................ [ 71% ]
................................................................................ [ 74% ]
................................................................................ [ 78% ]
................................................................................ [ 82% ]
................................................................................ [ 86% ]
................................................................................ [ 90% ]
................................................................................ [ 94% ]
................................................................................ [ 98% ]
............................                                                     [ 100% ]

 
meteoV12:184:22: fatal error: LittleFS.h: No such file or directory
 #include <LittleFS.h>  <===================================
                      ^
compilation terminated.
Plusieurs bibliothèque trouvées pour "WiFiClient.h"
Utilisé : C:\Users\Utilisateur\Documents\ArduinoData\packages\esp8266\hardware\esp8266\2.5.0\libraries\ESP8266WiFi
Non utilisé : C:\Users\Utilisateur\Documents\Arduino\libraries\WiFi101
Non utilisé : C:\Program Files\WindowsApps\ArduinoLLC.ArduinoIDE_1.8.57.0_x86__mdqgnx93n4wtt\libraries\WiFi
exit status 1
LittleFS.h: No such file or directory