thermochagpt

/**************************************************************************************************************************************************************************
//**************************************************** Thermomètre Navette Textile v3.0Claude Menu - Carte Nano (com25) ****************************************************
//**************************************************************************************************************************************************************************
// Version opérationnelle avec un risque d'instabilité du programme.
// Dfplayer opérationnel.
// Buzzer système.
// Stockage des messages à afficher sur l'écran OLED en mémoire programme. (Mémoire Flash)
// Prise en compte des éventuels évènements lors des boucles bloquantes :
//  - Détection des changements d'état des Dip Switch,
//  - Détection des changements d'état des boutons poussoirs
//  - Détection de la date et l'heure de départ du compte à rebours de la nouvelle année,
//  - Détection de la nouvelle heure pour l'annonce audio,
//  - Détection du changement de la valeur du potentiomètre du volume du Dfplayer.
// Points clignotants de l'heure sur l'écran OLED.
// Compte à rebours de la nouvelle année sur l'écran OLED.
// Moyenne de 50 relevés effectués sur la LDR.
// Echelle 1 de 10 à 36.5° et Echelle 2 de 20 à 46.5°.
// Led55 alumée = Echelle 1; Led55 et led54 = Echelle 2.
// Animation des barrettes de leds adressables après le compte à rebours de la nouvelle année.
// Menu Réglage heure, date.
//**************************************************************************************************************************************************************************
#include <Wire.h>                                                                                                                     // Librairie pour la gestion de la communication I2C
#include <Adafruit_SSD1306.h>                                                                                                         // Librairie pour la gestion de l'afficheur OLED 1.3" (128x64)
#include <Adafruit_NeoPixel.h>                                                                                                        // Librairie pour la gestion des Barrettes de leds adressables Neopixel (WS2812B)
#include <SPI.h>                                                                                                                      // Librairie pour la gestion de la communication SPI avec le Module Horloge DS3234
#include <SparkFunDS3234RTC.h>                                                                                                        // Librairie pour la gestion du Module Horloge DS3234
#include "DHT.h"                                                                                                                      // Librairie pour la gestion du Capteur DHT22 (Température et Taux Humidité)
#include "DFRobotDFPlayerMini.h"                                                                                                      // Librairie pour la gestion du Module Audio Dfplayer
#include <TimerOne.h>                                                                                                                 // Librairie pour la gestion de l'interruption logicielle par Timer
#include <avr/pgmspace.h>                                                                                                             // Librairie pour la gestion de la Mémoire
/*#include <avr/pgmspace.h>*/
#define DHTTYPE DHT22                                                                                                                 // Définit le type de capteur (Température et Taux Humidité)

#define BrocheBPDroite              A2                                                                                                // Broche Entrée Bouton Poussoir "Droite"
#define BrocheBPOK                  A3                                                                                                // Broche Entrée Bouton Poussoir "OK"
#define BrocheBPGauche              A1                                                                                                // Broche Entrée Bouton Poussoir "Gauche"
#define BrocheDipSwitchMuteGeneral  2                                                                                                 // Broche Entrée Dip Switch Mute Général
#define BrocheDipSwitchMutePartiel  3                                                                                                 // Broche Entrée Dip Switch Mute Partiel
#define BrocheDipSwitchVoix         5                                                                                                 // Broche Entrée Dip Switch Voix
#define BrochePotentiometreVolume   A6                                                                                                // Broche Entrée Potentiomètre du Volume du Dfplayer
#define BrocheLDR                   A7                                                                                                // Broche Entrée Cellule Photoélectrique LDR
#define BrocheBuzzer                A0                                                                                                // Broche du Buzzer 5v
#define BrocheCapteurDHT22          7                                                                                                 // Broche du Capteur DHT22
#define BrocheBarrettesTemperature  6                                                                                                 // Broche d'entrée (DIN) des Barrettes de leds adressables Neopixel pour l'affichage de la température courante et des vitesses de variations de la température et du taux d'humidité
#define BrocheDS3234                10                                                                                                // Broche du Module Horloge DS3234
#define BrocheOledReset             4                                                                                                 // Broche du Reset le l'Afficheur OLED

Adafruit_SSD1306 display(BrocheOledReset);                                                                                            // Crée l'objet "display"

const byte numLedRougeEchelleTemp1 PROGMEM = 55;                                                                                      // Définit la led 55 témoin de l'échelle de Température 1 ou 2 (10° à 36.5°)
const byte numLedRougeEchelleTemp2 PROGMEM = 54;                                                                                      // Définit la led 54 témoin de l'échelle de Température 2 (20° à 46.5°)

const byte nombreLedsColonne PROGMEM = 56;                                                                                            // Nombre de leds adressables de la colonne pour l'affichage de la température courante et des vitesses de variations de la température et du taux d'humidité (7 barrettes de 8 leds)

int LastvaleurLuminositeAmbiante = -1;                                                                                                // Dernière valeur de la luminosité ambiante lue par la LDR

float tauxHumiditeCourant = 0;                                                                                                        // Taux d'humidité courant relevé par le capteur DHT22
float LasttauxHumiditeCourant = -1;                                                                                                   // Dernière valeur courante du taux d'humidité courant relevée par le capteur DHT22
float temperatureCourante = 0;                                                                                                        // Température courante relevée par le capteur DHT22
float LasttemperatureCourante = -1;                                                                                                   // Dernière valeur courante de la température courante relevée par le capteur DHT22

const byte k PROGMEM = 150;                                                                                                           // Coefficient pour le calcul de la vitesse de la variation de la température et de la vitesse de la variation du taux d'humidité
float T1 = 0;                                                                                                                         // Relevé de la première température pour le calcul de la vitesse de la variation de la température
float T2 = 0;                                                                                                                         // Relevé de la deuxième température pour le calcul de la vitesse de la variation de la température
float H1 = 0;                                                                                                                         // Relevé du premier taux d'humidité pour le calcul de la vitesse de la variation du taux d'humidité
float H2 = 0;                                                                                                                         // Relevé du deuxième taux d'humidité pour le calcul de la vitesse de la variation du taux d'humidité
unsigned long t1TempoReleveVariations = 0;                                                                                            // Début de la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
boolean MajAffichageVariations = false;                                                                                               // Indicateur Activation / Désactivation de l'affichage des vitesses de variations de la température et du taux d'humidité
const unsigned long FrequenceReleveVariations PROGMEM = 30000;                                                                        // Fréquence de calcul et d'affichage des vitesses de variations de la température et du taux d'humidité
const unsigned long TempoAffichageVariations PROGMEM = 5000;                                                                          // Durée de l'affichage des vitesses de la variations de la température et du taux d'humidité

byte PageOled = 0;                                                                                                                    // Page courante de l'écran OLED
unsigned long t1TempoAffichageMessageOled = 0;                                                                                        // Début de la temporisation de la durée d'affichage de certains messages sur l'écran OLED (3 secondes)
const unsigned long TempoAffichageMessageOled PROGMEM = 3000;                                                                         // Durée d'affichage des messages sur l'écran OLED

boolean MajAffichageTemperatureCourante = false;                                                                                      // Indicateur Activation / Désactivation de l'affichage de la température courante sur la colonne de leds
boolean MajTauxHumiditeCourant = false;                                                                                               // Indicateur Activation / Désactivation de l'affichage du taux d'humidité courant sur l'afficheur Oled

byte Hrs = 0;                                                                                                                         // Heure Courante
byte Mins = 0;                                                                                                                        // Minutes courante
byte Secs = 0;                                                                                                                        // Seconde Courante
int LastMins = -1;                                                                                                                    // Dernière valeur courante des minutes
volatile boolean Osc2Points = true;                                                                                                   // Indicateur pour l'oscillation des 2 points de l'affichage de l'heure sur l'écran OLED

byte Jour = 0;                                                                                                                        // Jour du mois de la date courante (1 à 31)
byte Mois = 0;                                                                                                                        // Mois de la date courante (1 à 12)
byte Annee = 0;                                                                                                                       // Année de la date courante (0 à 99)
int LastJour = -1;                                                                                                                    // Dernière valeur courante du jour du mois

boolean LastEtatDipSwitchMuteGeneral = HIGH;                                                                                          // Dernier état de l'entrée du Dip Switch Mute Général
boolean LastEtatDipSwitchMutePartiel = HIGH;                                                                                          // Dernier état de l'entrée du Dip Switch Mute Partiel
boolean LastEtatDipSwitchVoix = HIGH;                                                                                                 // Dernier état de l'entrée du Dip Switch Voix
boolean EtatDipSwitchMuteGeneral = HIGH;                                                                                              // Etat de l'entrée du Dip Switch Mute Général
boolean EtatDipSwitchMutePartiel = HIGH;                                                                                              // Etat de l'entrée du Dip Switch Mute Partiel
boolean EtatDipSwitchVoix = HIGH;                                                                                                     // Etat de l'entrée du Dip Switch Mute Voix

boolean LastetatBPOK = HIGH;                                                                                                          // Dernier état courant de l'entrée du bouton poussoir BPOK
boolean etatBPOK = HIGH;                                                                                                              // Etat courant de l'entrée du bouton poussoir BPOK
boolean etatBPDroite = HIGH;                                                                                                          // Etat courant de l'entrée du bouton poussoir BPDroite
boolean etatBPGauche = HIGH;                                                                                                          // Etat courant de l'entrée du bouton poussoir BPGauche

boolean MuteGeneral = false;                                                                                                          // Indicateur du Mode Mute Général (0 ou 1)
boolean MutePartiel = false;                                                                                                          // Indicateur du Mode Mute Partiel (0 ou 1)
boolean Voix = false;                                                                                                                 // Indicateur de la voix sélectionnée (1 ou 2)
const byte HrsDebutMutePartiel PROGMEM = 23;                                                                                          // Heure du Début du Mute Partiel
const byte HrsFinMutePartiel PROGMEM = 6;                                                                                             // Heure de Fin du Mute Partiel

int valeurPotentiometreVolume = 0;                                                                                                    // Valeur courante lue sur la broche du potentiomètre du volume du Dfplayer
int LastvaleurPotentiometreVolume = -1;                                                                                               // Dernière valeur courante lue sur la broche du potentiomètre du volume du Dfplayer
byte VolumeDfplayer = 30;                                                                                                             // Volume par défaut du Dfplayer

int nbCycleAnimationCompteAReboursBarrettesLeds = 0;                                                                                  // Nombre de cycles de l'animation du compte à rebours de la nouvelle année

byte brightnessBarrettes = 0;                                                                                                         // Variable contenant la valeur courante de la luminosité des barrettes de leds adressables

boolean ModeMenu = false;                                                                                                             // Indicateur activation / désactivation du mode menu
boolean ModeReglages = false;                                                                                                         // Indicateur activation / désactivation du mode réglages
const byte PageMenuMin PROGMEM = 10;                                                                                                  // Page menu minimum
const byte PageMenuMax PROGMEM = 20;                                                                                                  // Page menu maximum
unsigned long t1TempoSortieModeMenu = 0;                                                                                              // Début de la temporisation de sortie automatique du mode menu
const unsigned long TempoSortieModeMenu PROGMEM = 15000;                                                                              // Durée de la temporisation de sortie automatique du mode menu

const byte HrsCompteRebours PROGMEM = 23;                                                                                             // Heures, minutes et date auxquelles se déclenche le compte à rebours de la nouvelle année
const byte MinsCompteRebours PROGMEM = 50;
const byte JourCompteRebours PROGMEM = 31;
const byte MoisCompteRebours PROGMEM = 12;

byte Hrstemp = 0;                                                                                                                     // Heures temporaires de réglages
byte Minstemp = 0;                                                                                                                    // Minutes temporaires de réglages
byte Jourtemp = 0;                                                                                                                    // Date temporaire de réglages
byte Moistemp = 0;
byte Anneetemp = 0;

