ThermometreHumiditéLumiereEcran20x4

/* ================================================================================================== */
// KRONOS 1.1
// Ollivier JULLIEN août 2020
// 100% libre de droit
// (en cas de copie, merci de citer l'auteur... il a travaillé dur pour vous le donner ;) )
// Merci à Serge DUCATEZ
/* ================================================================================================== */
// à voir => chaînes formatées
/* ================================================================================================== */
// Calendrier / Pendule / thermomètre / hygromètre
// Affichage multimode sur ecran LCD 1 couleur (bleu) 20x4
//
// RTC 1603 (RTC) Horloge en temps réel DFR0151
//    https://wiki.dfrobot.com/Gravity__I2C_DS1307_RTC_Module_SKU__DFR0151
//
// SHT15  (Capteur humidité / hygrométrie) (double I2C / pseudo I2C ??)
// Capteur de T° et d'humidité Gravity DFR0066
//    https://wiki.dfrobot.com/SHT1x_Humidity_and_Temperature_Sensor__SKU__DFR0066_
//
// Module 5 boutons (analogique) DFR0075
//     https://wiki.dfrobot.com/ADKeyboard_Module__SKU__DFR0075_
//
// capteur de lumière ambiante SEN0172 (juste parce que j'en ai un)
//    https://wiki.dfrobot.com/LX1972_ambient_light_sensor_SKU_SEN0172
//
// 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, la température en °C, le taux
// d'humidité de l'air, dont un avec défilement de la date du jour, et deux autres qui donnent la
// température en °F.
// Cette nouvelle version donne aussi l'intensité lumineuse ambiante.
// De plus j'ai rajouté une animation de la pendule sur l'écran 2, et un nouvel icone "calendrier"
// sur ce même écran.
// Elle comporte aussi le clignotement des ":" des horloges.
//
// Utilisation
//
// Le controle se fait par 5 boutons (Ben oui j'en avais 5 de dispo, c'est l'opulence.
//             BOUTON 1 BLANC
//                    O
//   BOUTON 2 ROUGE O O O BOUTON 4 VERT || AU CENTRE BOUTON 5 BLANC
//                    O
//             BOUTON 3 BLANC
// BOUTON 2 ROUGE passe au mode suivant (et retourne au premier une fois au bout)
// BOUTON 4 VERT  passe au mode précédent (et retourne au dernier une fois au bout)
// BOUTON 1 BLANC affiches les valeurs maximum de température et d'humidité atteinte depuis qu'il est branché
// BOUTON 3 BLANC affiches les valeurs minimum de température et d'humidité atteinte depuis qu'il est branché
// BOUTON 5 BLANC si on vient de mini ou maxi, on affiche le dernier mode selectionné avec ROUGE ou VERT
//
// Il faudra un peu modifier le code pour l'utiliser avec des boutons poussoirs différents de ce module
//
/* ================================================================================================== */
// Suite possible / prévue
/* ================================================================================================== */
// [x] FAIT : animation pendule sur 3 positions (3 caracteres speciaux), 4 mouvements
// [x] FAIT : animation des ":" dans les horloges
// [x] FAIT : ajouter un capteur de lumière ambiante SEN0172 (juste parce que j'en ai un)
// [x] FAIT : ajouter une icone calendrier
// [x] FAIT : le centrage automatique des lignes
//    => date ecran 1 / ligne 1 | et | jour ecran 2 / Ligne 2
// [x] FAIT : Rajouter l'année sur l'écran 1
// Accents sur le 'u' de août et les 'e' sur février et décembre
//    Peut me servir pour çà :
//    http://www.electronic-engineering.ch/microchip/datasheets/lcd/charset.gif
//    http://fabrice.sincere.pagesperso-orange.fr/cm_electronique/electronique_numerique20/annexe/conversion_decimal_hexa02.pdf
// Connexion RF433 avec une autre sonde température (pour mode extérieur intérieur) (+2)
// Mise à jour de l'heure par l'utilisateur (compliqué, mais...)
// ... et peut être de nouveaux modes d'affichage (écrans)
//
// J'attends vos idées...
//
// REMARQUE : Il semblerait que dans ce code, 'lcd.printByte()' peut être remplacé par 'lcd.write()'
// mais je ne sais pas si on a encore besoin du #DEFINE suivante... (je regarderai plus tard)
//
// #if defined(ARDUINO) && ARDUINO >= 100
// #define printByte(args)  write(args);
// #else
// #define printByte(args)  print(args,BYTE);
// #endif
//
//----------------------------------------------------------------------------------------------------------
// 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 pendulePre[8] = {0x0E, 0x15, 0x17, 0x11, 0x0E, 0x00, 0x00, 0x00};
uint8_t pendulePost[8] = {0x00, 0x00, 0x00, 0x0E, 0x15, 0x17, 0x11, 0x0E};
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
uint8_t lum[8] = {0x00, 0x04, 0x15, 0x0E, 0x1F, 0x0E, 0x15, 0x04};    //caractère spécial lumière
uint8_t cal[8] = {0x1F, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F};   //caractère spécial calendrier
// 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)

int pinAnalogLumiere = 1;
int lumiere;

int cyclePendule = 1;

bool etatDeuxPoints = 0;

int positionCentrage;

/* ================================================================================================== */
// fontctions
/* ================================================================================================== */

/* ================================================================================================== */
// fonction d'affichage de la lumiere
/* ================================================================================================== */

