/*******************************************************************************************\
|*                                                                                         *|
|*          KY-040 Écriture d'une chaîne de caractères au moyen d'un codeur rotatif.       *|
|*                                                                                         *|
|* Tourner pour faire défiler les caractères.                                              *|
|* Appuyer une fois pour valider le caractère et passer au caractère suivant.              *|
|* Faire un appui long (inférieur à 3 secondes) pour effacer le caractère courant et reve- *|
|* nir en arrière.                                                                         *|
|* Faire un appui très long (supérieur à 3 secondes) pour effacer la chaîne de caractères. *|
|* Faire un double appui pour valider et mémoriser la chaîne de caractères.                *|
\*******************************************************************************************/

/*******************************************************************************************\
|* Liste des Bibliothèques.                                                                *|
\*******************************************************************************************/

  #include "OneButton.h" // Bibliothèque de traitement d'un codeur rotatif
  #include <LiquidCrystal.h> // Bibliothèque de gestion des afficheurs LCD alphanumériques


/*******************************************************************************************\
|* Affectation des broches de l'ESP 32                                                     *|
\*******************************************************************************************/

  #define BP_backlight 15 // Bouton-poussoir de commande du rétroéclairage de l'afficheur LCD
  #define LCD_backlight 12 // Sortie de rétroéclairage de l'afficheur LCD
  #define Balancier 18 // Sortie de commande du Balancier
  #define Carillon 19 // Sortie de commande du Carillon
  #define LCD_RS 32 // Attribution de la broche RS de l'afficheur LCD
  #define LCD_EN 33 // Attribution de la broche EN de l'afficheur LCD
  #define LCD_D4 25 // Attribution de la broche D4 de l'afficheur LCD
  #define LCD_D5 26 // Attribution de la broche D5 de l'afficheur LCD
  #define LCD_D6 27 // Attribution de la broche D6 de l'afficheur LCD
  #define LCD_D7 14 // Attribution de la broche D7 de l'afficheur LCD
  #define ENCODER_CLK 2 // Affectation de la broche d'horloge du codeur rotatif
  #define ENCODER_DT  4 // Affectation de la broche de donnée du coeur rotatif
  OneButton ENCODER_SW(5, true) ; // Affectation de la broche du poussoir du codeur rotatif


/*******************************************************************************************\
|* Paramètrage de l'afficheur LCD : bus parallèle 4 bits, 20 caractères et 4 lignes        *|
\*******************************************************************************************/

    LiquidCrystal LCD(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7) ; // Paramétrage de l'afficheur LCD


/*******************************************************************************************\
 * Liste des Variables.                                                                    *|
\*******************************************************************************************/

// Variables d'Entrées/Sorties
  uint8_t counterEncoderChar = 32 ; // Compteur de code ASCII du codeur rotatif
  uint8_t counterEncoderHeure = 0 ; // Compteur des heures du codeur rotatif
  uint8_t counterEncoderMinute = 0 ; // Compteur des minutes du codeur rotatif

// Variables de communication
  char ssid[32] = "Wokwi-GUEST" ; // Nom du réseau WiFi
  char password[32] = "" ; // Mot de passe du réseau WiFi
  char hostname[32] = "Horloge ESP32" ; // Nom de l'hôte sur le réseau WiFi
  char ntpServer[32] = "pool.ntp.org" ; // Adresse du serveur NTP
  char timeZone[64] = "CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00" ; // Définition du fuseau horaire (voir https://sites.google.com/a/usapiens.com/opnode/time-zones)

// Variables temporelles
  uint8_t start_LCD_backlight[2] = {7,30} ; // Heure de démarrage du rétroéclairage de l'afficheur LCD
  uint8_t stop_LCD_backlight[2] = {23,30} ; // Heure d'arrêt du rétroéclairage de l'afficheur LCD 
  uint8_t start_Carillon[2] = {8,30} ; // Heure de démarrage du Carillon
  uint8_t stop_Carillon[2] = {21,15} ; // Heure d'arrêt du Carillon
  uint32_t clickTempo = 0 ; // Temporisation pour l'appuis très long