const char messageOLED00[] PROGMEM = "0";                                                                                             // Messages OLED stockés en mémoire programme (Mémoire flash)
const char messageOLED01[] PROGMEM = ":";
const char messageOLED02[] PROGMEM = "/";
const char messageOLED03[] PROGMEM = "%";
const char messageOLED04[] PROGMEM = "MUTE";
const char messageOLED05[] PROGMEM = "GENERAL";
const char messageOLED06[] PROGMEM = "PARTIEL";
const char messageOLED07[] PROGMEM = "ACTIVE";
const char messageOLED08[] PROGMEM = "DESACTIVE";
const char messageOLED09[] PROGMEM = "SELECTION";
const char messageOLED10[] PROGMEM = "VOIX";
const char messageOLED11[] PROGMEM = "1";
const char messageOLED12[] PROGMEM = "2";
const char messageOLED13[] PROGMEM = "VOLUME";
const char messageOLED14[] PROGMEM = "VITESSE";
const char messageOLED15[] PROGMEM = "VARIATION";
const char messageOLED16[] PROGMEM = "TEMP";
const char messageOLED17[] PROGMEM = "HUMIDITE";
const char messageOLED18[] PROGMEM = " ";
const char messageOLED19[] PROGMEM = "BONNE";
const char messageOLED20[] PROGMEM = "ANNEE";
const char messageOLED21[] PROGMEM = "20";
const char messageOLED22[] PROGMEM = "REGLAGE";
const char messageOLED23[] PROGMEM = "<TAPEZ OK>";
const char messageOLED24[] PROGMEM = "REGLEZ";
const char messageOLED25[] PROGMEM = "HEURE";
const char messageOLED26[] PROGMEM = "DATE";
const char messageOLED27[] PROGMEM = "LE JOUR";
const char messageOLED28[] PROGMEM = "LE MOIS";
const char messageOLED29[] PROGMEM = "L'ANNEE";

Adafruit_NeoPixel colonneLed(nombreLedsColonne, BrocheBarrettesTemperature, NEO_GRB + NEO_KHZ800);                                    // Crée l'objet "colonneLed"

DHT dht(BrocheCapteurDHT22, DHTTYPE);                                                                                                 // Crée l'objet "dht"

DFRobotDFPlayerMini myDFPlayer;                                                                                                       // Crée l'objet "myDFPlayer"

void setup()
{
  Serial.begin(9600);                                                                                                                 // Démarre la voie série pour la communication avec le Dfplayer

  pinMode(BrocheBuzzer, OUTPUT);                                                                                                      // Configure la broche en sortie

  pinMode(BrocheDipSwitchMuteGeneral, INPUT_PULLUP);                                                                                  // Configure les broches en entrées
  pinMode(BrocheDipSwitchMutePartiel, INPUT_PULLUP);
  pinMode(BrocheDipSwitchVoix, INPUT_PULLUP);
  pinMode(BrocheBPDroite, INPUT_PULLUP);
  pinMode(BrocheBPOK, INPUT_PULLUP);
  pinMode(BrocheBPGauche, INPUT_PULLUP);

  display.begin(SSD1306_SWITCHCAPVCC, 0x3D);                                                                                          // Initialise l'adresse de l'afficheur OLED avec la valeur 0x3D
  display.clearDisplay();                                                                                                             // Efface l'afficheur OLED
  display.setTextColor(WHITE, BLACK);                                                                                                 // Définit la couleur des caractères et la couleur du fond

  dht.begin();                                                                                                                        // Démarre la librairie du capteur DHT22

  colonneLed.begin();                                                                                                                 // Démarre la librairie Neopixels pour la gestion des barrettes de leds adressables
  colonneLed.setBrightness(brightnessBarrettes);                                                                                      // Définit la luminosité des barrettes de leds adressables
  FonctionEffaceBarrettesLeds();                                                                                                      // Appelle la fonction pour effacer toutes les barrettes de leds adressables

  LectureDipSwitch();                                                                                                                 // Appelle la fonction de lecture des Dip Switch pour initialiser leurs états
  if (!EtatDipSwitchMuteGeneral) {LastEtatDipSwitchMuteGeneral = LOW; MuteGeneral = true;}                                            // Mute général activé
  if (!EtatDipSwitchMutePartiel) {EtatDipSwitchMutePartiel = LOW; MutePartiel = true;}                                                // Mute partiel activé
  if (!EtatDipSwitchVoix)        {LastEtatDipSwitchVoix = LOW; Voix = true;}                                                          // 2ème voix activée

  rtc.begin(BrocheDS3234);                                                                                                            // Initialisation de la librairie du module horloge DS3234
rtc.setTime(0, 55, 23, 2, 31, 12, 19);                                                                                               // Réglage Heure / Date (Secs, Minutes, Heures, Jour de la semaine, Jour du mois, Mois, Année)

  myDFPlayer.begin(Serial);                                                                                                           // Initialisation de la librairie du Dfplayer
  myDFPlayer.volume(VolumeDfplayer);                                                                                                  // Définit le volume du Dfplayer par défaut

  Timer1.initialize(500000);                                                                                                          // Interruption toutes les demi-secondes (1000000µs = 1s)
  Timer1.attachInterrupt(Oscillations2Points);                                                                                        // Fonction Oscillations2Points exécutée toutes les demi-secondes

  randomSeed(analogRead(7));                                                                                                          // Initialise la fonction ramdom()

  Buzzer(20, 0, 1);                                                                                                                   // Active le buzzer 20ms

//**************************************************************************************************************************************************************************
}

