date heure temp hum LCD 4x20

/* ================================================================================================== */
// KRONOS 1.0
/* ================================================================================================== */
// à voir => chaînes formatées
/* ================================================================================================== */
// Calendrier / Pendule / thermomètre / hygromètre
// Affichage multimode sur ecran LCD 1 couleur (bleu) 20x4
// RTC 1603 (RTC)
// SHT15  (Capteur humidité / hygrométrie)
// Module 5 boutons (analogique) DFR0075 https://wiki.dfrobot.com/ADKeyboard_Module__SKU__DFR0075_
// Arduino Nano
// Afficheur LCD I2C 4X20 caractères
//  https://www.gotronic.fr/pj2-sbc-lcd20x4-fr-1440.pdf
//  https://www.gotronic.fr/pj2-pcf8574-3-1516.pdf
//  https://www.gotronic.fr/pj2-lcd2004-1515.pdf
/* ================================================================================================== */

/* ================================================================================================== */
// Ce "truc" possède 4 modes (ecran) d'affichages de la date, l'heure,
/* ================================================================================================== */
//----------------------------------------------------------------------------------------------------------
// IMPORTATION DES BIBLIOTHEQUES                                                                            |
//----------------------------------------------------------------------------------------------------------
#include <Wire.h>                                       // chargement de la bibliothèque de gestion simplifiée du cablage (I2C)
#include <DS1307.h>                                     // chargement de la bibliothèque de gestion du module RTC (Real Time Clock)
#include <SHT1x.h>                                      // chargement de la bibliothèque de gestion du module temperature humidité sht15
#include <LiquidCrystal_I2C.h>                          // chargement de la bibliothèque de gestion de l'ecran 4x20 I2C

LiquidCrystal_I2C lcd(0x27, 20, 4);                     // instanciation de l'occurence lcd() de l'objet LiquidCrystal_I2C

#define dataPin  10                                     // pin digital de connexion data Senseur SHT15
#define clockPin 11                                     // pin digital de connexion SCK Senseur SHT15
SHT1x sht15(dataPin, clockPin);                         // instanciation de l'occurence sht15() de l'objet SHT1x

//----------------------------------------------------------------------------------------------------------
// A modifier pour mettre "à l'heure"                                                                       |
//----------------------------------------------------------------------------------------------------------
#define update_mode 0                                   // 1 : Mise à jour du temps ; 0 : Affiche l'heure
//----------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------
// A modifier pour mettre "à l'heure"                                                                       |
//----------------------------------------------------------------------------------------------------------
#define TIME_YR    20  // <=                // année sans "20" de 2000                                      |
#define TIME_MTH   8   // <=                // numéro du mois de l'année                                    |
#define TIME_DATE  13  // <=                // jour du mois                                                 |
#define TIME_DOW   4   // <=                // jour de la semaine (lundi : 1; mardi : 2; mercredi : 3; etc) |
#define TIME_HR    16  // <=                // heures                                                       |
#define TIME_MIN   10  // <=                // minutes                                                      |
#define TIME_SEC   0   // <=                // secondes                                                     |
//----------------------------------------------------------------------------------------------------------

char* jour[] = {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"}; // nom du jour de la semaine

char* mois[] = {"janvier", "fevrier", "mars", "avril", "mai", "juin", "juillet", "aout", "septembre", "octobre", "novembre", "decembre"}; // nom du mois

// ???---???---  permet l'affichage des caractères spéciaux  ---???---???
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args)  write(args);
#else
#define printByte(args)  print(args,BYTE);
#endif
// ???---???---            ???---???---???---???             ---???---???

uint8_t pendule[8] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};          // caractère spécial pendule
uint8_t goutte[8] = {0x04, 0x04, 0x0A, 0x0A, 0x11, 0x11, 0x11, 0x0E}; // caractère spécial goutte
uint8_t thermo[8] = {0x04, 0x0A, 0x0B, 0x0A, 0x0F, 0x0E, 0x0F, 0x0E}; // caractère spécial thermomètre
// https://maxpromer.github.io/LCD-Character-Creator/

int rtc[7];                                       // tableau qui contiendra les valeurs du temps présent