// Variables d'affichage
  char accueil[80] = "                       Horloge ESP32       -------------                       " ; // Texte d'Accueil
  uint8_t menu = 0 ; // Numéro du Menu
  char Texte[64] ; // Chaîne de caractères à afficher
  String Texte_1 ; // Texte de la première ligne
  String Texte_2 ; // Texte de la deuxième ligne
  String Texte_3 ; // Texte de la troisième ligne
  String Texte_4 ; // Texte de la quatrième ligne
  char Result[64] = "" ; // Chaîne de caractères validée
  uint8_t posChar = 0 ; // Position du caractère à entrer


/*******************************************************************************************\
 * Programme d'initialisation à n'exécuter qu'une seule fois.                              *|
\*******************************************************************************************/

void setup() // Programme d'initialisation à n'exécuter qu'une seule fois
{
  // Mise en service de la communication série vers la console
    Serial.begin(115200) ; // Vitesse de communication : 115 200 Bauds

  // Initialisation de l'afficheur LCD
    LCD.begin(20,4) ; // Initialisation de l'afficheur LCD
    digitalWrite(LCD_backlight, HIGH) ; // Activation du rétro-éclairage
    LCD.clear() ; // Effacement de l'afficheur LCD

  // Initialisation des entrées/sorties
    pinMode (BP_backlight, INPUT_PULLUP) ; // Entrée du bouton poussoir de commande du rétroéclairage de l'afficheur LCD
    pinMode (LCD_backlight, OUTPUT) ; // Sortie de commande du rétroéclairage de l'afficheur LCD
    pinMode (Balancier, OUTPUT) ; // Sortie de commande du Balancier
    pinMode (Carillon, OUTPUT) ; // Sortie de commande du Carillon

  // Initialisation des broches du codeur rotatif
    pinMode(ENCODER_CLK, INPUT) ; // Broche d'horloge
    pinMode(ENCODER_DT, INPUT) ; // Broche de donnée

  // Initialisation des interruptions pour le codeur rotatif
    attachInterrupt(digitalPinToInterrupt(ENCODER_CLK), readEncoder, FALLING) ; // Initialisation des interruptions
    ENCODER_SW.attachClick(clickENCODER_SW) ; // Simple appui
    ENCODER_SW.attachDoubleClick(doubleclickENCODER_SW) ; // Double appui
    ENCODER_SW.attachLongPressStart(longPressStartENCODER_SW) ; // Début d'un appui long
    ENCODER_SW.attachLongPressStop(longPressStopENCODER_SW) ; // Appui long en cours
    ENCODER_SW.attachDuringLongPress(longPressENCODER_SW) ; // Fin d'un appui long

  // Affichage, sur le Terminal Série, du nom de l'horloge
  Serial.println("Horloge ESP32") ;
  Serial.println("") ;

}


/*******************************************************************************************\
|* Programme principal à exécuter en boucle répétitive                                     *|
\*******************************************************************************************/

void loop()
{
  // Lecture de l'état du poussoir du codeur rotatif
    ENCODER_SW.tick() ; // Lecture de l'état du poussoir du codeur rotatif
  
  // Affichage LCD du mode Normal
    if (menu == 0)
    {
      LCD.setCursor(0,0) ; LCD.print(String(accueil).substring(0,20)) ; // Affichage LCD du texte d'Accueil
      LCD.setCursor(0,1) ; LCD.print(String(accueil).substring(20,40)) ; // Affichage LCD du texte d'Accueil
      LCD.setCursor(0,2) ; LCD.print(String(accueil).substring(40,60)) ; // Affichage LCD du texte d'Accueil
      LCD.setCursor(0,3) ; LCD.print(String(accueil).substring(60,80)) ; // Affichage LCD du texte d'Accueil
    }
  // Affichage LCD du mode réglages
    else LCD_Regl() ;
}


/*******************************************************************************************\
|* Fonction de lecture de l'état du codeur rotatif.                                        *|
\*******************************************************************************************/

