Esp32ClockInternet

  const int decalage = 1;                                                 // la valeur dépend de votre fuseau horaire. Essayez 2 pour la France.
  //const int delaiDemande = 5 * 60;                                      // nombre de secondes entre deux demandes consécutives au serveur NTP
  const int delaiDemande = 10;                                            // MEILLEUR QUE CI-DESSUS QUI INTRODUIT UN LEGER RETARD

  unsigned long derniereDemande = millis();                               // moment de la plus récente demande au serveur NTP
  unsigned long derniereMaJ = millis();                                   // moment de la plus récente mise à jour de l'affichage de l'heure
  unsigned long MonTime;                                                  // MonTime est la variable remise en forme de heure minute pour la compatibilité TM1637
  unsigned long MaDate;                                                   // MaDate est la variable remise en forme de jour mois pour la compatibilité TM1637

  int compteur = 0;                                                       // Compteur utilisé dans l'affichage erreur pour limiter le nombre de bips
  time_t maintenant;
  struct tm * timeinfo;

  void setup()
  {

  Serial.begin(115200);
  pinMode(BrocheBuzzer, OUTPUT);
  pinMode(BrocheLedRouge, OUTPUT);
  pinMode(BrocheLedVerte, OUTPUT);
  pinMode(BrocheLedBleue, OUTPUT);

  digitalWrite (BrocheBuzzer, LOW);
  digitalWrite (BrocheLedRouge, LOW);
  digitalWrite (BrocheLedVerte, LOW);
  digitalWrite (BrocheLedBleue, LOW);

  display1.setBrightness(0x0f);                                           // Brillance maximale
  display2.setBrightness(0x0f);                                           // Brillance maximale

  display1.clear ();
  display2.clear ();

  delay (5);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
  {
  digitalWrite (BrocheLedBleue, LOW);
  digitalWrite (BrocheLedRouge, HIGH);
  digitalWrite (BrocheLedVerte, LOW);
  afficheErreur01();
  delay(10);
  display1.clear ();
  display2.clear ();
  }

  compteur = 0;
  digitalWrite (BrocheLedBleue, LOW);
  delay (10);
  digitalWrite (BrocheLedRouge, LOW);
  delay (10);
  digitalWrite (BrocheLedVerte, HIGH);
  delay (10);
  Buzzer(300, 10, 1);
  delay(200);

  configTime(decalage * 3600, 0, "fr.pool.ntp.org");
  delay(1200);
  time(&maintenant);

  }

  void loop()
  {
  digitalWrite (BrocheLedBleue, LOW);
  //------------------------------------------------------------------------Condition de demande de l'heure NTP---------------------------------------------------------------------------
  if ((millis() - derniereDemande) >=  delaiDemande * 1000 )              // Dernière demande depuis plus de 10 secondes
  {
  time(&maintenant);                                                      // Rafraichissement
  derniereDemande = millis();                                             // Réactualisation du temps de la dernière demande d'heure (en millisecondes)
  }
  //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  //--------------------------------------------------------------Détection du dépassement de millis () (redémarrage à zéro---------------------------------------------------------------
  if (millis() < derniereDemande )                                        // si millis () est plus bas que précédemment c'est donc qu'il redémarre enbas
  {
  time(&maintenant);                                                      // Rafraichissement
  derniereDemande = millis();                                             // Réactualisation du temps de la dernière demande d'heure (en millisecondes)
  }
  //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  //-------------------------------------------------------------------Condition sur la MAJ de l'affichage heure/date---------------------------------------------------------------------
  //+++++++++++++++Point important : dans notre cas le temps est incrémenté d'une seconde et l'afichage est mis à jour à chaque seconde (entre 2 lectures de l'heure NTP++++++++++++++++++
  if ((millis() - derniereMaJ) >=   1000 )
  {
  maintenant = maintenant + 1;                                            // Incrémentation d'une seconde
  afficheHeureDate();                                                     // Activation de la fonction afichage heure date
  derniereMaJ = millis();                                                 // Réactualisation du temps de la dernière
  }
  //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  }

  void afficheHeureDate()
  {
  if (WiFi.status() != WL_CONNECTED)
  {
  digitalWrite (BrocheLedBleue, LOW);
  digitalWrite (BrocheLedRouge, HIGH);
  digitalWrite (BrocheLedVerte, LOW);
  display1.clear ();
  display2.clear ();

  afficheErreur01();
  delay(10);
  }

  else
  {
  digitalWrite (BrocheLedBleue, LOW);
  digitalWrite (BrocheLedRouge, LOW);
  //delay (10);
  digitalWrite (BrocheLedVerte, HIGH);
  //delay (10);

  timeinfo = localtime(&maintenant);                                      // MAJ de timeinfo
  //MonTime = 100*timeinfo->tm_hour + timeinfo->tm_min +10000 ;           // Conversion pour Display (2 digits heures/ 2digits minutes
  MonTime = 100*timeinfo->tm_hour + timeinfo->tm_min ;

  //if (timeinfo->tm_min == 59)                                           // Faire le choix entre ces 2 lignes, ici pour signalisation incrémentation de l'heure
  if (timeinfo->tm_sec == 59)                                             // Faire le choix entre ces 2 lignes, ici pour signalisation incrémentation des minutes (principalement pout tests
  {
  LastEtatMin = HIGH;
  }
  //if ( timeinfo->tm_min == 0 && LastEtatMin == HIGH)
  if ( timeinfo->tm_sec == 0 && LastEtatMin == HIGH)
  {
  delay (10);
  digitalWrite (BrocheLedBleue, HIGH);
  LastEtatMin = LOW;
  Buzzer (15, 5,1);
  delay (10);
  }

  digitalWrite (BrocheLedBleue, LOW);
  MaDate = 100*timeinfo->tm_mday + timeinfo->tm_mon + 1;
  display1.showNumberDecEx(MonTime,0b01000000,true, 4,0);                 // Affichage MonTime en incluant ":"
  display2.showNumberDec(MaDate,true, 4,0);
  }
  }

  void afficheErreur01()
  {
  digitalWrite (BrocheLedBleue, LOW);
  compteur++;
  if (compteur < 5 )
  {
  Buzzer(40, 10, 6);                                                      // Signal sonore d'entrée en défaut
  }
  delay (1000);

  //-------------------------------------------------------------------Ci-dessous l'animation des segments---------------------------------------------------------------------------
  const uint8_t segments01 [] = {
  SEG_A ,
  SEG_A ,
  SEG_A ,
  SEG_A ,
  };

  const uint8_t segments02 [] =
  {
  SEG_G ,
  SEG_A ,
  SEG_G ,
  SEG_A ,
  };

  const uint8_t segments03 [] =
  {
  SEG_D ,
  SEG_G ,
  SEG_D ,
  SEG_G ,
  };

  const uint8_t segments04 [] =
  {
  SEG_D ,
  SEG_D ,
  SEG_D ,
  SEG_D ,
  };

  int tempo = 20;                                                          // tempo avant le passage à l'affichage suivant
  for (int i = 0; i < 30; i++)                                             // i = nmbre de repition de la boucle d'affichage
  {
  display1.setSegments (segments01, 4, 0);
  display2.setSegments (segments04, 4, 0);
  delay (tempo);

  display1.setSegments (segments02, 4, 0);
  display2.setSegments (segments03, 4, 0);
  delay (tempo);

  display1.setSegments (segments03, 4, 0);
  display2.setSegments (segments02, 4, 0);
  delay (tempo);

  display1.setSegments (segments04, 4, 0);
  display2.setSegments (segments01, 4, 0);
  delay (tempo);
  }
  }

  void Buzzer (int TempsH, int TempsL, int nb)                            // TempsH => délai buzzer ON, TempsL => délai buzzer OFF, nb => nombre de bips
  {
  for (int x = 1; x <= nb; x++) // ************************************** // Boucle le nombre de fois voulu passé par l'argument "int nb"
  {
  digitalWrite(BrocheBuzzer, HIGH);                                       // Active le buzzer
  delay (TempsH);                                                         // Temporisation à l'état haut du buzzer pendant la durée passée par l'argument "int TempsH"
  digitalWrite(BrocheBuzzer, LOW);                                        // Désactive le buzzer
  delay (TempsL);                                                         // Temporisation à l'état bas du buzzer pendant la durée passée par l'argument "int TempsL"
  }
  }