void loop()
{
//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE LA LECTURE DE L'HEURE **
  FonctionLectureDS3234(); // ******************************************************************************************************* // Appelle la fonction de la gestion du module RTC DS3234

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DU COMPTE A REBOURS *******
  if (Jour == pgm_read_byte(&JourCompteRebours) && Mois == pgm_read_byte(&MoisCompteRebours) // ************************************* // Si la date et l'heure de départ du compte à rebours de la nouvelle année sont atteintes
   && Hrs == pgm_read_byte(&HrsCompteRebours) && Mins == pgm_read_byte(&MinsCompteRebours) && Secs == 50)
  {
    int compteReboursSecs = 0;                                                                                                        // Déclare la variable pour le calcul du compte à rebours de la nouvelle année des secondes et pour l'afficher à partir de 10
    byte numerodeLedDepartCompteARebours = 0;                                                                                         // Déclare les variables de l'affichage du compte à rebours de la nouvelle année sur les barrettes de leds adressables
    byte nbledsCompteARebours = 0;

    FonctionEffaceBarrettesLeds();                                                                                                    // Appelle la fonction pour effacer toutes les barrettes de leds adressables

    myDFPlayer.play(49);                                                                                                              // Lit le fichier compte à rebours de la nouvelle année

    while(1) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Tant que le compte à rebours des secondes n'est pas fini
    {
      FonctionLectureDS3234();                                                                                                        // Appelle la fonction de la gestion du module RTC DS3234

      FonctionCadre(1);                                                                                                               // Efface l'afficheur OLED et Affiche le cadre (Taille police)

      compteReboursSecs = abs(Secs - 60);                                                                                             // Calcule la valeur du compte à rebours des secondes pour l'afficher à partir de 10

      display.setTextSize(5);                                                                                                         // Définit la taille du texte
      display.setCursor(37, 12);                                                                                                      // Positionne l'affichage du compte à rebours des secondes

      if (compteReboursSecs == 60) // ----------------------------------------------------------------------------------------------- // Si le compte à rebours des secondes est fini
      {
        colonneLed.setBrightness(150);                                                                                                // Définit la luminosité des barrettes de leds adressables
        display.setTextSize(3);                                                                                                       // Définit la taille du texte

        unsigned long timeout = millis();                                                                                             // Déclare et Démarre la temporisation d'affichage clignotante du message "BONNE ANNEE"
        while (millis() - timeout <= 5000) // ....................................................................................... // Affiche le message "BONNE ANNEE" clignotant
        {
          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
          FonctionCadre(0);                                                                                                           // Efface l'afficheur OLED et Affiche le cadre (Aucune taille police)
          display.setCursor(20, 7); LectureMemoireFlash(messageOLED19);                                                               // Affiche le message "BONNE"
          display.setCursor(20, 35); LectureMemoireFlash(messageOLED20);                                                              // Affiche le message "ANNEE"
          display.display();                                                                                                          // Rafraîchit l'affichage de l'écran OLED

          unsigned long timeout1 = millis();                                                                                          // Démarre la temporisation lors de laquelle le message est affiché
          while (millis() - timeout1 <= 700) // ===================================================================================== // Tant que la temporisation lors de laquelle le message est affiché n'est pas écoulée
          {
            unsigned long timeout2 = millis();                                                                                        // Démarre la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables
            while (millis() - timeout2 <= 150) // ___________________________________________________________________________________ // Tant que la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables n'est pas écoulée
            {
              AnimationCompteAReboursBarrettesLeds();                                                                                 // Appelle la fonction d'animation du compte à rebours de la nouvelle année sur les barrettes de leds adressables
            }
            while (millis() - timeout2 <= 200) // ___________________________________________________________________________________ // Tant que la temporisation corespondant à la durée d'effacement des barrettes de leds adressables n'est pas écoulée
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
            }
          }

          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
          FonctionCadre(0);                                                                                                           // Efface l'afficheur OLED et Affiche le cadre (Aucune taille police)
          display.display();                                                                                                          // Rafraîchit l'affichage de l'écran OLED

          timeout1 = millis();                                                                                                        // Démarre la temporisation lors de laquelle le message n'est pas affiché
          while (millis() - timeout1 <= 300) // ===================================================================================== // Tant que la temporisation lors de laquelle le message n'est pas affiché n'est pas écoulée
          {
            unsigned long timeout2 = millis();                                                                                        // Démarre la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables
            while (millis() - timeout2 <= 150) // ___________________________________________________________________________________ // Tant que la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables n'est pas écoulée
            {
              AnimationCompteAReboursBarrettesLeds();                                                                                 // Appelle la fonction d'animation du compte à rebours de la nouvelle année sur les barrettes de leds adressables
            }
            while (millis() - timeout2 <= 200) // ___________________________________________________________________________________ // Tant que la temporisation corespondant à la durée d'effacement des barrettes de leds adressables n'est pas écoulée
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
            }
          }
        }

        display.setTextSize(4);                                                                                                       // Définit la taille du texte

        timeout = millis();                                                                                                           // Redémarre la temporisation d'affichage fixe de la variable "Année"
        while (millis() - timeout <= 5000) // ....................................................................................... // Affiche la variable "Année" fixe
        {
          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
          FonctionCadre(0);                                                                                                           // Efface l'afficheur OLED et Affiche le cadre (Aucune taille police)
          display.setCursor(18, 17); LectureMemoireFlash(messageOLED21); display.print(Annee);                                        // Affiche "20" et Affiche la variable "Année"
          display.display();                                                                                                          // Rafraîchit l'affichage de l'écran OLED
          unsigned long timeout1 = millis();                                                                                          // Démarre la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables n'est pas écoulée
          while (millis() - timeout1 <= 150) // ===================================================================================== // Tant que la temporisation corespondant à la fréquence d'effacement des barrettes de leds adressables n'est pas écoulée
          {
            AnimationCompteAReboursBarrettesLeds();                                                                                   // Appelle la fonction d'animation du compte à rebours de la nouvelle année sur les barrettes de leds adressables
          }
        }

        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables
        colonneLed.setBrightness(brightnessBarrettes);                                                                                // Restaure la luminosité des barrettes de leds adressables
        FonctionCadre(1);                                                                                                             // Efface l'afficheur OLED et Affiche le cadre (Taille police)
        display.display();                                                                                                            // Rafraîchit l'affichage de l'écran OLED
        delay(300);                                                                                                                   // Temporise 300ms

        numerodeLedDepartCompteARebours = 0;                                                                                          // Réinitialise les variables de l'affichage du compte à rebours de la nouvelle année sur les barrettes de leds adressables
        nbledsCompteARebours = 0;
        nbCycleAnimationCompteAReboursBarrettesLeds = 0;
        LastvaleurLuminositeAmbiante = -1;                                                                                            // Force le calcul de la luminosité des barrettes de leds adressables
        LastMins = -1;                                                                                                                // Force l'affichage de l'heure courante
        LastJour = -1;                                                                                                                // Force l'affichage de la date courante
        LasttauxHumiditeCourant = -1;                                                                                                 // Force l'affichage du taux d'humidité courant
        t1TempoReleveVariations = 0;                                                                                                  // Réinitialise la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
        MajAffichageVariations = false;                                                                                               // Désactive l'indicateur de mise à jour des vitesses de variations de la température et du taux d'humidité
        MajAffichageTemperatureCourante = true;                                                                                       // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
        LasttemperatureCourante = -1;                                                                                                 // Force l'affichage de la température courante
        PageOled = 0;                                                                                                                 // Sélectionne la Page 0 de l'écran OLED
        break;                                                                                                                        // Sort de la boucle while()
      }
      else if (compteReboursSecs < 10) {LectureMemoireFlash(messageOLED00);} // ----------------------------------------------------- // Si le compte à rebours est inférieur à 10 on affiche "0"

      display.print(compteReboursSecs);                                                                                               // Affiche le compte à rebours des secondes sur l'écran OLED
      display.display();                                                                                                              // Rafraîchit l'affichage de l'écran OLED

      byte coul1 = random(1, 255);                                                                                                    // Premier paramètre des couleurs (rouge)
      byte coul2 = random(2, 255);                                                                                                    // Deuxième paramètre des couleurs (vert)
      byte coul3 = random(3, 255);                                                                                                    // Troisième paramètre des couleurs (bleu)

           if (compteReboursSecs == 10) {numerodeLedDepartCompteARebours = 0; nbledsCompteARebours = 4;} // ------------------------- // Positionne l'affichage sur les barrettes de leds adressables
      else if (compteReboursSecs == 9)  {numerodeLedDepartCompteARebours = 5;}
      else if (compteReboursSecs == 8)  {numerodeLedDepartCompteARebours = 10;}
      else if (compteReboursSecs == 7)  {numerodeLedDepartCompteARebours = 15;}
      else if (compteReboursSecs == 6)  {numerodeLedDepartCompteARebours = 20;}
      else if (compteReboursSecs == 5)  {numerodeLedDepartCompteARebours = 25; nbledsCompteARebours = 5;}
      else if (compteReboursSecs == 4)  {numerodeLedDepartCompteARebours = 31;}
      else if (compteReboursSecs == 3)  {numerodeLedDepartCompteARebours = 37;}
      else if (compteReboursSecs == 2)  {numerodeLedDepartCompteARebours = 43;}
      else if (compteReboursSecs == 1)  {numerodeLedDepartCompteARebours = 49; nbledsCompteARebours = 6;}

      for (int i = numerodeLedDepartCompteARebours; i <= numerodeLedDepartCompteARebours+nbledsCompteARebours; i++) // -------------- // Affiche le compte à rebours de la nouvelle année sur les barrettes de leds adressables
      {
        colonneLed.setPixelColor(i, colonneLed.Color(coul1, coul2, coul3));                                                           // Affiche la led de rang i sur les barrettes de leds adressables
        colonneLed.show();                                                                                                            // Rafraîchit l'affichage des barrettes de leds adressables
      }
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DES DIP SWITCH ************
  if (!ModeMenu) // ***************************************************************************************************************** // Si le mode menu est désactivé *****
  {
    LectureDipSwitch();                                                                                                               // Appelle la fonction de lecture des Dip Switch

    if (LastEtatDipSwitchMuteGeneral != EtatDipSwitchMuteGeneral) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'état du Dip Switch Mute Général a changé
    {
      Buzzer(3, 0, 1);
           if (!EtatDipSwitchMuteGeneral) {MuteGeneral = true;} // ------------------------------------------------------------------ // Active le Mute Général si le Dip Switch Mute Général est à 0
      else if (EtatDipSwitchMuteGeneral)  {MuteGeneral = false;} // ----------------------------------------------------------------- // Désactive le Mute Général si le Dip Switch Mute Général est à 1 (repos)

      t1TempoAffichageMessageOled = millis();                                                                                         // Démarre la temporisation de la durée d'affichages des messages sur l'écran OLED
      PageOled = 1;                                                                                                                   // Sélectionne la Page 1 de l'écran OLED
      LastEtatDipSwitchMuteGeneral = EtatDipSwitchMuteGeneral;                                                                        // Mémorise le dernier état du Dip Switch Mute Général
    }

    if (LastEtatDipSwitchMutePartiel != EtatDipSwitchMutePartiel) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'état du Dip Switch Mute Général a changé
    {
      Buzzer(3, 0, 1);
           if (!EtatDipSwitchMutePartiel) {MutePartiel = true;} // ------------------------------------------------------------------ // Active le Mute Partiel si le Dip Switch Mute Partiel est à 0
      else if (EtatDipSwitchMutePartiel)  {MutePartiel = false;} // ----------------------------------------------------------------- // Désactive le Mute Partiel si le Dip Switch Mute Partiel est à 1 (repos)

      t1TempoAffichageMessageOled = millis();                                                                                         // Démarre la temporisation de la durée d'affichages des messages sur l'écran OLED
      PageOled = 2;                                                                                                                   // Sélectionne la Page 2 de l'écran OLED
      LastEtatDipSwitchMutePartiel = EtatDipSwitchMutePartiel;                                                                        // Mémorise le dernier état du Dip Switch Mute Partiel
    }

    if (LastEtatDipSwitchVoix != EtatDipSwitchVoix) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'état du Dip Switch Voix a changé
    {
      Buzzer(3, 0, 1);
           if (!EtatDipSwitchVoix) {Voix = true;} // -------------------------------------------------------------------------------- // Active Voix 2 si le Dip Switch Voix est à 0
      else if (EtatDipSwitchVoix)  {Voix = false;} // ------------------------------------------------------------------------------- // Active Voix 1 si le Dip Switch Voix est à 1 (repos)

      t1TempoAffichageMessageOled = millis();                                                                                         // Démarre la temporisation de la durée d'affichages des messages sur l'écran OLED
      PageOled = 3;                                                                                                                   // Sélectionne la Page 3 de l'écran OLED
      LastEtatDipSwitchVoix = EtatDipSwitchVoix;                                                                                      // Mémorise le dernier état du Dip Switch Voix
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE BPOK *******************
  /*etatBPOK = digitalRead(BrocheBPOK); // ******************************************************************************************** // Lit l'état de BPOK ****************
  if (LastetatBPOK != etatBPOK) // ************************************************************************************************** // Si changement d'état du bouton poussoir BPOK
  {
    if (LastetatBPOK == HIGH && etatBPOK == LOW) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si front descendant sur BPOK (Pression sur BP)
    {
      if (!ModeMenu && !ModeReglages) // -------------------------------------------------------------------------------------------- // Si le mode menu est désactivé et Si le mode réglage est désactivé
      {
        Buzzer(20, 0, 1);
        ModeMenu = true;                                                                                                              // Active l'indicateur du mode menu
        PageOled = pgm_read_byte(&PageMenuMin);                                                                                       // Sélectionne la Page Menu 10 de l'écran OLED
        t1TempoSortieModeMenu = millis();                                                                                             // (Re)Démarre la temporisation de sortie automatique du mode menu
        LastetatBPOK = etatBPOK;                                                                                                      // Mémorise le dernier état BPOK
      }
      else if (ModeMenu && !ModeReglages) // ---------------------------------------------------------------------------------------- // Si le mode menu est activé et Si le mode réglages est désactivé
      {
        Buzzer(3, 0, 1);
        ModeReglages = true;                                                                                                          // Active le mode réglages

        if (PageOled == 10) // ...................................................................................................... // Si la Page Menu 10 est activée => Réglage de l'heure
        {
          Hrstemp = Hrs;                                                                                                              // Transfère les heures courantes dans la variable de réglage Hrstemp
          Minstemp = Mins;                                                                                                            // Transfère les minutes courantes dans la variable de réglage Minstemp
          PageOled = 11;                                                                                                              // Sélectionne la Page 11
        }
        else if (PageOled == 20) // ................................................................................................. // Si la Page Menu 20 est activée => Réglage de la date
        {
          Jourtemp = Jour;                                                                                                            // Transfère le jour courant dans la variable de réglage Jourtemp
          Moistemp = Mois;                                                                                                            // Transfère le mois courant dans la variable de réglage Moistemp
          Anneetemp = Annee;                                                                                                          // Transfère l'année courante dans la variable de réglage Anneetemp
          PageOled = 21;                                                                                                              // Sélectionne la Page 21
        }

        t1TempoSortieModeMenu = millis();                                                                                             // (Re)Démarre la temporisation de sortie automatique du mode menu
        LastetatBPOK = etatBPOK;                                                                                                      // Mémorise le dernier état BPOK
      }
      else if (ModeMenu && ModeReglages) // ----------------------------------------------------------------------------------------- // Si le mode menu est activé et Si le mode réglages est activé
      {
        Buzzer (100, 0, 1);

        if (PageOled == 11) // ...................................................................................................... // Si la Page Menu 11 est activée => Valide le réglage de l'heure courante
        {
          Hrs = Hrstemp;                                                                                                              // Transfère les heures de réglage dans la variable courante Hrs
          Mins = Minstemp;                                                                                                            // Transfère les minutes de réglage dans la variable courante Mins
          Secs = 0;

          rtc.setTime(Secs, Mins, Hrs, 4, Jour, Mois, Annee);                                                                         // Réglage Heure / Date (Secs, Minutes, Heures, Jour de la semaine, Jour du mois, Mois, Année)
        }
        else if (PageOled == 21) // ................................................................................................. // Si la Page Menu 21 est activée => Réglage du Mois courant
        {
          PageOled = 22;                                                                                                              // Sélectionne la Page 22
          LastetatBPOK = etatBPOK;                                                                                                    // Mémorise le dernier état BPOK
          return;                                                                                                                     // Retour début loop()
        }
        else if (PageOled == 22) // ................................................................................................. // Si la Page Menu 22 est activée => Réglage de l'Année courante
        {
          PageOled = 23;                                                                                                              // Sélectionne la Page 23
          LastetatBPOK = etatBPOK;                                                                                                    // Mémorise le dernier état BPOK
          return;                                                                                                                     // Retour début loop()
        }
        else if (PageOled == 23) // ................................................................................................. // Si la Page Menu 23 est activée => Valide le réglage de la date courante
        {
          Jour = Jourtemp;                                                                                                            // Transfère le jour de réglage dans la variable courante Jour
          Mois = Moistemp;                                                                                                            // Transfère le mois de réglage dans la variable courante Mois
          Annee = Anneetemp;                                                                                                          // Transfère l'année de réglage dans la variable courante Annee

          rtc.setTime(Secs, Mins, Hrs, 4, Jour, Mois, Annee);                                                                         // Mémorise l'heure et la date (Secs, Minutes, Heures, Jour de la semaine, Jour du mois, Mois, Année)
        }

        display.clearDisplay();                                                                                                       // Efface l'afficheur OLED
        ModeMenu = false;                                                                                                             // Désactive l'indicateur du mode menu
        ModeReglages = false;                                                                                                         // Désactive le mode réglages
        LastMins = -1;                                                                                                                // Force l'affichage de l'heure courante
        LastJour = -1;                                                                                                                // Force l'affichage de la date courante
        LasttauxHumiditeCourant = -1;                                                                                                 // Force l'affichage du taux d'humidité courant
        t1TempoSortieModeMenu = 0;                                                                                                    // Réinitialise la temporisation de sortie automatique du mode menu
        t1TempoReleveVariations = 0;                                                                                                  // Réinitialise la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
        MajAffichageVariations = false;                                                                                               // Désactive l'indicateur de mise à jour des vitesses de variations de la température et du taux d'humidité
        MajAffichageTemperatureCourante = true;                                                                                       // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
        LasttemperatureCourante = -1;                                                                                                 // Force l'affichage de la température courante
        PageOled = 0;                                                                                                                 // Sélectionne la Page 0 de l'écran OLED
        LastetatBPOK = etatBPOK;                                                                                                      // Mémorise le dernier état BPOK
      }
    }
    else {LastetatBPOK = HIGH;} // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si front montant sur Bouton Poussoir BPOK (BP relâché)
  }*/

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE BPDroite ***************
  if (digitalRead(BrocheBPDroite) == LOW) // **************************************************************************************** // Si niveau bas sur BPDroite (Pression sur BP)
  {
    Buzzer(1, 0, 1);

    if (!ModeMenu && !ModeReglages) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est désactivé et Si le mode réglage est désactivé
    {
        Buzzer(20, 0, 1);
        ModeMenu = true;                                                                                                              // Active l'indicateur du mode menu
        PageOled = pgm_read_byte(&PageMenuMin);                                                                                       // Sélectionne la Page Menu 10 de l'écran OLED
        t1TempoSortieModeMenu = millis();                                                                                             // (Re)Démarre la temporisation de sortie automatique du mode menu
        LastetatBPOK = etatBPOK;                                                                                                      // Mémorise le dernier état BPOK
    }
    else if (ModeMenu && !ModeReglages) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est activé et Si le mode réglages est désactivé
    {
      PageOled = PageOled + 10;                                                                                                       // Page suivante du menu
      if (PageOled > pgm_read_byte(&PageMenuMax)) {PageOled = pgm_read_byte(&PageMenuMin);}                                           // Borne les Pages Menu
      t1TempoSortieModeMenu = millis();                                                                                               // (Re)Démarre la temporisation de sortie automatique du mode menu
    }
    else if (ModeMenu && ModeReglages) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est activé et Si le mode réglages est activé
    {
      if (PageOled == 11) // -------------------------------------------------------------------------------------------------------- // Si la Page Menu 11 est activée => Réglage des minutes courantes
      {
        Minstemp++;                                                                                                                   // Incrémente les minutes de réglage
        if (Minstemp > 59) {Minstemp = 0;}                                                                                            // Borne les minutes de réglage
      }
      else if (PageOled == 21) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 21 est activée => Réglage du jour courant
      {
        Jourtemp++;                                                                                                                   // Incrémente les jours de réglage
        if (Jourtemp > 31) {Jourtemp = 1;}                                                                                            // Borne les jours de réglage
      }
      else if (PageOled == 22) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 22 est activée => Réglage du mois courant
      {
        Moistemp++;                                                                                                                   // Incrémente les mois de réglage
        if (Moistemp > 12) {Moistemp = 1;}                                                                                            // Borne les mois de réglage
      }
      else if (PageOled == 23) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 23 est activée => Réglage de l'année courante
      {
        Anneetemp++;                                                                                                                  // Incrémente les années de réglage
        if (Anneetemp > 99) {Anneetemp = 0;}                                                                                          // Borne les années de réglage
      }

      t1TempoSortieModeMenu = millis();                                                                                               // (Re)Démarre la temporisation de sortie automatique du mode menu
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE BPGauche ***************
  if (digitalRead(BrocheBPGauche) == LOW) // **************************************************************************************** // Si niveau bas sur BPGauche (Pression sur BP)
  {
    Buzzer(1, 0, 1);

    if (!ModeMenu && !ModeReglages) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est désactivé et Si le mode réglage est désactivé
    {
        Buzzer(20, 0, 1);
        ModeMenu = true;                                                                                                              // Active l'indicateur du mode menu
        PageOled = pgm_read_byte(&PageMenuMax);                                                                                       // Sélectionne la Page Menu 20 de l'écran OLED
        t1TempoSortieModeMenu = millis();                                                                                             // (Re)Démarre la temporisation de sortie automatique du mode menu
        LastetatBPOK = etatBPOK;                                                                                                      // Mémorise le dernier état BPOK
    }
    else if (ModeMenu && !ModeReglages) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est activé et Si le mode réglages est désactivé
    {
      PageOled = PageOled - 10;                                                                                                       // Page précédente du menu
      if (PageOled < pgm_read_byte(&PageMenuMin)) {PageOled = pgm_read_byte(&PageMenuMax);}                                           // Borne les Pages Menu
      t1TempoSortieModeMenu = millis();                                                                                               // (Re)Démarre la temporisation de sortie automatique du mode menu
    }
    else if (ModeMenu && ModeReglages) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode menu est activé et Si le mode réglages est activé
    {
      if (PageOled == 11) // -------------------------------------------------------------------------------------------------------- // Si la Page Menu 11 est activée => Réglage des heures courantes
      {
        Hrstemp++;                                                                                                                    // Incrémente les heures de réglage
        if (Hrstemp > 23) {Hrstemp = 0;}                                                                                              // Borne les heures de réglage
      }
      else if (PageOled == 21) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 21 est activée => Réglage du jour courant
      {
        Jourtemp--;                                                                                                                   // Décrémente les jours de réglage
        if (Jourtemp < 1) {Jourtemp = 31;}                                                                                            // Borne les jours de réglage
      }
      else if (PageOled == 22) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 22 est activée => Réglage du mois courant
      {
        Moistemp--;                                                                                                                   // Décrémente les mois de réglage
        if (Moistemp < 1) {Moistemp = 12;}                                                                                            // Borne les mois de réglage
      }
      else if (PageOled == 23) // --------------------------------------------------------------------------------------------------- // Si la Page Menu 23 est activée => Réglage de l'année courante
      {
        Anneetemp--;                                                                                                                  // Décrémente les années de réglage
        if (Anneetemp < 0) {Anneetemp = 99;}                                                                                          // Borne les années de réglage
      }

      t1TempoSortieModeMenu = millis();                                                                                               // (Re)Démarre la temporisation de sortie automatique du mode menu
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DU POTENTIOMETRE DU VOLUME
  if (!ModeMenu) // ***************************************************************************************************************** // Si le mode menu est désactivé *****
  {
    FonctionLecturePotentiometreVolume();                                                                                             // Appelle la fonction de lecture du potentiomètre du volume du Dfplayer

    if (LastvaleurPotentiometreVolume != valeurPotentiometreVolume // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la valeur lue a changé
     && abs(valeurPotentiometreVolume - LastvaleurPotentiometreVolume) > 30)                                                          // et Si l'écart entre la valeur actuelle et la dernière valeur est > 60
    {
      VolumeDfplayer = map(valeurPotentiometreVolume, 1023, 0, 30, 0);                                                                // Réétalonne la valeur du potentiomètre du volume du Dfplayer
      myDFPlayer.volume(VolumeDfplayer);                                                                                              // Définit le volume du Dfplayer

      t1TempoAffichageMessageOled = millis();                                                                                         // Démarre la temporisation de la durée d'affichages des messages sur l'écran OLED
      PageOled = 4;                                                                                                                   // Sélectionne la Page 4 de l'écran OLED
      LastvaleurPotentiometreVolume = valeurPotentiometreVolume;                                                                      // Mémorise la dernière valeur courante du potentiomètre du volume du Dfplayer
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE L'EFFACEMENT DES MESSAGES SUR L'ECRAN OLED
  if (millis() - t1TempoAffichageMessageOled >= pgm_read_dword(&TempoAffichageMessageOled) && t1TempoAffichageMessageOled != 0) // ** // Si la temporisation d'affichage des messages sur l'écran OLED est écoulées
  {
    display.clearDisplay();                                                                                                           // Efface l'afficheur OLED
    LastMins = -1;                                                                                                                    // Force l'affichage de l'heure courante
    LastJour = -1;                                                                                                                    // Force l'affichage de la date courante
    LasttauxHumiditeCourant = -1;                                                                                                     // Force l'affichage du taux d'humidité courant
    t1TempoAffichageMessageOled = 0;                                                                                                  // Réinitialise la temporisation de la durée d'affichages des messages sur l'écran OLED
    MajAffichageTemperatureCourante = true;                                                                                           // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
    LasttemperatureCourante = -1;                                                                                                     // Force l'affichage de la température courante
    PageOled = 0;                                                                                                                     // Sélectionne la Page 0 de l'écran OLED
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE LA SORTIE AUTOMATIQUE DU MODE MENU
  if (millis() - t1TempoSortieModeMenu >= pgm_read_dword(&TempoSortieModeMenu) && t1TempoSortieModeMenu != 0) // ******************** // Si la temporisation de la sortie automatique du mode menu est écoulée
  {
    display.clearDisplay();                                                                                                           // Efface l'afficheur OLED
    ModeMenu = false;                                                                                                                 // Désactive l'indicateur du mode menu
    ModeReglages = false;                                                                                                             // Désactive le mode réglages
    LastMins = -1;                                                                                                                    // Force l'affichage de l'heure courante
    LastJour = -1;                                                                                                                    // Force l'affichage de la date courante
    LasttauxHumiditeCourant = -1;                                                                                                     // Force l'affichage du taux d'humidité courant
    t1TempoSortieModeMenu = 0;                                                                                                        // Réinitialise la temporisation de sortie automatique du mode menu
    t1TempoReleveVariations = 0;                                                                                                      // Réinitialise la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
    MajAffichageVariations = false;                                                                                                   // Désactive l'indicateur de mise à jour des vitesses de variations de la température et du taux d'humidité
    MajAffichageTemperatureCourante = true;                                                                                           // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
    LasttemperatureCourante = -1;                                                                                                     // Force l'affichage de la température courante
    PageOled = 0;                                                                                                                     // Sélectionne la Page 0 de l'écran OLED
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE L'AFFICHAGE SUR L'ECRAN OLED
  if (PageOled == 0) // ************************************************************************************************************* // Si la Page 0 est sélectionnée *****
  {
    display.drawRoundRect(0, 0, display.width(), display.height(), 8, WHITE);                                                         // Affiche le cadre

    FonctionLectureDS3234();                                                                                                          // Appelle la fonction de la gestion du module RTC DS3234

    if (Osc2Points) {display.setTextSize(3); display.setCursor(57, 3); LectureMemoireFlash(messageOLED01); display.display();}        // Affiche l'oscillation des 2 points de l'affichage de l'heure sur l'écran OLED
    else {display.setTextSize(3); display.setCursor(57, 3); LectureMemoireFlash(messageOLED18); display.display();}

    if (LastMins != Mins) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la minute courante a changé
    {
      if (Hrs >= 0 && Hrs <= 23 && Mins >= 0 && Mins <= 59) // ---------------------------------------------------------------------- // Vérifie la validité des données lues => Affiche l'heure sur l'afficheur OLED
      {
        display.setTextSize(3);                                                                                                       // Définit la taille du texte
        display.setCursor(21, 3);                                                                                                     // Positionne l'affichage de l'heure courante
        if (Hrs < 10) {LectureMemoireFlash(messageOLED00);} display.print(Hrs);                                                       // Affiche "0" si la variable "Hrs" est inférieure à 10 et Affiche la variable "Hrs"
        FonctionOsc2Points();                                                                                                         // Appelle la fonction de gestion des deux points de l'affichage de l'heure sur l'écran OLED
        if (Mins < 10) {LectureMemoireFlash(messageOLED00);} display.print(Mins);                                                     // Affiche "0" si la variable "Mins" est inférieure à 10 et Affiche la variable "Mins"
        display.display();                                                                                                            // Rafraîchit l'affichage de l'écran OLED

        if (Mins == 0 && Secs == 0) // .............................................................................................. // Si les minutes et les secondes sont égales à 0
        {
          FonctionAnnonceNouvelleHeure();                                                                                             // Appelle la fonction d'annonce audio de la nouvelle heure
        }
      }
      else // ----------------------------------------------------------------------------------------------------------------------- // Si données lues erronées => Problème de lecture de l'heure courante
      {
        LastMins = -1;                                                                                                                // Force l'affichage de l'heure après relecture
        return;                                                                                                                       // Retour début boucle loop()
      }

      LastMins = Mins;                                                                                                                // Mémorise la dernière valeur des minutes
    }

    if (LastJour != Jour) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le jour du mois courant a changé
    {
      if (Jour >= 1 && Jour <= 31 && Mois >= 1 && Mois <= 12 && Annee >= 0 && Annee <= 99) // --------------------------------------- // Vérifie la validité des données lues => Affiche la date sur l'afficheur OLED
      {
        display.setTextSize(2);                                                                                                       // Définit la taille du texte
        display.setCursor(17, 28);                                                                                                    // Positionne l'affichage de la date courante
        if (Jour < 10) {LectureMemoireFlash(messageOLED00);} display.print(Jour);                                                     // Affiche "0" si la variable "Jour" est inférieure à 10 et Affiche la variable "Jour"
        LectureMemoireFlash(messageOLED02);                                                                                           // Affiche "/"
        if (Mois < 10) {LectureMemoireFlash(messageOLED00);} display.print(Mois);                                                     // Affiche "0" si la variable "Mois" est inférieure à 10 et Affiche la variable "Mois"
        LectureMemoireFlash(messageOLED02);                                                                                           // Affiche "/"
        display.print(Annee);                                                                                                         // Affiche la variable "Annee"
        display.display();                                                                                                            // Rafraîchit l'affichage de l'écran OLED
      }
      else // ----------------------------------------------------------------------------------------------------------------------- // Si données lues erronées => Problème de lecture de la date courante
      {
        LastJour = -1;                                                                                                                // Force l'affichage de la date courante après relecture
        return;                                                                                                                       // Retour début boucle loop()
      }

      LastJour = Jour;                                                                                                                // Mémorise la dernière valeur du jour
    }

    if (LasttauxHumiditeCourant != tauxHumiditeCourant && abs(LasttauxHumiditeCourant - tauxHumiditeCourant) > 0.25) // +++++++++++++ // Si le taux d'humidité courant a changé et si l'écart est de plus ou moins 0.26%
    {
      if (tauxHumiditeCourant >= 0.0 && tauxHumiditeCourant <= 100.0) // ------------------------------------------------------------ // Vérifie la validité de la donnée lue => Affiche le taux d'humidité sur l'afficheur OLED
      {
        display.setTextSize(2);                                                                                                       // Définit la taille du texte
        display.setCursor(30, 47);                                                                                                    // Positionne l'affichage du taux d'humidité courant
        if (tauxHumiditeCourant < 10) {LectureMemoireFlash(messageOLED00);} display.print(tauxHumiditeCourant);                       // Affiche "0" si la variable "tauxHumiditeCourant" est inférieure à 10 et Affiche la variable "tauxHumiditeCourant"
        LectureMemoireFlash(messageOLED03);                                                                                           // Affiche "%"
        display.display();                                                                                                            // Rafraîchit l'affichage de l'écran OLED
      }
      else // ----------------------------------------------------------------------------------------------------------------------- // Si données lues erronées => Problème de dépassement du taux d'humidité courant
      {
        LasttauxHumiditeCourant = -1;                                                                                                 // Force l'affichage du taux d'humidité courant après relecture
      }

      LasttauxHumiditeCourant = tauxHumiditeCourant;                                                                                  // Mémorise la dernière valeur courante du taux d'humidité
    }
  }
  else // *************************************************************************************************************************** // Si la Page sélectionnée est différente de 0
  {
    FonctionCadre(1);                                                                                                                 // Efface l'afficheur OLED et Affiche le cadre (Taille police)

    if (PageOled == 1) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 1 est sélectionnée
    {
      display.setCursor(41, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED04);                                                                                             // Affiche le message "MUTE" sur l'écran OLED
      display.setCursor(24, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED05);                                                                                             // Affiche le message "GENERAL" sur l'écran OLED
           if (MuteGeneral)  {display.setCursor(30, 44); LectureMemoireFlash(messageOLED07);}                                         // Si le Mute Général est activé
      else if (!MuteGeneral) {display.setCursor(12, 44); LectureMemoireFlash(messageOLED08);}                                         // Si le Mute Général est désactivé (repos)
    }
    else if (PageOled == 2) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 2 est sélectionnée
    {
      display.setCursor(41, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED04);                                                                                             // Affiche le message "MUTE" sur l'écran OLED
      display.setCursor(24, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED06);                                                                                             // Affiche le message "PARTIEL" sur l'écran OLED
           if (MutePartiel)  {display.setCursor(30, 44); LectureMemoireFlash(messageOLED07);}                                         // Si le Mute Partiel est activé
      else if (!MutePartiel) {display.setCursor(12, 44); LectureMemoireFlash(messageOLED08);}                                         // Si le Mute Partiel est désactivé (repos)
    }
    else if (PageOled == 3) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 3 est sélectionnée
    {
      display.setCursor(12, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED09);                                                                                             // Affiche le message "SELECTION" sur l'écran OLED
      display.setCursor(41, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED10);                                                                                             // Affiche le message "VOIX" sur l'écran OLED
           if (Voix)  {display.setCursor(61, 44); LectureMemoireFlash(messageOLED12);}                                                // Si Voix 2 est activée
      else if (!Voix) {display.setCursor(61, 44); LectureMemoireFlash(messageOLED11);}                                                // Si Voix 1 est activée (repos)
    }
    else if (PageOled == 4) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 4 est sélectionnée
    {
      display.setCursor(30, 8);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED13);                                                                                             // Affiche le message "VOLUME" sur l'écran OLED
      display.setTextSize(3);                                                                                                         // Définit la taille du texte
      display.setCursor(48, 32);                                                                                                      // Positionne le message
      if (VolumeDfplayer < 10) {display.setCursor(56, 32);}                                                                           // Centre l'affichage de la variable "VolumeDfplayer" si elle est inférieure à 10
      display.print(VolumeDfplayer);                                                                                                  // Affiche le volume du Dfplayer sur l'écran OLED
    }
    else if (PageOled == 10) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 10 est sélectionnée => Menu réglage heure courante
    {
      display.setCursor(24, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED22);                                                                                             // Affiche le message "REGLAGE" sur l'écran OLED
      display.setCursor(34, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED25);                                                                                             // Affiche le message "HEURE" sur l'écran OLED
      display.setCursor(4, 44);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED23);                                                                                             // Affiche le message "<TAPEZ OK>" sur l'écran OLED
    }
    else if (PageOled == 20) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 20 est sélectionnée => Menu réglage date
    {
      display.setCursor(24, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED22);                                                                                             // Affiche le message "REGLAGE" sur l'écran OLED
      display.setCursor(41, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED26);                                                                                             // Affiche le message "DATE" sur l'écran OLED
      display.setCursor(4, 44);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED23);                                                                                             // Affiche le message "<TAPEZ OK>" sur l'écran OLED
    }
    else if (PageOled == 11) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 11 est sélectionnée => Menu réglage heure courante
    {
      display.setCursor(30, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED24);                                                                                             // Affiche le message "REGLEZ" sur l'écran OLED
      display.setCursor(34, 24);                                                                                                      // Positionne le message
      LectureMemoireFlash(messageOLED25);                                                                                             // Affiche le message "HEURE" sur l'écran OLED
      display.setCursor(34, 44);                                                                                                      // Positionne le message
      if (Hrstemp < 10) {LectureMemoireFlash(messageOLED00);} display.print(Hrstemp);                                                 // Affiche l'heure de réglage sur l'afficheur OLED
      LectureMemoireFlash(messageOLED01);                                                                                             // Affiche le message ":"
      if (Minstemp < 10) {LectureMemoireFlash(messageOLED00);}display.print(Minstemp);
    }
    else if (PageOled == 21 || PageOled == 22 || PageOled == 23) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page 21 ou 22 ou 23 est sélectionnée => Menu réglage date courante
    {
      display.setCursor(30, 5);                                                                                                       // Positionne le message
      LectureMemoireFlash(messageOLED24);                                                                                             // Affiche le message "REGLEZ" sur l'écran OLED
      display.setCursor(24, 24);                                                                                                      // Positionne le message
           if (PageOled == 21) {LectureMemoireFlash(messageOLED27);}                                                                  // Affiche le message "LE JOUR" sur l'écran en fonction de la page menu activée
      else if (PageOled == 22) {LectureMemoireFlash(messageOLED28);}                                                                  // Affiche le message "LE MOIS" sur l'écran en fonction de la page menu activée
      else if (PageOled == 23) {LectureMemoireFlash(messageOLED29);}                                                                  // Affiche le message "L'ANNEE" sur l'écran en fonction de la page menu activée

      display.setCursor(17, 44);                                                                                                      // Positionne l'affichage de la date courante
      if (PageOled == 21) {display.setTextColor(BLACK, WHITE);}                                                                       // Définit la couleur des caractères et la couleur du fond
      if (Jourtemp < 10) {LectureMemoireFlash(messageOLED00);} display.print(Jourtemp);                                               // Affiche "0" si la variable "Jour" est inférieure à 10 et Affiche la variable "Jour"
      display.setTextColor(WHITE, BLACK);                                                                                             // Définit la couleur des caractères et la couleur du fond
      LectureMemoireFlash(messageOLED02);                                                                                             // Affiche "/"
      if (PageOled == 22) {display.setTextColor(BLACK, WHITE);}                                                                       // Définit la couleur des caractères et la couleur du fond
      if (Moistemp < 10) {LectureMemoireFlash(messageOLED00);} display.print(Moistemp);                                               // Affiche "0" si la variable "Mois" est inférieure à 10 et Affiche la variable "Mois"
      display.setTextColor(WHITE, BLACK);                                                                                             // Définit la couleur des caractères et la couleur du fond
      LectureMemoireFlash(messageOLED02);                                                                                             // Affiche "/"
      if (PageOled == 23) {display.setTextColor(BLACK, WHITE);}                                                                       // Définit la couleur des caractères et la couleur du fond
      display.print(Anneetemp);                                                                                                       // Affiche la variable "Annee"
      display.setTextColor(WHITE, BLACK);                                                                                             // Définit la couleur des caractères et la couleur du fond
    }

    display.display();                                                                                                                // Rafraîchit l'affichage de l'écran OLED
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE LA LECTURE ET DU CALCUL DE LA TEMPERATURE COURANTE
  temperatureCourante = dht.readTemperature(); // *********************************************************************************** // Relève la température courante ****
  //Serial.println(temperatureCourante);                                                                                                // Débug (Désactiver le Dfplayer pour libérer le port série)
  if (isnan(temperatureCourante)) {return;}                                                                                           // Vérifie si la lecture de la température courante a échoué

  static int CompteurRelevesTemperature = 0;                                                                                          // Déclare et Initialise les variables pour le calcul de la moyenne de la température
  static float SommeRelevesTemperature = 0.0;

  CompteurRelevesTemperature++;                                                                                                       // Incrémente le compteur des relevés de température
  SommeRelevesTemperature = SommeRelevesTemperature + temperatureCourante;                                                            // Calcule la somme des 50 relevés

  if (CompteurRelevesTemperature >= 50) // ****************************************************************************************** // Si 50 relevés ont été effectués
  {
    temperatureCourante = SommeRelevesTemperature / 50.0;                                                                             // Calcule la moyenne des 50 relevés
    //Serial.println(temperatureCourante, 2);                                                                                         // Débug (Désactiver le Dfplayer pour libérer le port série)
    CompteurRelevesTemperature = 0; SommeRelevesTemperature = 0.0;                                                                    // Réinitialisation des variables de calcul de la moyenne de la température
    MajAffichageTemperatureCourante = true;                                                                                           // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables

    if (t1TempoReleveVariations == 0) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la temporisation pour le calcul et d'affichage des vitesses de variations de la température et du taux d'humidité n'a pas démarré
    {
      T1 = temperatureCourante;                                                                                                       // Mémorise la première température pour le calcul de la vitesse de la variation de la température
      H1 = tauxHumiditeCourant;                                                                                                       // Mémorise le premier taux d'humidité pour le calcul de la vitesse de la variation du taux d'humidité
      t1TempoReleveVariations = millis();                                                                                             // Démarre la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
    }
    else if (millis() - t1TempoReleveVariations >= pgm_read_dword(&FrequenceReleveVariations) && t1TempoReleveVariations != 0) // +++ // Si la temporisation d'affichage des vitesses de variations de la température et du taux d'humidité est écoulée
    {
      T2 = temperatureCourante;                                                                                                       // Mémorise la deuxième température pour le calcul de la vitesse de la variation de la température
      H2 = tauxHumiditeCourant;                                                                                                       // Mémorise le deuxième taux d'humidité pour le calcul de la vitesse de la variation du taux d'humidité
      MajAffichageVariations = true;                                                                                                  // Active l'indicateur de mise à jour de l'affichage des vitesses de variations de la température et du taux d'humidité
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE LA LECTURE ET DU CALCUL DU TAUX D'HUMIDITE COURANT
  tauxHumiditeCourant = dht.readHumidity(); // ************************************************************************************** // Relève le taux d'humidité courant *
  //Serial.println(tauxHumiditeCourant);                                                                                                // Débug (Désactiver le Dfplayer pour libérer le port série)
  if (isnan(tauxHumiditeCourant)) {return;}                                                                                           // Vérifie si la lecture du taux d'humidité courant a échoué

  static int CompteurRelevesTauxHumidite = 0;                                                                                         // Déclare et Initialise les variables pour le calcul de la moyenne du taux d'humidité
  static float SommeRelevesTauxHumidite = 0.0;

  CompteurRelevesTauxHumidite++;                                                                                                      // Incrémente le compteur des relevés du taux d'humidité
  SommeRelevesTauxHumidite = SommeRelevesTauxHumidite + tauxHumiditeCourant;                                                          // Calcule la somme des 50 relevés

  if (CompteurRelevesTauxHumidite >= 50) // ***************************************************************************************** // Si 50 relevés ont été effectués
  {
    tauxHumiditeCourant = SommeRelevesTauxHumidite / 50.0;                                                                            // Calcule la moyenne des 50 relevés
    //Serial.println(tauxHumiditeCourant);                                                                                              // Débug (Désactiver le Dfplayer pour libérer le port série)
    CompteurRelevesTauxHumidite = 0; SommeRelevesTauxHumidite = 0.0;                                                                  // Réinitialisation des variables de calcul de la moyenne du taux d'humidité
    MajTauxHumiditeCourant = true;                                                                                                    // Active l'indicateur de mise à jour de l'affichage sur l'Oled
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE LA LUMINOSITE AMBIANTE *
  if (!ModeMenu) // ***************************************************************************************************************** // Si le mode menu est désactivé *****
  {
    int valeurLuminositeAmbiante = analogRead(BrocheLDR);                                                                             // Déclare et Lit la valeur analogique sur la broche de la cellule photoélectrique LDR (valeur entre 0 et 1023)

    static int CompteurRelevesLuminositeAmbiante = 0;                                                                                 // Déclare et Initialise les variables pour le calcul de la moyenne de la luminosité ambiante
    static unsigned int SommeRelevesLuminositeAmbiante = 0;

    CompteurRelevesLuminositeAmbiante++;                                                                                              // Incrémente le compteur des relevés de la luminosité ambiante
    SommeRelevesLuminositeAmbiante = SommeRelevesLuminositeAmbiante + valeurLuminositeAmbiante;                                       // Calcule la somme des 50 relevés

    if (CompteurRelevesLuminositeAmbiante >= 50) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si 50 relevés ont été effectués
    {
      valeurLuminositeAmbiante = int(SommeRelevesLuminositeAmbiante / 50.0);                                                          // Calcule la moyenne des 50 relevés
      //Serial.println(valeurLuminositeAmbiante);                                                                                       // Débug (Désactiver le Dfplayer pour libérer le port série)
      CompteurRelevesLuminositeAmbiante = 0; SommeRelevesLuminositeAmbiante = 0;                                                      // Réinitialisation des variables de calcul de la moyenne de la luminosité ambiante

      if ((LastvaleurLuminositeAmbiante != valeurLuminositeAmbiante // -------------------------------------------------------------- // Si la valeur lue a changé
        && abs(valeurLuminositeAmbiante - LastvaleurLuminositeAmbiante) > 30)                                                         // et Si le changement est supérieur à 60
        || LastvaleurLuminositeAmbiante == -1)                                                                                        // ou Si début du programme
      {
        brightnessBarrettes = map(valeurLuminositeAmbiante, 0, 1023, 5, 50);                                                          // Réétalonne la valeur de la lumière ambiante en luminosité pour les leds adressables
        //Serial.println(brightnessBarrettes);                                                                                        // Débug (Désactiver le Dfplayer pour libérer le port série)

        colonneLed.setBrightness(brightnessBarrettes);                                                                                // Définit la luminosité des barrettes de leds adressables
        MajAffichageTemperatureCourante = true;                                                                                       // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
        LasttemperatureCourante = -1;                                                                                                 // Force l'affichage de la température courante
        LastvaleurLuminositeAmbiante = valeurLuminositeAmbiante;                                                                      // Mémorise le dernier état de la lumière ambiante
      }
    }
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE L'AFFICHAGE DE LA TEMPERATURE COURANTE SUR LES BARRETTES DE LEDS ADRESSABLES
  if (MajAffichageTemperatureCourante && !ModeMenu) // ****************************************************************************** // Si la mise à jour de l'affichage de la température sur les barrettes de leds adressables est activée et Si le mode menu est désactivé
  {
    if (LasttemperatureCourante != temperatureCourante && abs(LasttemperatureCourante - temperatureCourante) >= 0.49) // ++++++++++++ // Si la température courante a changé et si l'écart est de plus ou moins 0.49°
    {
      if (temperatureCourante >= 9.75 && temperatureCourante <= 46.5) // ------------------------------------------------------------ // Vérifie la validité des données lues
      {
        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables

        if (temperatureCourante < 36.75) // ......................................................................................... // Si échelle de température 1
        {
          colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp1), colonneLed.Color(150, 0, 0));                             // Active le témoin de l'échelle de température 1 ou 2
          colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp2), colonneLed.Color(0, 0, 0));                               // Désactive le témoin de l'échelle de température 2

          for (int i = 0; i <= pgm_read_byte(&nombreLedsColonne) - 3; i++) // ======================================================= // Gestion de l'affichage des barrettes de leds adressables vers le haut
          {
            if (temperatureCourante >= i/2 + 9.75) {colonneLed.setPixelColor(i, colonneLed.Color(255, 0, 0));}                          // Calcule et Affiche l'état de la led degrés de rang i en rouge
            else {colonneLed.setPixelColor(i, colonneLed.Color(0, 50, 0));}                                                          // Affiche les autres leds en vert

            if (testEvenements()) // ________________________________________________________________________________________________ // Si la fonction retourne "Vrai" => On sort pour traiter l'évènement
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
              return;                                                                                                                 // Retourne au début de la loop()
            }

                 if (PageOled != 0) {delay(35);}                                                                                      // Si la Page 0 n'est pas sélectionnée => On temporise pendant 35ms
            else if (PageOled == 0)                                                                                                   // Si la Page 0 est sélectionnée => On continue d'afficher l'oscillation des deux points pour l'affichage de l'heure
            {
              FonctionOsc2Points();                                                                                                   // Appelle la fonction de gestion des deux points de l'affichage de l'heure sur l'écran OLED
            }

            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
          }
          /*for (int i = 0, j = 1; i <= pgm_read_byte(&nombreLedsColonne) - 3, // ===================================================== // Gestion de l'affichage des barrettes de leds adressables vers le haut
               j <= pgm_read_byte(&nombreLedsColonne) - 3; i = i + 2, j = j + 2)
          {
            if (temperatureCourante >= i/2 + 9.75) {colonneLed.setPixelColor(i, colonneLed.Color(255, 0, 0));}                        // Calcule et Affiche l'état de la led degrés de rang i en rouge
            else {colonneLed.setPixelColor(i, colonneLed.Color(0, 50, 0));}                                                           // Affiche les autres leds en vert

            if (temperatureCourante >= j/2 + 10.25) {colonneLed.setPixelColor(j, colonneLed.Color(50, 0, 0));}                        // Calcule et Affiche l'état de la led demi-degrés de rang j en rouge
            else {colonneLed.setPixelColor(j, colonneLed.Color(0, 50, 0));}                                                           // Affiche les autres leds en vert

            if (testEvenements()) // ________________________________________________________________________________________________ // Si la fonction retourne "Vrai" => On sort pour traiter l'évènement
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
              return;                                                                                                                 // Retourne au début de la loop()
            }

                 if (PageOled != 0) {delay(35);}                                                                                      // Si la Page 0 n'est pas sélectionnée => On temporise pendant 35ms
            else if (PageOled == 0)                                                                                                   // Si la Page 0 est sélectionnée => On continue d'afficher l'oscillation des deux points pour l'affichage de l'heure
            {
              FonctionOsc2Points();                                                                                                   // Appelle la fonction de gestion des deux points de l'affichage de l'heure sur l'écran OLED
            }

            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
          }*/
        }
        else // ..................................................................................................................... // Si échelle de température 2
        {
          colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp1), colonneLed.Color(150, 0, 0));                             // Active le témoin de l'échelle de température 1 ou 2
          colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp2), colonneLed.Color(150, 0, 0));                             // Active le témoin de l'échelle de température 2

          for (int i = 0; i <= pgm_read_byte(&nombreLedsColonne) - 3; i++) // ======================================================= // Gestion de l'affichage des barrettes de leds adressables vers le haut
          {
            if (temperatureCourante >= i/2 + 19.75) {colonneLed.setPixelColor(i, colonneLed.Color(255, 0, 0));}                       // Calcule et Affiche l'état de la led degrés de rang i en rouge
            else {colonneLed.setPixelColor(i, colonneLed.Color(0, 50, 0));}                                                           // Affiche les autres leds en vert

            if (testEvenements()) // ________________________________________________________________________________________________ // Si la fonction retourne "Vrai" => On sort pour traiter l'évènement
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
              return;                                                                                                                 // Retourne au début de la loop()
            }

            if (PageOled != 0) {delay(35);}                                                                                           // Si la Page 0 n'est pas sélectionnée => On temporise pendant 35ms
            else if (PageOled == 0)                                                                                                   // Si la Page 0 est sélectionnée => On continue d'afficher l'oscillation des deux points pour l'affichage de l'heure
            {
              FonctionOsc2Points();                                                                                                   // Appelle la fonction de gestion des deux points de l'affichage de l'heure sur l'écran OLED
            }

            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
          }

          /*for (int i = 0, j = 1; i <= pgm_read_byte(&nombreLedsColonne) - 3, // ===================================================== // Gestion de l'affichage des barrettes de leds adressables vers le haut
               j <= pgm_read_byte(&nombreLedsColonne) - 3; i = i + 2, j = j + 2)
          {
            if (temperatureCourante >= i/2 + 19.75) {colonneLed.setPixelColor(i, colonneLed.Color(255, 0, 0));}                       // Calcule et Affiche l'état de la led degrés de rang i en rouge
            else {colonneLed.setPixelColor(i, colonneLed.Color(0, 50, 0));}                                                           // Affiche les autres leds en vert

            if (temperatureCourante >= j/2 + 20.25) {colonneLed.setPixelColor(j, colonneLed.Color(50, 0, 0));}                        // Calcule et Affiche l'état de la led demi-degrés de rang j en rouge
            else {colonneLed.setPixelColor(j, colonneLed.Color(0, 50, 0));}                                                           // Affiche les autres leds en vert

            if (testEvenements()) // ________________________________________________________________________________________________ // Si la fonction retourne "Vrai" => On sort pour traiter l'évènement
            {
              FonctionEffaceBarrettesLeds();                                                                                          // Appelle la fonction pour effacer toutes les barrettes de leds adressables
              return;                                                                                                                 // Retourne au début de la loop()
            }

            if (PageOled != 0) {delay(35);}                                                                                           // Si la Page 0 n'est pas sélectionnée => On temporise pendant 35ms
            else if (PageOled == 0)                                                                                                   // Si la Page 0 est sélectionnée => On continue d'afficher l'oscillation des deux points pour l'affichage de l'heure
            {
              FonctionOsc2Points();                                                                                                   // Appelle la fonction de gestion des deux points de l'affichage de l'heure sur l'écran OLED
            }

            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
          }*/
        }
      }
      else // ----------------------------------------------------------------------------------------------------------------------- // Si dépassement de la température
      {
        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables

        if (temperatureCourante > 46.5) // .......................................................................................... // Si dépassement par le haut
        {
          for (int i = 0; i <= pgm_read_byte(&nombreLedsColonne) - 1; i++) // ======================================================= // Gestion de l'affichage des barrettes de leds adressables vers le haut
          {
            colonneLed.setPixelColor(i, colonneLed.Color(150, 0, 0));                                                                 // Affiche la led de rang i en rouge
            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
            delay(5);                                                                                                                 // Temporise 5ms
          }
        }
        else if (temperatureCourante < 9.75) // ..................................................................................... // Si dépassement par le bas
        {
          for (int i = pgm_read_byte(&nombreLedsColonne) - 1; i >= 0; i--) // ======================================================= // Gestion de l'affichage des barrettes de leds adressables vers le bas
          {
            colonneLed.setPixelColor(i, colonneLed.Color(0, 0, 150));                                                                 // Affiche la led de rang i en bleu
            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
            delay(5);                                                                                                                 // Temporise 5ms
          }
        }

        LasttemperatureCourante = -1;                                                                                                 // Force l'affichage de la température courante après relecture
        return;                                                                                                                       // Retour début boucle loop()
      }
      LasttemperatureCourante = temperatureCourante;                                                                                  // Mémorise la dernière valeur courante de la température
    }

    MajAffichageTemperatureCourante = false;                                                                                          // Désactive l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
  }

//**************************************************************************************************************************************************************************
//*********************************************************************************************************************************** // GESTION DE L'AFFICHAGE DE LA VITESSE DES VARIATIONS DE LA TEMPERATURE ET DE L'HUMIDITE SUR LES BARRETTES DE LEDS ADRESSABLES
  if (MajAffichageVariations && !ModeMenu) // *************************************************************************************** // Si la mise à jour de l'affichage des vitesses de variations de la température et du taux d'humidité sur les barrettes de leds adressables est activée et Si le mode menu est désactivé
  {
    FonctionEffaceBarrettesLeds();                                                                                                    // Appelle la fonction pour effacer toutes les barrettes de leds adressables

    colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp1), colonneLed.Color(0, 0, 0));                                     // Désactive le témoin de l'échelle de température 1 ou 2
    colonneLed.setPixelColor(pgm_read_byte(&numLedRougeEchelleTemp2), colonneLed.Color(0, 0, 0));                                     // Désactive le témoin de l'échelle de température 2

    float vitesseVariationTemperature = 0;                                                                                            // Déclare la variable contenant la vitesse de variation de la température
    float vitesseVariationHumidite = 0;                                                                                               // Déclare la variable contenant la vitesse de variation du taux d'humidité
    int coul1 = 0;                                                                                                                    // Premier paramètre des couleurs (rouge)
    int coul2 = 0;                                                                                                                    // Deuxième paramètre des couleurs (vert)
    int coul3 = 0;                                                                                                                    // Troisième paramètre des couleurs (bleu)
    unsigned long t1TempoAffichageVariations = 0;                                                                                     // Début de la temporisation d'affichage de la vitesse des variations

    vitesseVariationTemperature = (T2 - T1) * pgm_read_byte(&k);                                                                      // Calcule la vitesse de variation de la température
    vitesseVariationHumidite = (H2 - H1) * pgm_read_byte(&k);                                                                         // Calcule la vitesse de variation du taux d'humidité
    //Serial.println(vitesseVariationTemperature); Serial.println(vitesseVariationHumidite);                                            // Débug (Désactiver le Dfplayer pour libérer le port série)

    if (abs(vitesseVariationTemperature) > 56) {vitesseVariationTemperature = 56;} // *********************************************** // Borne la vitesse de variation de la température
    if (abs(vitesseVariationHumidite) > 56) {vitesseVariationHumidite = 56;} // ***************************************************** // Borne la vitesse de variation du taux d'humidité

    FonctionCadre(1);                                                                                                                 // Efface l'afficheur OLED et Affiche le cadre (Taille police)
    display.setCursor(24, 5); LectureMemoireFlash(messageOLED14);                                                                     // Affiche le message "VITESSE" sur l'écran OLED
    display.setCursor(12, 24); LectureMemoireFlash(messageOLED15);                                                                    // Affiche le message "VARIATION" sur l'écran OLED
    display.setCursor(41, 44); LectureMemoireFlash(messageOLED16);                                                                    // Affiche le message "TEMP" sur l'écran OLED
    display.display();                                                                                                                // Rafraîchit l'affichage de l'écran OLED

    t1TempoAffichageVariations = millis();                                                                                            // Démarre la temporisation d'affichage de la vitesse de variation de la température
    if (vitesseVariationTemperature == 0) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la vitesse de variation de la température est nulle
    {
      while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ---------------------------------- // Affiche la vitesse de variation de la température pendant 5 secondes
      {
        for (int i = 26, j = 28; i >= 0, j <= pgm_read_byte(&nombreLedsColonne) - 2; i--, j++) // ................................... // Gestion de l'affichage des barrettes de leds adressables vers le haut et vers le bas
        {
          colonneLed.setPixelColor(27, colonneLed.Color(255, 255, 0));                                                                // Affiche la led centrale en jaune
          colonneLed.setPixelColor(i, colonneLed.Color(0, 0, 150));                                                                   // Affiche les leds en bleu du centre vers le bas
          colonneLed.setPixelColor(j, colonneLed.Color(150, 0, 0));                                                                   // Affiche les leds en rouge du centre vers le haut
          colonneLed.show();                                                                                                          // Rafraîchit l'affichage des barrettes de leds adressables
          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          delay(25);                                                                                                                  // Temporise 25ms
        }

        if (testEvenements()) {break;} // ........................................................................................... // Si la fonction retourne "Vrai" => Sort de la boucle for()
        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables
      }
    }
    else if (vitesseVariationTemperature > 0) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la vitesse de variation de la température est positive
    {
      coul1 = 150; coul2 = 0; coul3 = 0;                                                                                              // Prépare l'affichage des leds en rouge

      while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ---------------------------------- // Affiche la variation de la vitesse de la température pendant 5 secondes
      {
        for (int i = 0; i < vitesseVariationTemperature; i++) // .................................................................... // Gestion de l'affichage des barrettes de leds adressables vers le haut
        {
          colonneLed.setPixelColor(i, colonneLed.Color(coul1, coul2, coul3));                                                         // Affiche la led de rang i en rouge vers le haut
          colonneLed.show();                                                                                                          // Rafraîchit l'affichage des barrettes de leds adressables
          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          delay(25);                                                                                                                  // Temporise 25ms
        }

        if (testEvenements()) {break;} // ........................................................................................... // Si la fonction retourne "Vrai" => Sort de la boucle for()
        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables
      }
    }
    else if (vitesseVariationTemperature < 0) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la vitesse de variation de la température est négative
    {
      coul1 = 0; coul2 = 0; coul3 = 150;                                                                                              // Prépare l'affichage des leds en bleu

      while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ---------------------------------- // Affiche la vitesse de variation de la température pendant 5 secondes
      { // .......................................................................................................................... // Gestion de l'affichage des barrettes de leds adressables vers le bas
        for (int i = pgm_read_byte(&nombreLedsColonne) - 3; i > pgm_read_byte(&nombreLedsColonne) - 3 - abs(vitesseVariationTemperature); i--)
        {
          colonneLed.setPixelColor(i, colonneLed.Color(coul1, coul2, coul3));                                                         // Affiche la led de rang i en bleu
          colonneLed.show();                                                                                                          // Rafraîchit l'affichage des barrettes de leds adressables
          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          delay(25);                                                                                                                  // Temporise 25ms
        }

        if (testEvenements()) {break;} // ........................................................................................... // Si la fonction retourne "Vrai" => Sort de la boucle for()
        FonctionEffaceBarrettesLeds();                                                                                                // Appelle la fonction pour effacer toutes les barrettes de leds adressables
      }
    }

    if (!testEvenements()) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la fonction a retourné "Faux" on continue avec l'affichage de la vitesse des variations du taux d'humidité
    {
      FonctionCadre(1);                                                                                                               // Efface l'afficheur OLED et Affiche le cadre (Taille police)
      display.setCursor(24, 5); LectureMemoireFlash(messageOLED14);                                                                   // Affiche le message "VITESSE" sur l'écran OLED
      display.setCursor(12, 24); LectureMemoireFlash(messageOLED15);                                                                  // Affiche le message "VARIATION" sur l'écran OLED
      display.setCursor(18, 44); LectureMemoireFlash(messageOLED17);                                                                  // Affiche le message "HUMIDITE" sur l'écran OLED
      display.display();                                                                                                              // Rafraîchit l'affichage de l'écran OLED

      t1TempoAffichageVariations = millis();                                                                                          // Démarre la temporisation d'affichage de la vitesse de variation du taux d'humidité
      if (vitesseVariationHumidite == 0) // ----------------------------------------------------------------------------------------- // Si la vitesse de variation du taux d'humidité est nulle
      {
        while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ................................ // Affiche la vitesse de variation du taux d'humidité pendant 5 secondes
        {
          for (int i = 28, j = 26; i >= 0, j <= pgm_read_byte(&nombreLedsColonne) - 2; i--, j++) // ================================= // Gestion de l'affichage des barrettes de leds adressables vers le haut et vers le bas
          {
            colonneLed.setPixelColor(27, colonneLed.Color(150, 0, 0));                                                                // Affiche la led centrale en rouge
            colonneLed.setPixelColor(i, colonneLed.Color(255, 255, 0));                                                               // Affiche les leds jaunes du centre vers le bas
            colonneLed.setPixelColor(j, colonneLed.Color(0, 150, 0));                                                                 // Affiche les leds vertes du centre vers le haut
            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
            if (testEvenements()) {break;} // _______________________________________________________________________________________ // Si la fonction retourne "Vrai" => Sort de la boucle for()
            delay(25);                                                                                                                // Temporise 25ms
          }

          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
        }
      }
      else if (vitesseVariationHumidite > 0) // ------------------------------------------------------------------------------------- // Si la vitesse de variation du taux d'humidité est positive
      {
        coul1 = 0; coul2 = 150; coul3 = 0;                                                                                            // Prépare l'affichage des leds en vert

        while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ................................ // Affiche la vitesse de variation du taux d'humidité pendant 5 secondes
        {
          for (int i = 0; i < vitesseVariationHumidite; i++) // ===================================================================== // Gestion de l'affichage des barrettes de leds adressables
          {
            colonneLed.setPixelColor(i, colonneLed.Color(coul1, coul2, coul3));                                                       // Affiche de la led de rang i en vert vert le haut
            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
            if (testEvenements()) {break;} // _______________________________________________________________________________________ // Si la fonction retourne "Vrai" => Sort de la boucle for()
            delay(25);                                                                                                                // Temporise 25ms
          }

          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
        }
      }
      else if (vitesseVariationHumidite < 0) // ------------------------------------------------------------------------------------- // Si la vitesse de variation du taux d'humidité est négative
      {
        coul1 = 255; coul2 = 255; coul3 = 0;                                                                                          // Prépare l'affichage des leds en jaune

        while (millis() - t1TempoAffichageVariations < pgm_read_dword(&TempoAffichageVariations)) // ................................ // Affiche la vitesse de variation du taux d'humidité pendant 5 secondes
        { // ======================================================================================================================== // Gestion de l'affichage des barrettes de leds adressables vers le bas
          for (int i = pgm_read_byte(&nombreLedsColonne) - 3; i > pgm_read_byte(&nombreLedsColonne) - 3 - abs(vitesseVariationHumidite); i--)
          {
            colonneLed.setPixelColor(i, colonneLed.Color(coul1, coul2, coul3));                                                       // Affiche la led de rang i en jaune vers le bas
            colonneLed.show();                                                                                                        // Rafraîchit l'affichage des barrettes de leds adressables
            if (testEvenements()) {break;} // _______________________________________________________________________________________ // Si la fonction retourne "Vrai" => Sort de la boucle for()
            delay(25);                                                                                                                // Temporise 25ms
          }

          if (testEvenements()) {break;} // ========================================================================================= // Si la fonction retourne "Vrai" => Sort de la boucle for()
          FonctionEffaceBarrettesLeds();                                                                                              // Appelle la fonction pour effacer toutes les barrettes de leds adressables
        }
      }
    }

    FonctionEffaceBarrettesLeds();                                                                                                    // Appelle la fonction pour effacer toutes les barrettes de leds adressables
    display.clearDisplay();                                                                                                           // Efface l'afficheur OLED
    LastMins = -1;                                                                                                                    // Force l'affichage de l'heure courante
    LastJour = -1;                                                                                                                    // Force l'affichage de la date courante
    LasttauxHumiditeCourant = -1;                                                                                                     // Force l'affichage du taux d'humidité courant
    t1TempoAffichageMessageOled = 0;                                                                                                  // Réinitialise la temporisation de la durée d'affichages des messages sur l'écran OLED
    PageOled = 0;                                                                                                                     // Sélectionne la Page 0 de l'écran OLED

    T1 = 0; T2 = 0;                                                                                                                   // Réinitialise les valeurs de la température pour le calcul de la temporisation d'affichage de la vitesse de variation de la température
    H1 = 0; H2 = 0;                                                                                                                   // Réinitialise les valeurs du taux d'humidité pour le calcul de la temporisation d'affichage de la vitesse de variation du taux d'humidité
    t1TempoReleveVariations = 0;                                                                                                      // Réinitialise la temporisation pour le calcul et l'affichage des vitesses de variations de la température et du taux d'humidité
    MajAffichageVariations = false;                                                                                                   // Désactive l'indicateur de mise à jour des vitesses de variations de la température et du taux d'humidité
    MajAffichageTemperatureCourante = true;                                                                                           // Active l'indicateur de mise à jour de l'affichage des barrettes de leds adressables
    LasttemperatureCourante = -1;                                                                                                     // Force l'affichage de la température courante
  }

//**************************************************************************************************************************************************************************
}