void readEncoder() // Fonction de lecture de l'état du codeur rotatif
{
  // État de la broche de donnée
    int dtValue = digitalRead(ENCODER_DT) ; // Lecture de l'état de la broche de donnée
  
  // Comptage
    if (dtValue == HIGH) // Si la broche est au niveau Haut, alors :
    {
      if (counterEncoderChar < 127) counterEncoderChar ++ ; // Le compteur de code ASCII du codeur rotatif est incrémenté
      else counterEncoderChar = 32 ; // Dépassement du compteur de code ASCII
      if (counterEncoderHeure < 23) counterEncoderHeure ++ ; // Le compteur des heures du codeur rotatif est incrémenté
      else counterEncoderHeure = 0 ; // Dépassement du compteur des heures
      if (counterEncoderMinute < 59) counterEncoderMinute ++ ; // Le compteur des minutes du codeur rotatif est incrémenté
      else counterEncoderMinute = 0 ; // Dépassement du compteur des minutes
    }
  // Décomptage
    if (dtValue == LOW) // Si la broche est au niveau Bas, alors :
    {
      if (counterEncoderChar > 32 ) counterEncoderChar -- ; // le compteur de code ASCII du codeur rotatif est décrémenté
      else counterEncoderChar = 127 ; // Dépassement du compteur de code ASCII
      if (counterEncoderHeure != 0) counterEncoderHeure -- ; // Le compteur des heures du codeur rotatif est décrémenté
      else counterEncoderHeure = 23 ; // Dépassement du compteur des heures
      if (counterEncoderMinute != 0) counterEncoderMinute -- ; // Le compteur des minutes du codeur rotatif est décrémenté
      else counterEncoderMinute = 59 ; // Dépassement du compteur des minutes
    }
}


/*******************************************************************************************\
|* Fonctions de lecture du compteur du codeur rotatif.                                     *|
\*******************************************************************************************/

//Fonction de lecture du compteur de code ASCII du codeur rotatif
  int getCounterEncoderChar() // Fonction de lecture du compteur de code ASCII du codeur rotatif
  {
    int result ; // Défini la variable "result"
    noInterrupts(); // Désactive les interrruptions pour s'assurer que readEncoder() ne change pas la valeur pendant qu'on la lit.
    result = counterEncoderChar; // Lecture du compteur de code ASCII du codeur rotatif
    interrupts(); // Activation des interruptions
    return result;
  }

// Fonction de lecture du compteur des heures du codeur rotatif
  int getCounterEncoderHeure() // Fonction de lecture du compteur des heures du codeur rotatif
  {
    int result ; // Défini la variable "result"
    noInterrupts(); // Désactive les interrruptions pour s'assurer que readEncoder() ne change pas la valeur pendant qu'on la lit.
    result = counterEncoderHeure; // Lecture du compteur des heures du codeur rotatif
    interrupts(); // Activation des interruptions
    return result;
  }

 // Fonction de lecture du compteur des minutes du codeur rotatif
  int getCounterEncoderMinute() // Fonction de lecture du compteur des minutes du codeur rotatif
  {
    int result ; // Défini la variable "result"
    noInterrupts(); // Désactive les interrruptions pour s'assurer que readEncoder() ne change pas la valeur pendant qu'on la lit.
    result = counterEncoderMinute; // Lecture du compteur des minutes du codeur rotatif
    interrupts(); // Activation des interruptions
    return result;
  }


/*******************************************************************************************\
|* Fonction d'affichage LCD du mode réglages.                                              *|
\*******************************************************************************************/

void LCD_Regl() // Fonction d'affichage LCD du mode réglages
{
  switch(menu)
  {
    case 11 : // Affichage de la plage horaire du rétroéclairage de l'afficheur LCD
    case 12 :
    case 13 :
    case 14 :
      LCD_Menu10("Eclairage Afficheur ", start_LCD_backlight, stop_LCD_backlight) ;
      break ;
    case 15 : // Affichage de la plage horaire du Carillon
    case 16 :
    case 17 :
    case 18 :
      LCD_Menu10("Fonction Carillon   ", start_Carillon, stop_Carillon) ;
      break ;
    case 21 : // Affichage du nom du réseau WiFi
      LCD_Menu20("SSID WiFi :         ") ;
      break ;
    case 22 : // Affichage du mot de passe du réseau WiFi
      LCD_Menu20("Mot de Passe WiFi : ") ;
      break ;
    case 23 : // Affichage du nom de l'hôte sur le réseau WiFi
      LCD_Menu20("Nom d'Hote WiFi :   ") ;
      break ;
    case 24 : // Affichage de l'adresse du serveur NTP
      LCD_Menu20("Serveur NTP :       ") ;
      break ;
    case 25 : // Affichage de la définition du fuseau horaire
      LCD_Menu20("Fuseau Horaire :    ") ;
      break ;
  }
}