void afficheLumiere(){
  lcd.home();
  lcd.printByte(3);
  lcd.print(" ");
  lcd.print(lumiere);
  lcd.print("%");
}

/* ================================================================================================== */
// fonction d'affichage du mode avec 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

      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

    lcd.setCursor(0, 1);
    lcd.print("  ");
    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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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);
    etatDeuxPoints = !etatDeuxPoints;

//------------------------------------------------------------------------------------------------------

    // Autre construction de la ligne possible

    /*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.print(temp_f, 1);                                         // valeur de la température en Celcius
    lcd.write(223);                                               // caractère "°" (attenteion utiliser lcd.write(); pas lcd.print();
    lcd.print("F ");
    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.print(lumiere);                                          // valeur tu taux d'humidité de l'air (en %)
    lcd.print("%");
    lcd.print("  ");
    lcd.printByte(3);
  }
}

/* ================================================================================================== */
// fonction d'affichage des valeurs maxi
/* ================================================================================================== */

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);
}

/* ================================================================================================== */
// fonction d'affichage des valeurs mini
/* ================================================================================================== */

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);
}

/* ================================================================================================== */
// fonction d'affichage de l'ecran (mode) 3
/* ================================================================================================== */

void showAll3() {
  RTC.get(rtc, true); {
    lcd.setCursor(0, 0);
    lcd.print("  ");
    lcd.printByte(6);
    lcd.print("  ");
    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(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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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.print(temp_f, 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(humidity);                          // valeur du taux d'humidité de l'air (en %)
    lcd.print("%");
    lcd.print("  -  ");
    lcd.print(lumiere);                          // valeur de l'intensité lumineuse (en %)
    lcd.print("%");
    lcd.print("  ");
    lcd.printByte(3);
    etatDeuxPoints = !etatDeuxPoints;
  }
}

/* ================================================================================================== */
// fonction d'affichage de l'ecran (mode) 2
/* ================================================================================================== */

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(" ");

    if (cyclePendule < 4){
      if (cyclePendule == 2){
        lcd.printByte(0);
      } else if (cyclePendule == 1){
        lcd.printByte(4);
      } else if (cyclePendule == 3){
        lcd.printByte(5);
      }
      cyclePendule += 1;
    }else{
      cyclePendule = 0;
      lcd.printByte(0);
      cyclePendule += 1;
    }

    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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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]);

    String ligne1 = String( jour[rtc[3] - 1]);
    longueurLigne = ligne1.length();
    if (longueurLigne <= 20){
      positionCentrage = (20 - longueurLigne)/2;
      lcd.setCursor(positionCentrage, 1);
    }else{
    lcd.setCursor(0, 1);
    }
    lcd.print(ligne1);
/*
    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(0, 3);
    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 - ");
    lcd.printByte(3);
    lcd.print("   ");
    lcd.print(lumiere);                         // valeur de l'intensité de la lumière (%)
    lcd.print("%");
    etatDeuxPoints = !etatDeuxPoints;
  }
}

/* ================================================================================================== */
// fonction d'affichage de l'ecran (mode) 1
/* ================================================================================================== */
//    Météo
/* ================================================================================================== */

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(" : ");                               // _ : _
  lcd.print(humidity);                            // valeur tu taux d'humidité de l'air (en %)
  lcd.print("% - ");                              // _%_
  lcd.printByte(3);
  lcd.print(" : ");                               // _ : _
  lcd.print(lumiere);                            // valeur tu taux d'humidité de l'air (en %)
  lcd.print("%");                                 // _%_
}

/* ================================================================================================== */
//    Calendrier / Horloge
/* ================================================================================================== */

void showtime1() {                                // fonction qui affiche l'heure
  RTC.get(rtc, true);                             // récupération des valeurs du module RTC
  {

    String ligne1 = String(jour[rtc[3] - 1]) + " " + String(rtc[4]);
    if (rtc[4] < 2) {
      ligne1 += "er";                             // on rajouter "er" apres le numero du jour si on est le 1er du mois
    }
    ligne1 += " " + String(mois[rtc[5] - 1]);
    longueurLigne = ligne1.length();
    if (longueurLigne <= 20){
      positionCentrage = (20 - longueurLigne)/2;
      lcd.setCursor(positionCentrage, 0);
    }else{
    lcd.setCursor(0, 0);
    }
    lcd.print(ligne1);

/*    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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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
    if (etatDeuxPoints == 1){
      lcd.print(":");                             // ":"
    } else {
      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
    lcd.print("  ");
    //lcd.printByte(6);
    lcd.print(" ");
    lcd.print(rtc[6]);
    etatDeuxPoints = !etatDeuxPoints;
  }
}

/* ================================================================================================== */
// fonction qui transforme les valeurs reçues du module 5 BP en numero de bouton
/* ================================================================================================== */

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
  lcd.createChar(3, lum);                         // création du caractère spécial thermometre
  lcd.createChar(4, pendulePre);                     // creation du caractère spécial pendule
  lcd.createChar(5, pendulePost);                     // creation du caractère spécial pendule
  lcd.createChar(6, cal);                     // creation du caractère spécial pendule

  //                      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 lumière, température et humidité des capteur

  if (millis() - cycleSensor >= MargeCycleSensor) {     // toutes les 30s
    lumiere = map(analogRead(pinAnalogLumiere), 0, 1023, 0, 100);
    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:
          //afficheLumiere();
          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;
      }
    }
  }
}