//**************************************************************************************************************************************************************************
//*** Efface les barrettes de leds adressables *****************************************************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionEffaceBarrettesLeds ()
{
  colonneLed.clear();                                                                                                                 // Efface les barrettes de leds adressables
  colonneLed.show();                                                                                                                  // Rafraîchit l'affichage des barrettes de leds adressables
}

//**************************************************************************************************************************************************************************
//*** Fonction test d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables ******************************
//**************************************************************************************************************************************************************************
boolean testEvenements ()
{
  boolean evenementdetecte = false;                                                                                                   // Déclare l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables

  FonctionLectureDS3234();                                                                                                            // Appelle la fonction de la gestion du module RTC DS3234

  if (Mins == 0 && Secs == 0) // **************************************************************************************************** // Si l'heure a changé et doit donc être annoncée
  {
    evenementdetecte = true;                                                                                                          // Active l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
    return evenementdetecte;                                                                                                          // Retourne la valeur "Vrai" de l'indicateur "evenementdetecte" dans "testEvenements()"
  }
  else if (Jour == pgm_read_byte(&JourCompteRebours) && Mois == pgm_read_byte(&MoisCompteRebours) // ******************************** // Si la date du compte à rebours de la  nouvelle année est atteinte
        && Hrs == pgm_read_byte(&HrsCompteRebours) && Mins == pgm_read_byte(&MinsCompteRebours) && Secs == 50)                        // et Si l'heure de départ du compte à rebours de la nouvelle année est atteinte
  {
    evenementdetecte = true;                                                                                                          // Active l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
    return evenementdetecte;                                                                                                          // Retourne la valeur "Vrai" de l'indicateur "evenementdetecte" dans "testEvenements()"
  }
  else if (digitalRead(BrocheBPOK) == LOW || digitalRead(BrocheBPDroite) == LOW || digitalRead(BrocheBPGauche) == LOW) // *********** // Si un des trois boutons poussoirs est activé
  {
    evenementdetecte = true;                                                                                                          // Active l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
    return evenementdetecte;                                                                                                          // Retourne la valeur "Vrai" de l'indicateur "evenementdetecte" dans "testEvenements()"
  }
  else {LectureDipSwitch();} // ***************************************************************************************************** // Appelle la fonction de lecture des Dip Switch

  if (LastEtatDipSwitchMuteGeneral != EtatDipSwitchMuteGeneral // ******************************************************************* // Si changement d'état du Dip Switch Mute Général
   || LastEtatDipSwitchMutePartiel != EtatDipSwitchMutePartiel                                                                        // ou Si changement d'état du Dip Switch Mute Partiel
   || LastEtatDipSwitchVoix != EtatDipSwitchVoix)                                                                                     // ou Si changement d'état du Dip Switch Voix
  {
    evenementdetecte = true;                                                                                                          // Active l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
    return evenementdetecte;                                                                                                          // Retourne la valeur "Vrai" de l'indicateur "evenementdetecte" dans "testEvenements()"
  }
  else {FonctionLecturePotentiometreVolume();} // *********************************************************************************** // Lit la valeur analogique sur la broche du curseur du potentiomètre (valeur entre 0 et 1023)

  if (LastvaleurPotentiometreVolume != valeurPotentiometreVolume // ***************************************************************** // Si la valeur lue a changé
   && abs(valeurPotentiometreVolume - LastvaleurPotentiometreVolume) > 30)                                                            // et Si l'écart entre la valeur actuelle et la dernière valeur est > 60
  {
    evenementdetecte = true;                                                                                                          // Active l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
  }
  else // *************************************************************************************************************************** // Sinon aucun évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barrettes de leds adressables
  {
    evenementdetecte = false;                                                                                                         // Desactive l'indicateur d'un évènement à prendre en compte pendant les boucles for() ou while() d'affichage sur les barretes de leds adressables
  }

  return evenementdetecte;                                                                                                            // Retourne la valeur "Vrai" ou "Faux" de l'indicateur "evenementdetecte" dans "testEvenements()"
}

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