/*******************************************************************************************\
|* Fonction d'affichage LCD des Menus 10 (réglage des plages horaires pour rétroéclairage  *|
|* LCD et fonctionnement du Carillon).                                                     *|
\*******************************************************************************************/

void LCD_Menu10(char* EnTete, uint8_t start[2], uint8_t stop[2]) // Fonction d'affichage LCD des Menus 10
{
  // Acquisition des valeurs du compteur des heures et des minutes
    switch(menu)
    {
      case 11 :
      case 15 :
        start[0] = getCounterEncoderHeure() ; // Acquisition de la valeur du compteur des heures pour le démarrage de la fonction
        break ;
      case 12 :
      case 16 :
        start[1] = getCounterEncoderMinute() ; // Acquisition de la valeur du compteur des minutes pour le démarrage de la fonction
        break ;
      case 13 :
      case 17 :
        stop[0] = getCounterEncoderHeure() ; // Acquisition de la valeur du compteur des heures pour l'arrêt de la fonction
        break ;
      case 14 :
      case 18 :
        stop[1] = getCounterEncoderMinute() ; // Acquisition de la valeur du compteur des minutes pour l'arrêt de la fonction
        break ; 
    }
  
  // Préparation du texte à afficher sur le LCD en mode réglage des plages horaires
    Texte_1 = String(EnTete) ;
    if (((menu >= 11) && (menu <= 14)) || ((menu >= 15) && (menu <= 18))) // Heure de démarrage de la fonction
    {
      Texte_2 = String("de ") ;
      if (start[0] < 10) Texte_2 += "0" ;
      Texte_2 += start[0] ;
    }
    if (((menu >= 12) && (menu <= 14)) || ((menu >= 16) && (menu <= 18))) // Minute de démarrage de la fonction
    {
      Texte_2 += ":" ;
      if (start[1] < 10) Texte_2 += "0" ;
      Texte_2 += start[1] ;
    }
    if (((menu >= 13) && (menu <= 14)) || ((menu >= 17) && (menu <= 18))) // Heure d'arrêt de la fonction
    {
      Texte_2 += String(" a ") ;
      if (stop[0] < 10) Texte_2 += "0" ;
      Texte_2 += stop[0] ;
    }
    if ((menu == 14) || (menu == 18)) // Minute d'arrêt de la fonction
    { 
      Texte_2 += ":" ;
      if (stop[1] < 10) Texte_2 += "0" ;
      Texte_2 += stop[1] ;
    }

  // Affichage LCD en mode réglage des plages horaires
    LCD.setCursor(0,0) ; LCD.print(Texte_1) ; // Affichage LCD de la fonction
    LCD.setCursor(0,1) ; LCD.print(Texte_2) ; // Affichage LCD du texte entrée
}


/*******************************************************************************************\
|* Fonction d'affichage LCD des Menus 20 (réglage des paramètres de communication WiFi).   *|
\*******************************************************************************************/

void LCD_Menu20(char* EnTete) // Fonction d'affichage LCD des Menus 20 (réglage des paramètres de communication WiFi)
{
  // Acquisition du nouveau caractère
    Texte[posChar] = getCounterEncoderChar() ; // Acquisition du nouveau caractère
  
  // Préparation du texte à afficher sur le LCD en mode réglage des paramètres de communication WiFi
    Texte_1 = String(EnTete) ;
    Texte_2 = String(Texte).substring(0,20) ;
    Texte_3 = String(Texte).substring(20,40) ;
    Texte_4 = String(Texte).substring(40,80) ;

  // Affichage LCD en mode réglage des paramètres de communication WiFi
    LCD.setCursor(0,0) ; LCD.print(Texte_1) ; // Affichage LCD de la fonction
    LCD.setCursor(0,1) ; LCD.print(Texte_2) ; // Affichage LCD du texte entrée
    LCD.setCursor(0,2) ; LCD.print(Texte_3) ; // Affichage LCD du texte entrée
    LCD.setCursor(0,3) ; LCD.print(Texte_4) ; // Affichage LCD du texte entrée
}


/*******************************************************************************************\
|* Fonction de lecture des paramètres de communication WiFi.                               *|
\*******************************************************************************************/