unsigned long cycle;                              // repère temporel pour l'affichage des secondes ("refresh" ou nouveau Serial.print())
unsigned long cycleSensor;                        // repère temporel pour la lecture des senseur de température et humidité
unsigned long MargeCycleSensor = 30000;           // delais entre chaque lecture des senseurs

float temp_c;                                     // température en celsius
float temp_f;                                     // température en Fareneit
float humidity;                                   // taux d'humidité de l'air

float temp_c_max = 0;                             // température max en celsius
float temp_c_min = 1000;                          // température min en celsius
float temp_f_max = 0;                             // température max en Fareneit
float temp_f_min = 1000;                          // température min en Fareneit
float hum_max = 0;                                // taux max d'humidité de l'air
float hum_min = 101;                              // taux min d'humidité de l'air

int modeAff = 0;                                  // mode d'écran à afficher
int modeAffMem;                                   // mise en memoire du dernier mode ecran affiché

int longueurLigne;                                // nombre de caractère à l'écran (à afficher)
int avance = 0;                                   // position du repère de défilement
int debutAff;                                     // premier caractère de la ligne affiché
int finAff;                                       // dernier caratcère de la ligne affiché

int valeurTouche[5] = {600, 650, 720,  800, 900 };  // valeurs analogiques de basculement d'un bouton à l'autre
                                                  // (j'ai modifié le 3eme je suis passé de 700 à 720)
int nombreCle = 5;                                // détermine le nombre de boutons
int cleActive;                                    // bouton activé
int cle = -1;                                     // valeur du bouton
int ancienneCle = -1;                             // ancienne valeur connu des boutons
const int nombreMode = 3;                         // nombre de mode : 4 (mode : 0)

/* ================================================================================================== */