//**************************************************************************************************************************************************************************
//*** Fonction Cadre sur écran Oled ****************************************************************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionCadre (boolean taillePolice)
{
  display.clearDisplay();                                                                                                             // Efface l'afficheur OLED
  display.drawRoundRect(0, 0, display.width(), display.height(), 8, WHITE);                                                           // Affiche le cadre
  if (taillePolice) {display.setTextSize(2);}                                                                                         // Définit la taille du texte
}

//**************************************************************************************************************************************************************************
//*** Fonction Lecture des 3 Dip Switch ************************************************************************************************************************************
//**************************************************************************************************************************************************************************
void  LectureDipSwitch ()
{
  EtatDipSwitchMuteGeneral = digitalRead(BrocheDipSwitchMuteGeneral);                                                                 // Lecture des états des 3 Dip Switch
  EtatDipSwitchMutePartiel = digitalRead(BrocheDipSwitchMutePartiel);
  EtatDipSwitchVoix = digitalRead(BrocheDipSwitchVoix);
}

//**************************************************************************************************************************************************************************
//*** Fonction Lecture Mémoire Flash et Affichage les messages sur l'écran OLED ********************************************************************************************
//**************************************************************************************************************************************************************************
void LectureMemoireFlash (const char AdresseMessage[])
{
  char CaractereTemporaire = pgm_read_byte(AdresseMessage);                                                                           // Récupère le premier caractère
  char i = 0;                                                                                                                         // Compte le nombre de déplacements

  while (CaractereTemporaire != '\0') // ******************************************************************************************** // Tant que le caractère récupéré est différent du caractère de fin de chaîne de caractères
  {
    display.print(CaractereTemporaire);                                                                                               // Affichage du caractère lu
    i++;                                                                                                                              // Incrémente le pointeur d'adresse de la donnée à lire
    CaractereTemporaire = pgm_read_byte(AdresseMessage + i);                                                                          // Récupère le caractère suivant
  }
}