void readConfig(char* Config) // Fonction de lecture des paramètres de communication WiFi
{
  LCD.clear() ; // Effacement du LCD
  if (String(Config).length() == 0) // Paramètre vide ?
  {
    posChar = 0 ; // Positionnement du premier caractère à modifier
    for(uint8_t i = 0 ; i < 64 ; i ++) Texte[i] = 0 ; // Effacement du buffer Texte
    counterEncoderChar = 32 ; // Affichage du caractère espace
  }
  else // Sinon
  {
    posChar = String(Config).length() - 1 ; // Positionnement du premier caractère à modifier
    for(uint8_t i = 0 ; i < (posChar + 1) ; i ++) Texte [i] = Config[i] ; // Enregistrement dans le buffet Texte des caractères mémorisés
    for(uint8_t i = (posChar + 1) ; i < 64 ; i ++) Texte[i] = 0 ; // Effacement des carractères suivants
    counterEncoderChar = Texte[posChar] ; // Affichage du dernier caractère
  }
}


/*******************************************************************************************\
|* Fonction de sauvegarde des paramètres de communication WiFi.                            *|
\*******************************************************************************************/

void saveConfig(char* Config) // Fonction de sauvegarde des paramètres de communication WiFi
{
  uint8_t size = sizeof(Config) ; // Nombre de caractères du paramètre à sauvegarder
  
  // Le paramètre est-il vide ?
    if (Texte[0] == 32) for(uint8_t i = 0 ; i < size ; i ++) Texte[i] = 0 ;
    if (String(Texte).length() == 0)
    {
      for(uint8_t i = 0 ; i < size ; i ++) Config[i] = 0 ; // Vidange du paramètre
    }
    else 
    {
      for(uint8_t i = 0 ; i < String(Texte).length() ; i ++) // Sauvegarde du paramètre
      {
        if ((Texte[i] <= 32) && (Texte[i+1] <= 32)) Config[i] = 0 ;
        else Config[i] = Texte[i] ;
      }
      for(uint8_t i = (String(Texte).length()) ; i < size ; i ++) Config[i] = 0 ;
    }

  // Affichage sur le terminal de la chaîne de caractères mémorisée
    switch(menu)
    {
      case 21 : // Affichage du nom du réseau WiFi
        Serial.print("SSID WiFi : ") ;
        break ;
      case 22 : // Affichage du mot de passe du réseau WiFi
        Serial.print("Mot de Passe WiFi : ") ;
        break ;
      case 23 : // Affichage du nom de l'hôte sur le réseau WiFi
        Serial.print("Nom d'Hote WiFi : ") ;
        break ;
      case 24 : // Affichage de l'adresse du serveur NTP
        Serial.print("Serveur NTP : ") ;
        break ;
      case 25 : // Affichage de la définition du fuseau horaire
        Serial.print("Fuseau Horaire : ") ;
        break ;
    }
    Serial.print((char)34) ;
    Serial.print(Config) ;
    Serial.println((char)34) ;
}

