Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- //**************************************************************************************************************************************************************************
- //**************************************************** Gestion Terrarium v1.0 - Ecran TFT Tactile - Carte Mega (com51) *****************************************************
- //**************************************************************************************************************************************************************************
- // Page Principale : Affichage de l'heure et de la date courantes.
- // Affichage de la température et du taux d'humidité courants.
- // Affichage des seuils de température jour et du taux d'humidité jour et des seuils de température nuit et du taux d'humidité nuit.
- // Affichage des boutons du ventilateur, du brumisateur et de l'éclairage et changement de la couleur des boutons en fonction de l'état de fonctionnement.
- // Affichage du bouton d'accès aux menus.
- // Menus : Bouton "annuler" pour le retour vers la Page principale et les réglages ne sont pas validés.
- // Bouton "annuler" pour le retour vers la Page 1 des menus et les réglages ne sont pas validés.
- // Boutons "droite" et "gauche" pour se déplacer dans les menus.
- // Boutons "haut" et "bas" pour se déplacer dans les menus.
- // Bouton "ok" pour valider les réglages.
- // Boutons "+" et "-" pour modifier les réglages.
- // Mode Jour / Nuit : Menus réglages des seuils de température jour et du taux d'humidité jour et des seuils de température nuit et du taux d'humidité nuit.
- // Réglage mode Manuel ou Automatique du ventilateur et du brumisateur.
- // Menu réglages de l'heure de départ jour et de l'heure de départ nuit.
- // Programmateur horaire Jour / Nuit de l'éclairage.
- // Programmateur horaire pour les repas et lecture d'une mélodie au démarrage du programmateur.
- // Réglage de l'heure courante.
- // Réglage de la date courante.
- // Sortie automatique des menus après un certain délai.
- // Restauration dans le menu setup des paramètres par défaut.
- // Mode Eco dans le menu setup : Extinction de l'écran TFT par le programmateur horaire Jour / Nuit de l'éclairage.
- // Mode Mute dans le menu setup.
- // Détection des créneaux horaires des programmateurs au démarrage du programme et dans la restauration dans le menu setup des paramètres par défaut.
- //**************************************************************************************************************************************************************************
- #include <Adafruit_GFX.h>
- #include <MCUFRIEND_kbv.h>
- MCUFRIEND_kbv tft;
- #include <TouchScreen.h> // Librairie pour la gestion de la Fonction Tactile de l'écran TFT
- #include <Wire.h> // Librairie pour la communication série avec le Module RTC PCF8523
- #include "RTClib.h" // Librairie pour la gestion de la date et de l'heure du Module RTC PCF8523
- #include <Adafruit_BME280.h> // Librairie pour la gestion du Module BME280
- #include "EEPROM.h" // Librairie pour la gestion de l'EEPROM interne
- #include <avr/pgmspace.h> // Librairie pour la gestion de la Mémoire
- #include "Pitches.h" // Librairie pour la gestion des notes de musique
- RTC_PCF8523 rtc; // Crée l'objet RTC
- Adafruit_BME280 bme; // Crée l'objet bme pour une connexion I2C
- #define BrocheBuzzer 53 // Broche sortie du Buzzer 5v
- #define BrocheLedRougeTemoinVentilateur 52 // Broche sortie de la led rouge témoin du ventilateur
- #define BrocheLedVerteTemoinBrumisateur 51 // Broche sortie de la led verte témoin du brumisateur
- #define BrocheLedJauneTemoinEclairage 50 // Broche sortie de la led jaune témoin de l'éclairage
- #define BrocheLedBleueMelodieRepas 49 // Broche sortie de la led bleue mélodie repas
- #define BrocheRelaisVentilationBoitier 22 // Broche sortie relais ventilation boitier
- #define BrocheRelaisVentilateur 23 // Broche sortie relais ventilateur
- #define BrocheRelaisBrumisateur 24 // Broche sortie relais brumisateur
- #define BrocheRelaisEclairage 25 // Broche sortie relais éclairage
- #define BrocheRelaisEclairageChauffant 26 // Broche sortie relais éclairage chauffant
- #define BrocheBPPlusTemperatureModeDemo 47 // Broche entrée du bouton poussoir "BPPlusTemperatureModeDemo" pour faire varier la température en mode démo
- #define BrocheBPMoinsTemperatureModeDemo 46 // Broche entrée du bouton poussoir "BPMoinsTemperatureModeDemo" pour faire varier la température en mode démo
- #define BrocheBPPlusHumiditeModeDemo 37 // Broche entrée du bouton poussoir "BPPlusHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- #define BrocheBPMoinsHumiditeModeDemo 48 // Broche entrée du bouton poussoir "BPMoinsHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- #define BrocheLedVerteTemoinModeDemo 45 // Broche sortie de la led verte témoin du mode démo
- uint8_t YP = A3; // Broche pour la fonction tactile de l'écran TFT
- uint8_t XM = A2; // Broche pour la fonction tactile de l'écran TFT
- uint8_t YM = 9; // Broche pour la fonction tactile de l'écran TFT
- uint8_t XP = 8; // Broche pour la fonction tactile de l'écran TFT
- uint16_t TS_LEFT = 953; // Calibrage de l'écran pour la fonction tactile
- uint16_t TS_RT = 73;
- uint16_t TS_TOP = 901;
- uint16_t TS_BOT = 137;
- TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); // Crée l'objet ts
- TSPoint tp; // Crée l'objet tp
- #define PressionMin 5 // Pression Min et Max acceptées
- #define PressionMax 1000
- #define BLACK 0x0000 // Variables contenant la valeur sur 16 bits des couleurs
- #define LIGHTBLUE 0x34DF
- #define BLUE 0x001F
- #define VERYDARKBLUE 0x0005
- #define LIGHTRED 0xF945
- #define RED 0xF800
- #define DARKRED 0x8800
- #define VERYDARKRED 0x3800
- #define GREEN 0x07E0
- #define VERYDARKGREEN 0x0140
- #define KHAKIGREEN 0x195B62
- #define CYAN 0x07FF
- #define VERYDARKCYAN 0x0145
- #define MAGENTA 0xF81F
- #define VERYDARKMAGENTA 0x3803
- #define YELLOW 0xFFE0
- #define VERYDARKYELLOW 0x3180
- #define WHITE 0xFFFF
- #define VERYDARKGRAY 0x2124
- #define GRAY 0xA514
- #define ORANGE 0xFC21
- #define VERYDARKORANGE 0x4920
- uint16_t g_identifier; // Identifiant de l'écran TFT
- uint8_t OrientationTFT = 1; // Variable contenant le sens d'affichage de l'écran TFT
- unsigned long tempoPression = 0; // Début de la temporisation entre deux pressions sur l'écran tactile TFT
- int Hrs = 0; // Heure courante
- int Mins = 0; // Minute courante
- int Secs = 0; // Seconde courante
- int LastMins = -1; // Dernières minutes courantes
- int LastSecs = -1;
- int HrsReglage = 0; // Heures de réglage
- int MinsReglage = 0; // Minutes de réglage
- int LastHrsReglage = -1; // Dernières heures de réglage
- int LastMinsReglage = -1; // Dernières minutes de réglage
- int Jour = 0; // Jour du mois de la date courante (1 à 31)
- int Mois = 0; // Mois de la date courante (1 à 12)
- int Annee = 0; // Année de la date courante
- int JourSemaine = 0; // Jour de la semaine courant (0 à 6 : 0 = Dimanche etc...)
- int LastJour = -1; // Dernier jour du mois courant
- int LastJourSemaine = -1; // Dernier jour de la semaine
- int JourReglage = 0; // Jour de réglage
- int MoisReglage = 0; // Mois de réglage
- int AnneeReglage = 0; // Année de réglage
- int LastJourReglage = -1; // Dernier jour de réglage
- int LastMoisReglage = -1; // Dernier mois de réglage
- int LastAnneeReglage = -1; // Dernière année de réglage
- int PageCourante = 0; // Page courante
- int LastPageCourante = -1; // Dernière Page courante
- float TemperatureCourante = 0.0; // Température courante relevée par le capteur BME280
- float LastTemperatureCourante = -100.0; // Dernière température courante relevée par le capteur BME280
- float TauxHumiditeCourant = 0.0; // Taux d'humidité courant relevé par le capteur BME280
- float LastTauxHumiditeCourant = -1; // Dernier taux d'humidité courant relevé par le capteur BME280
- float SeuilTemperatureJour = 42.0; // Seuil de jour de la température par défaut au dessus duquel le ventilateur s'active
- float LastSeuilTemperatureJour = -100.0; // Dernier seuil de jour de la température
- float SeuilTemperatureJourReglage = 0.0; // Seuil de jour de réglage de la température
- float LastSeuilTemperatureJourReglage = -100.0; // Dernier seuil de jour de réglage de la température
- int ModeManuelTemperature = 0; // Indicateur du mode manuel de la température
- int ModeManuelTemperatureReglage = 0; // Indicateur de réglage du mode manuel de la température
- int LastModeManuelTemperatureReglage = -1; // Dernier indicateur de réglage du mode manuel de la température
- const float SeuilMaxTemperatureJourReglage = 42.0; // Seuil de jour max de réglage de la température
- const float SeuilMinTemperatureJourReglage = 30.0; // Seuil de jour min de réglage de la température
- float SeuilTemperatureNuit = 30.0; // Seuil de nuit de la température par défaut au dessus duquel le ventilateur s'active
- float LastSeuilTemperatureNuit = -100.0; // Dernier seuil de nuit de la température
- float SeuilTemperatureNuitReglage = 0.0; // Seuil de nuit de réglage de la température
- float LastSeuilTemperatureNuitReglage = -100.0; // Dernier seuil de nuit de réglage de la température
- const float SeuilMaxTemperatureNuitReglage = 30.0; // Seuil de nuit max de réglage de la température
- const float SeuilMinTemperatureNuitReglage = 25.0; // Seuil de nuit min de réglage de la température
- float SeuilHumiditeJour = 25.5; // Seuil de jour du taux d'humidité par défaut au dessous duquel le brumisateur s'active
- float LastSeuilHumiditeJour = -1.0; // Dernier seuil de jour du taux d'humidité
- float SeuilHumiditeJourReglage = 0.0; // Seuil de jour de réglage du taux d'humidité
- float LastSeuilHumiditeJourReglage = -1.0; // Dernier seuil de jour de réglage du taux d'humidité
- int ModeManuelHumidite = 0; // Indicateur du mode manuel du taux d'humidité
- int ModeManuelHumiditeReglage = 0; // Indicateur de réglage du mode manuel du taux d'humidité
- int LastModeManuelHumiditeReglage = -1; // Dernier indicateur de réglage du mode manuel du taux d'humidité
- const float SeuilMaxHumiditeJourReglage = 30.0; // Seuil de jour max de réglage du taux d'humidité
- const float SeuilMinHumiditeJourReglage = 10.0; // Seuil de jour min de réglage du taux d'humidité
- float SeuilHumiditeNuit = 50.0; // Seuil de nuit du taux d'humidité par défaut au dessous duquel le brumisateur s'active
- float LastSeuilHumiditeNuit = -1.0; // Dernier seuil de nuit du taux d'humidité
- float SeuilHumiditeNuitReglage = 0.0; // Seuil de nuit de réglage du taux d'humidité
- float LastSeuilHumiditeNuitReglage = -1.0; // Dernier seuil de nuit de réglage du taux d'humidité
- const float SeuilMaxHumiditeNuitReglage = 60.0; // Seuil de nuit max de réglage du taux d'humidité
- const float SeuilMinHumiditeNuitReglage = 30.0; // Seuil de nuit min de réglage du taux d'humidité
- float SeuilTemperatureJourNuit = SeuilTemperatureJour; // Seuil jour / nuit de température
- float SeuilHumiditeJourNuit = SeuilHumiditeJour; // Seuil jour / nuit du taux d'humidité
- int ModeJourSeuilTemperature = 0; // Indicateur du mode jour pour les seuils de la température par défaut
- int LastModeJourSeuilTemperature = -1; // Dernier indicateur du mode jour pour les seuils de la température
- int ModeJourSeuilHumidite = 0; // Indicateur du mode jour pour les seuils du taux d'humidité par défaut
- int LastModeJourSeuilHumidite = -1; // Dernier indicateur du mode jour pour les seuils du taux d'humidité
- int HrsDepartSeuilsModeJour = 9; // Heures départ seuils mode jour par défaut
- int MinsDepartSeuilsModeJour = 00; // Minutes départ seuils mode jour par défaut
- int HrsDepartSeuilsModeNuit = 22; // Heures départ seuils mode nuit par défaut
- int MinsDepartSeuilsModeNuit = 30; // Minutes départ seuils mode nuit par défaut
- int HrsDepartSeuilsModeJourReglage = 0; // Heures départ de réglage seuils mode jour
- int MinsDepartSeuilsModeJourReglage = 0; // Minutes départ de réglage seuils mode jour
- int HrsDepartSeuilsModeNuitReglage = 0; // Heures départ de réglage seuils mode nuit
- int MinsDepartSeuilsModeNuitReglage = 0; // Minutes départ de réglage seuils mode nuit
- int LastHrsDepartSeuilsModeJourReglage = -1; // Dernières heures départ de réglage seuils mode jour
- int LastMinsDepartSeuilsModeJourReglage = -1; // Dernières minutes départ de réglage seuils mode jour
- int LastHrsDepartSeuilsModeNuitReglage = -1; // Dernières heures départ de réglage seuils mode nuit
- int LastMinsDepartSeuilsModeNuitReglage = -1; // Dernières minutes départ de réglage seuils mode nuit
- int hStartSeuilsModeJour = 0; // Variable contenant les heures et les minutes de départ seuils mode jour converties en un seul nombre entier
- int hStopSeuilsModeJour = 0; // Variable contenant les heures et les minutes de départ seuils mode nuit converties en un seul nombre entier
- boolean ProgSeuilsModeJourStarted = false; // Indicateur de déclenchement seuils mode jour
- boolean ProgSeuilsModeNuitStarted = false; // Indicateur de déclenchement seuils mode nuit
- boolean EtatVentilateur = LOW; // Indicateur d'état du fonctionnement du ventilateur
- boolean LastEtatVentilateur = HIGH; // Indicateur du dernier état du fonctionnement du ventilateur
- int16_t coulBoutonVentilateur; // Couleur courante du bouton "VENTILATEUR" de la Page 0
- boolean EtatBrumisateur = LOW; // Indicateur d'état du fonctionnement du brumisateur
- boolean LastEtatBrumisateur = HIGH; // Indicateur du dernier état du fonctionnement du brumisateur
- int16_t coulBoutonBrumisateur; // Couleur courante du bouton "BRUMISATEUR" de la Page 0
- boolean EtatEclairage = LOW; // Indicateur d'état du fonctionnement de l'éclairage
- boolean LastEtatEclairage = HIGH; // Indicateur du dernier état du fonctionnement de l'éclairage
- int16_t coulBoutonEclairage; // Couleur courante du bouton "ECLAIRAGE" de la Page 0
- int HrsDepartProgHoraireEclairage = 8; // Heures de départ du programmateur horaire de l'éclairage par défaut
- int MinsDepartProgHoraireEclairage = 30; // Minutes de départ du programmateur horaire de l'éclairage par défaut
- int HrsArretProgHoraireEclairage = 22; // Heures d'arrêt du programmateur horaire de l'éclairage par défaut
- int MinsArretProgHoraireEclairage = 00; // Minutes d'arrêt du programmateur horaire de l'éclairage par défaut
- int ModeProgHoraireEclairage = 1; // Indicateur du mode de fonctionnement du programmateur horaire de l'éclairage par défaut
- int IterationProgHoraireEclairage [] = {1, 1, 1, 1, 1, 1, 1}; // Itération du programmateur horaire de l'éclairage par défaut
- int HrsDepartProgHoraireEclairageReglage = 0; // Heures de départ de réglage du programmateur horaire de l'éclairage
- int MinsDepartProgHoraireEclairageReglage = 0; // Minutes de départ de réglage du programmateur horaire de l'éclairage
- int HrsArretProgHoraireEclairageReglage = 0; // Heures d'arrêt de réglage du programmateur horaire de l'éclairage
- int MinsArretProgHoraireEclairageReglage = 0; // Minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- int ModeProgHoraireEclairageReglage = 0; // Indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- int IterationProgHoraireEclairageReglage [] = {0, 0, 0, 0, 0, 0, 0}; // Itération de réglage du programmateur horaire de l'éclairage
- int LastHrsDepartProgHoraireEclairageReglage = -1; // Dernières heures de départ de réglage du programmateur horaire de l'éclairage
- int LastMinsDepartProgHoraireEclairageReglage = -1; // Dernières minutes de départ de réglage du programmateur horaire de l'éclairage
- int LastHrsArretProgHoraireEclairageReglage = -1; // Dernières heures d'arrêt de réglage du programmateur horaire de l'éclairage
- int LastMinsArretProgHoraireEclairageReglage = -1; // Dernières minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- int LastModeProgHoraireEclairageReglage = -1; // Dernier indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- int LastIterationProgHoraireEclairageReglage [] = {-1, -1, -1, -1, -1, -1, -1}; // Dernière itération de réglage du programmateur horaire de l'éclairage
- int hStartProgHoraireEclairage = 0; // Variable contenant les heures et les minutes de départ du programmateur horaire de l'éclairage converties en un seul nombre entier
- int hStopProgHoraireEclairage = 0; // Variable contenant les heures et les minutes d'arrêt du programmateur horaire de l'éclairage converties en un seul nombre entier
- boolean ProgHoraireEclairageStarted = false; // Indicateur de déclenchement du programmateur horaire de l'éclairage
- boolean ProgHoraireEclairageStopped = false; // Indicateur d'arrêt du programmateur horaire de l'éclairage
- int HrsDepart1ProgHoraireRepas = 11; // Heures de départ1 du programmateur horaire des repas par défaut
- int MinsDepart1ProgHoraireRepas = 30; // Minutes de départ1 du programmateur horaire des repas par défaut
- int HrsDepart2ProgHoraireRepas = 20; // Heures de départ2 du programmateur horaire des repas par défaut
- int MinsDepart2ProgHoraireRepas = 30; // Minutes de départ2 du programmateur horaire des repas par défaut
- int HrsDepart1ProgHoraireRepasReglage = 0; // Heures de départ1 de réglage du programmateur horaire des repas
- int MinsDepart1ProgHoraireRepasReglage = 0; // Minutes de départ1 de réglage du programmateur horaire des repas
- int HrsDepart2ProgHoraireRepasReglage = 0; // Heures de départ2 de réglage du programmateur horaire des repas
- int MinsDepart2ProgHoraireRepasReglage = 0; // Minutes de départ2 de réglage du programmateur horaire des repas
- int LastHrsDepart1ProgHoraireRepasReglage = -1; // Dernières heures de départ1 de réglage du programmateur horaire des repas
- int LastMinsDepart1ProgHoraireRepasReglage = -1; // Dernières minutes de départ1 de réglage du programmateur horaire des repas
- int LastHrsDepart2ProgHoraireRepasReglage = -1; // Dernières heures de départ2 de réglage du programmateur horaire des repas
- int LastMinsDepart2ProgHoraireRepasReglage = -1; // Dernières minutes de départ2 de réglage du programmateur horaire des repas
- int ModeProgHoraireRepas = 1; // Mode de fonctionnement du programmateur horaire des repas par defaut
- int ModeProgHoraireRepasReglage = 0; // Indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- int LastModeProgHoraireRepasReglage = -1; // Dernier indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- int IterationProgHoraireRepas [] = {1, 1, 1, 1, 1, 1, 1}; // Itération du programmateur horaire des repas par défaut
- int IterationProgHoraireRepasReglage [] = {0, 0, 0, 0, 0, 0, 0}; // Itération de réglage du programmateur horaire des repas
- int LastIterationProgHoraireRepasReglage [] = {-1, -1, -1, -1, -1, -1, -1}; // Dernière itération de réglage du programmateur horaire des repas
- unsigned long t1DebutTempoReactivationAffichagePages = 0; // Début de la temporisation avant la réactivation d'affichage des Pages
- unsigned long TempoReactivationAffichagePages = 3000ul; // Durée avant la réactivation d'affichage des Pages
- boolean etatReactivationAffichagePages = true; // Indicateur de réactivation d'affichage des Pages
- unsigned long t1DebutTempoSortieAutoMenus = 0; // Début de la temporisation de sortie automatique des menus
- unsigned long TempoSortieAutoMenus = 30000ul; // Durée de la temporisation de sortie automatique des menus
- boolean etatBoutonReglagesDefaut = false; // Etat du bouton "REGLAGES PAR DEFAUT"
- boolean LastetatBoutonReglagesDefaut = false; // Dernier état du bouton "REGLAGES PAR DEFAUT"
- int etatBoutonReglagesModeEco = 0; // Etat du bouton "MODE ECO ON/OFF"
- int LastetatBoutonReglagesModeEco = -1; // Dernier état du bouton "MODE ECO ON/OFF"
- int etatBoutonReglagesModeMute = 0; // Etat du bouton "MODE MUTE ON/OFF"
- int LastetatBoutonReglagesModeMute = -1; // Dernier état du bouton "MODE MUTE ON/OFF"
- boolean ModeEco = true; // Indicateur du mode Eco
- boolean EcranTFTOFF = false; // Indicateur de l'état de l'écran TFT
- boolean EcranTFTONTemporaire = false; // Indicateur temporaire ON de l'écran TFT
- boolean ModeMute = false; // Indicateur du mode Mute
- unsigned long t1DebutTempoBrumisateurON = 0; // Début de la temporisation d'activation du brumisateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- unsigned long t1DebutTempoVentilateurON = 0; // Début de la temporisation d'activation du ventilateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- boolean ModeDemo = false; // Indicateur du mode démo pour faire varier la température et le taux d'humidité avec des boutons poussoirs
- boolean EtatBPPlusTemperatureModeDemo = HIGH; // Etat courant du bouton poussoir "BPPlusTemperatureModeDemo" pour faire varier la température en mode démo
- boolean EtatBPMoinsTemperatureModeDemo = HIGH; // Etat courant du bouton poussoir "BPMoisTemperatureModeDemo" pour faire varier la température en mode démo
- boolean EtatBPPlusHumiditeModeDemo = HIGH; // Etat courant du bouton poussoir "BPPlusHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- boolean EtatBPMoinsHumiditeModeDemo = HIGH; // Etat courant du bouton poussoir "BPMoisHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- const char message1[] PROGMEM = "GESTION DU TERRARIUM A MARLEY"; // Messages TFT stockés en mémoire programme (Flash)
- const char message2[] PROGMEM = "SEUIL TEMPERATURE JOUR";
- const char message3[] PROGMEM = "SEUIL TAUX HUMIDITE JOUR";
- const char message4[] PROGMEM = "VENTILATEUR";
- const char message5[] PROGMEM = "BRUMISATEUR";
- const char message6[] PROGMEM = "NEONS";
- const char message7[] PROGMEM = "MENUS";
- const char message8[] PROGMEM = "REGLAGE SEUIL TEMPERATURE JOUR";
- const char message9[] PROGMEM = "REGLAGE SEUIL HUMIDITE JOUR";
- const char message10[] PROGMEM = "TEMPERATURE COURANTE";
- const char message11[] PROGMEM = "SEUIL TEMPERATURE NUIT";
- const char message12[] PROGMEM = "MODE";
- const char message13[] PROGMEM = "SEUIL HUMIDITE JOUR";
- const char message14[] PROGMEM = "REGLAGE SEUIL TEMPERATURE NUIT";
- const char message15[] PROGMEM = "REGLAGE SEUIL HUMIDITE NUIT";
- const char message16[] PROGMEM = "SEUIL HUMIDITE NUIT";
- const char message17[] PROGMEM = "TAUX HUMIDITE COURANT";
- const char message18[] PROGMEM = "MANUEL";
- const char message19[] PROGMEM = "REGLAGE HEURES SEUILS JOUR/NUIT";
- const char message20[] PROGMEM = "DEPART JOUR";
- const char message21[] PROGMEM = "DEPART NUIT";
- const char message22[] PROGMEM = "SEUIL TAUX HUMIDITE NUIT";
- const char message23[] PROGMEM = "REGLAGE PROGRAMMATEUR ECLAIRAGE";
- const char message24[] PROGMEM = "DEPART :";
- const char message25[] PROGMEM = "ARRET :";
- const char message26[] PROGMEM = "AUTO";
- const char message27[] PROGMEM = "VALIDATION";
- const char message28[] PROGMEM = "REGLAGES";
- const char message29[] PROGMEM = "DEPART";
- const char message30[] PROGMEM = "ARRET";
- const char message31[] PROGMEM = "REGLAGE PROGRAMMATEUR REPAS";
- const char message32[] PROGMEM = "HEURE REPAS 1";
- const char message33[] PROGMEM = "HEURE REPAS 2";
- const char message34[] PROGMEM = "REGLAGE DE L'HEURE COURANTE";
- const char message35[] PROGMEM = "REGLAGE DE LA DATE COURANTE";
- const char message36[] PROGMEM = "ON";
- const char message37[] PROGMEM = "OFF";
- const char message38[] PROGMEM = "JOUR";
- const char message39[] PROGMEM = "MOIS";
- const char message40[] PROGMEM = "ANNEE";
- const char message41[] PROGMEM = "OK";
- const char message42[] PROGMEM = "IL EST :";
- const char message43[] PROGMEM = "C'EST L'HEURE DU PREMIER REPAS";
- const char message44[] PROGMEM = "C'EST L'HEURE DU DEUXIEME REPAS";
- const char message45[] PROGMEM = "APPUYEZ SUR OK POUR SORTIR";
- const char message46[] PROGMEM = "MENU SETUP";
- const char message47[] PROGMEM = "REGLAGES PAR DEFAUT";
- const char message48[] PROGMEM = "MODE ECO";
- const char message49[] PROGMEM = "ACTIVE";
- const char message50[] PROGMEM = "MODE ECO ON";
- const char message51[] PROGMEM = "MODE ECO OFF";
- const char message52[] PROGMEM = "MODE MUTE ON";
- const char message53[] PROGMEM = "MODE MUTE OFF";
- const char message54[] PROGMEM = "ANNULES";
- const char message55[] PROGMEM = "ATTENTION";
- const char message56[] PROGMEM = "LES HEURES DE DEPART";
- const char message57[] PROGMEM = "SONT EGALES";
- const char message58[] PROGMEM = "AUX HEURES D'ARRET";
- const char message59[] PROGMEM = "LES HEURES DE JOUR";
- const char message60[] PROGMEM = "AUX HEURES DE NUIT";
- const char message61[] PROGMEM = "LES HEURES DU REPAS 1";
- const char message62[] PROGMEM = "AUX HEURES DU REPAS 2";
- const char message63[] PROGMEM = "ON/OFF";
- const char message64[] PROGMEM = "REPAS 1 :";
- const char message65[] PROGMEM = "REPAS 2 :";
- void setup()
- {
- Serial.begin(9600); // Démarre la communication série avec la console
- pinMode(BrocheBuzzer, OUTPUT); // Configure les broches en sorties
- pinMode(BrocheLedRougeTemoinVentilateur, OUTPUT);
- pinMode(BrocheLedVerteTemoinBrumisateur, OUTPUT);
- pinMode(BrocheLedJauneTemoinEclairage, OUTPUT);
- pinMode(BrocheLedBleueMelodieRepas, OUTPUT);
- pinMode(BrocheLedVerteTemoinModeDemo, OUTPUT);
- pinMode(BrocheRelaisVentilateur, OUTPUT);
- pinMode(BrocheRelaisBrumisateur, OUTPUT);
- pinMode(BrocheRelaisEclairage, OUTPUT);
- pinMode(BrocheRelaisEclairageChauffant, OUTPUT);
- pinMode(BrocheRelaisVentilationBoitier, OUTPUT);
- pinMode(BrocheBPPlusTemperatureModeDemo, INPUT_PULLUP); // Configure les broches en entrées
- pinMode(BrocheBPMoinsTemperatureModeDemo, INPUT_PULLUP);
- pinMode(BrocheBPPlusHumiditeModeDemo, INPUT_PULLUP);
- pinMode(BrocheBPMoinsHumiditeModeDemo, INPUT_PULLUP);
- int codeEEPROM1 = 0; // Initialisation de l'EEPROM à la première utilisation
- int codeEEPROM2 = 0;
- EEPROM.get(500, codeEEPROM1); // Lit les codes d'initialisation de l'EEPROM
- EEPROM.get(502, codeEEPROM2);
- if (codeEEPROM1 != 7731 || codeEEPROM2 != 7732) // Si les codes d'initialisation ne sont pas présents
- {
- EEPROM.put(0, SeuilTemperatureJour); // Initialise le seuil de jour de la température par défaut si EEPROM non configurée
- EEPROM.put(4, SeuilHumiditeJour); // Initialise le seuil de jour du taux d'humidité par défaut si EEPROM non configurée
- EEPROM.put(8, ModeManuelTemperature); // Initialise l'indicateur du mode manuel de la température par défaut si EEPROM non configurée
- EEPROM.put(12, ModeManuelHumidite); // Initialise l'indicateur du mode manuel du taux d'humidité par défaut si EEPROM non configurée
- EEPROM.put(16, SeuilTemperatureNuit); // Initialise le seuil de nuit de la température par défaut si EEPROM non configurée
- EEPROM.put(20, SeuilHumiditeNuit); // Initialise le seuil de nuit du taux d'humidité par défaut si EEPROM non configurée
- EEPROM.put(24, HrsDepartSeuilsModeJour); // Initialise les heures de départ seuils mode jour par défaut si EEPROM non configurée
- EEPROM.put(28, MinsDepartSeuilsModeJour); // Initialise les minutes de départ seuils mode jour par défaut si EEPROM non configurée
- EEPROM.put(32, HrsDepartSeuilsModeNuit); // Initialise les heures de départ seuils mode nuit par défaut si EEPROM non configurée
- EEPROM.put(36, MinsDepartSeuilsModeNuit); // Initialise les minutes de départ seuils mode nuit par défaut si EEPROM non configurée
- EEPROM.put(40, HrsDepartProgHoraireEclairage); // Initialise les heures de départ du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- EEPROM.put(44, MinsDepartProgHoraireEclairage); // Initialise les minutes de départ du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- EEPROM.put(48, HrsArretProgHoraireEclairage); // Initialise les heures d'arrêt du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- EEPROM.put(52, MinsArretProgHoraireEclairage); // Initialise les minutes d'arrêt du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- EEPROM.put(56, ModeProgHoraireEclairage); // Initialise l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- for (int i = 0; i < 7; i++) // Initialise l'itération du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- {
- EEPROM.put(60 + i*4, IterationProgHoraireEclairage[i]);
- }
- EEPROM.put(88, HrsDepart1ProgHoraireRepas); // Initialise les heures de départ1 du programmateur horaire des repas par défaut si EEPROM non configurée
- EEPROM.put(92, MinsDepart1ProgHoraireRepas); // Initialise les minutes de départ1 du programmateur horaire des repas par défaut si EEPROM non configurée
- EEPROM.put(96, HrsDepart2ProgHoraireRepas); // Initialise les heures de départ2 du programmateur horaire des repas par défaut si EEPROM non configurée
- EEPROM.put(100, MinsDepart2ProgHoraireRepas); // Initialise les minutes de départ2 du programmateur horaire des repas par défaut si EEPROM non configurée
- EEPROM.put(104, ModeEco); // Initialise l'indicateur du mode Eco par défaut si EEPROM non configurée
- EEPROM.put(108, ModeMute); // Initialise l'indicateur du mode Mute par défaut si EEPROM non configurée
- EEPROM.put(112, ModeProgHoraireRepas); // Initialise le mode de fonctionnement du programmateur horaire des repas par defaut si EEPROM non configurée
- for (int i = 0; i < 7; i++) // Initialise l'itération du programmateur horaire des repas par défaut si EEPROM non configurée
- {
- EEPROM.put(116 + i*4, IterationProgHoraireRepas[i]);
- }
- EEPROM.put(500, 7731); // Mémorise les codes d'initialisation de l'EEPROM
- EEPROM.put(502, 7732);
- }
- EEPROM.get(0, SeuilTemperatureJour); // Restaure le seuil de jour de la température
- EEPROM.get(4, SeuilHumiditeJour); // Restaure le seuil de jour du taux d'humidité
- EEPROM.get(8, ModeManuelTemperature); // Restaure l'indicateur du mode manuel de la température
- EEPROM.get(12, ModeManuelHumidite); // Restaure l'indicateur du mode manuel du taux d'humidité
- EEPROM.get(16, SeuilTemperatureNuit); // Restaure le seuil de nuit de la température
- EEPROM.get(20, SeuilHumiditeNuit); // Restaure le seuil de nuit du taux d'humidité
- EEPROM.get(24, HrsDepartSeuilsModeJour); // Restaure les heures de départ seuils mode jour
- EEPROM.get(28, MinsDepartSeuilsModeJour); // Restaure les minutes de départ seuils mode jour
- EEPROM.get(32, HrsDepartSeuilsModeNuit); // Restaure les heures de départ seuils mode nuit
- EEPROM.get(36, MinsDepartSeuilsModeNuit); // Restaure les minutes de départ seuils mode jour
- EEPROM.get(40, HrsDepartProgHoraireEclairage); // Restaure les heures de départ du programmateur horaire de l'éclairage
- EEPROM.get(44, MinsDepartProgHoraireEclairage); // Restaure les minutes de départ du programmateur horaire de l'éclairage
- EEPROM.get(48, HrsArretProgHoraireEclairage); // Restaure les heures d'arrêt du programmateur horaire de l'éclairage
- EEPROM.get(52, MinsArretProgHoraireEclairage); // Restaure les minutes d'arrêt du programmateur horaire de l'éclairage
- EEPROM.get(56, ModeProgHoraireEclairage); // Restaure l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage
- for (int i = 0; i < 7; i++) // Restaure l'itération du programmateur horaire de l'éclairage
- {
- EEPROM.get(60 + i*4, IterationProgHoraireEclairage[i]);
- delay(20); // Temporise 20ms
- }
- EEPROM.get(88,HrsDepart1ProgHoraireRepas); // Restaure les heures de départ1 du programmateur horaire des repas
- EEPROM.get(92,MinsDepart1ProgHoraireRepas); // Restaure les minutes de départ1 du programmateur horaire des repas
- EEPROM.get(96,HrsDepart2ProgHoraireRepas); // Restaure les heures de départ2 du programmateur horaire des repas
- EEPROM.get(100,MinsDepart2ProgHoraireRepas); // Restaure les minutes de départ2 du programmateur horaire des repas
- EEPROM.get(104, ModeEco); // Restaure l'indicateur du mode Eco
- EEPROM.get(108, ModeMute); // Restaure l'indicateur du mode Mute
- EEPROM.get(112, ModeProgHoraireRepas); // Restaure le mode de fonctionnement du programmateur horaire des repas
- for (int i = 0; i < 7; i++) // Restaure l'itération du programmateur horaire des repas
- {
- EEPROM.get(116 + i*4, IterationProgHoraireRepas[i]);
- }
- tft.begin(9600); // Démarre la communication avec l'écran TFT
- tft.reset(); // Initialise l'écran TFT
- g_identifier = tft.readID(); // Lecture de l'identifiant de l'écran TFT
- tft.begin(g_identifier); // Démarre la librairie de l'écran TFT
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.setRotation(OrientationTFT); // Initialise le sens d'affichage de l'écran TFT
- if (! rtc.begin()) {Serial.println("Couldn't find RTC"); while (1);} // Démarre la librairie du module RTC PCF8523
- //rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Réglage automatique Heure / Date via le port usb
- //rtc.adjust(DateTime(Annee, Mois, Jour, Hrs, Mins, Secs)); // Réglage Heure / Date manuel (Annee, Mois, Jour, Hrs, Mins, Secs)
- bme.begin(); // Démarre la librairie du module BME280
- Buzzer(20, 0, 1); // Active le buzzer 20ms
- delay(1000); // Temporise 1 seconde
- FonctionLecturePCF8523(); // Appelle la fonction de lecture de l'heure courante et de la date
- if (ModeProgHoraireEclairage) // ******************************************************************************************** // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- hStartProgHoraireEclairage = HrsDepartProgHoraireEclairage * 100 + MinsDepartProgHoraireEclairage; // Convertit les heures et les minutes de départ du programmateur horaire de l'éclairage en un seul nombre
- hStopProgHoraireEclairage = HrsArretProgHoraireEclairage * 100 + MinsArretProgHoraireEclairage; // Convertit les heures et les minutes de d'arrêt du programmateur horaire de l'éclairage en un seul nombre
- ProgHoraireEclairageStarted = false; // Désactive l'indicateur de déclenchement du programmateur horaire de l'éclairage
- ProgHoraireEclairageStopped = false; // Désactive l'indicateur de déclenchement du programmateur horaire de l'éclairage
- TestCreneauHoraireProgHoraireEclairage(); // Appelle la fonction test du créneau horaire du programmateur horaire de l'éclairage
- }
- if (!ModeManuelTemperature || !ModeManuelHumidite) // *********************************************************************** // Si l'indicateur du mode manuel de la température est désactivé ou Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- hStartSeuilsModeJour = HrsDepartSeuilsModeJour * 100 + MinsDepartSeuilsModeJour; // Convertit les heures et les minutes de départ seuils mode jour converties en un seul nombre entier
- hStopSeuilsModeJour = HrsDepartSeuilsModeNuit * 100 + MinsDepartSeuilsModeNuit; // Convertit les heures et les minutes de départ seuils mode nuit converties en un seul nombre entier
- ProgSeuilsModeJourStarted = false; // Désactive l'indicateur de déclenchement seuils mode jour
- ProgSeuilsModeNuitStarted = false; // Désactive l'indicateur de déclenchement seuils mode nuit
- TestCreneauHoraireSeuilsModeJourNuit(); // Appelle la fonction test du créneau horaire seuils mode jour/nuit
- }
- //**************************************************************************************************************************************************************************
- }
- void loop()
- {
- //**************************************************************************************************************************************************************************
- FonctionLecturePCF8523(); // ************************************************************************************************ // Appelle la fonction de lecture de l'heure courante et de la date
- FonctionLecturebme280(); // ************************************************************************************************* // Appelle la fonction de lecture de la température et du taux d'humidité
- //**************************************************************************************************************************************************************************
- GestionTactile (); // ******************************************************************************************************* // Appelle la fonction de gestion du mode tactile
- //**************************************************************************************************************************************************************************
- if (PageCourante == 0 && etatReactivationAffichagePages) // ***************************************************************** // Si la Page courante 0 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page principale
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 20, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 20, DARKRED);
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(40, 15); LectureMemoireFlash(message1); // Positionne et Affiche le titre "GESTION TERRARIUM v1.0"
- tft.drawLine(5, 48, 474, 48, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 49, 474, 49, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 50, 474, 50, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 145, 474, 145, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 145, 474, 145, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(YELLOW); // Définit la couleur du texte
- tft.setTextSize(1); // Définit la taille du texte
- Serial.print("!ModeJourSeuilTemperature : ");Serial.println(!ModeJourSeuilTemperature);
- Serial.print("LastModeJourSeuilTemperature : ");Serial.println(LastModeJourSeuilTemperature);
- Serial.print("ModeJourSeuilTemperature : ");Serial.println(ModeJourSeuilTemperature);
- if (ModeManuelTemperature) // ------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel de la température est activé
- {
- tft.setCursor(71, 220); LectureMemoireFlash(message12); tft.print(' '); LectureMemoireFlash(message18); // Positionne et Affiche "MODE MANUEL"
- }
- else if (ModeJourSeuilTemperature && LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // ----------------------- // Si l'indicateur du mode jour pour les seuils de la température est activé
- {
- tft.setCursor(38, 220); LectureMemoireFlash(message2); // Positionne et Affiche le texte "SEUIL TEMPERATURE JOUR"
- LastModeJourSeuilTemperature = ModeJourSeuilTemperature; // Mémorise le dernier indicateur du mode jour pour les seuils de la température
- }
- else if (!ModeJourSeuilTemperature && LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // ---------------------- // Si l'indicateur du mode jour pour les seuils de la température est désactivé
- {
- tft.setCursor(38, 220); LectureMemoireFlash(message11); // Positionne et Affiche le texte "SEUIL TEMPERATURE NUIT"
- LastModeJourSeuilTemperature = ModeJourSeuilTemperature; // Mémorise le dernier indicateur du mode jour pour les seuils de la température
- }
- if (ModeManuelHumidite) // ---------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel du taux d'humidité est activé
- {
- tft.setCursor(340, 220); LectureMemoireFlash(message12); tft.print(' '); LectureMemoireFlash(message18); // Positionne et Affiche "MODE MANUEL"
- }
- else if (ModeJourSeuilHumidite && LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // -------------------------------- // Si l'indicateur du mode jour pour les seuils du taux d'humidité est activé
- {
- tft.setCursor(290, 220); LectureMemoireFlash(message3); // Positionne et Affiche le texte "SEUIL TAUX HUMIDITE JOUR"
- LastModeJourSeuilHumidite = ModeJourSeuilHumidite; // Mémorise le dernier indicateur du mode jour pour les seuils du taux d'humidité est activé
- }
- else if (!ModeJourSeuilHumidite && LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // ------------------------------- // Si l'indicateur du mode jour pour les seuils du taux d'humidité est désactivé
- {
- tft.setCursor(290, 220); LectureMemoireFlash(message22); // Positionne et Affiche le texte "SEUIL TAUX HUMIDITE NUIT"
- LastModeJourSeuilHumidite = ModeJourSeuilHumidite; // Mémorise le dernier indicateur du mode jour pour les seuils du taux d'humidité est activé
- }
- tft.setTextSize(2); // Définit la taille du texte
- tft.drawLine(5, 277, 474, 277, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 278, 474, 278, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(BLACK); // Définit la couleur du texte
- tft.fillRoundRect(400, 10, 68, 21, 12, 0x07E0); // Affiche le Bouton "MENU"
- tft.drawRoundRect(398, 8, 72, 25, 12, 0x07E0);
- tft.setCursor(405, 13); LectureMemoireFlash(message7); // Positinne et Affiche le texte "MENU
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastSecs != Secs) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la minute courante a changé => Affiche l'heure courante
- {
- tft.setTextColor(BLUE, BLACK); tft.setTextSize(4); // Définit la couleur et la taille du texte
- tft.setCursor(15, 80); // Définit la position
- if (Hrs < 10) {tft.print('0');} tft.print(Hrs); // Affiche les heures
- tft.print(':'); // Affiche le texte
- if (Mins < 10) {tft.print('0');} tft.print(Mins);
- tft.print(':');
- if (Secs < 10) {tft.print('0');} tft.print(Secs);
- LastSecs = Secs; // Mémorise la dernière minute courante
- }
- if (LastJour != Jour) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le jour du mois a changé => Affiche la date courante
- {
- tft.setTextColor(BLUE, BLACK); tft.setTextSize(4); // Définit la couleur et la taille du texte
- tft.setCursor(230, 80); // Définit la position
- if (Jour < 10) {tft.print('0');} tft.print(Jour); // Affiche le jour du mois
- tft.print('/'); // Affiche le texte
- if (Mois < 10) {tft.print('0');} tft.print(Mois); // Affiche le mois
- tft.print('/'); // Affiche le texte
- tft.print(Annee); // Affiche l'année
- LastJour = Jour; // Mémorise le dernier jour du mois
- }
- 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 >= 200) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si 200 relevés ont été effectués
- {
- TemperatureCourante = SommeRelevesTemperature / 200.0; // Calcule la moyenne des 200 relevés
- //Serial.println(TemperatureCourante, 1); // Débug
- CompteurRelevesTemperature = 0; SommeRelevesTemperature = 0.0; // Réinitialisation des variables de calcul de la moyenne de la température
- if (LastTemperatureCourante != TemperatureCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la température courante a changé
- {
- if (TemperatureCourante < 0) {TemperatureCourante = 0.0;} // ---------------------------------------------------- // Borne la température courante entre 0 et 80 degrés
- else if (TemperatureCourante > 80) {TemperatureCourante = 80.0;}
- FonctionAffichageTemperatureCourante(); // Appelle la fonction d'affichage de la température courante
- LastTemperatureCourante = TemperatureCourante; // Mémorise la dernière valeur de la température courante
- }
- }
- else if (LastTemperatureCourante == -100) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si LastTemperatureCourante est égale à -100
- {
- if (TemperatureCourante < 0) {TemperatureCourante = 0.0;} // ------------------------------------------------------ // Borne la température courante entre 0 et 80 degrés
- else if (TemperatureCourante > 80) {TemperatureCourante = 80.0;}
- FonctionAffichageTemperatureCourante(); // Appelle la fonction d'affichage de la température courante
- LastTemperatureCourante = TemperatureCourante; // Mémorise la dernière valeur de la température courante
- }
- static int CompteurRelevesHumidite = 0; // Déclare et Initialise les variables pour le calcul de la moyenne du taux d'humidité
- static float SommeRelevesHumidite = 0.0;
- CompteurRelevesHumidite++; // Incrémente le compteur des relevés du taux d'humidité
- SommeRelevesHumidite = SommeRelevesHumidite + TauxHumiditeCourant; // Calcule la somme des 50 relevés
- if (CompteurRelevesHumidite >= 200) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si 200 relevés ont été effectués
- {
- TauxHumiditeCourant = SommeRelevesHumidite / 200.0; // Calcule la moyenne des 200 relevés
- //Serial.println(TauxHumiditeCourant, 1); // Débug
- CompteurRelevesHumidite = 0; SommeRelevesHumidite = 0.0; // Réinitialisation des variables de calcul de la moyenne du taux d'humidité
- if (LastTauxHumiditeCourant != TauxHumiditeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le taux d'humidité courant a changé
- {
- FonctionAffichageTauxHumiditeCourant(); // Appelle la fonction d'affichage du taux d'humidité courant
- LastTauxHumiditeCourant = TauxHumiditeCourant; // Mémorise la dernière valeur du taux d'humidité
- }
- }
- else if (LastTauxHumiditeCourant == -1) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si LastTauxHumiditeCourant est égale à -1
- {
- FonctionAffichageTauxHumiditeCourant(); // Appelle la fonction d'affichage du taux d'humidité courant
- LastTauxHumiditeCourant = TauxHumiditeCourant; // Mémorise la dernière valeur du taux d'humidité
- }
- if (LastSeuilTemperatureJour != SeuilTemperatureJour && ModeJourSeuilTemperature) // ++++++++++++++++++++++++++++++++++++++ // Si le seuil de jour de la température a changé
- {
- tft.setTextColor(WHITE); // Définit la couleur
- if (ModeManuelTemperature) // ------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel de la température est activé
- {
- tft.setTextColor(VERYDARKGRAY); // Définit la couleur
- }
- tft.setTextSize(2); // Taille du texte
- tft.fillRoundRect(58, 240, 90, 25, 12, 0x3B0A); // Affiche du seuil de la température
- tft.drawRoundRect(56, 238, 94, 29, 12, 0x3B0A);
- tft.setCursor(67, 245); tft.print(SeuilTemperatureJour, 1); // Affiche le texte
- tft.print((char)247); // Affiche le symbole degré
- tft.print('C'); // Affiche le caractère "C"
- LastSeuilTemperatureJour = SeuilTemperatureJour; // Mémorise le dernier seuil de jour de la température
- }
- if (LastSeuilTemperatureNuit != SeuilTemperatureNuit && !ModeJourSeuilTemperature) // +++++++++++++++++++++++++++++++++++++ // Si le seuil de nuit de la température a changé
- {
- tft.setTextColor(WHITE); // Définit la couleur
- if (ModeManuelTemperature) // ------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel de la température est activé
- {
- tft.setTextColor(VERYDARKGRAY); // Définit la couleur
- }
- tft.setTextSize(2); // Taille du texte
- tft.fillRoundRect(58, 240, 90, 25, 12, 0x3B0A); // Affiche du seuil de la température
- tft.drawRoundRect(56, 238, 94, 29, 12, 0x3B0A);
- tft.setCursor(67, 245); tft.print(SeuilTemperatureJour, 1); // Affiche le texte
- tft.print((char)247); // Affiche le symbole degré
- tft.print('C'); // Affiche le caractère "C"
- LastSeuilTemperatureNuit = SeuilTemperatureNuit; // Mémorise le dernier seuil de nuit de la température
- }
- if (LastSeuilHumiditeJour != SeuilHumiditeJour && ModeJourSeuilHumidite) // +++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de jour du taux d'humidité a changé
- {
- tft.setTextColor(WHITE); // Définit la couleur
- if (ModeManuelHumidite) // ---------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel de la température est activé
- {
- tft.setTextColor(VERYDARKGRAY); // Définit la couleur
- }
- tft.fillRoundRect(320, 240, 90, 25, 12, 0x3B0A); // Affiche du seuil du taux d'humidité
- tft.drawRoundRect(318, 238, 94, 29, 12, 0x3B0A);
- tft.setCursor(335, 245); tft.print(SeuilHumiditeJour, 1); // Affiche le texte
- tft.print('%'); // Affiche le caractère "%"
- LastSeuilHumiditeJour = SeuilHumiditeJour; // Mémorise le dernier seuil de jour du taux d'humidité
- }
- if (LastSeuilHumiditeNuit != SeuilHumiditeNuit && !ModeJourSeuilHumidite) // ++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de nuit du taux d'humidité a changé
- {
- tft.setTextColor(WHITE); // Définit la couleur
- if (ModeManuelHumidite) // ---------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel de la température est activé
- {
- tft.setTextColor(VERYDARKGRAY); // Définit la couleur
- }
- tft.fillRoundRect(320, 240, 90, 25, 12, 0x3B0A); // Affiche du seuil du taux d'humidité
- tft.drawRoundRect(318, 238, 94, 29, 12, 0x3B0A);
- tft.setCursor(335, 245); tft.print(SeuilHumiditeNuit, 1); // Affiche le texte
- tft.print('%'); // Affiche le caractère "%"
- LastSeuilHumiditeNuit = SeuilHumiditeNuit; // Mémorise le dernier seuil de nuit du taux d'humidité
- }
- if (LastEtatVentilateur != EtatVentilateur) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur d'état du fonctionnement du ventilateur a changé
- {
- if (EtatVentilateur) {coulBoutonVentilateur = KHAKIGREEN;} else {coulBoutonVentilateur = RED;} // Sélectionne la couleur du bouton "VENTILATEUR"
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille du texte
- tft.fillRoundRect(10, 285, 142, 25, 12, coulBoutonVentilateur); // Affiche le Bouton "VENTILATEUR"
- tft.drawRoundRect(8, 283, 146, 29, 12, coulBoutonVentilateur);
- tft.setCursor(16, 289); LectureMemoireFlash(message4); // Affiche le texte "VENTILATEUR"
- LastEtatVentilateur = EtatVentilateur; // Mémorise l'indicateur du dernier état du fonctionnement du ventilateur
- }
- if (LastEtatBrumisateur != EtatBrumisateur) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur d'état du fonctionnement du brumisateur a changé
- {
- if (EtatBrumisateur) {coulBoutonBrumisateur = KHAKIGREEN;} else {coulBoutonBrumisateur = RED;} // Sélectionne la couleur du bouton "BRUMISATEUR"
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille du texte
- tft.fillRoundRect(182, 285, 142, 25, 12, coulBoutonBrumisateur); // Affiche le Bouton "BRUMISATEUR"
- tft.drawRoundRect(180, 283, 146, 29, 12, coulBoutonBrumisateur);
- tft.setCursor(186, 289); LectureMemoireFlash(message5); // Affiche le texte "BRUMISATEUR"
- LastEtatBrumisateur = EtatBrumisateur; // Mémorise l'indicateur du dernier état du fonctionnement du brumisateur
- }
- if (LastEtatEclairage != EtatEclairage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur d'état du fonctionnement de l'éclairage a changé
- {
- if (EtatEclairage) {coulBoutonEclairage = KHAKIGREEN;} else {coulBoutonEclairage = RED;} // Sélectionne la couleur du bouton "NEONS"
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille du texte
- tft.fillRoundRect(400, 285, 68, 25, 12, coulBoutonEclairage); // Affiche le Bouton "NEONS"
- tft.drawRoundRect(398, 283, 72, 29, 12, coulBoutonEclairage);
- tft.setCursor(405, 289); LectureMemoireFlash(message6); // Affiche le texte "NEONS
- LastEtatEclairage = EtatEclairage; // Mémorise l'indicateur du dernier état du fonctionnement de l'éclairage
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 100 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 100 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du seuil de jour de la température
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message8); // Positionne et Affiche le titre "REGLAGE SEUIL TEMPERATURE JOUR"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(120, 42); LectureMemoireFlash(message10); // Positionne et Affiche le texte "TEMPERATURE COURANTE"
- tft.setCursor(120, 110); LectureMemoireFlash(message2); // Positionne et Affiche le texte "SEUIL TEMPERATURE JOUR"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(73, 160, 25, 25, GREEN); tft.drawRect(420, 160, 25, 25, GREEN); // Dessine les 2 boutons + et - et les cadres
- tft.setCursor(81, 165); tft.print('-'); tft.setCursor(426, 165); tft.print('+'); // Positionne et Affiche le texte
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(210, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(200, 290); LectureMemoireFlash(message18); // Affiche le texte "MANUEL"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taile
- if (TemperatureCourante >= 10) {tft.setCursor(190, 70); tft.print(TemperatureCourante, 1);} // Positionne et Affiche la température courante
- else if (TemperatureCourante >= 0 && TemperatureCourante < 10){tft.setCursor(190, 70); tft.print(' '); tft.print(TemperatureCourante, 1);}
- tft.setTextSize(2); tft.print((char)247); // Affiche le symbole degré
- tft.setTextSize(3); // Définit la taile
- tft.print('C'); // Affiche le caractère "C"
- if (LastPageCourante != 200) // ----------------------------------------------------------------------------------------- // Si la dernière Page courante est différente de 200
- {
- SeuilTemperatureJourReglage = SeuilTemperatureJour; // Transfère le seuil de jour de la température dans le seuil de jour de réglage de la température
- SeuilTemperatureNuitReglage = SeuilTemperatureNuit; // Transfère le seuil de nuit de la température dans le seuil de nuit de réglage de la température
- ModeManuelTemperatureReglage = ModeManuelTemperature; // Transfère l'indicateur du mode manuel de la température dans l'indicateur de réglage du mode manuel de la température
- }
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastSeuilTemperatureJourReglage != SeuilTemperatureJourReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de jour de réglage de la température a changé
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(6); // Définit la taile
- if (SeuilTemperatureJourReglage >= 10) {tft.setCursor(160, 180); tft.print(SeuilTemperatureJourReglage, 1);} // Positionne et Affiche le seuil de jour de réglage de la température
- else if (SeuilTemperatureJourReglage >= 0 && SeuilTemperatureJourReglage < 10){tft.setCursor(160, 180); tft.print(' '); tft.print(SeuilTemperatureJourReglage, 1);}
- tft.setTextSize(2); tft.print((char)247); // Affiche le symbole degré
- tft.setTextSize(6); // Définit la taile
- tft.print('C'); // Affiche le caractère "C"
- LastSeuilTemperatureJourReglage = SeuilTemperatureJourReglage; // Mémorise le dernier seuil de jour de réglage de la température a changé
- }
- if (LastModeManuelTemperatureReglage != ModeManuelTemperatureReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode manuel de la température a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeManuelTemperatureReglage) // ------------------------------------------------------------------------------------ // Si l'indicateur de réglage du mode manuel de la température est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeManuelTemperatureReglage) // ------------------------------------------------------------------------------ // Si l'indicateur de réglage du mode manuel de la température est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeManuelTemperatureReglage = ModeManuelTemperatureReglage; // Mémorise le dernier indicateur de réglage du mode manuel de la température
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 200 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 200 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du seuil de nuit de la température
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message14); // Positionne et Affiche le titre "REGLAGE SEUIL TEMPERATURE NUIT"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(120, 42); LectureMemoireFlash(message10); // Positionne et Affiche le texte "TEMPERATURE COURANTE"
- tft.setCursor(120, 110); LectureMemoireFlash(message11); // Positionne et Affiche le texte "SEUIL TEMPERATURE NUIT"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(73, 160, 25, 25, GREEN); tft.drawRect(420, 160, 25, 25, GREEN); // Dessine les 2 boutons + et - et les cadres
- tft.setCursor(81, 165); tft.print('-'); tft.setCursor(426, 165); tft.print('+'); // Positionne et Affiche le texte
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(210, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(200, 290); LectureMemoireFlash(message18); // Affiche le texte "MANUEL"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taile
- if (TemperatureCourante >= 10) {tft.setCursor(190, 70); tft.print(TemperatureCourante, 1);} // Positionne et Affiche la température courante
- else if (TemperatureCourante >= 0 && TemperatureCourante < 10){tft.setCursor(190, 70); tft.print(' '); tft.print(TemperatureCourante, 1);}
- tft.setTextSize(2); tft.print((char)247); // Affiche le symbole degré
- tft.setTextSize(3); // Définit la taile
- tft.print('C'); // Affiche le caractère "C"
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastSeuilTemperatureNuitReglage != SeuilTemperatureNuitReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de nuit de réglage de la température a changé
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(6); // Définit la taile
- if (SeuilTemperatureNuitReglage >= 10) {tft.setCursor(160, 180); tft.print(SeuilTemperatureNuitReglage, 1);} // Positionne et Affiche le seuil de nuit de réglage de la température
- else if (SeuilTemperatureNuitReglage >= 0 && SeuilTemperatureNuitReglage < 10){tft.setCursor(160, 180); tft.print(' '); tft.print(SeuilTemperatureNuitReglage, 1);}
- tft.setTextSize(2); tft.print((char)247); // Affiche le symbole degré
- tft.setTextSize(6); // Définit la taile
- tft.print('C'); // Affiche le caractère "C"
- LastSeuilTemperatureNuitReglage = SeuilTemperatureNuitReglage; // Mémorise le dernier seuil de nuit de réglage de la température a changé
- }
- if (LastModeManuelTemperatureReglage != ModeManuelTemperatureReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode manuel de la température a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeManuelTemperatureReglage) // ------------------------------------------------------------------------------------ // Si l'indicateur de réglage du mode manuel de la température est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeManuelTemperatureReglage) // ------------------------------------------------------------------------------ // Si l'indicateur de réglage du mode manuel de la température est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeManuelTemperatureReglage = ModeManuelTemperatureReglage; // Mémorise le dernier indicateur de réglage du mode manuel de la température
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 101 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 101 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du seuil de jour du taux d'humidité
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message9); // Positionne et Affiche le titre "REGLAGE SEUIL HUMIDITE JOUR"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(120, 42); LectureMemoireFlash(message17); // Positionne et Affiche le texte "TAUX HUMIDITE COURANT"
- tft.setCursor(120, 110); LectureMemoireFlash(message13); // Positionne et Affiche le texte "SEUIL HUMIDITE JOUR"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(73, 160, 25, 25, GREEN); tft.drawRect(420, 160, 25, 25, GREEN); // Dessine les 2 boutons + et - et les cadres
- tft.setCursor(81, 165); tft.print('-'); tft.setCursor(426, 165); tft.print('+'); // Positionne et Affiche le texte
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(210, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(200, 290); LectureMemoireFlash(message18); // Affiche le texte "MANUEL"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taile
- if (TauxHumiditeCourant >= 10) {tft.setCursor(190, 70); tft.print(TauxHumiditeCourant, 1);} // Positionne et Affiche le taux d'humidité
- else if (TauxHumiditeCourant >= 0 && TauxHumiditeCourant < 10){tft.setCursor(190, 70); tft.print(' '); tft.print(TauxHumiditeCourant, 1);}
- tft.setTextSize(3); // Définit la taile
- tft.print('%'); // Affiche le caractère "%"
- if (LastPageCourante != 201) // ----------------------------------------------------------------------------------------- // Si la dernière Page courante est différente de 200
- {
- SeuilHumiditeJourReglage = SeuilHumiditeJour; // Transfère le seuil de jour du taux d'humidité dans le seuil de jour de réglage du taux d'humidité
- SeuilHumiditeNuitReglage = SeuilHumiditeNuit; // Transfère le seuil de nuit du taux d'humidité dans le seuil de nuit de réglage du taux d'humidité
- ModeManuelHumiditeReglage = ModeManuelHumidite; // Transfère l'indicateur du mode manuel du taux d'humidité dans l'indicateur de réglage du mode manuel du taux d'humidité
- }
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastSeuilHumiditeJourReglage != SeuilHumiditeJourReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de jour de réglage du taux d'humidité a changé
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(6); // Définit la taile
- if (SeuilHumiditeJourReglage >= 10) {tft.setCursor(160, 180); tft.print(SeuilHumiditeJourReglage, 1);} // Positionne et Affiche le seuil de jour de réglage du taux d'humidité
- else if (SeuilHumiditeJourReglage >= 0 && SeuilHumiditeJourReglage < 10){tft.setCursor(160, 180); tft.print(' '); tft.print(SeuilHumiditeJourReglage, 1);}
- tft.setTextSize(6); // Définit la taile
- tft.print('%'); // Affiche le caractère "%"
- LastSeuilHumiditeJourReglage = SeuilHumiditeJourReglage; // Mémorise le dernier seuil de jour de réglage du taux d'humidité a changé
- }
- if (LastModeManuelHumiditeReglage != ModeManuelHumiditeReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode manuel du taux d'humidité a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeManuelHumiditeReglage) // --------------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode manuel du taux d'humidité est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeManuelHumiditeReglage) // --------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode manuel du taux d'humidité est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeManuelHumiditeReglage = ModeManuelHumiditeReglage; // Mémorise le dernier indicateur de réglage du mode manuel du taux d'humidité
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 201 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 201 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du seuil de nuit du taux d'humidité
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message15); // Positionne et Affiche le titre "REGLAGE SEUIL HUMIDITE NUIT"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(120, 42); LectureMemoireFlash(message17); // Positionne et Affiche le texte "TAUX HUMIDITE COURANT"
- tft.setCursor(120, 110); LectureMemoireFlash(message16); // Positionne et Affiche le texte "SEUIL HUMIDITE NUIT"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(73, 160, 25, 25, GREEN); tft.drawRect(420, 160, 25, 25, GREEN); // Dessine les 2 boutons + et - et les cadres
- tft.setCursor(81, 165); tft.print('-'); tft.setCursor(426, 165); tft.print('+'); // Positionne et Affiche le texte
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(210, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(200, 290); LectureMemoireFlash(message18); // Affiche le texte "MANUEL"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taile
- if (TauxHumiditeCourant >= 10) {tft.setCursor(190, 70); tft.print(TauxHumiditeCourant, 1);} // Positionne et Affiche le taux d'humidité
- else if (TauxHumiditeCourant >= 0 && TauxHumiditeCourant < 10){tft.setCursor(190, 70); tft.print(' '); tft.print(TauxHumiditeCourant, 1);}
- tft.setTextSize(3); // Définit la taile
- tft.print("%"); // Affiche le caractère "%"
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastSeuilHumiditeNuitReglage != SeuilHumiditeNuitReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le seuil de nuit de réglage du taux d'humidité a changé
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(6); // Définit la taile
- if (SeuilHumiditeNuitReglage >= 10) {tft.setCursor(160, 180); tft.print(SeuilHumiditeNuitReglage, 1);} // Positionne et Affiche le seuil de nuit de réglage du taux d'humidité
- else if (SeuilHumiditeNuitReglage >= 0 && SeuilHumiditeNuitReglage < 10){tft.setCursor(160, 180); tft.print(' '); tft.print(SeuilHumiditeNuitReglage, 1);}
- tft.setTextSize(6); // Affiche le caractère "%"
- tft.print("%");
- LastSeuilHumiditeNuitReglage = SeuilHumiditeNuitReglage; // Mémorise le dernier seuil de nuit de réglage du taux d'humidité a changé
- }
- if (LastModeManuelHumiditeReglage != ModeManuelHumiditeReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode manuel du taux d'humidité a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeManuelHumiditeReglage) // --------------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode manuel du taux d'humidité est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeManuelHumiditeReglage) // --------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode manuel du taux d'humidité est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeManuelHumiditeReglage = ModeManuelHumiditeReglage; // Mémorise le dernier indicateur de réglage du mode manuel du taux d'humidité
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 102 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 102 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message19); // Positionne et Affiche le titre "REGLAGE HEURES SEUILS JOUR/NUIT"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 175, 480, 175, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 176, 480, 176, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setTextSize(2); // Définit la taille
- tft.setCursor(50, 55); LectureMemoireFlash(message20); // Positionne et Affiche "DEPART JOUR"
- tft.setCursor(310, 55); LectureMemoireFlash(message21); // Positionne et Affiche "DEPART NUIT"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(64, 130, 25, 25, GREEN); tft.drawRect(118, 130, 25, 25, GREEN); // Dessine les 4 boutons + et les cadres
- tft.setTextSize(2); tft.setCursor(72, 136); tft.print('+'); tft.setCursor(126, 136); tft.print('+');
- tft.drawRect(326, 130, 25, 25, GREEN); tft.drawRect(380, 130, 25, 25, GREEN);
- tft.setCursor(333, 136); tft.print('+'); tft.setCursor(387, 136); tft.print('+');
- HrsDepartSeuilsModeJourReglage = HrsDepartSeuilsModeJour; // Transfère les heures départ seuils mode jour dans les heures départ de réglage seuils mode jour
- MinsDepartSeuilsModeJourReglage = MinsDepartSeuilsModeJour; // Transfère les minutes départ seuils mode jour dans les minutes départ de réglage seuils mode jour
- HrsDepartSeuilsModeNuitReglage = HrsDepartSeuilsModeNuit; // Transfère les heures départ seuils mode nuit dans les heures départ de réglage seuils mode nuit
- MinsDepartSeuilsModeNuitReglage = MinsDepartSeuilsModeNuit; // Transfère les minutes départ seuils mode nuit dans les minutes départ de réglage seuils mode nuit
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastHrsDepartSeuilsModeJourReglage != HrsDepartSeuilsModeJourReglage // +++++++++++++++++++++++++++++++++++++++++++++++ // Si les heures ou les minutes de départ de réglage seuils mode jour ont changé
- || LastMinsDepartSeuilsModeJourReglage != MinsDepartSeuilsModeJourReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(60, 87); // Positionne le texte
- if (HrsDepartSeuilsModeJourReglage < 10) {tft.print('0');} tft.print(HrsDepartSeuilsModeJourReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsDepartSeuilsModeJourReglage < 10) {tft.print('0');} tft.print(MinsDepartSeuilsModeJourReglage); // Affiche le texte
- LastHrsDepartSeuilsModeJourReglage = HrsDepartSeuilsModeJourReglage; // Mémorise les dernières heures départ de réglage seuils mode jour
- LastMinsDepartSeuilsModeJourReglage = MinsDepartSeuilsModeJourReglage; // Mémorise les dernière minutes départ de réglage seuils mode jour
- }
- if (LastHrsDepartSeuilsModeNuitReglage != HrsDepartSeuilsModeNuitReglage // +++++++++++++++++++++++++++++++++++++++++++++++ // Si les heures ou les minutes d'arrêt de réglage seuils mode nuit
- || LastMinsDepartSeuilsModeNuitReglage != MinsDepartSeuilsModeNuitReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(326, 87); // Positionne le texte
- if (HrsDepartSeuilsModeNuitReglage < 10) {tft.print('0');} tft.print(HrsDepartSeuilsModeNuitReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsDepartSeuilsModeNuitReglage < 10) {tft.print('0');} tft.print(MinsDepartSeuilsModeNuitReglage); // Affiche le texte
- LastHrsDepartSeuilsModeNuitReglage = HrsDepartSeuilsModeNuitReglage; // Mémorise les dernière heures départ de réglage seuils mode nuit
- LastMinsDepartSeuilsModeNuitReglage = MinsDepartSeuilsModeNuitReglage; // Mémorise les dernière minutes départ de réglage seuils mode nuit
- }
- if (LastMins != Mins) // -------------------------------------------------------------------------------------------------- // Si les minutes courantes ont changé
- {
- tft.setTextColor(WHITE, BLACK); tft.setTextSize(6); // Définit la couleur et la taille
- tft.setCursor(155, 205); // Définit la position
- if (Hrs < 10) {tft.print('0');} tft.print(Hrs); // Affiche les heures courantes
- tft.fillCircle(230, 230, 4, WHITE); tft.fillCircle(230, 212, 4, WHITE); // Affiche les deux points ":" de l'heure
- tft.setCursor(240, 205); // Définit la position
- if (Mins < 10) {tft.print('0');} tft.print(Mins); // Affiche les minutes courantes
- LastMins = Mins; // Mémorise les dernières minutes courantes
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 103 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 103 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du programmateur horaire d'éclairage
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message23); // Positionne et Affiche le titre "REGLAGE PROGRAMMATEUR ECLAIRAGE"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(235, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(235, 290); LectureMemoireFlash(message26); // Affiche le texte "AUTO"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 46); LectureMemoireFlash(message24); // Positionne et Affiche "DEPART :"
- tft.setCursor(80, 94); LectureMemoireFlash(message25); // Positionne et Affiche "ARRET :"
- if (LastPageCourante != 203) // ----------------------------------------------------------------------------------------- // Si la dernière Page courante est différente de 203
- {
- HrsDepartProgHoraireEclairageReglage = HrsDepartProgHoraireEclairage; // Transfère les heures de départ du programmateur horaire de l'éclairage dans les heures de départ de réglage du programmateur horaire de l'éclairage
- MinsDepartProgHoraireEclairageReglage = MinsDepartProgHoraireEclairage; // Transfère les minutes de départ du programmateur horaire de l'éclairage dans les minutes de départ de réglage du programmateur horaire de l'éclairage
- HrsArretProgHoraireEclairageReglage = HrsArretProgHoraireEclairage; // Transfère les heures d'arrêt du programmateur horaire de l'éclairage dans les heures d'arrêt de réglage du programmateur horaire de l'éclairage
- MinsArretProgHoraireEclairageReglage = MinsArretProgHoraireEclairage; // Transfère les minutes d'arrêt du programmateur horaire de l'éclairage dans les minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- ModeProgHoraireEclairageReglage = ModeProgHoraireEclairage; // Transfère l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage dans l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- for (int i = 0; i < 7; i++) // Transfère l'itération du programmateur horaire de l'éclairage dans l'itération de réglage du programmateur horaire de l'éclairage
- {
- IterationProgHoraireEclairageReglage[i] = IterationProgHoraireEclairage[i];
- }
- }
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(4); // Définit la taille
- tft.setCursor(270, 42); // Positionne le texte
- if (HrsDepartProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(HrsDepartProgHoraireEclairageReglage); // Affiche le texte
- tft.setCursor(325, 42); tft.print(':'); // Positionne et Affiche le caréctère ":"
- tft.setCursor(350, 42); // Positionne le texte
- if (MinsDepartProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(MinsDepartProgHoraireEclairageReglage); // Affiche le texte
- tft.setCursor(270, 90); // Positionne le texte
- if (HrsArretProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(HrsArretProgHoraireEclairageReglage); // Affiche le texte
- tft.setCursor(325, 90); tft.print(':'); // Positionne et Affiche le caréctère ":"
- tft.setCursor(350, 90); // Positionne le texte
- if (MinsArretProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(MinsArretProgHoraireEclairageReglage); // Positionne et Affiche le texte
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- uint16_t couleurBoutonsIteration; // Déclarare la variable couleur des boutons de l'itération
- tft.setTextSize(2); // Définit la taille
- tft.setTextColor(WHITE); // Définit la couleur
- if (LastIterationProgHoraireEclairageReglage[0] != IterationProgHoraireEclairageReglage[0]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[0]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(100, 190, 16, couleurBoutonsIteration); // Dessine le bouton Dimanche "D"
- tft.drawCircle(100, 190, 20, couleurBoutonsIteration);
- tft.setCursor(95, 183); tft.print('D'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[0] = IterationProgHoraireEclairageReglage[0]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[1] != IterationProgHoraireEclairageReglage[1]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[1]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(150, 190, 16, couleurBoutonsIteration); // Dessine le bouton Lundi "L"
- tft.drawCircle(150, 190, 20, couleurBoutonsIteration);
- tft.setCursor(145, 183); tft.print('L'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[1] = IterationProgHoraireEclairageReglage[1]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[2] != IterationProgHoraireEclairageReglage[2]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[2]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(200, 190, 16, couleurBoutonsIteration); // Dessine le bouton Mardi "M"
- tft.drawCircle(200, 190, 20, couleurBoutonsIteration);
- tft.setCursor(195, 183); tft.print('M'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[2] = IterationProgHoraireEclairageReglage[2]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[3] != IterationProgHoraireEclairageReglage[3]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[3]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(250, 190, 16, couleurBoutonsIteration); // Dessine le bouton Mercredi "M"
- tft.drawCircle(250, 190, 20, couleurBoutonsIteration);
- tft.setCursor(245, 183); tft.print('M'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[3] = IterationProgHoraireEclairageReglage[3]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[4] != IterationProgHoraireEclairageReglage[4]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[4]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(300, 190, 16, couleurBoutonsIteration); // Dessine le bouton Jeudi "J"
- tft.drawCircle(300, 190, 20, couleurBoutonsIteration);
- tft.setCursor(295, 183); tft.print('J'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[4] = IterationProgHoraireEclairageReglage[4]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[5] != IterationProgHoraireEclairageReglage[5]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[5]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(350, 190, 16, couleurBoutonsIteration); // Dessine le bouton Vendredi "V"
- tft.drawCircle(350, 190, 20, couleurBoutonsIteration);
- tft.setCursor(345, 183); tft.print('V'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[5] = IterationProgHoraireEclairageReglage[5]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastIterationProgHoraireEclairageReglage[6] != IterationProgHoraireEclairageReglage[6]) // ++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire de l'éclairage a changé
- {
- if (!IterationProgHoraireEclairageReglage[6]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(400, 190, 16, couleurBoutonsIteration); // Dessine le bouton Samedi "S"
- tft.drawCircle(400, 190, 20, couleurBoutonsIteration);
- tft.setCursor(395, 183); tft.print('S'); // Positionne et Affiche le texte
- LastIterationProgHoraireEclairageReglage[6] = IterationProgHoraireEclairageReglage[6]; // Mémorise l'itération de réglage du programmateur horaire de l'éclairage
- }
- if (LastModeProgHoraireEclairageReglage != ModeProgHoraireEclairageReglage) // ++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeProgHoraireEclairageReglage) // --------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeProgHoraireEclairageReglage) // --------------------------------------------------------------------------- // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeProgHoraireEclairageReglage = ModeProgHoraireEclairageReglage; // Mémorise le dernier indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 203 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 203 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du programmateur horaire d'éclairage
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message23); // Positionne et Affiche le titre "REGLAGE PROGRAMMATEUR ECLAIRAGE"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 175, 480, 175, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 176, 480, 176, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(51, 52); LectureMemoireFlash(message29); // Positionne et Affiche le texte "DEPART"
- tft.setCursor(310, 52); LectureMemoireFlash(message30); // Positionne et Affiche le texte "ARRET"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(64, 130, 25, 25, GREEN); tft.drawRect(118, 130, 25, 25, GREEN); // Dessine les 4 boutons + et les cadres
- tft.setTextSize(2); tft.setCursor(72, 136); tft.print('+'); tft.setCursor(126, 136); tft.print('+');
- tft.drawRect(326, 130, 25, 25, GREEN); tft.drawRect(380, 130, 25, 25, GREEN);
- tft.setCursor(333, 136); tft.print('+'); tft.setCursor(387, 136); tft.print('+');
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastHrsDepartProgHoraireEclairageReglage != HrsDepartProgHoraireEclairageReglage // +++++++++++++++++++++++++++++++++++ // Si les heures ou les minutes de départ de réglage du programmateur horaire de l'éclairage
- || LastMinsDepartProgHoraireEclairageReglage != MinsDepartProgHoraireEclairageReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(60, 87); // Positionne le texte
- if (HrsDepartProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(HrsDepartProgHoraireEclairageReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsDepartProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(MinsDepartProgHoraireEclairageReglage); // Affiche le texte
- LastHrsDepartProgHoraireEclairageReglage = HrsDepartProgHoraireEclairageReglage; // Mémorise les dernières heures de départ de réglage du programmateur horaire de l'éclairage
- LastMinsDepartProgHoraireEclairageReglage = MinsDepartProgHoraireEclairageReglage; // Mémorise les dernières minutes de départ de réglage du programmateur horaire de l'éclairage
- }
- if (LastHrsArretProgHoraireEclairageReglage != HrsArretProgHoraireEclairageReglage // +++++++++++++++++++++++++++++++++++++ // Si les heures ou les minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- || LastMinsArretProgHoraireEclairageReglage != MinsArretProgHoraireEclairageReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(300, 87); // Positionne le texte
- if (HrsArretProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(HrsArretProgHoraireEclairageReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsArretProgHoraireEclairageReglage < 10) {tft.print('0');} tft.print(MinsArretProgHoraireEclairageReglage); // Affiche le texte
- LastHrsArretProgHoraireEclairageReglage = HrsArretProgHoraireEclairageReglage; // Mémorise le dernières heures d'arrêt de réglage du programmateur horaire de l'éclairage
- LastMinsArretProgHoraireEclairageReglage = MinsArretProgHoraireEclairageReglage; // Mémorise les dernières minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- }
- if (LastMins != Mins) // -------------------------------------------------------------------------------------------------- // Si les minutes courantes ont changé
- {
- tft.setTextColor(WHITE, BLACK); tft.setTextSize(5); // Définit la couleur et la taille
- tft.setCursor(122, 198); // Définit la position
- if (Hrs < 10) {tft.print('0');} tft.print(Hrs); // Affiche les heures courantes
- tft.fillCircle(198, 226, 4, WHITE); tft.fillCircle(198, 208, 4, WHITE); // Affiche les deux points ":" de l'heure
- tft.setCursor(218, 198); // Définit la position
- if (Mins < 10) {tft.print('0');} tft.print(Mins); // Affiche les minutes courantes
- LastMins = Mins; // Mémorise les dernières minutes courantes
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 104 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 104 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du programmateur horaire des repas
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message31); // Positionne et Affiche le titre "REGLAGE PROGRAMMATEUR REPAS"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 175, 480, 175, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 176, 480, 176, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setTextSize(2); // Définit la taille
- tft.setCursor(50, 55); LectureMemoireFlash(message32); // Positionne et Affiche "HEURE REPAS 1"
- tft.setCursor(310, 55); LectureMemoireFlash(message33); // Positionne et Affiche "HEURE REPAS 2"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(64, 130, 25, 25, GREEN); tft.drawRect(118, 130, 25, 25, GREEN); // Dessine les 4 boutons + et les cadres
- tft.setTextSize(2); tft.setCursor(72, 136); tft.print('+'); tft.setCursor(126, 136); tft.print('+');
- tft.drawRect(326, 130, 25, 25, GREEN); tft.drawRect(380, 130, 25, 25, GREEN);
- tft.setCursor(333, 136); tft.print('+'); tft.setCursor(387, 136); tft.print('+');
- if (LastPageCourante != 204) // ----------------------------------------------------------------------------------------- // Si la dernière Page courante est différente de 204
- {
- HrsDepart1ProgHoraireRepasReglage = HrsDepart1ProgHoraireRepas; // Transfère les heures de départ1 du programmateur horaire des repas dans les heures de départ1 de réglage du programmateur horaire des repas
- MinsDepart1ProgHoraireRepasReglage = MinsDepart1ProgHoraireRepas; // Transfère les minutes de départ1 du programmateur horaire des repas dans les minutes de départ1 de réglage du programmateur horaire des repas
- HrsDepart2ProgHoraireRepasReglage = HrsDepart2ProgHoraireRepas; // Transfère les heures de départ2 du programmateur horaire des repas dans les heures de départ2 de réglage du programmateur horaire des repas
- MinsDepart2ProgHoraireRepasReglage = MinsDepart2ProgHoraireRepas; // Transfère les minutes de départ2 du programmateur horaire des repas dans les Minutes de départ2 de réglage du programmateur horaire des repas
- ModeProgHoraireRepasReglage = ModeProgHoraireRepas; // Transfère l'indicateur du mode de fonctionnement du programmateur horaire des repas dans l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- for (int i = 0; i < 7; i++) // Transfère l'itération du programmateur horaire des repas dans l'itération de réglage du programmateur horaire des repas
- {
- IterationProgHoraireRepasReglage[i] = IterationProgHoraireRepas[i];
- }
- }
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastHrsDepart1ProgHoraireRepasReglage != HrsDepart1ProgHoraireRepasReglage // +++++++++++++++++++++++++++++++++++++++++ // Si les heures ou les minutes de départ1 de réglage du programmateur horaire des repas ont changé
- || LastMinsDepart1ProgHoraireRepasReglage != MinsDepart1ProgHoraireRepasReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(60, 87); // Positionne le texte
- if (HrsDepart1ProgHoraireRepasReglage < 10) {tft.print('0');} tft.print(HrsDepart1ProgHoraireRepasReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsDepart1ProgHoraireRepasReglage < 10) {tft.print('0');} tft.print(MinsDepart1ProgHoraireRepasReglage); // Affiche le texte
- LastHrsDepart1ProgHoraireRepasReglage = HrsDepart1ProgHoraireRepasReglage; // Mémorise les dernières heures de départ1 de réglage du programmateur horaire des repas
- LastMinsDepart1ProgHoraireRepasReglage = MinsDepart1ProgHoraireRepasReglage; // Mémorise les dernière minutes de départ1 de réglage du programmateur horaire des repas
- }
- if (LastHrsDepart2ProgHoraireRepasReglage != HrsDepart2ProgHoraireRepasReglage // +++++++++++++++++++++++++++++++++++++++++ // Si Si les heures ou les minutes de départ2 de réglage du programmateur horaire des repas ont changé
- || LastMinsDepart2ProgHoraireRepasReglage != MinsDepart2ProgHoraireRepasReglage)
- {
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(326, 87); // Positionne le texte
- if (HrsDepart2ProgHoraireRepasReglage < 10) {tft.print('0');} tft.print(HrsDepart2ProgHoraireRepasReglage); // Affiche le texte
- tft.print(':'); // Affiche le caractère ":"
- if (MinsDepart2ProgHoraireRepasReglage < 10) {tft.print('0');} tft.print(MinsDepart2ProgHoraireRepasReglage); // Affiche le texte
- LastHrsDepart2ProgHoraireRepasReglage = HrsDepart2ProgHoraireRepasReglage; // Mémorise les dernières heures de départ2 de réglage du programmateur horaire des repas
- LastMinsDepart2ProgHoraireRepasReglage = MinsDepart2ProgHoraireRepasReglage; // Mémorise les dernière minutes de départ2 de réglage du programmateur horaire des repas
- }
- if (LastMins != Mins) // -------------------------------------------------------------------------------------------------- // Si les minutes courantes ont changé
- {
- tft.setTextColor(WHITE, BLACK); tft.setTextSize(6); // Définit la couleur et la taille
- tft.setCursor(155, 205); // Définit la position
- if (Hrs < 10) {tft.print('0');} tft.print(Hrs); // Affiche les heures courantes
- tft.fillCircle(230, 230, 4, WHITE); tft.fillCircle(230, 212, 4, WHITE); // Affiche les deux points ":" de l'heure
- tft.setCursor(240, 205); // Définit la position
- if (Mins < 10) {tft.print('0');} tft.print(Mins); // Affiche les minutes courantes
- LastMins = Mins; // Mémorise les dernières minutes courantes
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 501 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 501 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Réglage de l'heure courante
- {
- if (LastPageCourante != PageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message34); // Positionne et Affiche le titre "REGLAGE DE L'HEURE COURANTE"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawRoundRect(100, 42, 286, 76, 12, 0x3B0A); // Affiche le cadre de l'heure courante
- tft.drawRoundRect(96, 40, 290, 80, 12, 0x3B0A);
- tft.fillCircle(250, 95, 4, GREEN); tft.fillCircle(250, 72, 4, BLUE); // Affiche les deux points ":" de l'heure
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.drawRect(64, 130, 25, 25, GREEN); tft.drawRect(130, 130, 25, 25, GREEN); // Dessine les 4 boutons + et - et les cadres
- tft.setTextSize(2); tft.setCursor(71, 136); tft.print('-'); tft.setCursor(137, 136); tft.print('+');
- tft.drawRect(290, 130, 25, 25, GREEN); tft.drawRect(360, 130, 25, 25, GREEN);
- tft.setCursor(297, 136); tft.print('-'); tft.setCursor(367, 136); tft.print('+');
- HrsReglage = Hrs; // Transfère les heures courantes dans les heures de réglage
- MinsReglage = Mins; // Transfère les minutes courantes dans les heures de réglage
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastHrsReglage != HrsReglage || LastMinsReglage != MinsReglage) // ---------------------------------------------------- // Si les heures ou les minutes de réglages ont changé
- {
- tft.setTextColor(BLUE, BLACK); tft.setTextSize(8); // Définit le couleur et la taille
- tft.setCursor(130, 50); // Positionne le texte
- if (HrsReglage < 10) {tft.print('0');} tft.print(HrsReglage); // Affiche les heures de réglage
- tft.setCursor(280, 50); // Positionne le texte
- if (MinsReglage < 10) {tft.print('0');} tft.print(MinsReglage); // Affiche les minutes de réglage
- LastHrsReglage = HrsReglage; // Mémorise les dernières heures de réglage
- LastMinsReglage = MinsReglage; // Mémorise les dernières minutes de réglage
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 502 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 502 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Réglage de la date courante
- {
- if (LastPageCourante != PageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(90, 8); LectureMemoireFlash(message35); // Positionne et Affiche le titre "REGLAGE DE LA DATE COURANTE"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextSize(2); // Définit la taille
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setCursor(90, 105); LectureMemoireFlash(message38); // Positionne et Affiche "JOUR"
- tft.setCursor(90, 157); LectureMemoireFlash(message39); // Positionne et Affiche "MOIS"
- tft.setCursor(90, 209); LectureMemoireFlash(message40); // Positionne et Affiche "ANNEE"
- tft.setTextSize(2);
- tft.drawRect(200, 203, 25, 25, GREEN); tft.drawRect(370, 203, 25, 25, GREEN); // Dessine les 6 boutons + et - et les cadres
- tft.setCursor(208, 209); tft.print('-'); tft.setCursor(378, 209); tft.print('+');
- tft.drawRect(200, 151, 25, 25, GREEN); tft.drawRect(370, 151, 25, 25, GREEN);
- tft.setCursor(208, 157); tft.print('-'); tft.setCursor(378, 157); tft.print('+');
- tft.drawRect(200, 99, 25, 25, GREEN); tft.drawRect(370, 99, 25, 25, GREEN);
- tft.setCursor(208, 105); tft.print('-'); tft.setCursor(378, 105); tft.print('+');
- JourReglage = Jour; // Transfère le jour du mois de la date courante dans le jour de réglage
- MoisReglage = Mois; // Transfère le mois de la date courante dans Mois de réglage
- AnneeReglage = Annee; // Transfère l'année de la date courante dans l'année de réglage
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastJourSemaine != JourSemaine) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le dernier jour de la semaine a changé
- {
- uint16_t couleurBoutonsJour; // Déclarare la variable couleur des boutons
- tft.setTextSize(2); // Définit la taille
- tft.setTextColor(WHITE); // Définit la couleur
- if (JourSemaine == 0) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(90, 60, 16, couleurBoutonsJour); // Dessine le bouton Dimanche "D"
- tft.drawCircle(90, 60, 20, couleurBoutonsJour);
- tft.setCursor(86, 53); tft.print('D'); // Positionne et Affiche le texte
- if (JourSemaine == 1) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(140, 60, 16, couleurBoutonsJour); // Dessine le bouton Lundi "L"
- tft.drawCircle(140, 60, 20, couleurBoutonsJour);
- tft.setCursor(136, 53); tft.print('L'); // Positionne et Affiche le texte
- if (JourSemaine == 2) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(190, 60, 16, couleurBoutonsJour); // Dessine le bouton Mardi "M"
- tft.drawCircle(190, 60, 20, couleurBoutonsJour);
- tft.setCursor(186, 53); tft.print('M'); // Positionne et Affiche le texte
- if (JourSemaine == 3) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(240, 60, 16, couleurBoutonsJour); // Dessine le bouton Mercredi "M"
- tft.drawCircle(240, 60, 20, couleurBoutonsJour);
- tft.setCursor(236, 53); tft.print('M'); // Positionne et Affiche le texte
- if (JourSemaine == 4) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(290, 60, 16, couleurBoutonsJour); // Dessine le bouton Jeudi "J"
- tft.drawCircle(290, 60, 20, couleurBoutonsJour);
- tft.setCursor(286, 53); tft.print('J'); // Positionne et Affiche le texte
- if (JourSemaine == 5) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(340, 60, 16, couleurBoutonsJour); // Dessine le bouton Vendredi "V"
- tft.drawCircle(340, 60, 20, couleurBoutonsJour);
- tft.setCursor(336, 53); tft.print('V'); // Positionne et Affiche le texte
- if (JourSemaine == 6) {couleurBoutonsJour = 0x195B62;} else {couleurBoutonsJour = RED;} // Sélectionne la couleur
- tft.fillCircle(390, 60, 16, couleurBoutonsJour); // Dessine le bouton Samedi "S"
- tft.drawCircle(390, 60, 20, couleurBoutonsJour);
- tft.setCursor(386, 53); tft.print('S'); // Positionne et Affiche le texte
- LastJourSemaine = JourSemaine; // Mémorise le dernier jour de la semaine
- }
- if (LastJourReglage != JourReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le dernier jour de réglage a changé
- {
- tft.setTextSize(3); // Définit la taille
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setCursor(265, 100); if (JourReglage < 10) {tft.print('0');} tft.print(JourReglage); // Positionne et Affiche la variable de réglage
- LastJourReglage = JourReglage; // Mémorise le dernier jour de réglage
- }
- if (LastMoisReglage != MoisReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le dernier mois de réglage a changé
- {
- tft.setTextSize(3); // Définit la taille
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setCursor(265, 152); if (MoisReglage < 10) {tft.print('0');} tft.print(MoisReglage); // Positionne et Affiche le mois de réglage
- LastMoisReglage = MoisReglage; // Mémorise le dernier mois de réglage
- }
- if (LastAnneeReglage != AnneeReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la dernière année de réglage a changé
- {
- tft.setTextSize(3); // Définit la taille
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setCursor(265, 204); tft.print(AnneeReglage); // Positionne et Affiche la dernière année de réglage
- LastAnneeReglage = AnneeReglage; // Mémorise la dernière année de réglage
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 105 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 105 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Menu setup
- {
- if (LastPageCourante != PageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(160, 8); LectureMemoireFlash(message46); // Positionne et Affiche le titre "MENU SETUP"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- if (LastetatBoutonReglagesDefaut != etatBoutonReglagesDefaut) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'état du bouton "REGLAGES PAR DEFAUT" a changé
- {
- boolean autorisationAffichageValidationReglages = false; // Indicateur d'autorisation d'afficher la Page validation réglages
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille
- if (etatBoutonReglagesDefaut) // ---------------------------------------------------------------------------------------- // Si l'état du bouton "REGLAGES PAR DEFAUT" est activé
- {
- tft.fillRoundRect(120, 56, 236, 25, 12, KHAKIGREEN); // Affiche le bouton "REGLAGES PAR DEFAUT" en vert
- tft.drawRoundRect(118, 54, 240, 29, 12, KHAKIGREEN);
- tft.setCursor(125, 60); LectureMemoireFlash(message47); // Affiche le texte "REGLAGES PAR DEFAUT"
- etatBoutonReglagesDefaut = false; // Désactive l'état du bouton "REGLAGES PAR DEFAUT"
- delay(1000); // Temporise 1 seconde
- autorisationAffichageValidationReglages = true; // Active l'indicateur d'autorisation d'afficher la Page validation réglages
- }
- if (!etatBoutonReglagesDefaut) // --------------------------------------------------------------------------------------- // Si l'état du bouton "REGLAGES PAR DEFAUT" est activé
- {
- tft.fillRoundRect(120, 56, 236, 25, 12, RED); // Affiche le bouton "REGLAGES PAR DEFAUT" en rouge
- tft.drawRoundRect(118, 54, 240, 29, 12, RED);
- tft.setCursor(125, 60); LectureMemoireFlash(message47); // Affiche le texte "REGLAGES PAR DEFAUT"
- if (autorisationAffichageValidationReglages) // ....................................................................... // Si l'incateur d'autorisation d'afficher la Page validation réglages est activé
- {
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- }
- }
- LastetatBoutonReglagesDefaut = etatBoutonReglagesDefaut; // Mémorise le dernier état du bouton "REGLAGES PAR DEFAUT"
- }
- if (LastetatBoutonReglagesModeEco != etatBoutonReglagesModeEco && etatReactivationAffichagePages) // ++++++++++++++++++++++ // Si l'état du bouton "MODE ECO ON/OFF" a changé
- {
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille
- if (ModeEco) // --------------------------------------------------------------------------------------------------------- // Si l'état de l'indicateur du mode Eco est activé
- {
- tft.fillRoundRect(120, 106, 236, 25, 12, KHAKIGREEN); // Affiche le bouton "MODE ECO ON" en vert
- tft.drawRoundRect(118, 104, 240, 29, 12, KHAKIGREEN);
- tft.setCursor(140, 110); LectureMemoireFlash(message50); // Affiche le texte "MODE ECO ON"
- }
- else if (!ModeEco) // --------------------------------------------------------------------------------------------------- // Si l'état de l'indicateur du mode Eco est désactivé
- {
- tft.fillRoundRect(120, 106, 236, 25, 12, RED); // Affiche le bouton "MODE ECO OFF" en rouge
- tft.drawRoundRect(118, 104, 240, 29, 12, RED);
- tft.setCursor(140, 110); LectureMemoireFlash(message51); // Affiche le texte "MODE ECO OFF"
- }
- LastetatBoutonReglagesModeEco = etatBoutonReglagesModeEco; // Mémorise le dernier état du bouton "MODE ECO ON/OFF"
- }
- if (LastetatBoutonReglagesModeMute != etatBoutonReglagesModeMute && etatReactivationAffichagePages) // ++++++++++++++++++++ // Si l'état du bouton "MODE MUTE ON/OFF" a changé
- {
- tft.setTextColor(WHITE); tft.setTextSize(2); // Définit la couleur et la taille
- if (ModeMute) // -------------------------------------------------------------------------------------------------------- // Si l'état de l'indicateur du mode Mute est activé
- {
- tft.fillRoundRect(120, 156, 236, 25, 12, KHAKIGREEN); // Affiche le bouton "MODE MUTE ON" en vert
- tft.drawRoundRect(118, 154, 240, 29, 12, KHAKIGREEN);
- tft.setCursor(140, 160); LectureMemoireFlash(message52); // Affiche le texte "MODE MUTE ON"
- }
- else if (!ModeMute) // -------------------------------------------------------------------------------------------------- // Si l'état de l'indicateur du mode Mute est désactivé
- {
- tft.fillRoundRect(120, 156, 236, 25, 12, RED); // Affiche le bouton "MODE MUTE OFF" en rouge
- tft.drawRoundRect(118, 154, 240, 29, 12, RED);
- tft.setCursor(140, 160); LectureMemoireFlash(message53); // Affiche le texte "MODE MUTECO OFF"
- }
- LastetatBoutonReglagesModeMute = etatBoutonReglagesModeMute; // Mémorise le dernier état du bouton "MODE MUTE ON/OFF"
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 204 && etatReactivationAffichagePages) // ********************************************************** // Si la Page courante 204 est sélectionnée et Si l'indicateur de réactivation d'affichage des Pages est activé => Page réglage du programmateur horaire des repas
- {
- if (PageCourante != LastPageCourante) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante a changé
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- FonctionAffichageIconesPagesReglages(); // Appelle la fonction d'affichage des icônes des Pages de réglages
- tft.setTextColor(WHITE); // Définit la couleur du titre
- tft.setTextSize(2); // Définit la taille du titre
- tft.setCursor(60, 8); LectureMemoireFlash(message31); // Positionne et Affiche le titre "REGLAGE PROGRAMMATEUR REPAS"
- tft.drawLine(5, 31, 480, 31, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 32, 480, 32, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 33, 480, 33, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED, BLACK); // Définit la couleur
- tft.setCursor(235, 275); LectureMemoireFlash(message12); // Affiche le texte "MODE"
- tft.setCursor(235, 290); LectureMemoireFlash(message63); // Affiche "ON/OFF"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 46); LectureMemoireFlash(message64); // Positionne et Affiche "REPAS 1 :"
- tft.setCursor(80, 94); LectureMemoireFlash(message65); // Positionne et Affiche "REPAS 2 :"
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- tft.setTextColor(BLUE, BLACK); // Définit la couleur
- tft.setTextSize(4); // Définit la taille
- tft.setCursor(270, 42); // Positionne le texte
- if (HrsDepart1ProgHoraireRepas < 10) {tft.print('0');} tft.print(HrsDepart1ProgHoraireRepas); // Affiche le texte
- tft.setCursor(325, 42); tft.print(':'); // Positionne et Affiche le caractère ":"
- tft.setCursor(350, 42); // Positionne le texte
- if (MinsDepart1ProgHoraireRepas < 10) {tft.print('0');} tft.print(MinsDepart1ProgHoraireRepas); // Affiche le texte
- tft.setCursor(270, 90); // Positionne le texte
- if (HrsDepart2ProgHoraireRepas < 10) {tft.print('0');} tft.print(HrsDepart2ProgHoraireRepas); // Affiche le texte
- tft.setCursor(325, 90); tft.print(':'); // Positionne et Affiche le caractère ":"
- tft.setCursor(350, 90); // Positionne le texte
- if (MinsDepart2ProgHoraireRepas < 10) {tft.print('0');} tft.print(MinsDepart2ProgHoraireRepas); // Positionne et Affiche le texte
- LastPageCourante = PageCourante; // Mémorise la dernière Page courante
- }
- uint16_t couleurBoutonsIteration; // Déclarare la variable couleur des boutons de l'itération
- tft.setTextSize(2); // Définit la taille
- tft.setTextColor(WHITE); // Définit la couleur
- if (LastIterationProgHoraireRepasReglage[0] != IterationProgHoraireRepasReglage[0]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[0]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(100, 190, 16, couleurBoutonsIteration); // Dessine le bouton Dimanche "D"
- tft.drawCircle(100, 190, 20, couleurBoutonsIteration);
- tft.setCursor(95, 183); tft.print('D'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[0] = IterationProgHoraireRepasReglage[0]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[1] != IterationProgHoraireRepasReglage[1]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[1]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(150, 190, 16, couleurBoutonsIteration); // Dessine le bouton Lundi "L"
- tft.drawCircle(150, 190, 20, couleurBoutonsIteration);
- tft.setCursor(145, 183); tft.print('L'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[1] = IterationProgHoraireRepasReglage[1]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[2] != IterationProgHoraireRepasReglage[2]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[2]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(200, 190, 16, couleurBoutonsIteration); // Dessine le bouton Mardi "M"
- tft.drawCircle(200, 190, 20, couleurBoutonsIteration);
- tft.setCursor(195, 183); tft.print('M'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[2] = IterationProgHoraireRepasReglage[2]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[3] != IterationProgHoraireRepasReglage[3]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[3]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(250, 190, 16, couleurBoutonsIteration); // Dessine le bouton Mercredi "M"
- tft.drawCircle(250, 190, 20, couleurBoutonsIteration);
- tft.setCursor(245, 183); tft.print('M'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[3] = IterationProgHoraireRepasReglage[3]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[4] != IterationProgHoraireRepasReglage[4]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[4]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(300, 190, 16, couleurBoutonsIteration); // Dessine le bouton Jeudi "J"
- tft.drawCircle(300, 190, 20, couleurBoutonsIteration);
- tft.setCursor(295, 183); tft.print('J'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[4] = IterationProgHoraireRepasReglage[4]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[5] != IterationProgHoraireRepasReglage[5]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[5]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(350, 190, 16, couleurBoutonsIteration); // Dessine le bouton Vendredi "V"
- tft.drawCircle(350, 190, 20, couleurBoutonsIteration);
- tft.setCursor(345, 183); tft.print('V'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[5] = IterationProgHoraireRepasReglage[5]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastIterationProgHoraireRepasReglage[6] != IterationProgHoraireRepasReglage[6]) // ++++++++++++++++++++++++++++++++++++ // Si l'itération de réglage du programmateur horaire des repas a changé
- {
- if (!IterationProgHoraireRepasReglage[6]) {couleurBoutonsIteration = RED;} else {couleurBoutonsIteration = 0x195B62;} // Sélectionne la couleur
- tft.fillCircle(400, 190, 16, couleurBoutonsIteration); // Dessine le bouton Samedi "S"
- tft.drawCircle(400, 190, 20, couleurBoutonsIteration);
- tft.setCursor(395, 183); tft.print('S'); // Positionne et Affiche le texte
- LastIterationProgHoraireRepasReglage[6] = IterationProgHoraireRepasReglage[6]; // Mémorise l'itération de réglage du programmateur horaire des repas
- }
- if (LastModeProgHoraireRepasReglage != ModeProgHoraireRepasReglage) // ++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas a changé
- {
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- tft.setCursor(80, 280); LectureMemoireFlash(message36); tft.setCursor(365, 280); LectureMemoireFlash(message37); // Positionne et Affiche "ON" et "OFF"
- if (ModeProgHoraireRepasReglage) // ------------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas est activé
- {
- tft.drawRect(71, 270, 51, 39, GREEN); // Affiche un cadre autour de "ON"
- tft.drawRect(355, 270, 69, 39, BLACK); // Efface le cadre autour de "OFF"
- }
- else if (!ModeProgHoraireRepasReglage) // ------------------------------------------------------------------------------- // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas est désactivé
- {
- tft.drawRect(355, 270, 69, 39, GREEN); // Affiche un cadre autour de "OFF"
- tft.drawRect(71, 270, 51, 39, BLACK); // Efface le cadre autour de "ON"
- }
- LastModeProgHoraireRepasReglage = ModeProgHoraireRepasReglage; // Mémorise le dernier indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- }
- }
- //**************************************************************************************************************************************************************************
- if (!ModeManuelTemperature) // ********************************************************************************************** // Si l'indicateur du mode manuel de la température est désactivé
- {
- if (Hrs == HrsDepartSeuilsModeJour && Mins == MinsDepartSeuilsModeJour && Secs <= 2) // +++++++++++++++++++++++++++++++++++ // Si l'heure courante est égale à l'heure de départ du mode jour
- {
- SeuilTemperatureJourNuit = SeuilTemperatureJour; // Transfère le seuil de jour de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 1; // Active l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) {if (PageCourante == 0) {LastPageCourante = -1;}} // Réinitialise la dernière Page courante
- }
- else if (Hrs == HrsDepartSeuilsModeNuit && Mins == MinsDepartSeuilsModeNuit && Secs <= 2) // ++++++++++++++++++++++++++++++ // Si l'heure courante est égale à l'heure de départ du mode nuit
- {
- SeuilTemperatureJourNuit = SeuilTemperatureNuit; // Transfère le seuil de nuit de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 0; // Désactive l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) {if (PageCourante == 0) {LastPageCourante = -1;}} // Réinitialise la dernière Page courante
- }
- if (TemperatureCourante >= SeuilTemperatureJourNuit && !EtatVentilateur) // +++++++++++++++++++++++++++++++++++++++++++++++ // Si la température courante est supérieure ou égale seuil jour / nuit de température et Si le ventilateur est désactivé
- {
- if (t1DebutTempoVentilateurON == 0) {t1DebutTempoVentilateurON = millis();} // Démarre la temporisation d'activation du ventilateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- if (millis() - t1DebutTempoVentilateurON >= 2000ul && t1DebutTempoVentilateurON != 0) // -------------------------------- // Si le ventilateur est activé depuis plus de 2s
- {
- EtatVentilateur = HIGH; // Active l'indicateur d'état du fonctionnement du ventilateur
- LastEtatVentilateur = !EtatVentilateur; // Inverse l'indicateur du dernier état du fonctionnement du ventilateur
- digitalWrite(BrocheLedRougeTemoinVentilateur, EtatVentilateur); // Active la led témoin de fonctionnement du ventilateur
- digitalWrite(BrocheRelaisVentilateur, EtatVentilateur); // Active le relais du ventilateur
- t1DebutTempoVentilateurON = 0; // Réinitialise la temporisation d'activation du Ventilateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- Buzzer(20, 0, 1); // Active le buzzer 20ms
- }
- }
- else if (TemperatureCourante < SeuilTemperatureJourNuit && EtatVentilateur) // ++++++++++++++++++++++++++++++++++++++++++++ // Si la température courante est inférieure au seuil jour / nuit de température et Si le ventilateur est activé
- {
- EtatVentilateur = LOW; // Active l'indicateur d'état du fonctionnement du ventilateur
- LastEtatVentilateur = !EtatVentilateur; // Inverse l'indicateur du dernier état du fonctionnement du ventilateur
- digitalWrite(BrocheLedRougeTemoinVentilateur, EtatVentilateur); // Désactive la led témoin de fonctionnement du ventilateur
- }
- }
- //**************************************************************************************************************************************************************************
- if (!ModeManuelHumidite) // ************************************************************************************************* // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- if (Hrs == HrsDepartSeuilsModeJour && Mins == MinsDepartSeuilsModeJour && Secs <= 2) // +++++++++++++++++++++++++++++++++++ // Si l'heure courante est égale à l'heure de départ du mode jour
- {
- SeuilHumiditeJourNuit = SeuilHumiditeJour; // Transfère le seuil de jour du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 1; // Active l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) {if (PageCourante == 0) {LastPageCourante = -1;}} // Réinitialise la dernière Page courante
- }
- else if (Hrs == HrsDepartSeuilsModeNuit && Mins == MinsDepartSeuilsModeNuit && Secs <= 2) // ++++++++++++++++++++++++++++++ // Si l'heure courante est égale à l'heure de départ du mode nuit
- {
- SeuilHumiditeJourNuit = SeuilHumiditeNuit; // Transfère le seuil de nuit du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 0; // Désactive l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) {if (PageCourante == 0) {LastPageCourante = -1;}} // Réinitialise la dernière Page courante
- }
- if (TauxHumiditeCourant <= SeuilHumiditeJourNuit && !EtatBrumisateur) // ++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le taux d'humidité courant est inférieur ou égal au seuil jour / nuit du taux d'humidité et Si le brumisateur est désactivé
- {
- if (t1DebutTempoBrumisateurON == 0) {t1DebutTempoBrumisateurON = millis();} // Démarre la temporisation d'activation du brumisateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- if (millis() - t1DebutTempoBrumisateurON >= 2000ul && t1DebutTempoBrumisateurON != 0) // -------------------------------- // Si le brumisateur est activé depuis plus de 2s
- {
- EtatBrumisateur = HIGH; // Active l'indicateur d'état du fonctionnement du brumisateur
- LastEtatBrumisateur = !EtatBrumisateur; // Inverse l'indicateur du dernier état du fonctionnement du brumisateur
- digitalWrite(BrocheLedVerteTemoinBrumisateur, EtatBrumisateur); // Active la led témoin de fonctionnement du brumisateur
- digitalWrite(BrocheRelaisBrumisateur, EtatBrumisateur); // Active le relais du brumisateur
- t1DebutTempoBrumisateurON = 0; // Réinitialise la temporisation d'activation du brumisateur pour interdire des démarrages si le taux d'humidité varie autour du seuil du taux d'humidité
- Buzzer(20, 0, 1); // Active le buzzer 20ms
- }
- }
- else if (TauxHumiditeCourant > SeuilHumiditeJourNuit && EtatBrumisateur) // +++++++++++++++++++++++++++++++++++++++++++++++ // Si le taux d'humidité courant est supérieur au seuil jour / nuit du taux d'humidité et Si le brumisateur est activé
- {
- EtatBrumisateur = LOW; // Désactive l'indicateur d'état du fonctionnement du brumisateur
- LastEtatBrumisateur = !EtatBrumisateur; // Inverse l'indicateur du dernier état du fonctionnement du brumisateur
- digitalWrite(BrocheLedVerteTemoinBrumisateur, EtatBrumisateur); // Désactive la led témoin de fonctionnement du brumisateur
- digitalWrite(BrocheRelaisBrumisateur, EtatBrumisateur); // Désactive le relais du brumisateur
- }
- }
- //**************************************************************************************************************************************************************************
- if (ModeProgHoraireEclairage) // ******************************************************************************************** // Si l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- //Serial.println(IterationProgHoraireEclairage[JourSemaine]); // Débug
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- if (Hrs == HrsDepartProgHoraireEclairage && Mins == MinsDepartProgHoraireEclairage && Secs <= 2) // --------------------- // Si l'heure courante est égale à l'heure de départ du programmateur horaire de l'éclairage
- {
- EtatEclairage = HIGH; // Active l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Active la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Active le relais de l'éclairage
- if (ModeEco) // ....................................................................................................... // Si l'indicateur du mode Eco est activé
- {
- EcranTFTOFF = false; // Désactive l'indicateur de l'état de l'écran TFT
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- LastPageCourante = -1; // Sélectionne la Page -1 => Page inexistante
- etatReactivationAffichagePages = false; // Désactive l'indicateur de réactivation d'affichage des Pages
- TempoReactivationAffichagePages = 2000ul; // Définit la durée avant la réactivation d'affichage des Pages
- t1DebutTempoReactivationAffichagePages = millis(); // Démarre la temporisation avant la réactivation d'affichage des Pages
- }
- }
- else if (Hrs == HrsArretProgHoraireEclairage && Mins == MinsArretProgHoraireEclairage && Secs <= 2) // ------------------ // Si l'heure courante est égale à l'heure de d'arrêt du programmateur horaire de l'éclairage
- {
- EtatEclairage = LOW; // Désactive l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Désactive la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Désactive le relais de l'éclairage
- if (ModeEco) // ....................................................................................................... // Si l'indicateur du mode Eco est activé
- {
- if (etatReactivationAffichagePages) {FonctionPageAffichageModeEcoActive();} // Si l'indicateur de réactivation d'affichage des Pages est activé => Appelle la fonction d'affichage de la Page mode eco
- EcranTFTOFF = true; // Désactive l'indicateur de l'état de l'écran TFT
- PageCourante = -1; // Sélectionne la Page -1 => Page inexistante
- }
- }
- }
- }
- //**************************************************************************************************************************************************************************
- if (ModeProgHoraireRepas) // ************************************************************************************************ // Si l'indicateur du mode de fonctionnement du programmateur horaire des repas est activé
- {
- //Serial.println(IterationProgHoraireRepas[JourSemaine]); // Débug
- if (IterationProgHoraireRepas[JourSemaine] == 1) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'itération du programmateur horaire des repas du jour de la semaine courant est activé
- {
- if (Hrs == HrsDepart1ProgHoraireRepas && Mins == MinsDepart1ProgHoraireRepas && Secs <= 2) // --------------------------- // Si l'heure courante est égale à l'heure de départ du programmateur horaire des repas
- {
- PageCourante = 500; // Sélectionne la Page 500 => Page mélodie repas
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- FonctionMelodieRepas(1); // Appelle la fonction mélodie repas 1
- }
- else if (Hrs == HrsDepart2ProgHoraireRepas && Mins == MinsDepart2ProgHoraireRepas && Secs <= 2) // ---------------------- // Si l'heure courante est égale à l'heure de d'arrêt du programmateur horaire des repas
- {
- PageCourante = 500; // Sélectionne la Page 500 => Page mélodie repas
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- FonctionMelodieRepas(2); // Appelle la fonction mélodie repas 2
- }
- }
- }
- //**************************************************************************************************************************************************************************
- if (t1DebutTempoReactivationAffichagePages != 0) // ************************************************************************* // Si la temporisation avant la réactivation d'affichage des Pages a démarré
- {
- if (millis() - t1DebutTempoReactivationAffichagePages >= TempoReactivationAffichagePages) // ++++++++++++++++++++++++++++++ // Si la temporisation avant la réactivation d'affichage des Pages est écoulée
- {
- t1DebutTempoReactivationAffichagePages = 0; // Réinitialise la temporisation avant la réactivation d'affichage des Pages
- etatReactivationAffichagePages = true; // Active l'indicateur de réactivation d'affichage des Pages
- if (ModeEco && EcranTFTOFF) // ------------------------------------------------------------------------------------------ // Si l'indicateur du mode Eco est activé et Si l'indicateur de l'état de l'écran TFT est activé
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- }
- }
- }
- //**************************************************************************************************************************************************************************
- if (t1DebutTempoSortieAutoMenus != 0) // ************************************************************************************ // Si la temporisation de sortie automatique des menus a démarré
- {
- if (millis() - t1DebutTempoSortieAutoMenus >= TempoSortieAutoMenus) // ++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la temporisation de sortie automatique des menus est écouléé
- {
- if (EcranTFTONTemporaire) // -------------------------------------------------------------------------------------------- // Si l'indicateur temporaire ON de l'écran TFT est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- EcranTFTONTemporaire = false; // Désactive l'indicateur temporaire ON de l'écran TFT
- if (etatReactivationAffichagePages) {FonctionPageAffichageModeEcoActive();} // Si l'indicateur de réactivation d'affichage des Pages est activé => Appelle la fonction d'affichage de la Page mode eco
- EcranTFTOFF = true; // Désactive l'indicateur de l'état de l'écran TFT
- PageCourante = -1; // Sélectionne la Page -1 => Page inexistante
- }
- else
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- }
- t1DebutTempoSortieAutoMenus = 0; // Réinitialise la temporisation de sortie automatique des menus
- }
- }
- //**************************************************************************************************************************************************************************
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction de la lecture de l'heure et de la date dans le module RTC PCF8523 *******************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionLecturePCF8523 ()
- {
- DateTime now = rtc.now(); // Lit l'heure et la date dans le module RTC PCF8523
- Hrs = now.hour(); Mins = now.minute(); Secs = now.second(); // Récupère les heures, les minutes et les secondes courantes
- JourSemaine = now.dayOfTheWeek(); Jour = now.day(); Mois = now.month(); Annee = now.year(); // Récupère la date courante
- //Serial.print(Hrs); Serial.print(':'); Serial.print(Mins); Serial.print(':'); Serial.println(Secs); // Débug
- //Serial.print(JourSemaine); Serial.print(' '); Serial.print(Jour); Serial.print('/'); Serial.print(Mois); Serial.print('/'); Serial.println(Annee); // Débug
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction de la lecture de la température et du taux d'humidité dans le module BME280 *********************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionLecturebme280 ()
- {
- TemperatureCourante = bme.readTemperature(); // Lit la température courante dans le module BME280
- TauxHumiditeCourant = bme.readHumidity(); // Lit le taux d'humidité courant dans le module BME280
- //Serial.print("Temperature = "); Serial.print(TemperatureCourante, 1); Serial.println(" C"); // Débug
- //Serial.print("Humidite = "); Serial.print(TauxHumiditeCourant); Serial.println(" %"); // Débug
- if (ModeDemo) // ************************************************************************************************************ // Si le mode démo est activé
- {
- static float TemperatureCouranteModeDemo = TemperatureCourante; // Déclare la température courante du mode démo
- static float TauxHumiditeCourantModeDemo = TauxHumiditeCourant; // Déclare le taux d'humidité courant du mode démo
- digitalWrite(BrocheLedVerteTemoinModeDemo, HIGH); // Active la led verte témoin du mode démo
- EtatBPPlusTemperatureModeDemo = digitalRead(BrocheBPPlusTemperatureModeDemo); // Lit l'état courant du bouton poussoir "BPPlusTemperatureModeDemo" pour faire varier la température en mode démo
- if (EtatBPPlusTemperatureModeDemo == LOW) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Pression sur le bouton poussoir "BPPlusTemperatureModeDemo"
- {
- TemperatureCouranteModeDemo = TemperatureCouranteModeDemo + 0.5; // Incrémente la température courante du mode démo
- if (TemperatureCouranteModeDemo > 80.0) {TemperatureCouranteModeDemo = 80.0;} // Borne la température courante du mode démo
- delay(50); // Temporise 50ms
- }
- EtatBPMoinsTemperatureModeDemo = digitalRead(BrocheBPMoinsTemperatureModeDemo); // Lit l'état courant du bouton poussoir "BPMoinsTemperatureModeDemo" pour faire varier la température en mode démo
- if (EtatBPMoinsTemperatureModeDemo == LOW) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Pression sur le bouton poussoir "BPMoinsTemperatureModeDemo"
- {
- TemperatureCouranteModeDemo = TemperatureCouranteModeDemo - 0.5; // Décrémente la température courante du mode démo
- if (TemperatureCouranteModeDemo < 0.0) {TemperatureCouranteModeDemo = 0.0;} // Borne la température courante du mode démo
- delay(50); // Temporise 50ms
- }
- EtatBPPlusHumiditeModeDemo = digitalRead(BrocheBPPlusHumiditeModeDemo); // Lit l'état courant du bouton poussoir "BPPlusHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- if (EtatBPPlusHumiditeModeDemo == LOW) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Pression sur le bouton poussoir "BPPlusHumiditeModeDemo"
- {
- TauxHumiditeCourantModeDemo = TauxHumiditeCourantModeDemo + 1.0; // Incrémente le taux d'humidité du mode démo
- if (TauxHumiditeCourantModeDemo > 100.0) {TauxHumiditeCourantModeDemo = 100.0;} // Borne le taux d'humidité du mode démo
- delay(50); // Temporise 50ms
- }
- EtatBPMoinsHumiditeModeDemo = digitalRead(BrocheBPMoinsHumiditeModeDemo); // Lit l'état courant du bouton poussoir "BPMoinsHumiditeModeDemo" pour faire varier le taux d'humidité en mode démo
- if (EtatBPMoinsHumiditeModeDemo == LOW) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Pression sur le bouton poussoir "BPMoinsHumiditeModeDemo"
- {
- TauxHumiditeCourantModeDemo = TauxHumiditeCourantModeDemo - 1.0; // Décrémente le taux d'humidité du mode démo
- if (TauxHumiditeCourantModeDemo < 0.0) {TauxHumiditeCourantModeDemo = 0.0;} // Borne le taux d'humidité du mode démo
- delay(50); // Temporise 50ms
- }
- TemperatureCourante = TemperatureCouranteModeDemo; // Transfère la temperature courante du mode démo dans la température courante
- TauxHumiditeCourant = TauxHumiditeCourantModeDemo; // Transfère le taux d'humidité du mode démo dans le taux d'humidité courant
- }
- }
- //**************************************************************************************************************************************************************************
- //*** 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
- {
- if (ModeMute) {return;} // Si l'indicateur du mode Mute est activé
- 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 Lecture Mémoire Programme (Flash) ***************************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void LectureMemoireFlash (const char AdresseMessage[])
- {
- char CaractereTemporaire = pgm_read_byte(AdresseMessage); // Récupère le premier caractère de la chaîne de caractères à afficher
- 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
- {
- tft.print(CaractereTemporaire); // Affichage du caractère lu
- i++; // Incrémente le compteur de déplacements
- CaractereTemporaire = pgm_read_byte(AdresseMessage + i); // Récupère le caractère suivant
- }
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction d'affichage de la température courante **********************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionAffichageTemperatureCourante ()
- {
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(4); // Définit la taile
- if (TemperatureCourante >= 10) {tft.setCursor(40, 160); tft.print(TemperatureCourante, 1);} // ******************************* // Positionne et Affiche la température courante
- else if (TemperatureCourante >= 0 && TemperatureCourante < 10) {tft.setCursor(40, 160); tft.print(' '); tft.print(TemperatureCourante, 1);}
- tft.setTextSize(2); tft.print((char)247); // Affiche le symbole degré
- tft.setTextSize(4); // Définit la taile
- tft.print('C'); // Affiche le caractère "C"
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction d'affichage du taux d'humidité courant **********************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionAffichageTauxHumiditeCourant ()
- {
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setTextSize(4); // Définit la taile
- if (TauxHumiditeCourant >= 10) {tft.setCursor(310, 160); tft.print(TauxHumiditeCourant, 1);} // ****************************** // Positionne et Affiche le taux d'humidité courant
- else if (TauxHumiditeCourant >= 0 && TauxHumiditeCourant < 10) {tft.setCursor(310, 160); tft.print(' '); tft.print(TauxHumiditeCourant, 1);}
- tft.print('%'); // Affiche le caractère "%"
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction d'affichage des icônes des pages de réglages ****************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionAffichageIconesPagesReglages ()
- {
- tft.setTextSize(2); // Définit la taille du le texte
- if (PageCourante == 100 || PageCourante == 101 || PageCourante == 102 || PageCourante == 103 || PageCourante == 104 // ****** // Si la Page sélectionnée est 100 ou 101 ou 102 ou 103 ou 104
- || PageCourante == 105)
- {
- tft.setTextColor(BLACK, WHITE); // Définit le couleur
- tft.fillCircle(10, 140, 20, WHITE); // Dessine le bouton "<"
- tft.drawCircle(10, 140, 22, WHITE);
- tft.setCursor(6, 135); tft.print('<'); // Positionne et Affiche "<"
- tft.fillCircle(460, 140, 20, WHITE); // Dessine le bouton ">"
- tft.drawCircle(460, 140, 22, WHITE);
- tft.setCursor(464, 135); tft.print('>'); // Positionne et Affiche ">"
- }
- if (PageCourante == 100 || PageCourante == 101 || PageCourante == 103 || PageCourante == 104) // **************************** // Si la Page sélectionnée est 100 ou 101 ou 103 ou 104
- {
- tft.fillCircle(20, 300, 20, WHITE); // Dessine la touche
- tft.drawCircle(20, 300, 22, WHITE);
- tft.drawLine(17, 305, 22, 293, BLACK); // Affiche la Touche "Haut"
- tft.drawLine(27, 305, 22, 293, BLACK);
- tft.fillCircle(460, 300, 20, WHITE); // Dessine la touche
- tft.drawCircle(460, 300, 22, WHITE);
- tft.drawLine(455, 293, 460, 305, BLACK); // Affiche la Touche "Bas"
- tft.drawLine(465, 293, 460, 305, BLACK);
- }
- if (PageCourante == 200 || PageCourante == 201 || PageCourante == 203 || PageCourante == 204) // **************************** // Si la Page sélectionnée est 200 ou 201 ou 203 ou 204
- {
- tft.fillCircle(20, 300, 20, WHITE); // Dessine la touche
- tft.drawCircle(20, 300, 22, WHITE);
- tft.drawLine(17, 305, 22, 293, BLACK); // Affiche la Touche "Haut"
- tft.drawLine(27, 305, 22, 293, BLACK);
- tft.fillCircle(460, 300, 20, WHITE); // Dessine la touche
- tft.drawCircle(460, 300, 22, WHITE);
- tft.drawLine(455, 293, 460, 305, BLACK); // Affiche la Touche "Bas"
- tft.drawLine(465, 293, 460, 305, BLACK);
- }
- if (PageCourante == 200 || PageCourante == 201 || PageCourante == 102 || PageCourante == 203 || PageCourante == 204 // ***** // Si la Page sélectionnée est 200 ou 201 ou 102 ou 203 ou 104 ou 501 ou 502 ou 204
- || PageCourante == 501 || PageCourante == 502)
- {
- tft.setTextColor(BLACK, WHITE); // Définit la couleur
- tft.fillCircle(22, 214, 20, WHITE); // Dessine le bouton "OK"
- tft.drawCircle(22, 214, 22, WHITE);
- tft.setCursor(12, 208); LectureMemoireFlash(message41); // Posiitionne et Affiche "OK"
- tft.fillCircle(460, 214, 20, WHITE); // Dessine le bouton "X"
- tft.drawCircle(460, 214, 22, WHITE);
- tft.setCursor(455, 208); tft.print('X'); // Positionne et Affiche "X"
- }
- tft.setTextColor(WHITE); // Définit la couleur
- tft.fillRoundRect(460, 0, 20, 20, 2, RED); // Dessine le bouton "X" sur la barre des titres pour sortir d'une Page vers la Page 0
- tft.setCursor(464, 2); tft.print('X'); // Positionne et Affiche "X"
- } // Positionne et Affiche "X"
- //**************************************************************************************************************************************************************************
- //*** Fonction de réinitialisation des variable pour forcer l'affichage des Pages ******************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionReinitialisationVariablesAffichage ()
- {
- if (PageCourante == 0) // *************************************************************************************************** // Si la Page courante 0 est sélectionnée => Page principale
- {
- LastMins = -1; // Réinitialise la dernière minute courante
- LastJour = -1; // Réinitialise le dernier jour du mois courant
- LastTemperatureCourante = -100.0; // Réinitialise la dernière température courante
- LastTauxHumiditeCourant = -1.0; // Réinitialise le dernier taux d'humidité courant
- LastSeuilTemperatureJour = -100.0; // Réinitialise le dernier seuil de jour de la température
- LastSeuilTemperatureNuit = -100.0; // Réinitialise le dernier seuil de nuit de la température
- LastSeuilHumiditeJour = -1.0; // Réinitialise le dernier seuil de jour du taux d'humidité
- LastSeuilHumiditeNuit = -1.0; // Réinitialise le dernier seuil de nuit du taux d'humidité
- LastEtatVentilateur = !EtatVentilateur; // Réinitialise l'indicateur du dernier état du fonctionnement du ventilateur
- LastEtatBrumisateur = !EtatBrumisateur; // Réinitialise l'indicateur du dernier état du fonctionnement du brumisateur
- LastEtatEclairage = !EtatEclairage; // Réinitialise l'indicateur du dernier état du fonctionnement de l'aiclairage
- LastModeJourSeuilTemperature = -1; // Réinitialise le dernier indicateur du mode jour pour les seuils de la température
- LastModeJourSeuilHumidite = -1; // Réinitialise le dernier indicateur du mode jour pour les seuils du taux d'humidité
- tempoPression = 0; // Réinitialise la temporisation entre deux pressions sur l'écran tactile TFT
- if (!EcranTFTONTemporaire) {t1DebutTempoSortieAutoMenus = 0;} // Réinitialise la temporisation de sortie automatique des menus
- }
- else if (PageCourante == 100) // ******************************************************************************************** // Si la Page courante 100 est sélectionnée => Page réglage du seuil de jour de la température
- {
- LastSeuilTemperatureJourReglage = -100.0; // Réinitialise le dernier seuil de jour de réglage de la température
- LastModeManuelTemperatureReglage = -1; // Réinitialise le dernier indicateur de réglage du mode manuel de la température
- }
- else if (PageCourante == 200) // ******************************************************************************************** // Si la Page courante 200 est sélectionnée => Page réglage du seuil de nuit de la température
- {
- LastSeuilTemperatureNuitReglage = -100.0; // Réinitialise le dernier seuil de nuit de réglage de la température
- LastModeManuelTemperatureReglage = -1; // Réinitialise le dernier indicateur de réglage du mode manuel de la température
- }
- else if (PageCourante == 101) // ******************************************************************************************** // Si la Page courante 101 est sélectionnée => Page réglage du seuil de jour du taux d'humidité
- {
- LastSeuilHumiditeJourReglage = -1.0; // Réinitialise le dernier seuil de jour de réglage du taux d'humidité
- LastModeManuelHumiditeReglage = -1; // Réinitialise le dernier indicateur de réglage du mode manuel du taux d'humidité
- }
- else if (PageCourante == 201) // ******************************************************************************************** // Si la Page courante 201 est sélectionnée => Page réglage du seuil de nuit du taux d'humidité
- {
- LastSeuilHumiditeNuitReglage = -1.0; // Réinitialise le dernier seuil de jour de réglage du taux d'humidité
- LastModeManuelHumiditeReglage = -1; // Réinitialise le dernier indicateur de réglage du mode manuel du taux d'humidité
- }
- else if (PageCourante == 102) // ******************************************************************************************** // Si la Page courante 102 est sélectionnée => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- {
- LastHrsDepartSeuilsModeJourReglage = -1; // Réinitialise les dernières heures départ de réglage seuils mode jour
- LastMinsDepartSeuilsModeJourReglage = -1; // Réinitialise les dernières minutes départ de réglage seuils mode jour
- LastHrsDepartSeuilsModeNuitReglage = -1; // Réinitialise les dernières heures départ de réglage seuils mode nuit
- LastMinsDepartSeuilsModeNuitReglage = -1; // Réinitialise les dernières minutes départ de réglage seuils mode nuit
- LastMins = -1; // Réinitialise les dernières minutes courante
- }
- else if (PageCourante == 103) // ******************************************************************************************** // Si la Page courante 103 est sélectionnée => Page réglage du programmateur d'éclairage
- {
- LastHrsDepartProgHoraireEclairageReglage = -1; // Réinitialise les dernière heures de départ de réglage du programmateur horaire de l'éclairage
- LastMinsDepartProgHoraireEclairageReglage = -1; // Réinitialise les dernières minutes de départ de réglage du programmateur horaire de l'éclairage
- LastHrsArretProgHoraireEclairageReglage = -1; // Réinitialise les dernières heures d'arrêt de réglage du programmateur horaire de l'éclairage
- LastMinsArretProgHoraireEclairageReglage = -1; // Réinitialise les dernières minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- LastModeProgHoraireEclairageReglage = -1; // Réinitialise le dernier indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- for (int i = 0; i < 7; i++) // Réinitialise la dernière itération de réglage du mode du programmateur horaire de l'éclairage
- {
- LastIterationProgHoraireEclairageReglage[i] = !IterationProgHoraireEclairageReglage[i];
- }
- tempoPression = 0; // Réinitialise la temporisation entre deux pressions sur l'écran tactile TFT
- }
- else if (PageCourante == 203) // ******************************************************************************************** // Si la Page courante 203 est sélectionnée => Page réglage du programmateur horaire d'éclairage
- {
- LastHrsDepartProgHoraireEclairageReglage = -1; // Réinitialise les dernière heures de départ de réglage du programmateur horaire de l'éclairage
- LastMinsDepartProgHoraireEclairageReglage = -1; // Réinitialise les dernières minutes de départ de réglage du programmateur horaire de l'éclairage
- LastHrsArretProgHoraireEclairageReglage = -1; // Réinitialise les dernières heures d'arrêt de réglage du programmateur horaire de l'éclairage
- LastMinsArretProgHoraireEclairageReglage = -1; // Réinitialise les dernières minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- LastMins = -1; // Réinitialise les dernières minutes courante
- }
- else if (PageCourante == 104) // ******************************************************************************************** // Si la Page courante 104 est sélectionnée => Page réglage du programmateur horaire des repas
- {
- LastHrsDepart1ProgHoraireRepasReglage = -1; // Réinitialise les dernières heures de départ1 de réglage du programmateur horaire des repas
- LastMinsDepart1ProgHoraireRepasReglage = -1; // Réinitialise les dernières minutes de départ1 de réglage du programmateur horaire des repas
- LastHrsDepart2ProgHoraireRepasReglage = -1; // Réinitialise les dernières heures de départ2 de réglage du programmateur horaire des repas
- LastMinsDepart2ProgHoraireRepasReglage = -1; // Réinitialise les dernières minutes de départ2 de réglage du programmateur horaire des repas
- LastMins = -1; // Réinitialise les dernières minutes courante
- }
- else if (PageCourante == 204) // ******************************************************************************************** // Si la Page courante 204 est sélectionnée => Page réglage du programmateur horaire des repas
- {
- LastModeProgHoraireRepasReglage = -1; // Réinitialise le dernier indicateur de réglage du mode de fonctionnement du programmateur horaire repas
- for (int i = 0; i < 7; i++) // Réinitialise la dernière itération de réglage du mode du programmateur horaire repas
- {
- LastIterationProgHoraireRepasReglage[i] = !IterationProgHoraireRepasReglage[i];
- }
- tempoPression = 0; // Réinitialise la temporisation entre deux pressions sur l'écran tactile TFT
- }
- else if (PageCourante == 500) // ******************************************************************************************** // Si la Page courante 500 est sélectionnée => Page mélodie repas
- {
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- }
- else if (PageCourante == 501) // ******************************************************************************************** // Si la Page courante 501 est sélectionnée => Réglage de l'heure courante
- {
- LastHrsReglage = -1; // Réinitialise les dernières heures de réglage
- LastMinsReglage = -1; // Réinitialise les dernières minutes de réglage
- }
- else if (PageCourante == 502) // ******************************************************************************************** // Si la Page courante 502 est sélectionnée => Réglage de la date courante
- {
- LastJourSemaine = -1; // Réinitialise le dernier jour de la semaine
- LastJourReglage = -1; // Réinitialise le dernier jour de réglage
- LastMoisReglage = -1; // Réinitialise le dernier Mois de réglage
- LastAnneeReglage = -1; // Réinitialise la dernière année de réglage
- tempoPression = 0; // Réinitialise la temporisation entre deux pressions sur l'écran tactile TFT
- }
- else if (PageCourante == 105) // ******************************************************************************************** // Si la Page courante 105 est sélectionnée => Menu setup
- {
- LastetatBoutonReglagesDefaut = !etatBoutonReglagesDefaut; // Réinitialise le dernier l'état du bouton "REGLAGES PAR DEFAUT"
- LastetatBoutonReglagesModeEco = -1; // Réinitialise le dernier du bouton "MODE ECO ON/OFF"
- LastetatBoutonReglagesModeMute = -1; // Réinitialise le dernier état du bouton "MODE MUTE ON/OFF"
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- tempoPression = 0; // Réinitialise la temporisation entre deux pressions sur l'écran tactile TFT
- }
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction Gestion Tactile de l'écran TFT ******************************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void GestionTactile ()
- {
- uint16_t xpos, ypos; // Coordonnées de l'écran TFT
- tp = ts.getPoint(); // Lit les coordonnées de pression sur l'écran TFT
- pinMode(XM, OUTPUT); // Reconfigure les broches en sorties pour la fonction tactile
- pinMode(YP, OUTPUT);
- pinMode(XP, OUTPUT);
- pinMode(YM, OUTPUT);
- //Serial.print(tp.y); Serial.print(' ');
- //Serial.print(tp.x); Serial.print(' '); Serial.println(tp.z);
- if (tp.z > PressionMin && tp.z < PressionMax) // **************************************************************************** // Si le niveau de pression sur l'écran tactile est correct
- {
- xpos = map(tp.y, TS_LEFT, TS_RT, tft.width(), 0); // Convertit les coordonnées annalogiques tp.x et tp.y
- ypos = map(tp.x, TS_TOP, TS_BOT, tft.height(), 0);
- Serial.print(xpos); Serial.print(' '); Serial.println(ypos); // Débug
- //**************************************************************************************************************************************************************************
- if (ModeEco && EcranTFTOFF) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si l'indicateur du mode Eco est activé et Si l'indicateur de l'état de l'écran TFT est activé
- {
- if (xpos > 0 && xpos < 440 && ypos > 9 && ypos < 246) // ---------------------------------------------------------------- // Pression sur l'écran TFT
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- EcranTFTONTemporaire = true; // Active l'indicateur temporaire ON de l'écran TFT
- EcranTFTOFF = false; // Désactive l'indicateur de l'état de l'écran TFT
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- LastPageCourante = -1; // Sélectionne la Page -1 => Page inexistante
- etatReactivationAffichagePages = true; // Active l'indicateur de réactivation d'affichage des Pages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 0) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 0 est sélectionnée => Page Principale
- {
- if (millis() - tempoPression >= 1000ul && tempoPression != 0 || tempoPression == 0) // ---------------------------------- // Si la temporisation entre deux pressions est écoulée ou Si elle est égale à 0
- {
- if (xpos > 370 && xpos < 480 && ypos > 10 && ypos < 20) // ............................................................ // Pression sur le bouton "VENTILATEUR"
- {
- if (ModeManuelTemperature) // Si l'indicateur du mode manuel de la température est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- EtatVentilateur = !EtatVentilateur; // Inverse l'indicateur d'état du fonctionnement du ventilateur
- LastEtatVentilateur = !EtatVentilateur; // Inverse l'indicateur du dernier état du fonctionnement du ventilateur
- digitalWrite(BrocheLedRougeTemoinVentilateur, EtatVentilateur); // Active ou désactive la led témoin de fonctionnement du ventilateur
- digitalWrite(BrocheRelaisVentilateur, EtatVentilateur); // Active ou désactive le relais du ventilateur
- }
- }
- else if (xpos > 225 && xpos < 302 && ypos > 8 && ypos < 20) // ..................................................... // Pression sur le bouton "BRUMISATEUR"
- {
- if (ModeManuelHumidite) // Si l'indicateur du mode manuel du taux d'humidité est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- EtatBrumisateur = !EtatBrumisateur; // Active l'indicateur d'état du fonctionnement du brumisateur
- LastEtatBrumisateur = !EtatBrumisateur; // Inverse l'indicateur du dernier état du fonctionnement du brumisateur
- digitalWrite(BrocheLedVerteTemoinBrumisateur, EtatBrumisateur); // Active ou désactive la led témoin de fonctionnement du brumisateur
- digitalWrite(BrocheRelaisBrumisateur, EtatBrumisateur); // Active ou désactive le relais du brumisateur
- }
- }
- else if (xpos > 25 && xpos < 60 && ypos > 4 && ypos < 22) // ..................................................... // Pression sur le bouton "NEONS"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- EtatEclairage = !EtatEclairage; // Inverse l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Active ou désactive la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage); // Active ou désactive le relais de l'éclairage
- }
- else if (xpos > 37 && xpos < 56 && ypos > 299 && ypos < 310) // ....................................................... // Pression sur le bouton "MENUS"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 280 && xpos < 470 && ypos > 210 && ypos < 250) // ......................................................... // Pression sur l'heure courante
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 501; // Sélectionne la Page 501 => Réglage de l'heure courante
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 260 && ypos > 210 && ypos < 250) // ....................................................... // Pression sur la date courante
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 502; // Sélectionne la Page 502 => Réglage de la date courante
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- tempoPression = millis(); // (Dé)Redémarre la temporisation entre deux pressions
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 100) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 100 est sélectionnée => Page réglage du seuil de jour de la température
- {
- if (xpos > 395 && xpos < 402 && ypos > 140 && ypos < 158) // -------------------------------------------------------------- // Pression sur l'icone "-"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilTemperatureJourReglage = SeuilTemperatureJourReglage - 0.5; // Modifie le seuil de jour de réglage de la température
- if (SeuilTemperatureJourReglage <= SeuilMinTemperatureJourReglage) // ................................................. // Si le seuil de jour de réglage de la température est inférieur ou égale au le seuil de jour min de réglage de la température
- {
- SeuilTemperatureJourReglage = SeuilMinTemperatureJourReglage; // Borne le seuil de jour de réglage de la température
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 50 && xpos < 60 && ypos > 140 && ypos < 150) // ------------------------------------------------------- // Pression sur l'icone "+"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilTemperatureJourReglage = SeuilTemperatureJourReglage + 0.5; // Modifie le seuil de jour de réglage de la température
- if (SeuilTemperatureJourReglage >= SeuilMaxTemperatureJourReglage) // ................................................. // Si le seuil de jour de réglage de la température est supérieur ou égale au le seuil de jour max de réglage de la température
- {
- SeuilTemperatureJourReglage = SeuilMaxTemperatureJourReglage; // Borne le seuil de jour de réglage de la température
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 63 && xpos < 132 && ypos > 0 && ypos < 40) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeManuelTemperatureReglage) // .................................................................................. // Si l'indicateur de réglage du mode manuel est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelTemperatureReglage = false; // Désactive l'indicateur de réglage du mode manuel
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- else if (xpos > 390 && xpos < 420 && ypos > 10 && ypos < 30) // -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeManuelTemperatureReglage) // ................................................................................. // Si l'indicateur de réglage du mode manuel est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelTemperatureReglage = true; // Active l'indicateur de réglage du mode manuel
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) // ------------------------------------------------------------ // Pression sur le titre de la Page 100 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 101; // Sélectionne la Page 101 => Réglage du seuil de jour du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 105; // Sélectionne la Page 105 => Réglage menu setup
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 200; // Sélectionne la Page 200 => Réglage du seuil de nuit de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 200; // Sélectionne la Page 200 => Réglage du seuil de nuit de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 200) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 200 est sélectionnée => Page réglage du seuil de nuit de la température
- {
- if (xpos > 395 && xpos < 402 && ypos > 140 && ypos < 158) // -------------------------------------------------------------- // Pression sur l'icone "-"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilTemperatureNuitReglage = SeuilTemperatureNuitReglage - 0.5; // Modifie le seuil de nuit de réglage de la température
- if (SeuilTemperatureNuitReglage <= SeuilMinTemperatureNuitReglage) // ................................................. // Si le seuil de nuit de réglage de la température est inférieur ou égale au seuil de nuit min de réglage de la température
- {
- SeuilTemperatureNuitReglage = SeuilMinTemperatureNuitReglage; // Borne le seuil de nuit de réglage de la température
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 50 && xpos < 60 && ypos > 140 && ypos < 150) // ------------------------------------------------------- // Pression sur l'icone "+"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilTemperatureNuitReglage = SeuilTemperatureNuitReglage + 0.5; // Modifie le seuil de nuit de réglage de la température
- if (SeuilTemperatureNuitReglage >= SeuilMaxTemperatureNuitReglage) // ................................................. // Si le seuil de nuit de réglage de la température est supérieur ou égale au seuil de nuit max de réglage de la température
- {
- SeuilTemperatureNuitReglage = SeuilMaxTemperatureNuitReglage; // Borne le seuil de nuit de réglage de la température
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 63 && xpos < 132 && ypos > 0 && ypos < 40) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeManuelTemperatureReglage) // .................................................................................. // Si l'indicateur de réglage du mode manuel est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelTemperatureReglage = false; // Désactive l'indicateur de réglage du mode manuel
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 390 && xpos < 420 && ypos > 10 && ypos < 30) // -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeManuelTemperatureReglage) // ................................................................................. // Si l'indicateur de réglage du mode manuel est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelTemperatureReglage = true; // Active l'indicateur de réglage du mode manuel
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) // ............................................................ // Pression sur le titre de la Page 100 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilTemperatureJour = SeuilTemperatureJourReglage; // Transfère le seuil de jour de réglage de la température dans le seuil de jour de la température
- SeuilTemperatureNuit = SeuilTemperatureNuitReglage; // Transfère le seuil de nuit de réglage de la température dans le seuil de nuit de la température
- ModeManuelTemperature = ModeManuelTemperatureReglage; // Transfère l'indicateur de réglage du mode manuel de la température dans l'indicateur du mode manuel de la température
- EEPROM.put(0, SeuilTemperatureJour); // Mémorise le seuil de jour de la température
- EEPROM.put(16, SeuilTemperatureNuit); // Mémorise le seuil de nuit de la température
- EEPROM.put(8, ModeManuelTemperature); // Mémorise l'indicateur du mode manuel de la température
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 101) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 101 est sélectionnée => Page réglage du seuil de jour du taux d'humidité
- {
- if (xpos > 395 && xpos < 402 && ypos > 140 && ypos < 158) // -------------------------------------------------------------- // Pression sur l'icone "-"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilHumiditeJourReglage = SeuilHumiditeJourReglage - 0.5; // Modifie le seuil de jour de réglage du taux d'humidité
- if (SeuilHumiditeJourReglage <= SeuilMinHumiditeJourReglage) // ....................................................... // Si le seuil de jour de réglage du taux d'humidité est inférieur ou égale au le seuil de jour min de réglage du taux d'humidité
- {
- SeuilHumiditeJourReglage = SeuilMinHumiditeJourReglage; // Borne le seuil de jour de réglage du taux d'humidité
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 50 && xpos < 60 && ypos > 140 && ypos < 150) // ------------------------------------------------------- // Pression sur l'icone "+"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilHumiditeJourReglage = SeuilHumiditeJourReglage + 0.5; // Modifie le seuil de jour de réglage du taux d'humidité
- if (SeuilHumiditeJourReglage >= SeuilMaxHumiditeJourReglage) // ....................................................... // Si le seuil de jour de réglage du taux d'humidité est supérieur ou égale au le seuil de jour max de réglage du taux d'humidité
- {
- SeuilHumiditeJourReglage = SeuilMaxHumiditeJourReglage; // Borne le seuil de jour de réglage du taux d'humidité
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 63 && xpos < 132 && ypos > 0 && ypos < 40) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeManuelHumiditeReglage) // ..................................................................................... // Si l'indicateur de réglage du mode manuel est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelHumiditeReglage = false; // Désactive l'indicateur de réglage du mode manuel
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- else if (xpos > 390 && xpos < 420 && ypos > 10 && ypos < 30)// -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeManuelHumiditeReglage) // .................................................................................... // Si l'indicateur de réglage du mode manuel est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelHumiditeReglage = true; // Active l'indicateur de réglage du mode manuel
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) // ------------------------------------------------------------ // Pression sur le titre de la Page 101 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 102; // Sélectionne la Page 102 => Réglage des heures des seuils jour/nuit
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 201; // Sélectionne la Page 201 => Réglage du seuil de nuit du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 201; // Sélectionne la Page 201 => Réglage du seuil de nuit du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 201) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 201 est sélectionnée => Page réglage du seuil de nuit du taux d'humidité
- {
- if (xpos > 395 && xpos < 402 && ypos > 140 && ypos < 158) // -------------------------------------------------------------- // Pression sur l'icone "-"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilHumiditeNuitReglage = SeuilHumiditeNuitReglage - 0.5; // Modifie le seuil de nuit de réglage du taux d'humidité
- if (SeuilHumiditeNuitReglage <= SeuilMinHumiditeNuitReglage) // ....................................................... // Si le seuil de nuit de réglage du taux d'humidité est inférieur ou égale au seuil de nuit min de réglage du taux d'humidité
- {
- SeuilHumiditeNuitReglage = SeuilMinHumiditeNuitReglage; // Borne le seuil de nuit de réglage du taux d'humidité
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 50 && xpos < 60 && ypos > 140 && ypos < 150) // ------------------------------------------------------- // Pression sur l'icone "+"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilHumiditeNuitReglage = SeuilHumiditeNuitReglage + 0.5; // Modifie le seuil de nuit de réglage du taux d'humidité
- if (SeuilHumiditeNuitReglage >= SeuilMaxHumiditeNuitReglage) // ....................................................... // Si le seuil de nuit de réglage de la température est supérieur ou égale au seuil de nuit max de réglage du taux d'humidité
- {
- SeuilHumiditeNuitReglage = SeuilMaxHumiditeNuitReglage; // Borne le seuil de nuit de réglage du taux d'humidité
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 63 && xpos < 132 && ypos > 0 && ypos < 40) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeManuelHumiditeReglage) // ..................................................................................... // Si l'indicateur de réglage du mode manuel est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelHumiditeReglage = false; // Désactive l'indicateur de réglage du mode manuel
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 390 && xpos < 420 && ypos > 10 && ypos < 30) // -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeManuelHumiditeReglage) // .................................................................................... // Si l'indicateur de réglage du mode manuel est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeManuelHumiditeReglage = true; // Active l'indicateur de réglage du mode manuel
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325)// ------------------------------------------------------------ // Pression sur le titre de la Page 201 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 101; // Sélectionne la Page 101 => Réglage du seuil de jour du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 101; // Sélectionne la Page 101 => Réglage du seuil de jour du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 101; // Sélectionne la Page 101 => Réglage du seuil de jour du taux d'humidité
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- SeuilHumiditeJour = SeuilHumiditeJourReglage; // Transfère le seuil de jour de réglage du taux d'humidité dans le seuil de jour du taux d'humidité
- SeuilHumiditeNuit = SeuilHumiditeNuitReglage; // Transfère le seuil de nuit de réglage du taux d'humidité dans le seuil de nuit du taux d'humidité
- ModeManuelHumidite = ModeManuelHumiditeReglage; // Transfère l'indicateur de réglage du mode manuel du taux d'humidité dans l'indicateur du mode manuel du taux d'humidité
- EEPROM.put(4, SeuilHumiditeJour); // Mémorise le seuil de jour du taux d'humidité
- EEPROM.put(20, SeuilHumiditeNuit); // Mémorise le seuil de nuit du taux d'humidité
- EEPROM.put(12, ModeManuelHumidite); // Mémorise l'indicateur du mode manuel du taux d'humidité
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 102) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 102 est sélectionnée => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- {
- if (xpos > 405 && xpos < 420 && ypos > 173 && ypos < 185) // -------------------------------------------------------------- // Pression sur l'icone "+" Départ jour
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepartSeuilsModeJourReglage++; if (HrsDepartSeuilsModeJourReglage > 23) {HrsDepartSeuilsModeJourReglage = 0;} // Modifie et Borne les heures départ de réglage seuils mode jour
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 350 && xpos < 360 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ jour
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsDepartSeuilsModeJourReglage++; if (MinsDepartSeuilsModeJourReglage > 59) {MinsDepartSeuilsModeJourReglage = 0;} // Modifie et Borne les minutes départ de réglage seuils mode nuit
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 140 && xpos < 150 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ nuit
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepartSeuilsModeNuitReglage++; if (HrsDepartSeuilsModeNuitReglage > 23) {HrsDepartSeuilsModeNuitReglage = 0;} // Modifie et Borne les heures départ de réglage seuils mode nuit
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 90 && xpos < 100 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ nuit
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsDepartSeuilsModeNuitReglage++; if (MinsDepartSeuilsModeNuitReglage > 59) {MinsDepartSeuilsModeNuitReglage = 0;} // Modifie et Borne les minutes départ de réglage seuils mode nuit
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 102 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 103; // Sélectionne la Page 103 => Réglage du programmateur horaire d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 101; // Sélectionne la Page 101 => Réglage du seuil de jour du taux d'humidité
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 102; // Sélectionne la Page 102 => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- if (HrsDepartSeuilsModeJourReglage == HrsDepartSeuilsModeNuitReglage // ............................................... // Si les heures départ de réglage seuils mode jour sont égales aux heures départ de réglage seuils mode nuit
- && MinsDepartSeuilsModeJourReglage == MinsDepartSeuilsModeNuitReglage)
- {
- FonctionPageMessagesErreur(); // Appelle la fonction d'affichage des messages d'erreur
- PageCourante = 102; // Sélectionne la Page 102 => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- }
- else // ............................................................................................................... // Validation des réglages
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepartSeuilsModeJour = HrsDepartSeuilsModeJourReglage; // Transfère les heures départ de réglage seuils mode jour dans les heures départ seuils mode jour
- MinsDepartSeuilsModeJour = MinsDepartSeuilsModeJourReglage; // Transfère les minutes départ de réglage seuils mode jour dans les minutes départ seuils mode jour
- HrsDepartSeuilsModeNuit = HrsDepartSeuilsModeNuitReglage; // Transfère les heures départ de réglage seuils mode nuit dans les heures départ seuils mode nuit
- MinsDepartSeuilsModeNuit = MinsDepartSeuilsModeNuitReglage; // Transfère les minutes départ de réglage seuils mode nuit dans les minutes départ seuils mode nuit
- EEPROM.put(24, HrsDepartSeuilsModeJour); // Mémorise les heures départ seuils mode jour
- EEPROM.put(28, MinsDepartSeuilsModeJour); // Mémorise les minutes départ seuils mode jour
- EEPROM.put(32, HrsDepartSeuilsModeNuit); // Mémorise les heures départ seuils mode nuit
- EEPROM.put(36, MinsDepartSeuilsModeNuit); // Mémorise les minutes départ seuils mode nuit
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 103) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante 103 est sélectionnée => Page réglage du programmateur horaire d'éclairage
- {
- if (millis() - tempoPression >= 500ul && tempoPression != 0 || tempoPression == 0) // ----------------------------------- // Si la temporisation entre deux pressions est écoulée ou Si elle est égale à 0
- {
- if (xpos > 380 && xpos < 400 && ypos > 120 && ypos < 130) // ............................................................. // Pression sur le bouton "D"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[0] = !IterationProgHoraireEclairageReglage[0]; // Inverse l'itération 0 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 330 && xpos < 350 && ypos > 120 && ypos < 130) // ...................................................... // Pression sur le bouton "L"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[1] = !IterationProgHoraireEclairageReglage[1]; // Inverse l'itération 1 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 280 && xpos < 290 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "M"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[2] = !IterationProgHoraireEclairageReglage[2]; // Inverse l'itération 2 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 235 && xpos < 245 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "M"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[3] = !IterationProgHoraireEclairageReglage[3]; // Inverse l'itération 3 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 180 && xpos < 190 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "J"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[4] = !IterationProgHoraireEclairageReglage[4]; // Inverse l'itération 4 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 130 && xpos < 140 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "V"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[5] = !IterationProgHoraireEclairageReglage[5]; // Inverse l'itération 5 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 80 && xpos < 90 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "S"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireEclairageReglage[6] = !IterationProgHoraireEclairageReglage[6]; // Inverse l'itération 6 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- tempoPression = millis(); // (Dé)Redémarre la temporisation entre deux pressions
- }
- if (xpos > 150 && xpos < 160 && ypos > 200 && ypos < 290) // ------------------------------------------------------------- // Pression sur l'heure de départ ou d'arrêt
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 203; // Sélectionne la Page 203 => Réglage du programmateur d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 90 && xpos < 115 && ypos > 10 && ypos < 25) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeProgHoraireEclairageReglage) // ............................................................................... // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeProgHoraireEclairageReglage = false; // Désactive l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 380 && xpos < 400 && ypos > 10 && ypos < 25) // -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeProgHoraireEclairageReglage) // .............................................................................. // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeProgHoraireEclairageReglage = true; // Active l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) // ------------------------------------------------------------ // Pression sur le titre de la Page 103 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 102; // Sélectionne la Page 102 => Réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 203; // Sélectionne la Page 203 => Réglage du programmateur d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 203; // Sélectionne la Page 203 => Réglage du programmateur d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 203) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante 203 est sélectionnée => Page réglage du programmateur horaire d'éclairage
- {
- if (xpos > 405 && xpos < 420 && ypos > 173 && ypos < 185) // -------------------------------------------------------------- // Pression sur l'icone "+" Départ
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepartProgHoraireEclairageReglage++; // Modifie les heures de départ de réglage du programmateur horaire de l'éclairage
- if (HrsDepartProgHoraireEclairageReglage > 23) {HrsDepartProgHoraireEclairageReglage = 0;} // Borne les heures de départ de réglage du programmateur horaire de l'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 350 && xpos < 360 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsDepartProgHoraireEclairageReglage++; // Modifie les minutes de départ de réglage du programmateur horaire de l'éclairage
- if (MinsDepartProgHoraireEclairageReglage > 59) {MinsDepartProgHoraireEclairageReglage = 0;} // Borne les minutes de départ de réglage du programmateur horaire de l'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 140 && xpos < 150 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Arrêt
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsArretProgHoraireEclairageReglage++; // Modifie les heures d'arrêt de réglage du programmateur horaire de l'éclairage
- if (HrsArretProgHoraireEclairageReglage > 23) {HrsArretProgHoraireEclairageReglage = 0;} // Modifie les heures d'arrêt de réglage du programmateur horaire de l'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 90 && xpos < 100 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Arrêt
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsArretProgHoraireEclairageReglage++; // Modifie les minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- if (MinsArretProgHoraireEclairageReglage > 59) {MinsArretProgHoraireEclairageReglage = 0;} // Borne les minutes d'arrêt de réglage du programmateur horaire de l'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 203 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 103; // Sélectionne la Page 103 => Réglage du programmateur horaire d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 103; // Sélectionne la Page 103 => Réglage du programmateur horaire d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 103; // Sélectionne la Page 103 => Réglage du programmateur horaire d'éclairage
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110)// ------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- if (HrsDepartProgHoraireEclairageReglage == HrsArretProgHoraireEclairageReglage // .................................... // Si les heures de départ de réglage du programmateur horaire de l'éclairage sont égales aux heures d'arrêt de réglage du programmateur horaire de l'éclairage
- && MinsDepartProgHoraireEclairageReglage == MinsArretProgHoraireEclairageReglage)
- {
- FonctionPageMessagesErreur(); // Appelle la fonction d'affichage des messages d'erreur
- PageCourante = 203; // Sélectionne la Page 203 => Réglage du programmateur d'éclairage
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- }
- else // ............................................................................................................... // Validation des réglages
- {
- HrsDepartProgHoraireEclairage = HrsDepartProgHoraireEclairageReglage; // Transfère les heures de départ de réglage du programmateur horaire de l'éclairage dans les heures de départ du programmateur horaire de l'éclairage
- MinsDepartProgHoraireEclairage = MinsDepartProgHoraireEclairageReglage; // Transfère les minutes de départ de réglage du programmateur horaire de l'éclairage dans les minutes de départ du programmateur horaire de l'éclairage
- HrsArretProgHoraireEclairage = HrsArretProgHoraireEclairageReglage; // Transfère les heures d'arrêt de réglage du programmateur horaire de l'éclairage dans les heures d'arrêt du programmateur horaire de l'éclairage
- MinsArretProgHoraireEclairage = MinsArretProgHoraireEclairageReglage; // Transfère les minutes d'arrêt de réglage du programmateur horaire de l'éclairage dans les minutes d'arrêt du programmateur horaire de l'éclairage
- ModeProgHoraireEclairage = ModeProgHoraireEclairageReglage; // Transfère l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage dans l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage
- for (int i = 0; i < 7; i++) // Transfère l'itération de réglage du programmateur horaire de l'éclairage dans l'itération du programmateur horaire de l'éclairage
- {
- IterationProgHoraireEclairage[i] = IterationProgHoraireEclairageReglage[i];
- EEPROM.put(60 + i*4, IterationProgHoraireEclairage[i]); // Mémorise l'itération du programmateur horaire de l'éclairage
- delay(20); // Temporise 20ms
- }
- EEPROM.put(40, HrsDepartProgHoraireEclairage); // Mémorise les heures de départ du programmateur horaire de l'éclairage
- EEPROM.put(44, MinsDepartProgHoraireEclairage); // Mémorise les minutes de départ du programmateur horaire de l'éclairage
- EEPROM.put(48, HrsArretProgHoraireEclairage); // Mémorise les heures d'arrêt du programmateur horaire de l'éclairage
- EEPROM.put(52, MinsArretProgHoraireEclairage); // Mémorise les minutes d'arrêt du programmateur horaire de l'éclairage
- EEPROM.put(56, ModeProgHoraireEclairage); // Mémorise l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 104) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante 104 est sélectionnée => Page réglage du programmateur horaire des repas
- {
- if (xpos > 405 && xpos < 420 && ypos > 173 && ypos < 185) // -------------------------------------------------------------- // Pression sur l'icone "+" Départ repas 1
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepart1ProgHoraireRepasReglage++; // Modifie les heures de départ1 de réglage du programmateur horaire des repas
- if (HrsDepart1ProgHoraireRepasReglage > 23) {HrsDepart1ProgHoraireRepasReglage = 0;} // Borne les heures de départ1 de réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 350 && xpos < 360 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ repas 1
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsDepart1ProgHoraireRepasReglage++; // Modifie les minutes de départ1 de réglage du programmateur horaire des repas
- if (MinsDepart1ProgHoraireRepasReglage > 59) {MinsDepart1ProgHoraireRepasReglage = 0;} // Modifie les minutes de départ1 de réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 140 && xpos < 150 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ repas 2
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepart2ProgHoraireRepasReglage++; // Modifie les heures de départ2 de réglage du programmateur horaire des repas
- if (HrsDepart2ProgHoraireRepasReglage > 23) {HrsDepart2ProgHoraireRepasReglage = 0;} // Borne les heures de départ2 de réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 90 && xpos < 100 && ypos > 173 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Départ repas 2
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsDepart2ProgHoraireRepasReglage++; // Modifie les minutes de départ2 de réglage du programmateur horaire des repas
- if (MinsDepart2ProgHoraireRepasReglage > 59) {MinsDepart2ProgHoraireRepasReglage = 0;} // Borne les minutes de départ2 de réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 104 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 105; // Sélectionne la Page 105 => Réglage menu setup
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 103; // Sélectionne la Page 103 => Réglage du programmateur horaire d'éclairage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 204; // Sélectionne la Page 204 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 204; // Sélectionne la Page 204 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- else if (PageCourante == 204) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante 204 est sélectionnée => Page réglage du programmateur horaire des repas
- {
- if (millis() - tempoPression >= 500ul && tempoPression != 0 || tempoPression == 0) // ----------------------------------- // Si la temporisation entre deux pressions est écoulée ou Si elle est égale à 0
- {
- if (xpos > 380 && xpos < 400 && ypos > 120 && ypos < 130) // ............................................................. // Pression sur le bouton "D"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[0] = !IterationProgHoraireRepasReglage[0]; // Inverse l'itération 0 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 330 && xpos < 350 && ypos > 120 && ypos < 130) // ...................................................... // Pression sur le bouton "L"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[1] = !IterationProgHoraireRepasReglage[1]; // Inverse l'itération 1 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 280 && xpos < 290 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "M"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[2] = !IterationProgHoraireRepasReglage[2]; // Inverse l'itération 2 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 235 && xpos < 245 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "M"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[3] = !IterationProgHoraireRepasReglage[3]; // Inverse l'itération 3 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 180 && xpos < 190 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "J"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[4] = !IterationProgHoraireRepasReglage[4]; // Inverse l'itération 4 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 130 && xpos < 140 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "V"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[5] = !IterationProgHoraireRepasReglage[5]; // Inverse l'itération 5 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 80 && xpos < 90 && ypos > 120 && ypos < 130) // ..................................................... // Pression sur le bouton "S"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- IterationProgHoraireRepasReglage[6] = !IterationProgHoraireRepasReglage[6]; // Inverse l'itération 6 de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- tempoPression = millis(); // (Dé)Redémarre la temporisation entre deux pressions
- }
- if (xpos > 150 && xpos < 160 && ypos > 200 && ypos < 290) // ------------------------------------------------------------- // Pression sur l'heure de départ ou d'arrêt
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 90 && xpos < 115 && ypos > 10 && ypos < 25) // ------------------------------------------------------- // Pression sur le bouton "OFF"
- {
- if (ModeProgHoraireRepasReglage) // ................................................................................... // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeProgHoraireRepasReglage = false; // Désactive l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if(xpos > 380 && xpos < 400 && ypos > 10 && ypos < 25) // -------------------------------------------------------- // Pression sur le bouton "ON"
- {
- if (!ModeProgHoraireRepasReglage) // .................................................................................. // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est désactivé
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeProgHoraireRepasReglage = true; // Active l'indicateur de réglage du mode de fonctionnement du programmateur horaire des repas
- }
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) // ------------------------------------------------------------ // Pression sur le titre de la Page 204 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if ((xpos > 460 && xpos < 480) && ypos > 0 && ypos < 20) // ------------------------------------------------------- // Pression sur le bouton "Haut"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 0 && xpos < 35 && ypos > 0 && ypos < 35) // ------------------------------------- // Pression sur le bouton "Bas"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Réglage du seuil de jour de la température
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- if (HrsDepart1ProgHoraireRepasReglage == HrsDepart2ProgHoraireRepasReglage // ......................................... // Si les heures de départ1 de réglage du programmateur horaire des repas sont égales aux heures de départ2 de réglage du programmateur horaire des repas
- && MinsDepart1ProgHoraireRepasReglage == MinsDepart2ProgHoraireRepasReglage)
- {
- FonctionPageMessagesErreur(); // Appelle la fonction d'affichage des messages d'erreur
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- LastPageCourante = -1; // Réinitialise la dernière Page courante
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- }
- else // ............................................................................................................... // Validation des réglages
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsDepart1ProgHoraireRepas = HrsDepart1ProgHoraireRepasReglage; // Transfère les heures de départ1 de réglage du programmateur horaire des repas dans les heures de départ1 du programmateur horaire des repas
- MinsDepart1ProgHoraireRepas = MinsDepart1ProgHoraireRepasReglage; // Transfère les minutes de départ1 de réglage du programmateur horaire des repas dans les minutes de départ1 du programmateur horaire des repas
- HrsDepart2ProgHoraireRepas = HrsDepart2ProgHoraireRepasReglage; // Transfère les heures de départ2 de réglage du programmateur horaire des repas dans les heures de départ2 du programmateur horaire des repas
- MinsDepart2ProgHoraireRepas = MinsDepart2ProgHoraireRepasReglage; // Transfère les minutes de départ2 de réglage du programmateur horaire des repas dans les Minutes de départ2 du programmateur horaire des repas
- ModeProgHoraireRepas = ModeProgHoraireRepasReglage; // Transfère l'indicateur de réglage du mode de fonctionnement du programmateur horaire repas dans l'indicateur du mode de fonctionnement du programmateur horaire des repas
- for (int i = 0; i < 7; i++) // Transfère l'itération de réglage du programmateur horaire Repas dans l'itération du programmateur horaire des repas
- {
- IterationProgHoraireRepas[i] = IterationProgHoraireRepasReglage[i];
- EEPROM.put(116 + i*4, IterationProgHoraireRepas[i]); // Mémorise l'itération du programmateur horaire des repas
- }
- EEPROM.put(88,HrsDepart1ProgHoraireRepas); // Mémorise les heures de départ1 du programmateur horaire des repas
- EEPROM.put(92,MinsDepart1ProgHoraireRepas); // Mémorise les minutes de départ1 du programmateur horaire des repas
- EEPROM.put(96,HrsDepart2ProgHoraireRepas); // Mémorise les heures de départ2 du programmateur horaire des repas
- EEPROM.put(100,MinsDepart2ProgHoraireRepas); // Mémorise les minutes de départ2 du programmateur horaire des repas
- EEPROM.put(112, ModeProgHoraireRepas); // Mémorise l'indicateur du mode de fonctionnement du programmateur horaire des repas
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 500) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 500 est sélectionnée => Page mélodie repas
- {
- if (xpos > 260 && xpos < 270 && ypos > 100 && ypos < 110) // ------------------------------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 501) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 501 est sélectionnée => Réglage de l'heure courante
- {
- if (xpos > 405 && xpos < 415 && ypos > 175 && ypos < 185) // -------------------------------------------------------------- // Pression sur l'icone "-" Hrs courantes
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsReglage--; if (HrsReglage < 0) {HrsReglage = 23;} // Modifie et Borne les heures de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 335 && xpos < 350 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Hrs courantes
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- HrsReglage++; if (HrsReglage > 23) {HrsReglage = 0;} // Modifie et Borne les heures de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 180 && xpos < 190 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "-" Mins courantes
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsReglage--; if (MinsReglage < 0) {MinsReglage = 59;} // Modifie et Borne les minutes de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 108 && xpos < 116 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur l'icone "+" Mins courantes
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MinsReglage++; if (MinsReglage > 59) {MinsReglage = 0;} // Modifie et Borne les minutes de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- Hrs = HrsReglage; // Transfère les heures de réglage dans les heures courantes
- Mins = MinsReglage; // Transfère les minutes de réglage dans les minutes courantes
- rtc.adjust(DateTime(Annee, Mois, Jour, Hrs, Mins, Secs)); // Réglage Heure / Date
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 501 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 502) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Page courante 501 est sélectionnée => Réglage de la date courante
- {
- if (millis() - tempoPression >= 100ul && tempoPression != 0 || tempoPression == 0) // ----------------------------------- // Si la temporisation entre deux pressions est écoulée ou Si elle est égale à 0
- {
- if (xpos > 270 && xpos < 278 && ypos > 210 && ypos < 220) // .......................................................... // Pression sur l'icone "-" Jour
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- JourReglage--; if (JourReglage < 1) {JourReglage = 31;} // Modifie le jour de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 100 && xpos < 110 && ypos > 205 && ypos < 213) // ..................................................... // Pression sur l'icone "+" Jour
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- JourReglage++; if (JourReglage > 31) {JourReglage = 1;} // Modifie le jour de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 270 && xpos < 278 && ypos > 151 && ypos < 165) // ..................................................... // Pression sur l'icone "-" Mois
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MoisReglage--; if (MoisReglage < 1) {MoisReglage = 12;} // Modifie le mois de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 100 && xpos < 110 && ypos > 150 && ypos < 160) // ..................................................... // Pression sur l'icone "+" Mois
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- MoisReglage++; if (MoisReglage > 12) {MoisReglage = 1;} // Modifie le mois de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- tempoPression = millis(); // (Dé)Redémarre la temporisation entre deux pressions
- }
- if (xpos > 270 && xpos < 278 && ypos > 95 && ypos < 105) // ------------------------------------------------------------ // Pression sur l'icone "-" Année
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- AnneeReglage--; if (AnneeReglage < 2000) {AnneeReglage = 2099;} // Modifie l'année de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 100 && xpos < 110 && ypos > 94 && ypos < 100) // ------------------------------------------------------- // Pression sur l'icone "+" Mois
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- AnneeReglage++; if (AnneeReglage > 2099) {AnneeReglage = 2000;} // Modifie l'année de réglage
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 450 && xpos < 65510) && ypos > 95 && ypos < 110) // ------------------------------------ // Pression sur l'icone "OK"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- Jour = JourReglage; // Transfère le jour de réglage dans le jour de la date courante
- Mois = MoisReglage; // Transfère le mois de réglage dans le mois de la date courante
- Annee = AnneeReglage; // Transfère l'année de réglage dans l'année de la date courante
- rtc.adjust(DateTime(Annee, Mois, Jour, Hrs, Mins, Secs)); // Réglage Heure / Date
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- }
- else if (xpos > 20 && xpos < 40 && ypos > 95 && ypos < 110) // ------------------------------------------------------- // Pression sur l'icone "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- FonctionPageAffichageAnnulationReglages(); // Appelle la fonction d'affichage annulation réglages
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 501 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- }
- //**************************************************************************************************************************************************************************
- else if (PageCourante == 105) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si la Page courante 105 est sélectionnée => Page menu setup
- {
- if (millis() - tempoPression >= 1000ul && tempoPression != 0 || tempoPression == 0) // ---------------------------------- // Si la temporisation entre deux pressions est écoulée ou Si elle est égale à 0
- {
- if (xpos > 240 && xpos < 260 && ypos > 190 && ypos < 210) // ........................................................... // Pression sur le bouton "MODE ECO ON/OFF"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeEco = !ModeEco; // Inverse l'indicateur du mode Eco
- if (ModeEco) // Si l'indicateur du mode Eco est activé
- {
- EcranTFTOFF = false; // Désactive l'indicateur de l'état de l'écran TFT
- EcranTFTONTemporaire = false; // Désactive l'indicateur temporaire ON de l'écran TFT
- }
- EEPROM.put(104, ModeEco); // Mémorise l'indicateur du mode Eco
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 240 && xpos < 255 && ypos > 135 && ypos < 165) // ...................................................... // Pression sur le bouton "MODE MUTE ON/OFF"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- ModeMute = !ModeMute; // Inverse l'indicateur du mode Mute
- EEPROM.put(108, ModeMute); // Mémorise l'indicateur du mode Mute
- FonctionPageAffichageValidationReglages(); // Appelle la fonction d'affichage validation réglages
- FonctionReinitialisationVariablesAffichage(); // Appelle la fonction de réinitialisation des variable pour forcer l'affichage de la Page
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- tempoPression = millis(); // (Dé)Redémarre la temporisation entre deux pressions
- }
- if (xpos > 225 && xpos < 245 && ypos > 250 && ypos < 265) // --------------------------------------------------------------- // Pression sur le bouton "REGLAGES PAR DEFAUT"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- etatBoutonReglagesDefaut = true; // Active l'état du bouton "REGLAGES PAR DEFAUT"
- FonctionRestaurationReglagesDefaut(); // Appelle la fonction de restauration des réglages par défaut
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if (xpos > 15 && xpos < 25 && ypos > 315 && ypos < 325) //------------------------------------------------------------- // Pression sur le titre de la Page 105 avec l'icône "X"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- else if (xpos > 25 && xpos < 35 && ypos > 175 && ypos < 185) // ------------------------------------------------------- // Pression sur le bouton ">"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 100; // Sélectionne la Page 100 => Réglage du seuil de jour de la température
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- else if ((xpos > 465 && xpos < 480) && ypos > 170 && ypos < 190) // ------------------------------------ // Pression sur le bouton "<"
- {
- Buzzer(3, 0, 1); // Active le buzzer 3ms
- PageCourante = 104; // Sélectionne la Page 104 => Page réglage du programmateur horaire des repas
- t1DebutTempoSortieAutoMenus = millis(); // (Re)Démarre la temporisation de sortie automatique des menus
- }
- }
- }
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction Page d'affichage de la Page mode eco ************************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionPageAffichageModeEcoActive ()
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 40, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 40, DARKRED);
- tft.drawLine(5, 38, 474, 38, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 39, 474, 39, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 200, 474, 200, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 201, 474, 201, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(GREEN); // Définit la couleur
- tft.setTextSize(5); // Définit la taille
- tft.setCursor(80, 65); LectureMemoireFlash(message48); // Positionne et Affiche "MODE ECO"
- tft.setCursor(110, 135); LectureMemoireFlash(message49); // Positionne et Affiche "ACTIVE"
- Buzzer(100, 50, 2); // Active le buzzer
- etatReactivationAffichagePages = false; // Désactive l'indicateur de réactivation d'affichage des Pages
- TempoReactivationAffichagePages = 3000ul; // Définit la durée avant la réactivation d'affichage des Pages
- t1DebutTempoReactivationAffichagePages = millis(); // Démarre la temporisation avant la réactivation d'affichage des Pages
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction d'affichage de la Page validation réglages ******************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionPageAffichageValidationReglages (){
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 40, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 40, DARKRED);
- tft.drawLine(5, 38, 474, 38, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 39, 474, 39, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 250, 474, 250, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 249, 474, 249, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(GREEN); // Définit la couleur
- tft.setTextSize(5); // Définit la taille
- tft.setCursor(100, 90); LectureMemoireFlash(message27); // Positionne et Affiche "VALIDATION"
- tft.setCursor(100, 160); LectureMemoireFlash(message28); // Positionne et Affiche "REGLAGES"
- Buzzer(100, 50, 2); // Active le buzzer
- etatReactivationAffichagePages = false; // Désactive l'indicateur de réactivation d'affichage des Pages
- TempoReactivationAffichagePages = 3000ul; // Définit la durée avant la réactivation d'affichage des Pages
- t1DebutTempoReactivationAffichagePages = millis(); // Démarre la temporisation avant la réactivation d'affichage des Pages
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction d'affichage de la Page annulation réglages ******************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionPageAffichageAnnulationReglages ()
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 40, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 40, DARKRED);
- tft.drawLine(5, 38, 474, 38, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 39, 474, 39, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 250, 474, 250, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 249, 474, 249, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(GREEN); // Définit la couleur
- tft.setTextSize(5); // Définit la taille
- tft.setCursor(100, 90); LectureMemoireFlash(message28); // Positionne et Affiche "REGLAGES"
- tft.setCursor(100, 160); LectureMemoireFlash(message54); // Positionne et Affiche "ANNULES"
- Buzzer(300, 0, 1); // Active le buzzer
- etatReactivationAffichagePages = false; // Désactive l'indicateur de réactivation d'affichage des Pages
- TempoReactivationAffichagePages = 3000ul; // Définit la durée avant la réactivation d'affichage des Pages
- t1DebutTempoReactivationAffichagePages = millis(); // Démarre la temporisation avant la réactivation d'affichage des Pages
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction Page d'affichage des messages d'erreur **********************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionPageMessagesErreur ()
- {
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 40, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 40, DARKRED);
- tft.drawLine(5, 70, 474, 70, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 71, 474, 71, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 206, 474, 206, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 207, 474, 207, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED); // Définit la couleur
- tft.setTextSize(5); // Définit la taille
- tft.setCursor(80, 20); LectureMemoireFlash(message55); // Positionne et Affiche "ATTENTION"
- tft.setTextColor(WHITE); // Définit la couleur
- tft.setTextSize(3); // Définit la taille
- if (PageCourante == 203) // ************************************************************************************************* // Si la Page 203 est sélectionnée => Page réglage du programmateur horaire d'éclairage
- {
- tft.setCursor(80, 96); LectureMemoireFlash(message56); // Positionne et Affiche "LES HEURES DE DEPART"
- tft.setCursor(120, 126); LectureMemoireFlash(message57); // Positionne et Affiche "SONT EGALES"
- tft.setCursor(80, 156); LectureMemoireFlash(message58); // Positionne et Affiche "AUX HEURES D'ARRET"
- }
- else if (PageCourante == 102) // ******************************************************************************************** // Si la Page 102 est sélectionnée => Page réglage des heures de départ jour et de départ nuit pour activer les seuils en fonction du mode jour/nuit
- {
- tft.setCursor(80, 96); LectureMemoireFlash(message59); // Positionne et Affiche "LES HEURES DE JOUR"
- tft.setCursor(120, 126); LectureMemoireFlash(message57); // Positionne et Affiche "SONT EGALES"
- tft.setCursor(80, 156); LectureMemoireFlash(message60); // Positionne et Affiche "AUX HEURES DE NUIT"
- }
- else if (PageCourante == 204) // ******************************************************************************************** // Si la Page 104 est sélectionnée => Page réglage du programmateur horaire des repas
- {
- tft.setCursor(80, 96); LectureMemoireFlash(message61); // Positionne et Affiche "LES HEURES DU REPAS 1"
- tft.setCursor(120, 126); LectureMemoireFlash(message57); // Positionne et Affiche "SONT EGALES"
- tft.setCursor(80, 156); LectureMemoireFlash(message62); // Positionne et Affiche "AUX HEURES DU REPAS 2"
- }
- Buzzer(300, 0, 1); // Active le buzzer
- etatReactivationAffichagePages = false; // Désactive l'indicateur de réactivation d'affichage des Pages
- TempoReactivationAffichagePages = 3000ul; // Définit la durée avant la réactivation d'affichage des Pages
- t1DebutTempoReactivationAffichagePages = millis(); // Démarre la temporisation avant la réactivation d'affichage des Pages
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction Page 500 Mélodie repas **************************************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionMelodieRepas (int numeroRepas)
- {
- int melody[] = { // Tableau des notes du thème de la mélodie Mario
- NOTE_E7, NOTE_E7, 0, NOTE_E7,
- 0, NOTE_C7, NOTE_E7, 0,
- NOTE_G7, 0, 0, 0,
- NOTE_G6, 0, 0, 0,
- NOTE_C7, 0, 0, NOTE_G6,
- 0, 0, NOTE_E6, 0,
- 0, NOTE_A6, 0, NOTE_B6,
- 0, NOTE_AS6, NOTE_A6, 0,
- NOTE_G6, NOTE_E7, NOTE_G7,
- NOTE_A7, 0, NOTE_F7, NOTE_G7,
- 0, NOTE_E7, 0, NOTE_C7,
- NOTE_D7, NOTE_B6, 0, 0,
- NOTE_C7, 0, 0, NOTE_G6,
- 0, 0, NOTE_E6, 0,
- 0, NOTE_A6, 0, NOTE_B6,
- 0, NOTE_AS6, NOTE_A6, 0,
- NOTE_G6, NOTE_E7, NOTE_G7,
- NOTE_A7, 0, NOTE_F7, NOTE_G7,
- 0, NOTE_E7, 0, NOTE_C7,
- NOTE_D7, NOTE_B6, 0, 0
- };
- int tempo[] = { // Tableau des tempo du thème de la mélodie Mario
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 9, 9, 9,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 9, 9, 9,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- 12, 12, 12, 12,
- };
- tft.fillScreen(BLACK); // Initialise la couleur du fond d'écran
- tft.drawRoundRect(0, 0, 480, 320, 40, DARKRED); // Trace un cadre en rouge foncé au bord de l'écran TFT
- tft.drawRoundRect(1, 1, 478, 318, 40, DARKRED);
- tft.setTextSize(3); // Définit la taille du le texte
- tft.setTextColor(RED); // Définit la couleur
- tft.setCursor(85, 20); LectureMemoireFlash(message42); // Positionne et Affiche "IL EST :"
- tft.setTextColor(WHITE, BLACK); // Définit la couleur
- tft.setCursor(250, 20); // Définit la position
- if (Hrs < 10) {tft.print('0');} tft.print(Hrs); // Affiche les heures courantes
- tft.print(':'); // Affiche les deux points ":" de l'heure
- if (Mins < 10) {tft.print('0');} tft.print(Mins); // Affiche les minutes courantes
- tft.drawLine(5, 55, 474, 55, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 55, 474, 55, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextSize(2); // Définit la taille du le texte
- tft.setTextColor(YELLOW); // Définit la couleur
- if (numeroRepas == 1) {tft.setCursor(60, 84); LectureMemoireFlash(message43);} // Positionne et Affiche "C'EST L'HEURE DU PREMIER REPAS"
- else if (numeroRepas == 2) {tft.setCursor(60, 84); LectureMemoireFlash(message44);} // Positionne et Affiche "C'EST L'HEURE DU DEUXIEME REPAS"
- tft.drawLine(5, 125, 474, 125, DARKRED); // Trace une ligne rouge horizontale
- tft.drawLine(5, 125, 474, 125, DARKRED); // Trace une ligne rouge horizontale
- tft.setTextColor(RED); // Définit la couleur
- tft.setCursor(60, 152); LectureMemoireFlash(message45); // Positionne et Affiche "APPUYEZ SUR OK POUR SORTIR"
- tft.setTextSize(2); // Définit la taille du le texte
- tft.setTextColor(BLACK, WHITE); // Définit la couleur
- tft.fillCircle(220, 208, 20, WHITE); // Dessine le bouton "OK"
- tft.drawCircle(220, 208, 22, WHITE);
- tft.setCursor(210, 202); LectureMemoireFlash(message41); // Positionne et Affiche "OK"
- int size = sizeof(melody) / sizeof(int); // Déclare et Calcule la taille de la mélodie
- for (int compteur = 0; compteur < 10; compteur++) // ************************************************************************ // Jour la mélodie 10 fois
- {
- for (int thisNote = 0; thisNote < size; thisNote++) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Parcourt toutes les notes de la mélodie
- {
- int noteDuration = 1000 / tempo[thisNote]; // Déclare et Calcule la durée de la note
- if (ModeMute) {melody[thisNote] = 0;} // Si l'indicateur du mode Mute est activé
- buzz(BrocheBuzzer, melody[thisNote], noteDuration); // Appelle la fonction de lecture de la mélodie repas
- int pauseBetweenNotes = noteDuration * 1.30; // Déclare et Calcule la pause entre les notes
- delay(pauseBetweenNotes); // Temporise de la durée de la pause calculée
- buzz(BrocheBuzzer, 0, noteDuration); // Stoppe la lecture pendant la pause calculée
- GestionTactile (); // Appelle la fonction de gestion du mode tactile
- if (PageCourante == 0) {return;} // ------------------------------------------------------------------------------------- // Si la Page courante 0 est sélectionnée => Sort de la fonction
- }
- }
- PageCourante = 0; // Sélectionne la Page 0 => Page principale
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction lecture de la mélodie repas *********************************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void buzz (int targetPin, long frequency, long length)
- {
- digitalWrite(BrocheLedBleueMelodieRepas, HIGH); // Active la led bleue mélodie repas
- long delayValue = 1000000 / frequency / 2; // Déclare et Calcule la valeur du délai entre les transitions
- long numCycles = frequency * length / 1000; // Déclare et Calcule le nombre de cycles pour une synchronisation appropriée
- for (long i = 0; i < numCycles; i++) // ************************************************************************************* // Parcourt le nombre de cycles pour la durée calculée
- {
- digitalWrite(targetPin, HIGH); // Active le buzzer
- delayMicroseconds(delayValue); // Temporise de la valeur du délai entre les transitions
- digitalWrite(targetPin, LOW); // Désactive le buzzer
- delayMicroseconds(delayValue); // Temporise de la valeur du délai entre les transitions
- }
- digitalWrite(BrocheLedBleueMelodieRepas, LOW); // Désactive la led bleue mélodie repas
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction de restauration des réglages par défaut *********************************************************************************************************************
- //**************************************************************************************************************************************************************************
- void FonctionRestaurationReglagesDefaut ()
- {
- SeuilTemperatureJour = 32.5; // Restaure le seuil de jour de la température par défaut au dessus duquel le ventilateur s'active
- LastSeuilTemperatureJour = -100.0; // Restaure le dernier seuil de jour de la température
- SeuilTemperatureNuit = 27.5; // Restaure le seuil de nuit de la température par défaut au dessus duquel le ventilateur s'active
- LastSeuilTemperatureNuit = -100.0; // Restaure le dernier seuil de nuit de la température
- SeuilHumiditeJour = 12.5; // Restaure le seuil de jour du taux d'humidité par défaut au dessous duquel le brumisateur s'active
- LastSeuilHumiditeJour = -1.0; // Restaure le dernier seuil de jour du taux d'humidité
- SeuilHumiditeNuit = 55.0; // Restaure le seuil de nuit du taux d'humidité par défaut au dessous duquel le brumisateur s'active
- LastSeuilHumiditeNuit = -1.0; // Restaure le dernier seuil de nuit du taux d'humidité
- ModeManuelTemperature = 0; // Restaure l'indicateur du mode manuel de la température par défaut
- ModeManuelHumidite = 0; // Restaure l'indicateur du mode manuel du taux d'humidité par défaut
- HrsDepartSeuilsModeJour = 8; // Restaure les heures départ seuils mode jour par défaut
- MinsDepartSeuilsModeJour = 30; // Restaure les minutes départ seuils mode jour par défaut
- HrsDepartSeuilsModeNuit = 22; // Restaure les heures départ seuils mode nuit par défaut
- MinsDepartSeuilsModeNuit = 30; // Restaure les minutes départ seuils mode nuit par défaut
- ModeJourSeuilTemperature = 0; // Restaure l'indicateur du mode jour pour les seuils de la température par défaut
- ModeJourSeuilHumidite = 0; // Restaure l'indicateur du mode jour pour les seuils du taux d'humidité par défaut
- LastModeJourSeuilTemperature = -1; // Restaure le dernier indicateur du mode jour pour les seuils de la température
- LastModeJourSeuilHumidite = -1; // Restaure le dernier indicateur du mode jour pour les seuils du taux d'humidité
- HrsDepartProgHoraireEclairage = 8; // Restaure les heures de départ du programmateur horaire de l'éclairage par défaut
- MinsDepartProgHoraireEclairage = 30; // Restaure les minutes de départ du programmateur horaire de l'éclairage par défaut
- HrsArretProgHoraireEclairage = 22; // Restaure les heures d'arrêt du programmateur horaire de l'éclairage par défaut
- MinsArretProgHoraireEclairage = 30; // Restaure les minutes d'arrêt du programmateur horaire de l'éclairage par défaut
- ModeProgHoraireEclairage = 1; // Restaure l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage par défaut
- HrsDepart1ProgHoraireRepas = 8; // Restaure les heures de départ1 du programmateur horaire des repas par défaut
- MinsDepart1ProgHoraireRepas = 30; // Restaure les minutes de départ1 du programmateur horaire des repas par défaut
- HrsDepart2ProgHoraireRepas = 22; // Restaure les heures de départ2 du programmateur horaire des repas par défaut
- MinsDepart2ProgHoraireRepas = 30; // Restaure les minutes de départ2 du programmateur horaire des repas par défaut
- for (int i = 0; i < 7; i++) // Restaure l'itération du programmateur horaire de l'éclairage par défaut
- {
- IterationProgHoraireEclairage[i] = 1;
- }
- ModeEco = true; // Restaure l'indicateur du mode Eco par défaut
- ModeMute = false; // Restaure l'indicateur du mode Mute par défaut
- ModeProgHoraireRepas = 1; // Restaure l'indicateur du mode de fonctionnement du programmateur horaire des repas par défaut
- for (int i = 0; i < 7; i++) // Restaure l'itération du programmateur horaire des repas par défaut
- {
- IterationProgHoraireRepas[i] = 1;
- }
- EEPROM.put(0, SeuilTemperatureJour); // Mémorise le seuil de jour de la température par défaut
- EEPROM.put(4, SeuilHumiditeJour); // Mémorise le seuil de jour du taux d'humidité par défaut
- EEPROM.put(8, ModeManuelTemperature); // Mémorise l'indicateur du mode manuel de la température
- EEPROM.put(12, ModeManuelHumidite); // Mémorise l'indicateur du mode manuel du taux d'humidité
- EEPROM.put(16, SeuilTemperatureNuit); // Mémorise le seuil de nuit de la température par défaut
- EEPROM.put(20, SeuilHumiditeNuit); // Mémorise le seuil de nuit du taux d'humidité par défaut
- EEPROM.put(24, HrsDepartSeuilsModeJour); // Mémorise les heures de départ seuils mode jour par défaut
- EEPROM.put(28, MinsDepartSeuilsModeJour); // Mémorise les minutes de départ seuils mode jour par défaut
- EEPROM.put(32, HrsDepartSeuilsModeNuit); // Mémorise les heures de départ seuils mode nuit par défaut
- EEPROM.put(36, MinsDepartSeuilsModeNuit); // Mémorise les minutes de départ seuils mode nuit par défaut
- EEPROM.put(40, HrsDepartProgHoraireEclairage); // Mémorise les heures de départ du programmateur horaire de l'éclairage par défaut
- EEPROM.put(44, MinsDepartProgHoraireEclairage); // Mémorise les minutes de départ du programmateur horaire de l'éclairage par défaut
- EEPROM.put(48, HrsArretProgHoraireEclairage); // Mémorise les heures d'arrêt du programmateur horaire de l'éclairage par défaut
- EEPROM.put(52, MinsArretProgHoraireEclairage); // Mémorise les minutes d'arrêt du programmateur horaire de l'éclairage par défaut
- EEPROM.put(56, ModeProgHoraireEclairage); // Mémorise l'indicateur du mode de fonctionnement du programmateur horaire de l'éclairage par défaut
- for (int i = 0; i < 7; i++) // Mémorise l'itération du programmateur horaire de l'éclairage par défaut si EEPROM non configurée
- {
- EEPROM.put(60 + i*4, IterationProgHoraireEclairage[i]);
- }
- EEPROM.put(88, HrsDepart1ProgHoraireRepas); // Mémorise les heures de départ1 du programmateur horaire des repas par défaut
- EEPROM.put(92, MinsDepart1ProgHoraireRepas); // Mémorise les minutes de départ1 du programmateur horaire des repas par défaut
- EEPROM.put(96, HrsDepart2ProgHoraireRepas); // Mémorise les heures de départ2 du programmateur horaire des repas par défaut
- EEPROM.put(100, MinsDepart2ProgHoraireRepas); // Mémorise les minutes de départ2 du programmateur horaire des repas par défaut
- EEPROM.put(104, ModeEco); // Mémorise l'indicateur du mode Eco par défaut
- EEPROM.put(108, ModeMute); // Mémorise l'indicateur du mode Mute par défaut
- EEPROM.put(112, ModeProgHoraireRepas); // Mémorise le mode de fonctionnement du programmateur horaire des repas par defaut
- for (int i = 0; i < 7; i++) // Mémorise l'itération du programmateur horaire des repas par défaut
- {
- EEPROM.put(116 + i*4, IterationProgHoraireRepas[i]);
- }
- if (ModeProgHoraireEclairage) // ******************************************************************************************** // Si l'indicateur de réglage du mode de fonctionnement du programmateur horaire de l'éclairage est activé
- {
- hStartProgHoraireEclairage = HrsDepartProgHoraireEclairage * 100 + MinsDepartProgHoraireEclairage; // Convertit les heures et les minutes de départ du programmateur horaire de l'éclairage en un seul nombre
- hStopProgHoraireEclairage = HrsArretProgHoraireEclairage * 100 + MinsArretProgHoraireEclairage; // Convertit les heures et les minutes de d'arrêt du programmateur horaire de l'éclairage en un seul nombre
- ProgHoraireEclairageStarted = false; // Désactive l'indicateur de déclenchement du programmateur horaire de l'éclairage
- ProgHoraireEclairageStopped = false; // Désactive l'indicateur de déclenchement du programmateur horaire de l'éclairage
- TestCreneauHoraireProgHoraireEclairage(); // Appelle la fonction test du créneau horaire du programmateur horaire de l'éclairage
- }
- if (!ModeManuelTemperature || !ModeManuelHumidite) // *********************************************************************** // Si l'indicateur du mode manuel de la température est désactivé ou Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- hStartSeuilsModeJour = HrsDepartSeuilsModeJour * 100 + MinsDepartSeuilsModeJour; // Convertit les heures et les minutes de départ seuils mode jour converties en un seul nombre entier
- hStopSeuilsModeJour = HrsDepartSeuilsModeNuit * 100 + MinsDepartSeuilsModeNuit; // Convertit les heures et les minutes de départ seuils mode nuit converties en un seul nombre entier
- ProgSeuilsModeJourStarted = false; // Désactive l'indicateur de déclenchement seuils mode jour
- ProgSeuilsModeNuitStarted = false; // Désactive l'indicateur de déclenchement seuils mode nuit
- TestCreneauHoraireSeuilsModeJourNuit(); // Appelle la fonction test du créneau horaire seuils mode jour/nuit
- }
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction test du créneau horaire du programmateur horaire de l'éclairage *********************************************************************************************
- //**************************************************************************************************************************************************************************
- void TestCreneauHoraireProgHoraireEclairage ()
- {
- int hHrs = Hrs * 100 + Mins; // Convertit les heures et les minutes courantes en un seul nombre entier
- if (hStartProgHoraireEclairage < hStopProgHoraireEclairage) // ************************************************************** // Teste la plage horaire de fonctionnement programmateur horaire de l'éclairage sur 1 jour
- {
- if (hStartProgHoraireEclairage <= hHrs && hHrs < hStopProgHoraireEclairage) // ++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est dans la plage horaire
- {
- //Serial.println("passage1");
- if (!ProgHoraireEclairageStarted) // ------------------------------------------------------------------------------------ // Démarre le programmateur horaire de l'éclairage
- {
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // ............................................................... // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- EtatEclairage = HIGH; // Active l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Active la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Active le relais de l'éclairage
- }
- ProgHoraireEclairageStarted = true; ProgHoraireEclairageStopped = false; // Active l'indicateur de déclenchement du programmateur horaire de l'éclairage
- }
- }
- else // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est en dehors de la plage horaire
- {
- //Serial.println("passage2");
- if (!ProgHoraireEclairageStopped) // ------------------------------------------------------------------------------------ // Arrête le programmateur horaire de l'éclairage
- {
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // ............................................................... // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- EtatEclairage = LOW; // Désactive l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Désactive la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Désactive le relais de l'éclairage
- }
- ProgHoraireEclairageStarted = false; ProgHoraireEclairageStopped = true; // Active l'indicateur d'arrêt du programmateur horaire de l'éclairage
- }
- }
- }
- else if (hStartProgHoraireEclairage > hStopProgHoraireEclairage) // ********************************************************* // Teste la plage horaire de fonctionnement du programmateur horaire de l'éclairage sur 2 jours
- {
- if (hStartProgHoraireEclairage > hHrs && hHrs >= hStopProgHoraireEclairage) // ++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est en dehors de la plage horaire
- {
- //Serial.println("passage3");
- if (!ProgHoraireEclairageStopped) // ------------------------------------------------------------------------------------ // Arrête le programmateur horaire de l'éclairage
- {
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // ............................................................... // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- EtatEclairage = LOW; // Désactive l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Désactive la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Désactive le relais de l'éclairage
- }
- ProgHoraireEclairageStarted = false; ProgHoraireEclairageStopped = true; // Active l'indicateur d'arrêt du programmateur horaire de l'éclairage
- }
- }
- else // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est dans la plage horaire
- {
- //Serial.println("passage4");
- if (!ProgHoraireEclairageStarted) // ------------------------------------------------------------------------------------ // Démarre le programmateur horaire de l'éclairage
- {
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // ............................................................... // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- EtatEclairage = HIGH; // Active l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Active la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Active le relais de l'éclairage
- }
- ProgHoraireEclairageStarted = true; ProgHoraireEclairageStopped = false; // Active l'indicateur de déclenchement du programmateur horaire de l'éclairage
- }
- }
- }
- else if (hStartProgHoraireEclairage == hStopProgHoraireEclairage) // ******************************************************** // Plage horaire nulle
- {
- //Serial.println("passage5");
- if (!ProgHoraireEclairageStopped) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Arrête le programmateur horaire de l'éclairage
- {
- if (IterationProgHoraireEclairage[JourSemaine] == 1) // ----------------------------------------------------------------- // Si l'itération du programmateur horaire de l'éclairage du jour de la semaine courant est activé
- {
- EtatEclairage = LOW; // Désactive l'indicateur d'état du fonctionnement de l'éclairage
- LastEtatEclairage = !EtatEclairage; // Inverse l'indicateur du dernier état du fonctionnement de l'éclairage
- digitalWrite(BrocheLedJauneTemoinEclairage, EtatEclairage); // Désactive la led témoin de fonctionnement de l'éclairage
- digitalWrite(BrocheRelaisEclairage, EtatEclairage);
- digitalWrite(BrocheRelaisEclairageChauffant, EtatEclairage);
- digitalWrite(BrocheRelaisVentilationBoitier, EtatEclairage); // Désactive le relais de l'éclairage
- }
- ProgHoraireEclairageStarted = false; ProgHoraireEclairageStopped = true; // Active l'indicateur d'arrêt du programmateur horaire de l'éclairage
- }
- }
- }
- //**************************************************************************************************************************************************************************
- //*** Fonction la fonction test du créneau horaire seuils mode jour/nuit ***************************************************************************************************
- //**************************************************************************************************************************************************************************
- void TestCreneauHoraireSeuilsModeJourNuit ()
- {
- int hHrs = Hrs * 100 + Mins; // Convertit les heures et les minutes courantes en un seul nombre entier
- if (hStartSeuilsModeJour < hStopSeuilsModeJour) // ************************************************************************** // Teste la plage horaire de fonctionnement des seuils mode jour/nuit sur 1 jour
- {
- if (hStartSeuilsModeJour <= hHrs && hHrs < hStopSeuilsModeJour) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est dans la plage horaire
- {
- //Serial.println("passage1");
- if (!ProgSeuilsModeJourStarted) // -------------------------------------------------------------------------------------- // Démarre les seuils mode jour
- {
- if (!ModeManuelTemperature) // ........................................................................................ // Si l'indicateur du mode manuel de la température est désactivé
- {
- SeuilTemperatureJourNuit = SeuilTemperatureJour; // Transfère le seuil de jour de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 1; // Active l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- if (!ModeManuelHumidite) // ........................................................................................... // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- SeuilHumiditeJourNuit = SeuilHumiditeJour; // Transfère le seuil de jour du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 1; // Active l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- ProgSeuilsModeJourStarted = true; ProgSeuilsModeNuitStarted = false; // Active l'indicateur de déclenchement du seuils mode jour
- }
- }
- else // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est en dehors de la plage horaire
- {
- //Serial.println("passage2");
- if (!ProgSeuilsModeNuitStarted) // -------------------------------------------------------------------------------------- // Démarre les seuils mode nuit
- {
- if (!ModeManuelTemperature) // ........................................................................................ // Si l'indicateur du mode manuel de la température est désactivé
- {
- SeuilTemperatureJourNuit = SeuilTemperatureNuit; // Transfère le seuil de nuit de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 0; // Désactive l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- if (!ModeManuelHumidite) // ........................................................................................... // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- SeuilHumiditeJourNuit = SeuilHumiditeNuit; // Transfère le seuil de nuit du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 0; // Désactive l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- ProgSeuilsModeJourStarted = false; ProgSeuilsModeNuitStarted = true; // Active l'indicateur de déclenchement seuils mode nuit
- }
- }
- }
- else if (hStartSeuilsModeJour > hStopSeuilsModeJour) // ********************************************************************* // Teste la Plage horaire des seuils mode jour/nuit sur 2 jours
- {
- if (hStartProgHoraireEclairage > hHrs && hHrs >= hStopSeuilsModeJour) // ++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est en dehors de la plage horaire
- {
- //Serial.println("passage3");
- if (!ProgSeuilsModeNuitStarted) // -------------------------------------------------------------------------------------- // Démarre les seuils mode nuit
- {
- if (!ModeManuelTemperature) // ........................................................................................ // Si l'indicateur du mode manuel de la température est désactivé
- {
- SeuilTemperatureJourNuit = SeuilTemperatureNuit; // Transfère le seuil de nuit de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 0; // Désactive l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- if (!ModeManuelHumidite) // ........................................................................................... // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- SeuilHumiditeJourNuit = SeuilHumiditeNuit; // Transfère le seuil de nuit du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 0; // Désactive l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // Réinitialise la dernière Page courant
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- ProgSeuilsModeJourStarted = false; ProgSeuilsModeNuitStarted = true; // Active l'indicateur de déclenchement seuils mode nuit
- }
- }
- else // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // L'heure courante est dans la plage horaire
- {
- //Serial.println("passage4");
- if (!ProgSeuilsModeJourStarted) // -------------------------------------------------------------------------------------- // Démarre les seuils mode jour
- {
- if (!ModeManuelTemperature) // ........................................................................................ // Si l'indicateur du mode manuel de la température est désactivé
- {
- SeuilTemperatureJourNuit = SeuilTemperatureJour; // Transfère le seuil de jour de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 1; // Active l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // Réinitialise la dernière Page courante
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- if (!ModeManuelHumidite) // ........................................................................................... // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- SeuilHumiditeJourNuit = SeuilHumiditeJour; // Transfère le seuil de jour du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 1; // Active l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // Réinitialise la dernière Page courante
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- ProgSeuilsModeJourStarted = true; ProgSeuilsModeNuitStarted = false; // Active l'indicateur de déclenchement du seuils mode jour
- }
- }
- }
- else if (hStartSeuilsModeJour == hStopSeuilsModeJour) // ******************************************************************** // Plage horaire nulle
- {
- //Serial.println("passage5");
- if (!ProgSeuilsModeNuitStarted) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Démarre les seuils mode nuit
- {
- if (!ModeManuelTemperature) // ------------------------------------------------------------------------------------------ // Si l'indicateur du mode manuel de la température est désactivé
- {
- SeuilTemperatureJourNuit = SeuilTemperatureNuit; // Transfère le seuil de nuit de la température dans le seuil jour / nuit de température
- ModeJourSeuilTemperature = 0; // Désactive l'indicateur du mode jour pour les seuils de la température
- if (LastModeJourSeuilTemperature != ModeJourSeuilTemperature) // Réinitialise la dernière Page courante
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- if (!ModeManuelHumidite) // --------------------------------------------------------------------------------------------- // Si l'indicateur du mode manuel du taux d'humidité est désactivé
- {
- SeuilHumiditeJourNuit = SeuilHumiditeNuit; // Transfère le seuil de nuit du taux d'humidité dans le seuil jour / nuit du taux d'humidité
- ModeJourSeuilHumidite = 0; // Désactive l'indicateur du mode jour pour les seuils du taux d'humidité
- if (LastModeJourSeuilHumidite != ModeJourSeuilHumidite) // Réinitialise la dernière Page courante
- {
- if (PageCourante == 0) {LastPageCourante = -1;}
- }
- }
- ProgSeuilsModeJourStarted = false; ProgSeuilsModeNuitStarted = true; // Active l'indicateur de déclenchement seuils mode nuit
- }
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