//**************************************************************************************************************************************************************************
//*** Fonction Gestion des deux points de l'affichage de l'heure sur l'écran OLED ******************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionOsc2Points ()
{
  display.setTextSize(3);                                                                                                             // Définit la taille du texte
  display.setCursor(57, 3);                                                                                                           // Positionne l'affichage des deux points sur l'écran OLED
  if (Osc2Points) {LectureMemoireFlash(messageOLED01);} else {LectureMemoireFlash(messageOLED18);}                                    // Affiche l'oscillation des 2 points de l'affichage de l'heure sur l'écran OLED
  display.display();                                                                                                                  // Rafraîchit l'affichage de l'écran OLED
}

//**************************************************************************************************************************************************************************
//*** Fonction Interruption pour l'oscillation des 2 points de l'affichage de l'heure sur l'écran OLED *********************************************************************
//**************************************************************************************************************************************************************************
void Oscillations2Points ()
{
  Osc2Points = !Osc2Points;                                                                                                           // Inverse l'état de la variable pour l'oscillation des 2 points de l'affichage de l'heure sur l'écran OLED
}

//**************************************************************************************************************************************************************************
//*** Fonction Annonce audio de la nouvelle heure **************************************************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionAnnonceNouvelleHeure ()
{
  int pisteAudioHeure = 0;                                                                                                            // Déclare la variable pisteAudioHeure

  Buzzer(8, 100, 2);

  if (!MuteGeneral && !MutePartiel) // ********************************************************************************************** // Le son du Dfplayer n'est jamais coupé
  {
    if (!Voix) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Lecture des 24 premières pistes voix masculine (Voix 1)
    {
      pisteAudioHeure = Hrs;                                                                                                          // Calcule la piste du Dfplayer à lire
      if (Hrs == 0) {pisteAudioHeure = Hrs + 24;}                                                                                     // S'il est minuit lecture de la piste 24
    }
    else if (Voix) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Lecture des 24 pistes suivante voix féminine (Voix 2)
    {
      pisteAudioHeure = Hrs + 24;                                                                                                     // Calcule la piste du Dfplayer à lire
      if (Hrs == 0) {pisteAudioHeure = Hrs + 48;}                                                                                     // S'il est minuit lecture de la piste 48
    }
  }
  else if (!MuteGeneral && MutePartiel) // ****************************************************************************************** // Le son du Dfplayer est coupé partiellement
  {
    if (Hrs <= pgm_read_byte(&HrsDebutMutePartiel) && Hrs >= pgm_read_byte(&HrsFinMutePartiel)) // ++++++++++++++++++++++++++++++++++ // Le son du Dfplayer est coupé dans ce créneaux horaire
    {
      if (!Voix) // ----------------------------------------------------------------------------------------------------------------- // Lecture des 24 premières pistes voix masculine (Voix 1)
      {
        pisteAudioHeure = Hrs;                                                                                                        // Calcule la piste du Dfplayer à lire
        if (Hrs == 0) {pisteAudioHeure = Hrs + 24;}                                                                                   // S'il est minuit lecture de la piste 24
      }
      else if (Voix) // ------------------------------------------------------------------------------------------------------------- // Lecture des 24 pistes suivante voix féminine (Voix 2)
      {
        pisteAudioHeure = Hrs + 24;                                                                                                   // Calcule la piste du Dfplayer à lire
        if (Hrs == 0) {pisteAudioHeure = Hrs + 48;}                                                                                   // S'il est minuit lecture de la piste 48
      }
    }
  }

  delay(100);                                                                                                                         // Temporise 100ms
  myDFPlayer.play(pisteAudioHeure);                                                                                                   // Lit la piste audio heure
}