/*******************************************************************************************\
|* Appel des fonctions du poussoir du codeur.                                              *|
\*******************************************************************************************/

  /*****************************************************************************************\
  |* Fonction appelée pour un simple clic du poussoir du codeur.                           *|
  \*****************************************************************************************/

  void clickENCODER_SW() // Fonction appelée pour un simple clic du poussoir du codeur rotatif
  {
    switch(menu)
    {
      case 0 :
        menu = 11 ; // Passage au réglage de l'heure de démarrage du rétroéclairage
        counterEncoderHeure = start_LCD_backlight[0] ; // Acquisition de l'heure de démarrage du rétroéclairage mémorisée 
        LCD.clear() ; // Effacement du LCD
        break ;
      case 11 :
        menu = 12 ; // Passage au réglage de la minute de démarrage du rétroéclairage
        counterEncoderMinute = start_LCD_backlight[1] ; // Acquisition de la minute de démarrage du rétroéclairage mémorisée 
        break ;
      case 12 :
        menu = 13 ; // Passage au réglage de l'heure d'arrêt du rétroéclairage
        counterEncoderHeure = stop_LCD_backlight[0] ; // Acquisition de l'heure d'arrêt du rétroéclairage mémorisée 
        break ;
      case 13 :
        menu = 14 ; // Passage au réglage de la minute d'arrêt du rétroéclairage
        counterEncoderMinute = stop_LCD_backlight[1] ; // Acquisition de la minute d'arrêt du rétroéclairage mémorisée 
        break ;
      case 15 :
        menu = 16 ; // Passage au réglage de la minute de démarrage du Carillon
        counterEncoderMinute = start_Carillon[1] ; // Acquisition de la minute de démarrage du Carrillon mémorisée 
        break ;
      case 16 :
        menu = 17 ; // Passage au réglage de l'heure d'arrêt du Carillon
        counterEncoderHeure = stop_Carillon[0] ; // Acquisition de l'heure d'arrêt du Carrillon mémorisée 
        break ;
      case 17 :
        menu = 18 ; // Passage au réglage de la minute d'arrêt du Carillon
        counterEncoderMinute = stop_Carillon[1] ; // Acquisition de la minute d'arrêt du Carrillon mémorisée 
        break ;
      case 21 :
      case 22 :
      case 23 :
      case 24 :
      case 25 :
        posChar ++ ; // Validation du caractère courant et déplacement d'un caractère
        break ;
    }
  }

  /*****************************************************************************************\
  |* Fonction appelée pour un double clic du poussoir du codeur.                           *|
  \*****************************************************************************************/

  void doubleclickENCODER_SW() // Fonction appelée pour un double clic du poussoir du codeur
  {
    switch(menu)
    {
      case 14 :
        // Affichage sur le terminal de la plage horaire du rétroéclairage 
          Serial.print("Eclairage Afficheur de ") ;
          Serial.print(start_LCD_backlight[0]) ;
          Serial.print(":") ;
          Serial.print(start_LCD_backlight[1]) ;
          Serial.print(" à ") ;
          Serial.print(stop_LCD_backlight[0]) ;
          Serial.print(":");
          Serial.println(stop_LCD_backlight[1]) ;
        menu = 15 ; // Passage au réglage de l'heure de démarrage du Carillon
        counterEncoderHeure = start_Carillon[0] ; // Acquisition de l'heure de démarrage du Carrillon mémorisée 
        LCD.clear() ; // Effacement du LCD
        break ;
      case 18 :
           // Affichage sur le terminal de la plage horaire du Carillon 
          Serial.print("Fonction Carillon de ") ;
          Serial.print(start_Carillon[0]) ;
          Serial.print(":") ;
          Serial.print(start_Carillon[1]) ;
          Serial.print(" à ") ;
          Serial.print(stop_Carillon[0]) ;
          Serial.print(":");
          Serial.println(stop_Carillon[1]) ;
          Serial.println() ;
        menu = 0 ; // Retour à l'affichage du mode Normal 
        LCD.clear() ; // Effacement du LCD
        break ;
      case 21 :
        saveConfig(ssid) ; // Sauvegarde du SSID
        menu = 22 ; // Passage au paramètre suivant
        readConfig(password) ; // Acquisition du Mot de Passe mémorisée
        break ;
      case 22 :
        saveConfig(password) ; // Sauvegarde du Mot de Passe
        menu = 23 ; // Passage au paramètre suivant
        readConfig(hostname) ; // Acquisition du Nom d'Hôte mémorisé
        break ;
      case 23 :
        saveConfig(hostname) ; // Sauvegarde du Nom d'Hôte
        menu = 24 ; // Passage au paramètre suivant
        readConfig(ntpServer) ; // Acquisition du Serveur NTP mémorisée
        break ;
      case 24 :
        saveConfig(ntpServer) ; // Sauvegarde du Serveur NTP
        menu = 25 ; // Passage au paramètre suivant
        readConfig(timeZone) ; // Acquisition du Fuseau Horaire mémorisé
        break ;
      case 25 :
        saveConfig(timeZone) ; // Sauvegarde du Fuseau Horaire
        Serial.println("") ;
        menu = 0 ; // Retour à l'affichage du mode Normal 
        LCD.clear() ;
        break ;
    }
  }

  /*****************************************************************************************\
  |* Fonction appelée une fois, lors d'un appui long sur le poussoir du codeur.            *|
  \*****************************************************************************************/

  void longPressStartENCODER_SW() // Fonction appelée une fois, lors d'un appui long sur le poussoir du codeur
  {
    switch(menu)
    {
      case 0 :
        menu = 21 ; // Passage aux réglages des paramètres de communication
        readConfig(ssid) ; // Acquisition du SSID mémorisé
        break ;
      case 12 :
        menu = 11 ; // Retour au réglage de l'heure de démarage du rétroéclairage
        counterEncoderHeure = start_LCD_backlight[0] ; // Acquisition de l'heure de démarrage du rétroéclairage mémorisée
        LCD.setCursor(5,1) ; LCD.print("   ") ; // Effacement des carractères précédents
        break ;
      case 13 :
        menu = 12 ; // Retour au réglage de la minute de démarage du rétroéclairage
        counterEncoderMinute = start_LCD_backlight[1] ; // Acquisition de la minute de démarrage du rétroéclairage mémorisée
        LCD.setCursor(8,1) ; LCD.print("     ") ; // Effacement des carractères précédents
        break ;
      case 14 :
        menu = 13 ; // Retour au réglage de l'heure d'arrêt du rétroéclairage
        counterEncoderHeure = stop_LCD_backlight[0] ; // Acquisition de l'heure d'arrêt du rétroéclairage mémorisée
        LCD.setCursor(13,1) ; LCD.print("   ") ; // Effacement des carractères précédents
        break ;
      case 16 :
        menu = 15 ; // Retour au réglage de l'heure de démarage du Carillon
        counterEncoderHeure = start_Carillon[0] ; // Acquisition de l'heure de démarrage du Carillon mémorisée
        LCD.setCursor(5,1) ; LCD.print("   ") ; // Effacement des carractères précédents
        break ;
      case 17 :
        menu = 16 ; // Retour au réglage de la minute de démarage du Carillon
        counterEncoderMinute = start_Carillon[1] ; // Acquisition de la minute de démarrage du Carillon mémorisée
        LCD.setCursor(8,1) ; LCD.print("     ") ; // Effacement des carractères précédents
        break ;
      case 18 :
        menu = 17 ; // Retour au réglage de l'heure d'arrêt du Carillon
        counterEncoderHeure = stop_Carillon[0] ; // Acquisition de l'heure d'arrêt du Carillon mémorisée
        LCD.setCursor(13,1) ; LCD.print("   ") ; // Effacement des carractères précédents
        break ;
      case 21 :
      case 22 :
      case 23 :
      case 24 :
      case 25 :
        if (posChar == 0) // Premier caractère ?
        { 
          counterEncoderChar = 32 ; // Réinitialisation du compteur de caractères (affichage du caractère espace) 
          return ;
        }
        Texte[posChar] = 32 ; // Effacement du caractère courant
        counterEncoderChar = Texte[posChar - 1] ; // Positionnement du compteur de caractères à la valeur du caractère précédent
        posChar -- ; // Déplacement d'un caractère à gauche
        break ;
    }
    // Initialisation de la temporisation pour un appui très long
      clickTempo = millis() + 3000 ; // Initialisation à 3 secondes
  }


  /*****************************************************************************************\
  |* Fonction appelée une fois, lors d'un appui très long sur le poussoir du codeur.       *|
  \*****************************************************************************************/

  void longPressENCODER_SW() // Fonction appelée une fois, lors d'un appui très long sur le poussoir du codeur
  {
    if (millis() > clickTempo) // Est-ce un appuis très long ?
    {
      switch(menu)
      {
        case 11 :
          menu = 21 ; // Passage aux réglages des paramètres de communication
          readConfig(ssid) ; // Acquisition du SSID mémorisé
          break ;
        case 21 :
        case 22 :
        case 23 :
        case 24 :
        case 25 :
          for (int8_t i = 0 ; i < 64 ; i ++) Texte[i] = 0 ; // Effacement du texte
          LCD.clear() ; // Effacement du LCD
          posChar = 0 ; // Positionne sur le premier caractère
          counterEncoderChar = 32 ; // Réinitialisation du compteur de caractères (affichage du caractère espace)
          break ;
      }

    // Initialisation de la temporisation pour un appui très long
    clickTempo = millis() + 300000 ; // Initialisation à 300 secondes
  }
}

  /*****************************************************************************************\
  |* Fonction appelée une fois, lors du relachement du poussoir du codeur après un appui   *|
  |* long.                                                                                 *|
  \*****************************************************************************************/

  void longPressStopENCODER_SW() // Fonction appelée une fois, lors du relachement du poussoir du codeur après un appui long.
  {
  }