// fontction de défilement
/* ================================================================================================== */
void showDefil1() {
  RTC.get(rtc, true); {
    // ligne 1
    String ligne1 = String(jour[rtc[3] - 1]) + " " + String(rtc[4]);  // 'jour de la semaine' + " " + 'numéro du jour'
    if (rtc[4] < 2) {                                                 // si le 'numéro du jour' est "1"...
      ligne1 += "er ";                                                // ... on rajoute "er" juste après
    }
    ligne1 += " " + String(mois[rtc[5] - 1]) + " " + String(rtc[6]);  // " " + 'nom du mois' + " " + 'année' (4 chiffres)
    longueurLigne = ligne1.length();                                  // longuer de la chaine (nombre de caractère)

    if (avance < 19) {                                                // du tour 0 au tour 18

      debutAff = 0;                                                   // premier caractère = 0
      finAff = avance + 1;                                            // dernier caractère = numéro du tour (valeur de 'avance')
      lcd.setCursor((19 - avance), 0);                                // on positionne le curseur "(a droite - le nombre de tour fait)
      avance += 1;                                                    // on avance d'un cran le repere

    } else if (avance >= 19 && avance <= (longueurLigne + 19)) {      // du tour 19 au tour longueur + 19 (tant qu'on est pas a la fin de la ligne)

      debutAff = avance - 19;                                         // le premier caractere prend la valeur avance - 19
      finAff = avance + 1;                                            // le dernier caractère prend la valeur avance + 1
      lcd.setCursor(0, 0);                                            // curseur en haut à gauche
      avance += 1;                                                    // on avance d'un cran le repere

    } else if (avance > (longueurLigne + 19)) {                       // si c'est la fin

      //debutAff = longueurLigne - 20;                                  //
      //finAff = longueurLigne;                                         //
      lcd.setCursor(0, 0);                                            // curseur en haut à gauche
      avance = 0;

    }

    ligne1 = ligne1.substring(int(debutAff), int(finAff));            // on ne prend que ce qui est à afficher de la ligne

    if (ligne1.length() < 20 && avance > 19) {                        //
      for (int i = 0; i <= 20 - ligne1.length(); i++) {             //
        ligne1 += " ";                                                //on ajoute " " a la fin de la chaine pour que le 0 ne reste pas affiché
      }
    }
    lcd.print(ligne1);                                                // on l'affiche

    // Ligne 2                                                        // Construction de la ligne2

    String ligne2;                                                    // création de la chaine
    if (rtc[2] < 10) {                                                // si heure < 10
      ligne2 = "0" + String(rtc[2]) + ":";                            // on fait la concaténation en commencant par un "0"
    }else{                                                            // sinon
      ligne2 = String(rtc[2]) + ":";                                  // on fait la concaténation
    }
    if (rtc[1] < 10) {
      ligne2 += "0" + String(rtc[1]) + ":";
    }else{
      ligne2 += String(rtc[1]) + ":";
    }
    if (rtc[0] < 10) {
      ligne2 += "0" + String(rtc[0]);
    }else{
      ligne2 += String(rtc[0]);
    }
    lcd.setCursor(6, 1);
    lcd.print(ligne2);

// Ligne 3                                                        // Construction de la ligne3
    lcd.setCursor(0, 2);
    lcd.printByte(2);                                             // affichage du caractère spécial
    lcd.print("      ");
    if (temp_c < 10) {
      lcd.print("0");                                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(temp_c, 1);                                         // valeur de la température en Celcius
    lcd.write(223);                                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
    lcd.print("C");
    lcd.print("      ");
    lcd.printByte(2);

// Ligne 4
    lcd.setCursor(0, 3);
    lcd.printByte(1);
    lcd.print("      ");
    lcd.print(humidity);                                          // valeur tu taux d'humidité de l'air (en %)
    lcd.print("%");
    lcd.print("      ");

    lcd.printByte(1);
  }
}

/* ================================================================================================== */

void showMax() {
  lcd.setCursor(6, 0);
  lcd.print("MAXIMUM");
  lcd.setCursor(0, 1);
  lcd.printByte(2);
  lcd.print("      ");
  if (temp_c_max < 10) {
    lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
  }
  lcd.print(temp_c_max, 1);                     // valeur de la température en Celcius
  lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("C");
  lcd.print("      ");
  lcd.printByte(2);
  lcd.setCursor(0, 2);
  lcd.printByte(2);
  lcd.print("      ");
  if (temp_f_max < 10) {
    lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
  }
  lcd.print(temp_f_max, 1);                     // valeur de la température en Celcius
  lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("F");
  lcd.print("      ");
  lcd.printByte(2);
  lcd.setCursor(0, 3);
  lcd.printByte(1);
  lcd.print("      ");
  lcd.print(hum_max);                           // valeur de la température en Celcius
  lcd.print("%");
  lcd.print("      ");
  lcd.printByte(1);
}

void showMin() {
  lcd.setCursor(6, 0);
  lcd.print("MINIMUM");
  lcd.setCursor(0, 1);
  lcd.printByte(2);
  lcd.print("      ");
  if (temp_c_min < 10) {
    lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
  }
  lcd.print(temp_c_min, 1);                     // valeur de la température en Celcius
  lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("C");
  lcd.print("      ");
  lcd.printByte(2);
  lcd.setCursor(0, 2);
  lcd.printByte(2);
  lcd.print("      ");
  if (temp_f_min < 10) {
    lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
  }
  lcd.print(temp_f_min, 1);                     // valeur de la température en Celcius
  lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("F");
  lcd.print("      ");
  lcd.printByte(2);
  lcd.setCursor(0, 3);
  lcd.printByte(1);
  lcd.print("      ");
  lcd.print(hum_min);                           // valeur de la température en Celcius
  lcd.print("%");
  lcd.print("      ");
  lcd.printByte(1);
}

void showAll3() {
  RTC.get(rtc, true); {
    lcd.setCursor(5, 0);
    if (rtc[4] < 10) {
      lcd.print("0");                            // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(rtc[4]);
    lcd.print("/");
    if (rtc[5] < 10) {
      lcd.print("0");                            // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(rtc[5]);
    lcd.print("/");
    lcd.print(rtc[6]);
    lcd.setCursor(0, 1);
    lcd.printByte(0);
    lcd.print("     ");
    if (rtc[2] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les heures sont inférieures à 10
    }
    lcd.print( rtc[2]);                           // heures minutes secondes
    lcd.print(":");                               // ":"
    if (rtc[1] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print( rtc[1]);                           // valeur des minutes
    lcd.print(":");                               // ":"
    if (rtc[0] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les secondes sont inférieures à 10
    }
    lcd.print( rtc[0]);
    lcd.print("     ");
    lcd.printByte(0);
    lcd.setCursor(0, 2);
    lcd.printByte(2);
    lcd.print("      ");
    if (temp_c < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(temp_c, 1);                         // valeur de la température en Celcius
    lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
    lcd.print("C");
    lcd.print("      ");
    lcd.printByte(2);
    lcd.setCursor(0, 3);
    lcd.printByte(1);
    lcd.print("      ");
    lcd.print(humidity);                          // valeur tu taux d'humidité de l'air (en %)
    lcd.print("%");
    lcd.print("      ");

    lcd.printByte(1);
  }
}

void showAll2() {
  RTC.get(rtc, true); {                           // récupération des valeurs du module RTC
    lcd.setCursor(0, 0);
    if (rtc[4] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(rtc[4]);
    lcd.print("/");
    if (rtc[5] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print(rtc[5]);
    lcd.print("/");
    lcd.print(rtc[6]);
    lcd.print(" ");
    lcd.printByte(0);
    if (rtc[2] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les heures sont inférieures à 10
    }
    lcd.print( rtc[2]);                           // heures minutes secondes
    lcd.print(":");                               // ":"
    if (rtc[1] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print( rtc[1]);                           // valeur des minutes
    lcd.print(":");                               // ":"
    if (rtc[0] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les secondes sont inférieures à 10
    }
    lcd.print( rtc[0]);
    lcd.setCursor(6, 1);
    lcd.print( jour[rtc[3] - 1]);
    lcd.setCursor(0, 2);
    lcd.printByte(2);
    lcd.print(" ");
    lcd.print(temp_c, 1);                         // valeur de la température en Celcius
    lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
    lcd.print("C - ");
    lcd.printByte(1);
    lcd.print(" ");
    lcd.print(humidity);                          // valeur tu taux d'humidité de l'air (en %)
    lcd.print("%");
    lcd.setCursor(5, 3);
    lcd.print("(");
    lcd.printByte(2);
    lcd.print(" ");
    lcd.print(temp_f, 1);                         // valeur de la température en Farenheight
    lcd.write(223);                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
    lcd.print("F)");
  }
}

void showMeteo1 () {                              // fonction qui affiche la température et l'humidité
  lcd.setCursor(0, 2);                            // position du curseur 1er caractère (0) 3ème ligne (2)
  lcd.printByte(2);
  lcd.print(" : ");
  //lcd.print("T : ");                            // __T : __
  lcd.print(temp_c, 1);                           // valeur de la température en Celcius
  lcd.write(223);                                 // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("C (");                               // _C (_
  lcd.print(temp_f, 1);                           // valeur de la température en Farenheight
  lcd.write(223);                                 // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
  lcd.print("F)");                                // _F)_
  lcd.setCursor(0, 3);                            // position du curseur 1er caractère (0) 4ème ligne (3)
  lcd.printByte(1);
  lcd.print(" :    ");                            // _H :    _
  //lcd.print("H :    ");                         // _H :    _
  lcd.print(humidity);                            // valeur tu taux d'humidité de l'air (en %)
  lcd.print("%");                                 // _%_
}


void showtime1() {                                // fonction qui affiche l'heure
  RTC.get(rtc, true);                             // récupération des valeurs du module RTC
  {
    //lcd.clear();                                // efface l'écran
    lcd.setCursor(0, 0);                          // position du curseur 1er caractère (0) 1ère ligne (0)
    lcd.print( jour[rtc[3] - 1]);                 // jour de la semaine
    lcd.print(" ");                               // "espace"
    lcd.print(rtc[4]);                            // date mois année : numéro du jour
    if (rtc[4] < 2) {
      lcd.print("er");                            // on rajouter "er" apres le numero du jour si on est le 1er du mois
    }
    lcd.print(" ");                               // "espace"
    lcd.print( mois[rtc[5] - 1]);                 // mois de l'année
    lcd.print(" ");                               // "espace"
    //lcd.print( rtc[6]);                         // année avec "20" de 2000

    lcd.setCursor(0, 1);
    lcd.printByte(0);
    lcd.print(" :   ");
    if (rtc[2] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les heures sont inférieures à 10
    }
    lcd.print( rtc[2]);                           // heures minutes secondes
    lcd.print(":");                               // ":"
    if (rtc[1] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les minutes sont inférieures à 10
    }
    lcd.print( rtc[1]);                           // valeur des minutes
    lcd.print(":");                               // ":"
    if (rtc[0] < 10) {
      lcd.print("0");                             // on rajoute un zéro si les secondes sont inférieures à 10
    }
    lcd.print( rtc[0]);                           // valeur des secondes
  }
}

int recupCle(unsigned int input) {                // transforme la valeur du clavier en numero de touche
  int k;
  for (k = 0; k < nombreCle; k++) {
    if (input < valeurTouche[k]) {
      return k;
    }
  }
  if (k >= nombreCle) {
    k = -1;                                       // En cas de valeur non valide
  }
  return k;
}
/* ================================================================================================== */
// SETUP
/* ================================================================================================== */

void setup() {
  Serial.begin(9600);
  lcd.init();                                     // initialisation de l'écran
  Wire.begin();                                   // lancement connexion simplifiée
  lcd.backlight();                                // éclairage de l'écran
  lcd.createChar(0, pendule);                     // creation du caractère spécial pendule
  lcd.createChar(1, goutte);                      // création du caractère spécial goutte
  lcd.createChar(2, thermo);                      // création du caractère spécial thermometre

  //                      Mise à jour du Temps
  if (update_mode) {                              // si updata_flag 1 l'heure est mise à jour
    showtime1();                                  // on affiche l'heure actuelle
    lcd.setCursor(5, 3);                          // sur la dernière ligne à partir de la cinquieme colonne
    lcd.print("Ancienne heure");                  // on affiche l'heure actuelle
    RTC.stop();                                   // on arete la l'horloge (RTC)
                                                  // valeurs de mise a jour du Temps
    RTC.set(DS1307_SEC, TIME_SEC);                // secondes => (valeurs entrées ci dessus)
    RTC.set(DS1307_MIN, TIME_MIN);                // minutes => (valeurs entrées ci dessus)
    RTC.set(DS1307_HR, TIME_HR);                  // heures => (valeurs entrées ci dessus)
    RTC.set(DS1307_DOW, TIME_DOW);                // jour de la semaine => (valeurs entrées ci dessus)
    RTC.set(DS1307_DATE, TIME_DATE);              // numéro du jour du mois => (valeurs entrées ci dessus)
    RTC.set(DS1307_MTH, TIME_MTH);                // mois => (valeurs entrées ci dessus)
    RTC.set(DS1307_YR, TIME_YR);                  // année => (valeurs entrées ci dessus)
    RTC.start();                                  // l'horloge (RTC) est relancée avec les nouvelles valeurs
    showtime1();                                  // on affiche la nouvelle heure
    lcd.setCursor(3, 3);                          // sur la dernière ligne à partir de la troisieme colonne
    lcd.print("Heure mise à jour");               // on affiche que c'est fait

  } else {                                        // sinon on lance le Temps

    cycle = millis();                             // marquage temporel pour les secondes
    cycleSensor = millis() + MargeCycleSensor;    // marquage plus marge pour les senseurs (1 seule fois)

  }
}

/* ================================================================================================== */
// LOOP
/* ================================================================================================== */

void loop() {

  // 1. on prend les valeurs température et humidité du capteur

  if (millis() - cycleSensor >= MargeCycleSensor) {     // toutes les 30s
    cycleSensor = millis();                             // réinitialisation du repère temporel des senseurs
    temp_c = sht15.readTemperatureC();                  // lecture température celsius
    temp_f = sht15.readTemperatureF();                  // lecture température Farenheit
    humidity = sht15.readHumidity();                    // lecture taux d'humidité

    // 2. on met a jour les valeurs min et max si nécessaire

    if (temp_c > temp_c_max) {                          // si la température mesurée est supérieure à la température max enregistrée
      temp_c_max = temp_c;                              // alors la température mesurée devient la température max
    }

    if (temp_c < temp_c_min) {                          // (voir ci dessus et remplacer "max" par "min")
      temp_c_min = temp_c;                              //
    }

    if (temp_f > temp_f_max) {                          // meme principe que ci dessus : "voir ci-dessus et remplacer
      temp_f_max = temp_f;                              //
    }

    if (temp_f < temp_f_min) {                          // (pareil...)
      temp_f_min = temp_f;                              //
    }

    if (humidity > hum_max) {                           // ...
      hum_max = humidity;                               //
    }

    if (humidity < hum_min) {                           //
      hum_min = humidity;                               //
    }

  }

  // 3. on met à jour l'affichage toutes les secondes
  // c'est ici que seront gérés les modes d'affichage contrôlé par un module 5 BP

  // Contrôle du mode d'affichage par le module 5 boutons
  // https://wiki.dfrobot.com/ADKeyboard_Module__SKU__DFR0075_

  // on détermine le numero du mode d'affichage à faire
  // ce numero va de 0 à nombreMode + 2
  // nombreMode est le nombre d'affichage des valeurs
  // il faut y rajouter 2 valeurs supplémentaire pour Min et Max

  cleActive = analogRead(0);                            // on recupere la valeur du bouton enfoncé
  cle = recupCle(cleActive);                            // on la transforme en numero de bouton
  if (cle != ancienneCle) {                             // on vient d'enfoncer
    delay(50);                                          // pause'café
    cleActive = analogRead(0);                          // on relit la valeur
    cle = recupCle(cleActive);                          // on la transforme en numero de bouton
    if (cle != ancienneCle) {                           // on vient de le relacher
      ancienneCle = cle;                                // reaffectation
      if (cle >= 0) {                                   // vérification validité
        switch (cle) {                                  // on voit alors les différents cas
          case 0:                                       // cle = 0; bouton 1 "haut"
            if (modeAff <= 3) {                         // si on vient d'un mode affichage "horloge"
              modeAffMem = modeAff;                     // on garde cette valeur en memoire
            }
            modeAff = (nombreMode + 1);                 // 3
            lcd.clear();                                // efface ecran
            break;                                      // stop => etape suivante
          case 1:                                       // cle = 1; bouton 2 "gauche"
            if (modeAff > 0) {                          // on vérifie qu'on soit pas au bout
              modeAff -= 1;                             // on retire 1
            } else {                                    // sinon
              modeAff = nombreMode;                     // on passe au max
            }
            lcd.clear();                                // efface ecran
            break;                                      // stop => etape suivante
          case 2:                                       // cle = 2; bouton 3 "bas"
            if (modeAff <= 3) {                         // si on vient d'un mode affichage "horloge"
              modeAffMem = modeAff;                     // on garde cette valeur en memoire
            }
            modeAff = (nombreMode + 2);                 // 4
            lcd.clear();                                // on vide l'ecran pour l'affichage du mode a venir
            break;                                      // stop => etape suivante
          case 3:                                       // cle = 3; bouton 4 "droite"
            if (modeAff < nombreMode) {                 // si on est pas au "bout haut" des modes (nombreMode)
              modeAff += 1;                             // on passe au niveau suivant (+1)
            } else {                                    // sinon
              modeAff = 0;                              // on remet le mode au "bout bas" des modes (0)
            }
            lcd.clear();                                // efface ecran
            break;                                      // stop => etape suivante
          case 4:                                       // pas encore utilisé bouton du milieu
            if (modeAff > nombreMode) {                 // Si on est en mode mini ou maxi
              modeAff = modeAffMem;                     // on rappelle le mode d'affichage mémorisé
            }
            lcd.clear();
            break;                                      // stop => etape suivante
        }
      }
    }
  }

  if (millis() - cycle >= 500) {                     // toutes les secondes
    cycle = millis();                                 // réinitialisation du repère temporel de l'heure (seconde)
    if (update_mode == 0) {                           // si updata_flag 0

      switch (modeAff) {
        case 0:
          showtime1();                                // Affichage Mode 1
          showMeteo1();
          break;
        case 1:
          showAll2();                                 // Affichage Mode 2
          break;
        case 2:
          showAll3();                                 // Affichage Mode 3
          break;
        case 3:
          showDefil1();                               // Affichage Mode 4
          break;
        case 4:
          showMax();                                 // Affichage Mode Max
          break;
        case 5:
          showMin();                                 // Affichage Mode Min
          break;
      }
    }
  }
}