//**************************************************************************************************************************************************************************
//*** Fonction de la Gestion du Module RTC DS3234 **************************************************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionLectureDS3234 ()
{
  rtc.update();                                                                                                                       // Lit l'heure et la date dans le module RTC DS3234
  Hrs = rtc.hour(); Mins = rtc.minute(); Secs = rtc.second();                                                                         // Récupère les heures, les minutes et les secondes courantes
  Jour = rtc.date(); Mois = rtc.month(); Annee = rtc.year();                                                                          // Récupère la date courante
}

//**************************************************************************************************************************************************************************
//*** Fonction Animation Couleur du compte à rebours de la nouvelle année sur les barrettes de leds adressables ************************************************************
//**************************************************************************************************************************************************************************
int couleurColonne(byte positionColonne)
{
  positionColonne = 255 - positionColonne;

       if (positionColonne < 85)  {return colonneLed.Color(255 - positionColonne * 3, 0, positionColonne * 3);}
  else if (positionColonne < 170) {positionColonne -= 85; return colonneLed.Color(0, positionColonne * 3, 255 - positionColonne * 3);}
  else {positionColonne -= 170; return colonneLed.Color(positionColonne * 3, 255 - positionColonne * 3, 0);}
}

//**************************************************************************************************************************************************************************
//*** Fonction Animation du compte à rebours de la nouvelle année sur les barrettes de leds adressables ********************************************************************
//**************************************************************************************************************************************************************************
void AnimationCompteAReboursBarrettesLeds ()
{
  for (int i = 0; i < pgm_read_byte(&nombreLedsColonne); i++)
  {
    colonneLed.setPixelColor(i, couleurColonne(((i * 256 / pgm_read_byte(&nombreLedsColonne)) + nbCycleAnimationCompteAReboursBarrettesLeds) & 255));
  }

  colonneLed.show();                                                                                                                  // Rafraîchit l'affichage des barrettes de leds adressables

  nbCycleAnimationCompteAReboursBarrettesLeds++;
  if (nbCycleAnimationCompteAReboursBarrettesLeds == 256 * 5) {nbCycleAnimationCompteAReboursBarrettesLeds = 0;}
}

//**************************************************************************************************************************************************************************
//*** Fonction Lecture du potentiomètre du volume du Dfplayer **************************************************************************************************************
//**************************************************************************************************************************************************************************
void FonctionLecturePotentiometreVolume ()
{
  valeurPotentiometreVolume = analogRead(BrochePotentiometreVolume);                                                                  // Lit la valeur analogique sur la broche du curseur du potentiomètre (valeur entre 0 et 1023)
}