API tools faq
paste
Advertisement
Ollivier

Calendrier météo multi foncton LCD en cours

Ollivier
Aug 21st, 2020 (edited)
149
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 77.64 KB | None | 0 0
raw download clone embed print report
  1. /* ================================================================================================== */
  2. // KRONOS 1.1
  3. // Ollivier JULLIEN août 2020
  4. // 100% libre de droit
  5. // (en cas de copie, merci de citer l'auteur... il a travaillé dur pour vous le donner ;) )
  6. // Merci à Serge DUCATEZ
  7. /* ================================================================================================== */
  8. // à voir => chaînes formatées
  9. /* ================================================================================================== */
  10. // Calendrier / Pendule / thermomètre / hygromètre
  11. // Affichage multimode sur ecran LCD 1 couleur (bleu) 20x4
  12. //
  13. // RTC 1603 (RTC) Horloge en temps réel DFR0151
  14. //    https://wiki.dfrobot.com/Gravity__I2C_DS1307_RTC_Module_SKU__DFR0151
  15. //
  16. // SHT15  (Capteur humidité / hygrométrie) (double I2C / pseudo I2C ??)
  17. // Capteur de T° et d'humidité Gravity DFR0066
  18. //    https://wiki.dfrobot.com/SHT1x_Humidity_and_Temperature_Sensor__SKU__DFR0066_
  19. //
  20. // Module 5 boutons (analogique) DFR0075
  21. //     https://wiki.dfrobot.com/ADKeyboard_Module__SKU__DFR0075_
  22. //
  23. // capteur de lumière ambiante SEN0172 (juste parce que j'en ai un)
  24. //    https://wiki.dfrobot.com/LX1972_ambient_light_sensor_SKU_SEN0172
  25. //
  26. // Arduino Nano
  27. //
  28. // Afficheur LCD I2C 4X20 caractères
  29. //    https://www.gotronic.fr/pj2-sbc-lcd20x4-fr-1440.pdf
  30. //    https://www.gotronic.fr/pj2-pcf8574-3-1516.pdf
  31. //    https://www.gotronic.fr/pj2-lcd2004-1515.pdf
  32. /* ================================================================================================== */
  33.  
  34. /* ================================================================================================== */
  35. // Ce "truc" possède 4 modes (ecran) d'affichages de la date, l'heure, la température en °C, le taux
  36. // d'humidité de l'air, dont un avec défilement de la date du jour, et deux autres qui donnent la
  37. // température en °F.
  38. // Cette nouvelle version donne aussi l'intensité lumineuse ambiante.
  39. // De plus j'ai rajouté une animation de la pendule sur l'écran 2, et un nouvel icone "calendrier"
  40. // sur ce même écran.
  41. // Elle comporte aussi le clignotement des ":" des horloges.
  42. //
  43. // Utilisation
  44. //
  45. // Le controle se fait par 5 boutons (Ben oui j'en avais 5 de dispo, c'est l'opulence.
  46. //             BOUTON 1 BLANC
  47. //                    O
  48. //   BOUTON 2 ROUGE O O O BOUTON 4 BLEU || AU CENTRE BOUTON 5 BLANC
  49. //                    O
  50. //             BOUTON 3 BLANC
  51. // BOUTON 2 ROUGE passe au mode suivant (et retourne au premier une fois au bout)
  52. // BOUTON 4 VERT  passe au mode précédent (et retourne au dernier une fois au bout)
  53. // BOUTON 1 BLANC affiches les valeurs maximum de température et d'humidité atteinte depuis qu'il est branché
  54. // BOUTON 3 BLANC affiches les valeurs minimum de température et d'humidité atteinte depuis qu'il est branché
  55. // BOUTON 5 BLANC si on vient de mini ou maxi, on affiche le dernier mode selectionné avec ROUGE ou VERT
  56. //
  57. // Il faudra un peu modifier le code pour l'utiliser avec des boutons poussoirs différents de ce module
  58. //
  59. /* ================================================================================================== */
  60. // Suite possible / prévue
  61. /* ================================================================================================== */
  62. // [x] FAIT : animation pendule sur 3 positions (3 caracteres speciaux), 4 mouvements
  63. // [x] FAIT : animation des ":" dans les horloges
  64. // [x] FAIT : ajouter un capteur de lumière ambiante SEN0172 (juste parce que j'en ai un)
  65. // [x] FAIT : ajouter une icone calendrier
  66. // [x] FAIT : le centrage automatique des lignes
  67. //    => date ecran 1 / ligne 1 | et | jour ecran 2 / Ligne 2
  68. // [x] FAIT : Rajouter l'année sur l'écran 1
  69. // [x] FAIT : Mise à jour de l'heure par l'utilisateur (compliqué, mais...)
  70. // [x] FAIT : Clignottement du chiffre à modifier en mode réglage
  71. // [x] FAIT : Libération de RAM et d'espace de stockage
  72. // [x] FAIT : Défilement message utilisateur (light)
  73. // [x] FAIT : Réveil : Rajouter une alarme réglable par l'utilisateur
  74. // [x] FAIT : (le mode peut être évolutif avec snooze, différentes mélodies, ...)
  75. // [x] FAIT : Pré écoute de la sonnerie lors du réglage du reveil
  76. // [x] FAIT : Enregistrement des valeurs mini, maxi, valeurs du reveil (EEPROM)
  77. // Connexion RF433 avec une autre sonde température (pour mode extérieur intérieur)
  78. // Accents sur le 'u' de août et les 'e' sur février et décembre
  79. //    Peut me servir pour çà :
  80. //    http://www.electronic-engineering.ch/microchip/datasheets/lcd/charset.gif
  81. //    http://fabrice.sincere.pagesperso-orange.fr/cm_electronique/electronique_numerique20/annexe/conversion_decimal_hexa02.pdf
  82. // ... et peut être de nouveaux modes d'affichage (écrans)
  83. //
  84. // J'attends vos idées...
  85. //
  86. // REMARQUE : Il semblerait que dans ce code, 'lcd.printByte()' peut être remplacé par 'lcd.write()'
  87. // mais je ne sais pas si on a encore besoin du #DEFINE suivante... (je regarderai plus tard)
  88. //
  89. // #if defined(ARDUINO) && ARDUINO >= 100
  90. // #define printByte(args)  write(args);
  91. // #else
  92. // #define printByte(args)  print(args,BYTE);
  93. // #endif
  94. //
  95. //----------------------------------------------------------------------------------------------------------
  96. // IMPORTATION DES BIBLIOTHEQUES                                                                            |
  97. //----------------------------------------------------------------------------------------------------------
  98. #include <Wire.h>                                       // chargement de la bibliothèque de gestion simplifiée du cablage (I2C)
  99. #include <DS1307.h>                                     // chargement de la bibliothèque de gestion du module RTC (Real Time Clock)
  100. #include <SHT1x.h>                                      // chargement de la bibliothèque de gestion du module temperature humidité sht15
  101. #include <LiquidCrystal_I2C.h>                          // chargement de la bibliothèque de gestion de l'ecran 4x20 I2C
  102. #include <avr/pgmspace.h>                               // chargement de la bibliothèque de gestion de 'F' :)
  103. #include "EEPROM.h"
  104.  
  105. LiquidCrystal_I2C lcd(0x27, 20, 4);                     // instanciation de l'occurence lcd() de l'objet LiquidCrystal_I2C
  106.  
  107. #define dataPin  10                                     // pin digital de connexion data Senseur SHT15
  108. #define clockPin 11                                     // pin digital de connexion SCK Senseur SHT15
  109. SHT1x sht15(dataPin, clockPin);                         // instanciation de l'occurence sht15() de l'objet SHT1x
  110.  
  111. #define pinAnalogLumiere 1
  112. #define pinBuzzer 6
  113.  
  114. //----------------------------------------------------------------------------------------------------------
  115. // A modifier pour mettre "à l'heure"                                                                       |
  116. //----------------------------------------------------------------------------------------------------------
  117. bool update_mode = 0;                                   // 1 : Mise à jour du temps ; 0 : Affiche l'heure
  118. //----------------------------------------------------------------------------------------------------------
  119.  
  120. //----------------------------------------------------------------------------------------------------------
  121. // A modifier pour mettre "à l'heure"                                                                       |
  122. //----------------------------------------------------------------------------------------------------------
  123. #define TIME_YR    20  // <=                // année sans "20" de 2000                                      |
  124. #define TIME_MTH   8   // <=                // numéro du mois de l'année                                    |
  125. #define TIME_DATE  13  // <=                // jour du mois                                                 |
  126. #define TIME_DOW   4   // <=                // jour de la semaine (lundi : 1; mardi : 2; mercredi : 3; etc) |
  127. #define TIME_HR    16  // <=                // heures                                                       |
  128. #define TIME_MIN   10  // <=                // minutes                                                      |
  129. #define TIME_SEC   0   // <=                // secondes                                                     |
  130. //----------------------------------------------------------------------------------------------------------
  131.  
  132. char* jour[] = {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"}; // nom du jour de la semaine
  133.  
  134. char* mois[] = {"janvier", "fevrier", "mars", "avril", "mai", "juin", "juillet", "aout", "septembre", "octobre", "novembre", "decembre"}; // nom du mois
  135.  
  136. // ???---???---  permet l'affichage des caractères spéciaux  ---???---???
  137. #if defined(ARDUINO) && ARDUINO >= 100
  138. #define printByte(args)  write(args);
  139. #else
  140. #define printByte(args)  print(args,BYTE);
  141. #endif
  142. // ???---???---            ???---???---???---???             ---???---???
  143.  
  144. uint8_t repetition[8] = {0x18, 0x14, 0x18, 0x15, 0x03, 0x07, 0x03, 0x01};
  145. uint8_t sonnerie[8] = {0x01, 0x01, 0x01, 0x01, 0x0F, 0x1F, 0x1F, 0x0E};
  146. uint8_t pendule[8] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};          // caractère spécial pendule
  147. uint8_t goutte[8] = {0x04, 0x04, 0x0A, 0x0A, 0x11, 0x11, 0x11, 0x0E}; // caractère spécial goutte
  148. uint8_t thermo[8] = {0x04, 0x0A, 0x0B, 0x0A, 0x0F, 0x0E, 0x0F, 0x0E}; // caractère spécial thermomètre
  149. uint8_t reveilOn[8] = {0x1F, 0x11, 0x15, 0x13, 0x15, 0x15, 0x1F, 0x00};    //caractère spécial lumière
  150. uint8_t cal[8] = {0x1F, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F};   //caractère spécial calendrier
  151. // https://maxpromer.github.io/LCD-Character-Creator/
  152.  
  153. int rtc[7];                                       // tableau qui contiendra les valeurs du temps présent
  154.  
  155. int anneeActuel;
  156. int moisActuel;
  157. int jourSemActuel;
  158. int jourActuel;
  159. int heureActuel;
  160. int minuteActuel;
  161. int secondeActuel;
  162.  
  163. unsigned long cycle;                              // repère temporel pour l'affichage des secondes ("refresh" ou nouveau Serial.print())
  164. unsigned long cycleSensor;                        // repère temporel pour la lecture des senseur de température et humidité
  165. unsigned long MargeCycleSensor = 30000;           // delais entre chaque lecture des senseurs
  166.  
  167. float temp_c;                                     // température en celsius
  168. float temp_f;                                     // température en Fareneit
  169. float humidite;                                   // taux d'humidité de l'air
  170. int lumiere;
  171.  
  172. float temp_c_max = 0;                             // température max en celsius
  173. float temp_c_min = 1000;                          // température min en celsius
  174. float temp_f_max = 0;                             // température max en Fareneit
  175. float temp_f_min = 1000;                          // température min en Fareneit
  176. float hum_max = 0;                                // taux max d'humidité de l'air
  177. float hum_min = 101;                              // taux min d'humidité de l'air
  178.  
  179. int modeAff = 0;                                  // mode d'écran à afficher
  180. int modeAffMem;                                   // mise en memoire du dernier mode ecran affiché
  181.  
  182. int longueurLigne;                                // nombre de caractère à l'écran (à afficher)
  183. int avance = 0;                                   // position du repère de défilement
  184. int debutAff;                                     // premier caractère de la ligne affiché
  185. int finAff;                                       // dernier caratcère de la ligne affiché
  186.  
  187. int valLimiteHauteModule[5] = {600, 650, 720,  820, 900};  // valeurs analogiques de basculement d'un bouton à l'autre
  188. // (j'ai modifié le 3eme je suis passé de 700 à 720)
  189.  
  190. const int nombreBoutons = 5;                      // détermine le nombre de boutons
  191. const int pinModule5BP = 0;
  192.  
  193. int valeurLue;                                    // bouton activé
  194. int numBouton = -1;                               // valeur du bouton
  195. int derniereLue = -1;                             // ancienne valeur connu des boutons
  196. int memoireNumBouton = -1;
  197. int ancienneMemoireNumBouton = -1;
  198. unsigned long debutPression;
  199. unsigned long debutEntreDeux;
  200.  
  201. unsigned long dureePression;
  202. unsigned long dureeEntreDeux;
  203.  
  204. const int nombreMode = 3;                         // nombre de mode : 4 (mode : 0)
  205.  
  206. int cyclePendule = 1;
  207.  
  208. bool etatDeuxPoints = true;
  209.  
  210. int positionCentrage;
  211.  
  212. // Variables de mise à jour de l'heure -----
  213.  
  214. int anneeR;
  215. int moisR;
  216. int jourR;
  217. int jourSemR;
  218. int heureR;
  219. int minuteR;
  220. int secondeR;
  221. int positionR;
  222. int positionRmarge;
  223. bool etatClignoSelect = 0;
  224. unsigned long cligno;
  225.  
  226. // Variables du défilement instructions utilisateur -----
  227. // Pour la prochaine version, prévoire un affichage séquentiel, plutôt...
  228.  
  229. String Chaine = "";
  230. String ligne = "";
  231. String texte = "";
  232. String Chaine20Espaces = "                    ";
  233. char myChar;
  234. int k = 0;
  235.  
  236. const char messageUser1[]   PROGMEM = "< Prec. / Suiv. > / Rouge + / Bleu - / Vert : Valid. / Long Vert : Annul.";  
  237. const char messageUser2[]   PROGMEM = "< NON / Long Vert : Annul. / OUI >";
  238.  
  239. // Variables du réveil -----
  240.  
  241. int heureReveil = 11;
  242. int heureReveilReglage = 11;
  243. int minuteReveil = 47;
  244. int minuteReveilReglage = 47;
  245. bool reveilActif = false;
  246. bool reveilActifReglage = false;
  247. int positionReglageReveil = 2;
  248. bool joursReveilActif[7] ={true, true, false, false, false, false, false};
  249. bool joursReveilActifReglage[7] ={true, true, false, false, false, false, false};
  250.  
  251. int positionsCursReglageReveil[14] = {5, 13, 14, 16, 17, 5, 7, 9, 11, 13, 15, 17, 11, 9};
  252. int positionsCursReglage[11] = {0, 12, 13, 15, 16, 18, 19, 6, 7, 9, 10};
  253.  
  254. bool alarmeOn = false;
  255. unsigned long validiteAlarmeOff = -60000;
  256.  
  257. int timerBoucle = 500;
  258. int timerBoucleAlarme = 900;
  259.  
  260. int numeroSonnerie = 1;
  261. int numeroSonnerieReglage = 1;
  262.  
  263. int numeroRepet = 0;
  264. int numeroRepetReglage = 0;
  265. int heureMemoireRepet;
  266. int minuteMemoireRepet;
  267. bool repetOn = false;
  268.  
  269. bool jourActifForce = false;
  270.  
  271. bool nouveauJour = false;
  272.  
  273. bool ecouteSonnerieTest=false;
  274. int tourEcoute1 = 0;
  275. int tourEcoute0 = 0;
  276.  
  277. // tableau des valeurs d'initialisation
  278.  
  279. int valeurInit[18] = {
  280.  
  281.   0,    // Réveil On / Off      // val 0 ou 1
  282.   22,   // Heures               // val : entre 0 et 23
  283.   33,   // Minutes              // val : entre 0 et 59
  284.   1,    // Lundi                // val 0 ou 1
  285.   0,    // Mardi                // val 0 ou 1
  286.   1,    // Mercredi             // val 0 ou 1
  287.   0,    // Jeudi                // val 0 ou 1
  288.   1,    // Vendredi             // val 0 ou 1
  289.   1,    // Samedi               // val 0 ou 1
  290.   0,    // Dimanche             // val 0 ou 1
  291.   3,    // °C mini              // val : entre -40 et 128
  292.   37,   // °F mini              // val entre -4 et 262.4
  293.   7,    // % Humidité mini      // val entre 0 et 100
  294.   32,   // °C maxi              // val entre -40 et 128
  295.   89,   // °F maxi              // val entre -4 et 262.4
  296.   88,   // % Humidité maxi      // int entre 0 et 100
  297.   1,    // N° de sonnerie       // int entre 1 et 4
  298.   2     // Multiplicateur repet // int entre 0 et 4
  299. };
  300.  
  301. byte valeurLueEEPROM;
  302.  
  303. //#define INIT      // à décocher pour faire une initialisation
  304.  
  305. /* ================================================================================================== */
  306. // fonctions
  307. /* ================================================================================================== */
  308.  
  309. /* ================================================================================================== */
  310. // fonction qui surveille l'heure et lancer l'alarme quand il faut
  311. /* ================================================================================================== */
  312.  
  313. void alarmeReveilVerif(){
  314.   if (millis() - validiteAlarmeOff > 60000){
  315.     alarmeOn = false;
  316.   }
  317.   if (reveilActif == true && alarmeOn == false){
  318.     if (joursReveilActif[jourSemActuel-1] == true && heureReveil == heureActuel && minuteReveil == minuteActuel){
  319.       modeAffMem = modeAff;
  320.       modeAff = 10;
  321.       alarmeOn = true;
  322.       validiteAlarmeOff = millis();
  323.       timerBoucle = timerBoucleAlarme;
  324.     }
  325.   }
  326. }
  327.  
  328. /* ================================================================================================== */
  329. // fonction d'affichage du mode Validation du réglage du réveil
  330. /* ================================================================================================== */
  331.  
  332. void validReglageReveil(){
  333. // Ligne 1
  334.   lcd.setCursor(0, 0);
  335.   lcd.print(F(" VALIDER REGLAGES ? "));
  336.   // Ligne 2
  337.   lcd.setCursor(0, 1);
  338.   lcd.printByte(3);
  339.   if (reveilActifReglage == true){
  340.     lcd.print(F(" on  "));
  341.   } else {
  342.     lcd.print(F("off  "));
  343.   }
  344.   lcd.printByte(4);
  345.   if (numeroRepetReglage == 0){
  346.     lcd.print(F("-----"));
  347.   }else{
  348.     if (numeroRepetReglage*5 < 10){
  349.       lcd.print(F(" "));
  350.     }
  351.   lcd.print(numeroRepetReglage*5);
  352.   lcd.print(F(" mn "));
  353.   }
  354.   lcd.print(F("  "));
  355.   lcd.printByte(0);
  356.   if (heureReveilReglage < 10){
  357.     lcd.print(F("0"));
  358.   }
  359.   lcd.print(heureReveilReglage);
  360.   lcd.print(F(":"));
  361.   if (minuteReveilReglage < 10){
  362.     lcd.print(F("0"));
  363.   }
  364.   lcd.print(minuteReveilReglage);
  365.  
  366.   lcd.setCursor(0, 2);
  367.   lcd.printByte(5);
  368.   lcd.print(F(" "));
  369.   lcd.print(numeroSonnerieReglage);
  370.   lcd.print(F("  "));
  371.   lcd.printByte(6);
  372.   lcd.print(F(" "));
  373.   for (int x = 0; x <= 6; x++){
  374.     String jourCh = jour[x];                        // on récupère le jour dans le tableau existant (chaine)
  375.                                                     // mais comme on n'a besoin que du premier caractère :
  376.     char initCh = jourCh[0];                        // on extrait le premier caractère
  377.     if (joursReveilActifReglage[x] == true){        // Si le jour est actif (doit sonner)
  378.       initCh = toupper(initCh);                     // on le passe en majuscule
  379.     }
  380.     jourCh = "";                                    // on vide notre chaine
  381.     jourCh += initCh;                               // on y ajoute le caractère ci-dessus
  382.     lcd.print(jourCh);                              // et on affiche
  383.     if (x <= 5){
  384.       lcd.print(F("|"));
  385.     }
  386.   }
  387.    
  388. // Affichage message
  389.   if (k <= ligne.length()){            // remplacer messageUser2 par ligne pour utiliser la fonction
  390.     k++;
  391.   } else {
  392.     k=0;
  393.   }
  394.   texte = ligne.substring(k, k + 20);  // remplacer messageUser2 par ligne pour utiliser la fonction
  395.   lcd.setCursor(0, 3);
  396.   lcd.print(texte);
  397.  
  398. }
  399. /* ================================================================================================== */
  400. // fonction d'affichage du mode Réglage du réveil Ecran 1
  401. /* ================================================================================================== */
  402.  
  403. void showReveilEcran1(){
  404. // Ligne 1
  405.   lcd.setCursor(0, 0);
  406.   lcd.print(F(" REGLAGES REVEIL  1 "));
  407. // Ligne 2
  408.   lcd.setCursor(0, 1);
  409.   lcd.print(F("  "));
  410.   lcd.printByte(3);
  411.   if (reveilActifReglage == true){
  412.     lcd.print(F("  on  | "));
  413.   } else {
  414.     lcd.print(F("  off | "));
  415.   }  
  416.   lcd.printByte(0);
  417.   lcd.print(F(" "));
  418.   if (heureReveilReglage < 10){
  419.     lcd.print(F("0"));
  420.   }
  421.   lcd.print(heureReveilReglage);
  422.   lcd.print(F(":"));
  423.   if (minuteReveilReglage < 10){
  424.     lcd.print(F("0"));
  425.   }
  426.   lcd.print(minuteReveilReglage);
  427.   lcd.print(F("  "));
  428.  
  429. // Ligne 3
  430.   lcd.setCursor(0, 2);
  431.   lcd.print(F("  "));
  432.   lcd.printByte(6);
  433.   lcd.print(F("  "));
  434.   for (int x = 0; x <= 6; x++){
  435.     String jourCh = jour[x];                        // on récupère le jour dans le tableau existant (chaine)
  436.                                                     // mais comme on n'a besoin que du premier caractère :
  437.     char initCh = jourCh[0];                        // on extrait le premier caractère
  438.     if (joursReveilActifReglage[x] == true){        // Si le jour est actif (doit sonner)
  439.       initCh = toupper(initCh);                     // on le passe en majuscule
  440.     }
  441.     jourCh = "";                                    // on vide notre chaine
  442.     jourCh += initCh;                               // on y ajoute le caractère ci-dessus
  443.     lcd.print(jourCh);                              // et on affiche
  444.     if (x <= 5){
  445.       lcd.print(F("|"));
  446.     }
  447.   }
  448.  
  449. // Ligne 4
  450.  
  451. // Affichage message
  452.   if (k <= ligne.length()){            // remplacer messageUser2 par ligne pour utiliser la fonction
  453.     k++;
  454.   } else {
  455.     k=0;
  456.   }
  457.   texte = ligne.substring(k, k + 20);  // remplacer messageUser2 par ligne pour utiliser la fonction
  458.   lcd.setCursor(0, 3);
  459.   lcd.print(texte);
  460.  
  461. // Clignottement de l'élément sélectionné
  462. if (etatClignoSelect == 1){
  463.     if (positionReglageReveil < 6){
  464.       lcd.setCursor(positionsCursReglageReveil[positionReglageReveil-1],1);
  465.       lcd.print(F(" "));
  466.       if (positionReglageReveil == 1){
  467.         lcd.print(F("  "));
  468.       }
  469.     } else {
  470.       lcd.setCursor(positionsCursReglageReveil[positionReglageReveil-1],2);
  471.       lcd.print(F(" "));
  472.       if (positionReglageReveil >= 13){
  473.       modeAff = 11;
  474.       lcd.clear();
  475.       }
  476.     }
  477.   }
  478.   etatClignoSelect = !etatClignoSelect;
  479. }
  480.  
  481.  
  482. /* ================================================================================================== */
  483. // fonction d'affichage du mode Réglage du réveil Ecran 2
  484. /* ================================================================================================== */
  485.  
  486. void showReveilEcran2(){
  487. // Ligne 1
  488.   lcd.setCursor(0, 0);
  489.   lcd.print(F(" REGLAGES REVEIL  2 "));
  490. // Ligne 2
  491.   lcd.setCursor(0, 1);
  492.   lcd.print(F("        "));
  493.   lcd.printByte(5);
  494.   lcd.print(F("  "));
  495.   lcd.print(numeroSonnerieReglage);
  496.  
  497. // Ligne 3
  498.   lcd.setCursor(0, 2);
  499.   lcd.print(F("      "));
  500.   lcd.printByte(4);
  501.   lcd.print(F("  "));
  502.   if (numeroRepetReglage == 0){
  503.     lcd.print(F("-----"));
  504.   }else{
  505.   if (numeroRepetReglage*5 < 10){
  506.     lcd.print(F(" "));
  507.   }
  508.   lcd.print(numeroRepetReglage*5);
  509.   lcd.print(F(" mn "));
  510.   }
  511.  
  512. // Ligne 4
  513.  
  514. // Affichage message
  515.   if (k <= ligne.length()){            // remplacer messageUser2 par ligne pour utiliser la fonction
  516.     k++;
  517.   } else {
  518.     k=0;
  519.   }
  520.   texte = ligne.substring(k, k + 20);  // remplacer messageUser2 par ligne pour utiliser la fonction
  521.   lcd.setCursor(0, 3);
  522.   lcd.print(texte);
  523.  
  524. // Clignottement de l'élément sélectionné
  525. if (etatClignoSelect == 1){
  526.     if (positionReglageReveil < 13){
  527.       modeAff = 8;
  528.       lcd.clear();
  529.     } else {
  530.       if (positionReglageReveil == 13){
  531.       lcd.setCursor(positionsCursReglageReveil[positionReglageReveil-1],1);
  532.       lcd.print(F(" "));
  533.       } else if (positionReglageReveil == 14){
  534.       lcd.setCursor(positionsCursReglageReveil[positionReglageReveil-1],2);
  535.       lcd.print(F("     "));
  536.       }
  537.     }
  538.     if (ecouteSonnerieTest == true){
  539.       switch (numeroSonnerieReglage) {
  540.       case 1:
  541.         tone(pinBuzzer, 440);         // 1
  542.         break;
  543.       case 2:
  544.         tone(pinBuzzer, 440, 450);    // 2  
  545.         break;
  546.       case 3:
  547.         tone(pinBuzzer, 440, 200);    // 3
  548.         delay(300);                   // 3
  549.         tone(pinBuzzer, 440, 200);    // 3  
  550.         break;
  551.       case 4:
  552.         tone(pinBuzzer, 440, 150);    // 4
  553.         delay(200);                   // 4
  554.         tone(pinBuzzer, 440, 150);    // 4
  555.         delay(200);                   // 4
  556.         tone(pinBuzzer, 440, 150);    // 4  
  557.         break;
  558.       }
  559.       tourEcoute1 ++;
  560.     }
  561.   } else {
  562.     if (ecouteSonnerieTest == true){
  563.       switch (numeroSonnerieReglage) {
  564.       case 1:
  565.         noTone(pinBuzzer);          // 1
  566.         break;
  567.       case 2:
  568.         tone(pinBuzzer, 440, 450);  // 2
  569.         break;
  570.       case 3:
  571.         noTone(pinBuzzer);          // 3
  572.         break;
  573.       case 4:
  574.         noTone(pinBuzzer);          // 4
  575.         break;
  576.       }
  577.       tourEcoute0 ++;
  578.     }
  579.   }
  580.   if (tourEcoute0 >= 4 && tourEcoute0 >= 4){
  581.     ecouteSonnerieTest = false;
  582.   }
  583.   etatClignoSelect = !etatClignoSelect;
  584. }
  585.  
  586. /* ================================================================================================== */
  587. // fonction d'affichage du mode Alarme du réveil
  588. /* ================================================================================================== */
  589.  
  590. void showAlarme(){
  591.   if (etatClignoSelect == 1){
  592.     lcd.setCursor(0, 0);
  593.     lcd.print(F("      ALARME !      "));
  594.     lcd.setCursor(0, 1);
  595.     lcd.print(F("        "));
  596.     lcd.write(242);
  597.     lcd.print(F("  "));
  598.     lcd.write(242);
  599.     lcd.print(F("        "));
  600.     lcd.setCursor(0, 2);
  601.     lcd.print(F("      (______)      "));
  602.     lcd.setCursor(0, 3);
  603.     lcd.print(F(" C'est maintenant ! "));
  604.     switch (numeroSonnerie) {
  605.       case 1:
  606.         tone(pinBuzzer, 440);         // 1
  607.         break;
  608.       case 2:
  609.         tone(pinBuzzer, 440, 450);    // 2  
  610.         break;
  611.       case 3:
  612.         tone(pinBuzzer, 440, 200);    // 3
  613.         delay(300);                   // 3
  614.         tone(pinBuzzer, 440, 200);    // 3  
  615.         break;
  616.       case 4:
  617.         tone(pinBuzzer, 440, 150);    // 4
  618.         delay(200);                   // 4
  619.         tone(pinBuzzer, 440, 150);    // 4
  620.         delay(200);                   // 4
  621.         tone(pinBuzzer, 440, 150);    // 4  
  622.         break;
  623.     }
  624.   } else {
  625.     lcd.setCursor(0, 0);
  626.     lcd.print(Chaine20Espaces);
  627.     lcd.setCursor(0, 1);
  628.     lcd.print(F("      ALARME !      "));
  629.     lcd.setCursor(0, 2);
  630.     lcd.print(F(" C'est maintenant ! "));
  631.     lcd.setCursor(0, 3);
  632.     lcd.print(Chaine20Espaces);
  633.     switch (numeroSonnerie) {
  634.       case 1:
  635.         noTone(pinBuzzer);          // 1
  636.         break;
  637.       case 2:
  638.         tone(pinBuzzer, 440, 450);  // 2
  639.         break;
  640.       case 3:
  641.         noTone(pinBuzzer);          // 3
  642.         break;
  643.       case 4:
  644.         noTone(pinBuzzer);          // 4
  645.         break;
  646.     }
  647.   }
  648.   etatClignoSelect = !etatClignoSelect;
  649. }
  650.  
  651. /* ================================================================================================== */
  652. // fonction qui récupere les instructions défilantes
  653. /* ================================================================================================== */
  654.  
  655. void recupeTexte(const char message[]){
  656.   ligne="";
  657.   Chaine="";
  658.   for (byte j = 0; j < strlen_P(message); j++)
  659.   {
  660.     myChar = pgm_read_byte_near(message + j);
  661.     Chaine = Chaine + myChar;
  662.   }
  663.  
  664.   ligne = Chaine20Espaces; // Construit la Chaîne de caractères à faire défiler
  665.   ligne = ligne + Chaine;
  666.   ligne = ligne + " ";
  667. }
  668.  
  669. // Affichage de la date sous la forme xx/xx/xxxx
  670.  
  671. void affDate() {
  672.   if (jourActuel < 10) {
  673.     lcd.print(F("0"));
  674.   }
  675.   lcd.print(jourActuel);
  676.   lcd.print(F("/"));
  677.   if (moisActuel < 10) {
  678.     lcd.print(F("0"));
  679.   }
  680.   lcd.print(moisActuel);
  681.   lcd.print(F("/"));
  682.   lcd.print(anneeActuel);
  683. }
  684.  
  685. // Affichage de l'heure
  686.  
  687. void affHeure() {
  688.   if (heureActuel < 10) {
  689.     lcd.print(F("0"));
  690.   }
  691.   lcd.print( heureActuel);
  692.   if (etatDeuxPoints == false) {
  693.     lcd.print(F(":"));
  694.   } else {
  695.     lcd.print(F(" "));
  696.   }
  697.   if (minuteActuel < 10) {
  698.     lcd.print(F("0"));
  699.   }
  700.   lcd.print( minuteActuel);
  701.   if (etatDeuxPoints == false) {
  702.     lcd.print(F(":"));
  703.   } else {
  704.     lcd.print(F(" "));
  705.   }
  706.   if (secondeActuel < 10) {
  707.     lcd.print(F("0"));
  708.   }
  709.   lcd.print( secondeActuel);
  710.   etatDeuxPoints = !etatDeuxPoints;
  711. }
  712.  
  713. // Affichage de la température en Celsius
  714.  
  715. void affCelsius(float cMinMaxActuelle) {
  716.   if (cMinMaxActuelle < 0 && abs(cMinMaxActuelle) >= 10 && abs(cMinMaxActuelle) < 45) {
  717.     lcd.print(F("-"));
  718.   } else if (cMinMaxActuelle < 0 && abs(cMinMaxActuelle) < 10) {
  719.     lcd.print(F(" -"));
  720.   } else if (cMinMaxActuelle >= 0 && cMinMaxActuelle < 10) {
  721.     lcd.print(F("  "));
  722.   } else if (cMinMaxActuelle >= 10 && cMinMaxActuelle < 100) {
  723.     lcd.print(F(" "));
  724.   }
  725.   lcd.print(cMinMaxActuelle, 1);
  726.   lcd.print(F(" "));
  727.   lcd.write(223);
  728.   lcd.print(F("C"));
  729. }
  730.  
  731. void affFahrenheit(float fMinMaxActuelle) {
  732.   if (fMinMaxActuelle < 0 && abs(fMinMaxActuelle) >= 10 && abs(fMinMaxActuelle) < 50) {
  733.     lcd.print(F("-"));
  734.   } else if (fMinMaxActuelle < 0 && abs(fMinMaxActuelle) < 10) {
  735.     lcd.print(F(" -"));
  736.   } else if (fMinMaxActuelle >= 0 && fMinMaxActuelle < 10) {
  737.     lcd.print(F("  "));
  738.   } else if (fMinMaxActuelle >= 10 && fMinMaxActuelle < 100) {
  739.     lcd.print(F(" "));
  740.   }
  741.   lcd.print(fMinMaxActuelle, 1);
  742.   lcd.print(F(" "));
  743.   lcd.write(223);
  744.   lcd.print(F("F"));
  745. }
  746.  
  747. // Affichage du taux d'humidité
  748.  
  749. void affHumidite(float hMinMaxActuelle) {
  750.   lcd.print(hMinMaxActuelle, 1);
  751.   lcd.print(F(" %"));
  752. }
  753.  
  754. // Affichage du taux de lumiere
  755.  
  756. void affLumiere() {
  757.   lcd.print(lumiere);
  758.   lcd.print(F(" %"));
  759. }
  760. /* ================================================================================================== */
  761. // fonction d'affichage du mode avec défilement
  762. /* ================================================================================================== */
  763.  
  764. void showDefil1() {
  765.  
  766.     //------------------------------------------------------------------------------------------------------
  767.  
  768.     // ligne 1
  769.     String ligne1 = String(jour[jourSemActuel - 1]) + " " + String(jourActuel);  // 'jour de la semaine' + " " + 'numéro du jour'
  770.     if (jourActuel < 2) {                                                 // si le 'numéro du jour' est "1"...
  771.       ligne1 += "er ";                                                // ... on rajoute "er" juste après
  772.     }
  773.     ligne1 += " " + String(mois[moisActuel - 1]) + " " + String(anneeActuel);  // " " + 'nom du mois' + " " + 'année' (4 chiffres)
  774.     longueurLigne = ligne1.length();                                  // longuer de la chaine (nombre de caractère)
  775.  
  776.     if (avance < 19) {                                                // du tour 0 au tour 18
  777.  
  778.       debutAff = 0;                                                   // premier caractère = 0
  779.       finAff = avance + 1;                                            // dernier caractère = numéro du tour (valeur de 'avance')
  780.       lcd.setCursor((19 - avance), 0);                                // on positionne le curseur "(a droite - le nombre de tour fait)
  781.       avance += 1;                                                    // on avance d'un cran le repere
  782.  
  783.     } else if (avance >= 19 && avance <= (longueurLigne + 19)) {      // du tour 19 au tour longueur + 19 (tant qu'on est pas a la fin de la ligne)
  784.  
  785.       debutAff = avance - 19;                                         // le premier caractere prend la valeur avance - 19
  786.       finAff = avance + 1;                                            // le dernier caractère prend la valeur avance + 1
  787.       lcd.setCursor(0, 0);                                            // curseur en haut à gauche
  788.       avance += 1;                                                    // on avance d'un cran le repere
  789.  
  790.     } else if (avance > (longueurLigne + 19)) {                       // si c'est la fin
  791.  
  792.       lcd.setCursor(0, 0);                                            // curseur en haut à gauche
  793.       avance = 0;
  794.  
  795.     }
  796.  
  797.     ligne1 = ligne1.substring(int(debutAff), int(finAff));            // on ne prend que ce qui est à afficher de la ligne
  798.  
  799.     if (ligne1.length() < 20 && avance > 19) {                        //
  800.       for (int i = 0; i <= 20 - ligne1.length(); i++) {               //
  801.         ligne1 += " ";                                                //on ajoute " " a la fin de la chaine pour que le 0 ne reste pas affiché
  802.       }
  803.     }
  804.     lcd.print(ligne1);                                                // on l'affiche
  805.  
  806.     //------------------------------------------------------------------------------------------------------
  807.  
  808.     // Ligne 2                                                        // Construction de la ligne2
  809.  
  810.     lcd.setCursor(0, 1);
  811.     if (reveilActif == true){
  812.       lcd.printByte(3);
  813.     } else {
  814.       lcd.print(F(" "));
  815.     }
  816.     lcd.print(F(" "));
  817.     lcd.printByte(0);
  818.     lcd.print(F("   "));
  819.  
  820.     affHeure();
  821.  
  822.     lcd.print(F("   "));
  823.     lcd.printByte(0);
  824.     if (reveilActif == true){
  825.       lcd.print(F(" "));
  826.       lcd.printByte(3);
  827.     } else {
  828.       lcd.print(F("  "));
  829.     }
  830.  
  831.     // Ligne 3                                                        // Construction de la ligne3
  832.     lcd.setCursor(0, 2);
  833.     lcd.printByte(2);
  834.    
  835.     affCelsius(temp_c);
  836.  
  837.     lcd.print(F(" "));
  838.  
  839.     affFahrenheit(temp_f);
  840.  
  841.     lcd.print(F(" "));
  842.     lcd.printByte(2);
  843.  
  844.     // Ligne 4
  845.     lcd.setCursor(0, 3);
  846.     lcd.printByte(1);
  847.     lcd.print(F("  "));
  848.  
  849.     affHumidite(humidite);
  850.  
  851.     lcd.print(F("    "));
  852.  
  853.     affLumiere();
  854.  
  855.     lcd.print(F("  "));
  856.     lcd.print(F("*"));
  857.  
  858. }
  859.  
  860. /* ================================================================================================== */
  861. // fonction d'affichage des valeurs maxi
  862. /* ================================================================================================== */
  863.  
  864. void showMax() {
  865.   lcd.setCursor(6, 0);
  866.   lcd.print(F("MAXIMUM"));
  867.   lcd.setCursor(0, 1);
  868.   lcd.printByte(2);
  869.   lcd.print(F("     "));
  870.  
  871.   affCelsius(temp_c_max);
  872.  
  873.   lcd.print(F("     "));
  874.   lcd.printByte(2);
  875.   lcd.setCursor(0, 2);
  876.   lcd.printByte(2);
  877.   lcd.print(F("     "));
  878.  
  879.   affFahrenheit(temp_f_max);
  880.  
  881.   lcd.print(F("     "));
  882.   lcd.printByte(2);
  883.   lcd.setCursor(0, 3);
  884.   lcd.printByte(1);
  885.   lcd.print(F("      "));
  886.  
  887.   affHumidite(hum_max);
  888.  
  889.   lcd.print(F("      "));
  890.   lcd.printByte(1);
  891. }
  892.  
  893. /* ================================================================================================== */
  894. // fonction d'affichage des valeurs mini
  895. /* ================================================================================================== */
  896.  
  897. void showMin() {
  898.   lcd.setCursor(6, 0);
  899.   lcd.print(F("MINIMUM"));
  900.   lcd.setCursor(0, 1);
  901.   lcd.printByte(2);
  902.   lcd.print(F("    "));
  903.  
  904.   affCelsius(temp_c_min);
  905.  
  906.   lcd.print(F("      "));
  907.   lcd.printByte(2);
  908.   lcd.setCursor(0, 2);
  909.   lcd.printByte(2);
  910.   lcd.print(F("    "));
  911.  
  912.   affFahrenheit(temp_f_min);
  913.  
  914.   lcd.print(F("      "));
  915.   lcd.printByte(2);
  916.   lcd.setCursor(0, 3);
  917.   lcd.printByte(1);
  918.   lcd.print(F("      "));
  919.  
  920.   affHumidite(hum_max);
  921.  
  922.   lcd.print(F("      "));
  923.   lcd.printByte(1);
  924. }
  925.  
  926. /* ================================================================================================== */
  927. // fonction d'affichage de l'ecran (mode) 3
  928. /* ================================================================================================== */
  929.  
  930. void showAll3() {
  931.  
  932.     lcd.setCursor(0, 0);
  933.     lcd.print(F("  "));
  934.     lcd.printByte(6);
  935.     lcd.print(F("  "));
  936.  
  937.     affDate();
  938.  
  939.     lcd.print(F("  "));
  940.     lcd.printByte(6);
  941.  
  942.     lcd.setCursor(0, 1);
  943.     lcd.printByte(0);
  944.     if (reveilActif == true){
  945.       lcd.print(F("   "));
  946.       lcd.printByte(3);
  947.     } else {
  948.       lcd.print(F("    "));
  949.     }
  950.     lcd.print(F(" "));
  951.    
  952.     affHeure();
  953.    
  954.     if (reveilActif == true){
  955.       lcd.print(F(" "));
  956.       lcd.printByte(3);
  957.     } else {
  958.       lcd.print(F("  "));
  959.     }
  960.     lcd.print(F("   "));
  961.     lcd.printByte(0);
  962.  
  963.     lcd.setCursor(0, 2);
  964.     lcd.printByte(2);
  965.  
  966.     affCelsius(temp_c);
  967.  
  968.     lcd.print(F(" "));
  969.  
  970.     affFahrenheit(temp_f);
  971.  
  972.     lcd.print(F(" "));
  973.     lcd.printByte(2);
  974.     lcd.setCursor(0, 3);
  975.     lcd.printByte(1);
  976.     lcd.print(F("  "));
  977.  
  978.     affHumidite(humidite);
  979.  
  980.     lcd.print(F("    "));
  981.  
  982.     affLumiere();
  983.  
  984.     lcd.print(F("  "));
  985.     lcd.print(F("*"));;
  986.  
  987. }
  988.  
  989. /* ================================================================================================== */
  990. // fonction d'affichage de l'ecran (mode) 2
  991. /* ================================================================================================== */
  992.  
  993. void showAll2() {
  994.  
  995.     if (nouveauJour == true){
  996.       lcd.setCursor(0, 0);
  997.       lcd.print(F("                    "));
  998.     }
  999.     //-------------------------------- Début de ligne 1 -----
  1000.     //-------------------------------- Début du jourSem -----
  1001.     String ligne1 = String( jour[jourSemActuel - 1]);
  1002.     longueurLigne = ligne1.length() + 10;                       // + 10 pour ajouter la date les espaces et l'anim
  1003.     if (longueurLigne <= 20) {
  1004.       positionCentrage = (20 - longueurLigne) / 2;
  1005.       lcd.setCursor(positionCentrage, 0);
  1006.     } else {
  1007.       lcd.setCursor(0, 0);
  1008.     }
  1009.  
  1010.     lcd.print(jour[jourSemActuel - 1]);
  1011.     //-------------------------------- Fin du jourSem -------
  1012.  
  1013.     lcd.print(F(" "));
  1014.  
  1015.     //-------------------------------- Début de la date -----
  1016.  
  1017.     affDate();
  1018.  
  1019.     //-------------------------------- Fin de la date -------
  1020.     //-------------------------------- Fin de ligne 1 ------- --
  1021.  
  1022.     //-------------------------------- Début de ligne 2 ----- --
  1023.     lcd.setCursor(4, 1);
  1024.     //-------------------------------- Début de l'heure -----
  1025.     lcd.printByte(0);
  1026.     lcd.print(" ");
  1027.  
  1028.     affHeure();
  1029.     if (reveilActif == true){
  1030.       lcd.print(F(" "));
  1031.       lcd.printByte(3);
  1032.     } else {
  1033.       lcd.print(F("   "));
  1034.     }
  1035.  
  1036.     //-------------------------------- Fin de l'heure -------
  1037.     //-------------------------------- Fin de ligne 2 ------- --
  1038.  
  1039.     lcd.setCursor(0, 2);
  1040.     lcd.printByte(2);
  1041.  
  1042.     affCelsius(temp_c);
  1043.  
  1044.     lcd.print(F(" - "));
  1045.     lcd.printByte(1);
  1046.     lcd.print(F(" "));
  1047.  
  1048.     affHumidite(humidite);
  1049.  
  1050.     lcd.setCursor(0, 3);
  1051.     lcd.printByte(2);
  1052.  
  1053.     affFahrenheit(temp_f);
  1054.  
  1055.     lcd.print(F(" - "));
  1056.     lcd.print(F("*"));;
  1057.     lcd.print(F("  "));
  1058.  
  1059.     affLumiere();
  1060.  
  1061. }
  1062.  
  1063. /* ================================================================================================== */
  1064. // fonction d'affichage de l'ecran (mode) 1
  1065. /* ================================================================================================== */
  1066.  
  1067. void showAll1() {                                // fonction qui affiche l'heure
  1068.  
  1069.  
  1070.  
  1071.     String ligne1 = String(jour[jourSemActuel - 1]) + " " + String(jourActuel);
  1072.     if (jourActuel < 2) {
  1073.       ligne1 += "er";                             // on rajouter "er" apres le numero du jour si on est le 1er du mois
  1074.     }
  1075.     ligne1 += " " + String(mois[moisActuel - 1]);
  1076.     longueurLigne = ligne1.length();
  1077.     if (longueurLigne <= 20) {
  1078.       positionCentrage = (20 - longueurLigne) / 2;
  1079.       lcd.setCursor(positionCentrage, 0);
  1080.     } else {
  1081.       lcd.setCursor(0, 0);
  1082.     }
  1083.     lcd.print(ligne1);
  1084.  
  1085.     lcd.setCursor(0, 1);
  1086.     lcd.printByte(0);
  1087.     lcd.print(F(" : "));
  1088.  
  1089.     affHeure();
  1090.  
  1091.     lcd.print(F(" "));
  1092.     lcd.print(F("("));
  1093.     lcd.print(anneeActuel);
  1094.     lcd.print(F(")"));
  1095.     if (reveilActif == true){
  1096.       lcd.printByte(3);
  1097.     } else {
  1098.       lcd.print(F(" "));
  1099.     }
  1100.  
  1101.     lcd.setCursor(0, 2);
  1102.     lcd.printByte(2);
  1103.     lcd.print(F(" :"));
  1104.  
  1105.     affCelsius(temp_c);
  1106.  
  1107.     lcd.print(F(" "));
  1108.     affFahrenheit(temp_f);
  1109.  
  1110.     lcd.setCursor(0, 3);
  1111.     lcd.printByte(1);
  1112.     lcd.print(F(" : "));
  1113.  
  1114.     affHumidite(humidite);
  1115.  
  1116.     lcd.print(F("  "));
  1117.     lcd.print(F("*"));;
  1118.     lcd.print(F(" : "));
  1119.  
  1120.     affLumiere();
  1121. }
  1122.  
  1123. void showNow () {
  1124.   lcd.setCursor(0, 0);
  1125.   lcd.print(F("REGLAGE DATE / HEURE"));
  1126.   lcd.setCursor(0, 1);
  1127.   lcd.print(jour[jourSemR-1]);
  1128.   lcd.print(F(" "));
  1129.   lcd.setCursor(12, 1);
  1130.   if (jourR < 10){
  1131.     lcd.print(F("0"));    
  1132.   }
  1133.   lcd.print(jourR);
  1134.   lcd.print(F("/"));
  1135.   if (moisR < 10){
  1136.     lcd.print(F("0"));    
  1137.   }
  1138.   lcd.print(moisR);
  1139.   lcd.print(F("/"));
  1140.   lcd.print(anneeR-2000);
  1141.   lcd.setCursor(5, 2);
  1142.   lcd.print(F("|"));
  1143.   if (heureR < 10) {
  1144.     lcd.print(F("0"));
  1145.   }
  1146.   lcd.print(heureR);
  1147.   lcd.print(F(":"));
  1148.   if (minuteR < 10) {
  1149.     lcd.print(F("0"));
  1150.   }
  1151.   lcd.print(minuteR);
  1152.   lcd.print(F("|"));
  1153.   lcd.print(F("oo"));
  1154.   lcd.print(F("|"));
  1155.   // ------------------------------------------------------------------
  1156.  
  1157.   if (etatClignoSelect == 1){
  1158.     if (positionR < 8){
  1159.       lcd.setCursor(positionsCursReglage[positionR-1],1);
  1160.       lcd.print(F(" "));
  1161.       if (positionR == 1){
  1162.         lcd.print(F("          "));
  1163.       }
  1164.     } else {
  1165.       lcd.setCursor(positionsCursReglage[positionR-1],2);
  1166.       lcd.print(F(" "));
  1167.     }
  1168.   }
  1169.   etatClignoSelect = !etatClignoSelect;
  1170.   // -------------------------------------------------------------------
  1171.  
  1172.   if (k <= ligne.length()){
  1173.     k++;
  1174.   } else {
  1175.     k=0;
  1176.   }
  1177.   texte = ligne.substring(k, k + 20);
  1178.   lcd.setCursor(0, 3);
  1179.   lcd.print(texte);
  1180. }
  1181.  
  1182. /* ================================================================================================== */
  1183. // fonction qui valide les réglages de la date et de l'heure
  1184. /* ================================================================================================== */
  1185.  
  1186. void affValidRegl() {
  1187.   lcd.setCursor(0, 0);
  1188.   lcd.print(F("VALIDER CE REGLAGE ?"));
  1189.   lcd.setCursor(0, 1);
  1190.   lcd.print(jour[jourSemR-1]);
  1191.   lcd.print(F(" "));
  1192.   if (jourR < 10){
  1193.     lcd.print(F("0"));    
  1194.   }
  1195.   lcd.setCursor(12, 1);
  1196.   lcd.print(jourR);
  1197.   lcd.print(F("/"));
  1198.   if (moisR < 10){
  1199.     lcd.print(F("0"));    
  1200.   }
  1201.   lcd.print(moisR);
  1202.   lcd.print(F("/"));
  1203.   lcd.print(anneeR-2000);
  1204.   lcd.setCursor(6, 2);
  1205.   if (heureR < 10) {
  1206.     lcd.print(F("0"));
  1207.   }
  1208.   lcd.print(heureR);
  1209.   lcd.print(F(":"));
  1210.   if (minuteR < 10) {
  1211.     lcd.print(F("0"));
  1212.   }
  1213.   lcd.print(minuteR);
  1214.   lcd.print(F(":"));
  1215.   lcd.print(F("oo"));
  1216.  
  1217.   if (k <= ligne.length()){            // remplacer messageUser2 par ligne pour utiliser la fonction
  1218.     k++;
  1219.   } else {
  1220.     k=0;
  1221.   }
  1222.   texte = ligne.substring(k, k + 20);  // remplacer messageUser2 par ligne pour utiliser la fonction
  1223.   lcd.setCursor(0, 3);
  1224.   lcd.print(texte);
  1225. }
  1226.  
  1227. /* ================================================================================================== */
  1228. // fonction qui transforme les valeurs reçues du module 5 BP en numero de bouton
  1229. /* ================================================================================================== */
  1230.  
  1231. int recupNumBouton (unsigned int lecture) {
  1232.  
  1233.   int boucleLecture;
  1234.   for (boucleLecture = 0; boucleLecture < nombreBoutons; boucleLecture ++) {
  1235.     if (lecture < valLimiteHauteModule[boucleLecture]) {
  1236.       return boucleLecture;
  1237.     }
  1238.   }
  1239.   if (boucleLecture >= nombreBoutons) {
  1240.     boucleLecture = -1;
  1241.   }
  1242.   return boucleLecture;
  1243.  
  1244. }
  1245.  
  1246. void recupereRTC (){
  1247.   RTC.get(rtc, true); {
  1248.     anneeActuel = rtc[6];
  1249.     moisActuel = rtc[5];
  1250.     jourActuel = rtc[4];
  1251.     jourSemActuel = rtc[3];
  1252.     heureActuel = rtc[2];
  1253.     minuteActuel = rtc[1];
  1254.     secondeActuel = rtc[0];
  1255.   }
  1256. }
  1257.  
  1258. /* ================================================================================================== */
  1259. /* ================================================================================================== */
  1260. // SETUP
  1261. /* ================================================================================================== */
  1262.  
  1263. void setup() {
  1264.  
  1265.   lcd.init();                                       // initialisation de l'écran
  1266.   Wire.begin();                                     // lancement connexion simplifiée
  1267.   lcd.backlight();                                  // éclairage de l'écran
  1268.   lcd.createChar(0, pendule);                       // creation du caractère spécial Pendule etat1
  1269.   lcd.createChar(1, goutte);                        // création du caractère spécial goutte
  1270.   lcd.createChar(2, thermo);                        // création du caractère spécial thermometre
  1271.   lcd.createChar(3, reveilOn);                      // création du caractère spécial lumière
  1272.   lcd.createChar(4, repetition);                    // creation du caractère spécial Repet
  1273.   lcd.createChar(5, sonnerie);                   // creation du caractère spécial Pendule etat1
  1274.   lcd.createChar(6, cal);                           // création du caractère spécial agenda
  1275.  
  1276.   pinMode(pinBuzzer, OUTPUT);
  1277.  
  1278.   cycle = millis();
  1279.   cycleSensor = millis() + MargeCycleSensor;
  1280.  
  1281.   #if defined(INIT)
  1282.  
  1283. // INIT
  1284.   for (int i = 0; i < 18; i++) {
  1285.     switch (i){
  1286.       case 0: // Reveil On / Off
  1287.         EEPROM.update(i, valeurInit[0]);
  1288.         break;
  1289.       case 1: // heures
  1290.         EEPROM.update(i, valeurInit[1]);
  1291.         break;
  1292.       case 2: // minutes
  1293.         EEPROM.update(i, valeurInit[2]);
  1294.         break;
  1295.       case 3: // lundi
  1296.         EEPROM.update(i, valeurInit[3]);
  1297.         break;
  1298.       case 4: // mardi
  1299.         EEPROM.update(i, valeurInit[4]);
  1300.         break;
  1301.       case 5: // mercredi
  1302.         EEPROM.update(i, valeurInit[5]);
  1303.         break;
  1304.       case 6: // jeudi
  1305.         EEPROM.update(i, valeurInit[6]);
  1306.         break;
  1307.       case 7: // vendredi
  1308.         EEPROM.update(i, valeurInit[7]);
  1309.         break;
  1310.       case 8: // samedi
  1311.         EEPROM.update(i, valeurInit[8]);
  1312.         break;
  1313.       case 9: // dimanche                     // ENREGISTREMENT CORRECTION
  1314.         EEPROM.update(i, valeurInit[9]);      // j'ai fait exprès de faire une erreur dans l'INIT
  1315.         break;                                // une valeur supp à 1 pour une valeur bool
  1316.       case 10:  // °C mini
  1317.         EEPROM.update(i, valeurInit[10]);
  1318.         break;
  1319.       case 11:  //
  1320.         EEPROM.update(i, valeurInit[11]);
  1321.         break;
  1322.       case 12:
  1323.         EEPROM.update(i, valeurInit[12]);
  1324.         break;
  1325.       case 13:
  1326.         EEPROM.update(i, valeurInit[13]);
  1327.         break;
  1328.       case 14:
  1329.         EEPROM.update(i, valeurInit[14]);
  1330.         break;
  1331.       case 15:
  1332.         EEPROM.update(i, valeurInit[15]);
  1333.         break;
  1334.       case 16:
  1335.         EEPROM.update(i, valeurInit[16]);
  1336.         break;
  1337.       case 17:
  1338.         EEPROM.update(i, valeurInit[17]);
  1339.         break;
  1340.     }
  1341.   }
  1342.  
  1343. #else
  1344.  
  1345. // RECUP
  1346.   for (int i = 0; i < 18; i++) {
  1347.     valeurLueEEPROM = EEPROM.read(i);
  1348.     switch (i){
  1349.       case 0:
  1350.         if (valeurLueEEPROM == 0){
  1351.           reveilActif = false;
  1352.         } else if (valeurLueEEPROM == 1){
  1353.           reveilActif = true;
  1354.         } else {
  1355.           reveilActif = false;
  1356.           EEPROM.update(i, 0);
  1357.         }
  1358.         break;
  1359.       case 1:
  1360.         heureReveil = valeurLueEEPROM;
  1361.         break;
  1362.       case 2:
  1363.         minuteReveil = valeurLueEEPROM;
  1364.         break;
  1365.       case 3:
  1366.         if (valeurLueEEPROM == 0){
  1367.           joursReveilActif[0] = false;
  1368.         } else if (valeurLueEEPROM == 1){
  1369.           joursReveilActif[0] = true;
  1370.         } else {
  1371.           joursReveilActif[0] = false;
  1372.           EEPROM.update(i, 0);
  1373.         }
  1374.         break;
  1375.       case 4:
  1376.         if (valeurLueEEPROM == 0){
  1377.           joursReveilActif[1] = false;
  1378.         } else if (valeurLueEEPROM == 1){
  1379.           joursReveilActif[1] = true;
  1380.         } else {
  1381.           joursReveilActif[1] = false;
  1382.           EEPROM.update(i, 0);
  1383.         }
  1384.         break;
  1385.       case 5:
  1386.         if (valeurLueEEPROM == 0){
  1387.           joursReveilActif[2] = false;
  1388.         } else if (valeurLueEEPROM == 1){
  1389.           joursReveilActif[2] = true;
  1390.         } else {
  1391.           joursReveilActif[2] = false;
  1392.           EEPROM.update(i, 0);
  1393.         }
  1394.         break;
  1395.       case 6:
  1396.         if (valeurLueEEPROM == 0){
  1397.           joursReveilActif[3] = false;
  1398.         } else if (valeurLueEEPROM == 1){
  1399.           joursReveilActif[3] = true;
  1400.         } else {
  1401.           joursReveilActif[3] = false;
  1402.           EEPROM.update(i, 0);
  1403.         }
  1404.         break;
  1405.       case 7:
  1406.         if (valeurLueEEPROM == 0){
  1407.           joursReveilActif[4] = false;
  1408.         } else if (valeurLueEEPROM == 1){
  1409.           joursReveilActif[4] = true;
  1410.         } else {
  1411.           joursReveilActif[4] = false;
  1412.           EEPROM.update(i, 0);
  1413.         }
  1414.         break;
  1415.       case 8:
  1416.         if (valeurLueEEPROM == 0){
  1417.           joursReveilActif[5] = false;
  1418.         } else if (valeurLueEEPROM == 1){
  1419.           joursReveilActif[5] = true;
  1420.         } else {
  1421.           joursReveilActif[5] = false;
  1422.           EEPROM.update(i, 0);
  1423.         }
  1424.         break;
  1425.       case 9:
  1426.         if (valeurLueEEPROM == 0){
  1427.           joursReveilActif[6] = false;
  1428.         } else if (valeurLueEEPROM == 1){
  1429.           joursReveilActif[6] = true;
  1430.         } else {
  1431.           joursReveilActif[6] = false;
  1432.           EEPROM.update(i, 0);
  1433.         }
  1434.         break;
  1435.       case 10:
  1436.         temp_c_min = valeurLueEEPROM;
  1437.         break;
  1438.       case 11:
  1439.         temp_f_min = valeurLueEEPROM;
  1440.         break;
  1441.       case 12:
  1442.         hum_min = valeurLueEEPROM;
  1443.         break;
  1444.       case 13:
  1445.         temp_c_max = valeurLueEEPROM;
  1446.         break;
  1447.       case 14:
  1448.         temp_f_max = valeurLueEEPROM;
  1449.         break;
  1450.       case 15:
  1451.         hum_max = valeurLueEEPROM;
  1452.         break;
  1453.       case 16:
  1454.         if (valeurLueEEPROM > 0 && valeurLueEEPROM <= 4){
  1455.           numeroSonnerie = valeurLueEEPROM;
  1456.         } else {
  1457.           numeroSonnerie = 1;
  1458.           EEPROM.update(i, 1);
  1459.         }
  1460.         break;
  1461.       case 17:
  1462.         if (numeroRepet < 4){
  1463.           numeroRepet = valeurLueEEPROM;
  1464.         } else {        // if (numeroRepet >= 4) [valeur incorrecte]
  1465.           numeroRepet = 1;
  1466.           EEPROM.update(i, 1);
  1467.         }
  1468.         break;
  1469.     }
  1470.   }
  1471. #endif
  1472.  
  1473. }
  1474.  
  1475. /* ================================================================================================== */
  1476. /* ================================================================================================== */
  1477. // LOOP
  1478. /* ================================================================================================== */
  1479.  
  1480. void loop() {
  1481.  
  1482.   // 0. on prend les valeurs de la pendule
  1483.  
  1484.   recupereRTC ();
  1485.   alarmeReveilVerif();
  1486.  
  1487.   if (heureActuel == 0 && secondeActuel < 1){
  1488.     nouveauJour = true;
  1489.   } else {
  1490.     nouveauJour = false;
  1491.   }
  1492.  
  1493.   // 1. on prend les valeurs lumière, température et humidité des capteur
  1494.  
  1495.   if (millis() - cycleSensor >= MargeCycleSensor && update_mode == 0) {
  1496.     lumiere = map(analogRead(pinAnalogLumiere), 0, 1023, 0, 100);
  1497.     cycleSensor = millis();
  1498.     temp_c = sht15.readTemperatureC();
  1499.     temp_f = sht15.readTemperatureF();
  1500.     humidite = sht15.readHumidity();
  1501.  
  1502.     // 2. on met a jour les valeurs min et max si nécessaire
  1503.  
  1504.     if (temp_c > temp_c_max) {                          // si la température mesurée est supérieure à la température max enregistrée
  1505.       temp_c_max = temp_c;                              // alors la température mesurée devient la température max
  1506.       EEPROM.update(13, temp_c_max);
  1507.     }
  1508.  
  1509.     if (temp_c < temp_c_min) {                          // (voir ci dessus et remplacer "max" par "min")
  1510.       temp_c_min = temp_c;                              //
  1511.       EEPROM.update(10, temp_c_min);
  1512.     }
  1513.  
  1514.     if (temp_f > temp_f_max) {                          // meme principe que ci dessus : "voir ci-dessus et remplacer
  1515.       temp_f_max = temp_f;                              //
  1516.       EEPROM.update(14, temp_f_max);
  1517.     }
  1518.  
  1519.     if (temp_f < temp_f_min) {                          // (pareil...)
  1520.       temp_f_min = temp_f;                              //
  1521.       EEPROM.update(11, temp_f_min);
  1522.     }
  1523.  
  1524.     if (humidite > hum_max) {                           // ...
  1525.       hum_max = humidite;                               //
  1526.       EEPROM.update(16, hum_max);
  1527.     }
  1528.  
  1529.     if (humidite < hum_min) {                           //
  1530.       hum_min = humidite;                               //
  1531.       EEPROM.update(12, hum_min);
  1532.     }
  1533.  
  1534.   }
  1535.  
  1536.   // 3. on met à jour l'affichage toutes les secondes
  1537.   // c'est ici que seront gérés les modes d'affichage contrôlé par un module 5 BP
  1538.   valeurLue = analogRead(pinModule5BP);
  1539.   delay(50);
  1540.   valeurLue = analogRead(pinModule5BP);
  1541.   numBouton = recupNumBouton(valeurLue);
  1542.  
  1543. // ===================================================================================================================
  1544. // =========================== Navigation ============================================================================
  1545. // ===================================================================================================================
  1546.  
  1547. // Si on vient d'enfoncer le bouton ----------------------------------------------------------------------------------
  1548.  
  1549.   if (numBouton != derniereLue && numBouton != -1) {
  1550.     dureeEntreDeux = (millis() - debutEntreDeux);
  1551.     debutPression = millis();
  1552.     derniereLue = numBouton;
  1553.     ancienneMemoireNumBouton = memoireNumBouton;
  1554.     memoireNumBouton = numBouton;
  1555.  
  1556. // Si on vient de relâchcer le bouton ---------------------------------------------------------------------------------
  1557.  
  1558.   } else if (numBouton != derniereLue && numBouton == -1) {
  1559.     debutEntreDeux = millis();
  1560.     dureePression = millis() - debutPression;
  1561.     derniereLue = numBouton;
  1562.     if (dureeEntreDeux > 350) {
  1563. // =========================== Clic court ================================================================================
  1564.       if (dureePression < 500 ) {
  1565. // =========================== Mode Afficahe =============================================================================
  1566.         if (update_mode == 0) {
  1567.           switch (memoireNumBouton) {
  1568. // Bouton 0 --------------------------------------------------------------------------------------------------------------
  1569.             case 0:                                       // cle = 0; bouton 1 "haut"
  1570. // ---------- Ecran d'affichage quelconque -------------------------------------------------------------------------------
  1571.               if (modeAff <= 3) {                         // si on vient d'un mode affichage "horloge"
  1572.                 modeAffMem = modeAff;                     // on garde cette valeur en memoire
  1573.                 modeAff = (nombreMode + 1);               // 3
  1574.                 lcd.clear();                              // efface ecran
  1575. // ---------- Ecran de réglage du réveil  --------------------------------------------------------------------------------
  1576.               } else if (modeAff == 8 || modeAff == 11) {
  1577.                 if (positionReglageReveil == 1){
  1578.                   reveilActifReglage = !reveilActifReglage;
  1579.                 } else if (positionReglageReveil == 14){
  1580.                   if (numeroRepetReglage < 4){
  1581.                     numeroRepetReglage += 1;
  1582.                   }
  1583.                 } else if (positionReglageReveil == 2){
  1584.                   if (heureReveilReglage < 14){
  1585.                     heureReveilReglage += 10;
  1586.                   }
  1587.                 } else if (positionReglageReveil == 3){
  1588.                   if (heureReveilReglage < 23){
  1589.                     heureReveilReglage++;
  1590.                   }
  1591.                 } else if (positionReglageReveil == 4){
  1592.                   if (minuteReveilReglage < 49){
  1593.                     minuteReveilReglage += 10;
  1594.                   }
  1595.                 } else if (positionReglageReveil == 5){
  1596.                   if (minuteReveilReglage < 59){
  1597.                     minuteReveilReglage ++;
  1598.                   }
  1599.                 } else if (positionReglageReveil == 13){
  1600.                   if (numeroSonnerieReglage < 4){
  1601.                     numeroSonnerieReglage ++;
  1602.                     ecouteSonnerieTest = true;
  1603.                     tourEcoute1 = 0;
  1604.                     tourEcoute0 = 0;
  1605.                   }
  1606.                 } else if (positionReglageReveil > 5 && positionReglageReveil < 13){
  1607.                   joursReveilActifReglage[positionReglageReveil-6] = !joursReveilActifReglage[positionReglageReveil-6];
  1608.                 }
  1609. // ---------- Ecran d'alarme (que si repet actif) ------------------------------------------------------------------------
  1610.               } else if (modeAff == 10 && numeroRepet > 0){
  1611.                 timerBoucle = 500;
  1612.                 if (repetOn == false){
  1613.                   heureMemoireRepet = heureReveil;
  1614.                   minuteMemoireRepet = minuteReveil;
  1615.                 }
  1616.                 minuteReveil += numeroRepet*5;
  1617.                 modeAff = modeAffMem;
  1618.                 noTone(pinBuzzer);
  1619.                 if (minuteReveil >= 60){
  1620.                   minuteReveil -= 60;
  1621.                   heureReveil +=1;
  1622.                   if (heureReveil >= 24){
  1623.                     heureReveil = 0;
  1624.                     if (joursReveilActif[(jourSemActuel + 2)] == false){
  1625.                       joursReveilActif[(jourSemActuel + 2)] == true;
  1626.                       jourActifForce = true;
  1627.                     }
  1628.                   }
  1629.                 }
  1630.                 repetOn = true;
  1631.               }
  1632.               break;                                        // stop => etape suivante
  1633. // Bouton 1 --------------------------------------------------------------------------------------------------------------
  1634.             case 1:                                         // cle = 1; bouton 2 "gauche"
  1635.               if (modeAff <= 3){
  1636.                 if (modeAff > 0) {                          // on vérifie qu'on soit pas au bout
  1637.                   modeAff -= 1;                             // on retire 1
  1638.                 } else {                                    // sinon
  1639.                   modeAff = nombreMode;                     // on passe au max
  1640.                 }
  1641.                 lcd.clear();                                // efface ecran
  1642. // ---------- Ecran de réglage du réveil  --------------------------------------------------------------------------------
  1643.               } else if (modeAff == 8 || modeAff == 11){
  1644.                 if (positionReglageReveil > 1){
  1645.                   positionReglageReveil --;
  1646.                 } else {
  1647.                   positionReglageReveil = 14;
  1648.                 }
  1649.               } else if (modeAff == 9){
  1650.                 positionReglageReveil = 1;
  1651.                 modeAff=8;
  1652.                 recupeTexte(messageUser1);
  1653.                 k = 0;
  1654.               }
  1655.               break;                                      // stop => etape suivante
  1656. // Bouton 2 --------------------------------------------------------------------------------------------------------------
  1657.             case 2:                                       // cle = 2; bouton 3 "bas"
  1658. // ---------- Ecran d'affichage quelconque -------------------------------------------------------------------------------
  1659.               if (modeAff <= 3) {                         // si on vient d'un mode affichage "horloge"
  1660.                 modeAffMem = modeAff;                     // on garde cette valeur en memoire
  1661.                 modeAff = (nombreMode + 2);               // 4
  1662.                 lcd.clear();                              // on vide l'ecran pour l'affichage du mode a venir
  1663. // ---------- Ecran de réglage du réveil  --------------------------------------------------------------------------------
  1664.               } else if (modeAff == 8 || modeAff == 11) {
  1665.                 if (positionReglageReveil == 1){
  1666.                   reveilActifReglage = !reveilActifReglage;
  1667.                 } else if (positionReglageReveil == 14){
  1668.                   if (numeroRepetReglage > 0){
  1669.                     numeroRepetReglage -= 1;
  1670.                   }
  1671.                 } else if (positionReglageReveil == 2){
  1672.                   if (heureReveilReglage > 10){
  1673.                     heureReveilReglage -= 10;
  1674.                   }
  1675.                 } else if (positionReglageReveil == 3){
  1676.                   if (heureReveilReglage > 0){
  1677.                     heureReveilReglage -= 1;
  1678.                   }
  1679.                 } else if (positionReglageReveil == 4){
  1680.                   if (minuteReveilReglage > 10){
  1681.                     minuteReveilReglage -= 10;
  1682.                   }
  1683.                 } else if (positionReglageReveil == 5){
  1684.                   if (minuteReveilReglage > 0){
  1685.                     minuteReveilReglage -=1;
  1686.                   }
  1687.                 } else if (positionReglageReveil == 13){
  1688.                   if (numeroSonnerieReglage > 1){
  1689.                     numeroSonnerieReglage --;
  1690.                     ecouteSonnerieTest = true;
  1691.                     tourEcoute1 = 0;
  1692.                     tourEcoute0 = 0;
  1693.                   }
  1694.                 } else if (positionReglageReveil > 5 && positionReglageReveil < 13){
  1695.                   joursReveilActifReglage[positionReglageReveil-6] = !joursReveilActifReglage[positionReglageReveil-6];
  1696.                 }
  1697.               }
  1698.               break;                                        // stop => etape suivante
  1699. // Bouton 3 --------------------------------------------------------------------------------------------------------------
  1700.             case 3:                                         // cle = 3; bouton 4 "droite"
  1701. // ---------- Ecran d'affichage quelconque -------------------------------------------------------------------------------
  1702.               if (modeAff <= 3){
  1703.                 if (modeAff < nombreMode) {                 // si on est pas au "bout haut" des modes (nombreMode)
  1704.                   modeAff += 1;                             // on passe au niveau suivant (+1)
  1705.                 } else {                                    // sinon
  1706.                   modeAff = 0;                              // on remet le mode au "bout bas" des modes (0)
  1707.                 }
  1708.                 lcd.clear();                                // efface ecran
  1709.               }
  1710. // ---------- Ecran de réglage du réveil  --------------------------------------------------------------------------------
  1711.               if (modeAff == 8 || modeAff == 11){
  1712.                 if (positionReglageReveil < 14){
  1713.                   positionReglageReveil ++;
  1714.                 } else {
  1715.                   positionReglageReveil = 1;
  1716.                 }
  1717. // ---------- Ecran de validation du réglage du réveil -------------------------------------------------------------------
  1718.               } else if (modeAff == 9){
  1719.                 reveilActif = reveilActifReglage;
  1720.                 numeroSonnerie = numeroSonnerieReglage;
  1721.                 numeroRepet = numeroRepetReglage;
  1722.                 heureReveil = heureReveilReglage;
  1723.                 minuteReveil = minuteReveilReglage;
  1724.                
  1725.                 for (int w = 0; w < 7; w++){
  1726.                   joursReveilActif[w] = joursReveilActifReglage[w];
  1727.                 }
  1728.                
  1729.                 for (int m = 0; m < 18; m++){
  1730.                   switch (m){
  1731.                     case 0:
  1732.                       if (reveilActif == 0){
  1733.                         EEPROM.update(m, 0);
  1734.                       } else {
  1735.                         EEPROM.update(m, 1);
  1736.                       }
  1737.                       break;
  1738.                     case 1:
  1739.                         EEPROM.update(m, heureReveil);
  1740.                       break;
  1741.                     case 2:
  1742.                         EEPROM.update(m, minuteReveil);
  1743.                       break;
  1744.                     case 3:
  1745.                       if (joursReveilActif[0] == 0){
  1746.                         EEPROM.update(m, 0);
  1747.                       } else {
  1748.                         EEPROM.update(m, 1);
  1749.                       }
  1750.                       break;
  1751.                     case 4:
  1752.                       if (joursReveilActif[1] == 0){
  1753.                         EEPROM.update(m, 0);
  1754.                       } else {
  1755.                         EEPROM.update(m, 1);
  1756.                       }
  1757.                       break;
  1758.                     case 5:
  1759.                       if (joursReveilActif[2] == 0){
  1760.                         EEPROM.update(m, 0);
  1761.                       } else {
  1762.                         EEPROM.update(m, 1);
  1763.                       }
  1764.                       break;
  1765.                     case 6:
  1766.                       if (joursReveilActif[3] == 0){
  1767.                         EEPROM.update(m, 0);
  1768.                       } else {
  1769.                         EEPROM.update(m, 1);
  1770.                       }
  1771.                       break;
  1772.                     case 7:
  1773.                       if (joursReveilActif[4] == 0){
  1774.                         EEPROM.update(m, 0);
  1775.                       } else {
  1776.                         EEPROM.update(m, 1);
  1777.                       }
  1778.                       break;
  1779.                     case 8:
  1780.                       if (joursReveilActif[5] == 0){
  1781.                         EEPROM.update(m, 0);
  1782.                       } else {
  1783.                         EEPROM.update(m, 1);
  1784.                       }
  1785.                       break;
  1786.                     case 9:
  1787.                       if (joursReveilActif[6] == 0){
  1788.                         EEPROM.update(m, 0);
  1789.                       } else {
  1790.                         EEPROM.update(m, 1);
  1791.                       }
  1792.                       break;
  1793.                     case 16:
  1794.                       EEPROM.update(m, numeroSonnerie);
  1795.                       break;
  1796.                     case 17:
  1797.                       EEPROM.update(m, numeroRepet);
  1798.                       break;
  1799.                   }
  1800.                 }
  1801.                
  1802.                 timerBoucle = 500;
  1803.                 positionReglageReveil = 1;
  1804.                 modeAff = modeAffMem;
  1805.                 lcd.clear();
  1806.               }
  1807.               break;                                      // stop => etape suivante
  1808. // Bouton 4 --------------------------------------------------------------------------------------------------------------
  1809.             case 4:                                       // pas encore utilisé bouton du milieu
  1810. // ---------- Ecran Mini ou Maxi  ----------------------------------------------------------------------------------------
  1811.               if (modeAff > nombreMode && modeAff <= (nombreMode + 2)) { // Si on est en mode mini ou maxi
  1812.                 modeAff = modeAffMem;                     // on rappelle le mode d'affichage mémorisé
  1813.                 lcd.clear();
  1814. // ---------- Ecran Réglage reveil ---------------------------------------------------------------------------------------
  1815.               } else if (modeAff == 8 || modeAff == 11){
  1816.                 modeAff = 9;
  1817.                 recupeTexte(messageUser2);
  1818.                 k = 0;
  1819.               } else if (modeAff == 9){
  1820.                 modeAff = modeAffMem;
  1821.                 lcd.clear();
  1822.               }
  1823. // ---------- Ecran d'alarme ---------------------------------------------------------------------------------------------
  1824.               else if (modeAff == 10){
  1825.                 modeAff = modeAffMem;
  1826.                 timerBoucle = 500;
  1827.                 if (repetOn == true){
  1828.                   heureReveil = heureMemoireRepet;
  1829.                   minuteReveil = minuteMemoireRepet;
  1830.                   repetOn = false;
  1831.                 }
  1832.                 if (jourActifForce = true){
  1833.                   joursReveilActif[(jourSemActuel + 1)] == false;
  1834.                 }
  1835.                 noTone(pinBuzzer);
  1836.                 lcd.clear();
  1837.               }
  1838.               break;                                      // stop => etape suivante
  1839.           }
  1840. // =========================== Mode Réglage =============================================================================
  1841.         } else {
  1842.           switch (memoireNumBouton) {
  1843. // Bouton 0 --------------------------------------------------------------------------------------------------------------
  1844.             case 0:
  1845. // ---------- Ecran de Réglage -------------------------------------------------------------------------------------------
  1846.               if (modeAff == 6) {
  1847.               switch (positionR) {
  1848.                 case 1:
  1849.                   if (jourSemR < 7) {
  1850.                     jourSemR += 1;
  1851.                   }
  1852.                   break;
  1853.                 case 2:
  1854.                   if (jourR <= 21) {
  1855.                     jourR += 10;
  1856.                   }
  1857.                   break;
  1858.                 case 3:
  1859.                 if (jourR <= 30) {
  1860.                     jourR += 1;
  1861.                   }
  1862.                   break;
  1863.                 case 4:
  1864.                   if (moisR <= 2) {
  1865.                     moisR += 10;
  1866.                   }
  1867.                   break;
  1868.                 case 5:
  1869.                   if (moisR <= 11) {
  1870.                     moisR += 1;
  1871.                   }
  1872.                   break;
  1873.                 case 6:
  1874.                   anneeR += 10;
  1875.                   break;
  1876.                 case 7:
  1877.                   anneeR += 1;
  1878.                   break;
  1879.                 case 8:
  1880.                   if (heureR <= 13) {
  1881.                     heureR += 10;
  1882.                   }
  1883.                   break;
  1884.                 case 9:
  1885.                   if (heureR < 23) {
  1886.                     heureR ++;
  1887.                   }
  1888.                   break;
  1889.                 case 10:
  1890.                   if (minuteR < 50) {
  1891.                     minuteR += 10;
  1892.                   }
  1893.                   break;
  1894.                 case 11:
  1895.                   if (minuteR < 59) {
  1896.                     minuteR ++;
  1897.                   }
  1898.                   break;
  1899.               }
  1900.  
  1901.               }
  1902.               break;
  1903. // Bouton 1 --------------------------------------------------------------------------------------------------------------
  1904.             case 1:
  1905. // ---------- Ecran de Réglage -------------------------------------------------------------------------------------------
  1906.               if (modeAff == 6) {
  1907.                 if (positionR > 1) {
  1908.                   positionR--;
  1909.                 }
  1910. // ---------- Ecran de  validation du réglage ----------------------------------------------------------------------------
  1911.               } else if (modeAff == 7) {
  1912.                 modeAff = 6;
  1913.                 k = 0;
  1914.                 recupeTexte(messageUser1);
  1915.                 lcd.clear();
  1916.               }
  1917.               break;
  1918. // Bouton 2 --------------------------------------------------------------------------------------------------------------
  1919.             case 2:
  1920. // ---------- Ecran de Réglage -------------------------------------------------------------------------------------------
  1921.               if (modeAff == 6) {
  1922.               switch (positionR) {
  1923.                 case 1:
  1924.                   if (jourSemR > 1) {
  1925.                     jourSemR -= 1;
  1926.                   }
  1927.                   break;
  1928.                 case 2:
  1929.                   if (jourR > 10) {
  1930.                     jourR -= 10;
  1931.                   }
  1932.                   break;
  1933.                 case 3:
  1934.                 if (jourR > 1) {
  1935.                     jourR -= 1;
  1936.                   }
  1937.                   break;
  1938.                 case 4:
  1939.                   if (moisR > 10) {
  1940.                     moisR -= 10;
  1941.                   }
  1942.                   break;
  1943.                 case 5:
  1944.                   if (moisR > 1) {
  1945.                     moisR -= 1;
  1946.                   }
  1947.                   break;
  1948.                 case 6:
  1949.                   if ((anneeR - 2000) > 30){
  1950.                     anneeR -= 10;
  1951.                   }
  1952.                   break;
  1953.                 case 7:
  1954.                   if ((anneeR - 2000) > 1){
  1955.                   anneeR -= 1;
  1956.                   }
  1957.                   break;
  1958.                 case 8:
  1959.                   if (heureR >= 10) {
  1960.                     heureR -= 10;
  1961.                   }
  1962.                   break;
  1963.                 case 9:
  1964.                   if (heureR > 0) {
  1965.                     heureR --;
  1966.                   }
  1967.                   break;
  1968.                 case 10:
  1969.                   if (minuteR >= 10) {
  1970.                     minuteR -= 10;
  1971.                   }
  1972.                   break;
  1973.                 case 11:
  1974.                   if (minuteR > 0) {
  1975.                     minuteR --;
  1976.                   }
  1977.                   break;
  1978.               }
  1979.  
  1980.               }
  1981.               break;
  1982. // Bouton 3 --------------------------------------------------------------------------------------------------------------
  1983.             case 3:
  1984. // ---------- Ecran de Réglage -------------------------------------------------------------------------------------------
  1985.               if (modeAff == 6){
  1986.                 if (positionR < 11) {
  1987.                   positionR++;
  1988.                 }
  1989.               modeAff = 6;
  1990.               //lcd.clear();
  1991. // ---------- Ecran de  validation du réglage ----------------------------------------------------------------------------
  1992.               } else if (modeAff == 7){
  1993.  
  1994.               RTC.stop();
  1995.               if (minuteActuel != minuteR){
  1996.                 RTC.set(DS1307_MIN, minuteR);
  1997.                 RTC.set(DS1307_SEC, 1);
  1998.               }
  1999.               if (heureActuel != heureR){
  2000.                 RTC.set(DS1307_HR, heureR);
  2001.                 RTC.set(DS1307_SEC, 1);
  2002.               }
  2003.               if (jourSemActuel != jourSemR){
  2004.                 RTC.set(DS1307_DOW,jourSemR);
  2005.               }
  2006.               if (jourActuel != jourR){
  2007.                 RTC.set(DS1307_DATE,jourR);
  2008.               }
  2009.               if (moisActuel != moisR){
  2010.                 RTC.set(DS1307_MTH,moisR);
  2011.               }
  2012.               if (anneeActuel != anneeR){
  2013.                 RTC.set(DS1307_YR,anneeR);
  2014.               }
  2015.               RTC.start();
  2016.               update_mode == 0;
  2017.               modeAff = modeAffMem;
  2018.               lcd.clear();
  2019.               }
  2020.               break;
  2021. // Bouton 4 --------------------------------------------------------------------------------------------------------------
  2022.             case 4:
  2023. // ---------- Ecran de Réglage -------------------------------------------------------------------------------------------
  2024.               if (modeAff == 6) {
  2025.                 modeAff = 7;
  2026.               }
  2027.               recupeTexte(messageUser2);
  2028.               k = 0;
  2029.               lcd.clear();
  2030.               break;
  2031.           }
  2032.         }
  2033. // =========================== Clic Long =================================================================================
  2034.       } else if (dureePression >= 500) {
  2035. // =========================== Mode Affichage ============================================================================
  2036.         if (update_mode == 0) {
  2037.           switch (memoireNumBouton) {
  2038.             case 0:
  2039. // ---------- Ecran d'affichage quelconque -------------------------------------------------------------------------------
  2040.               if (modeAff <= 3) {
  2041.                 modeAffMem = modeAff;
  2042.                 reveilActifReglage = reveilActif;
  2043.                 numeroRepetReglage = numeroRepet;
  2044.                 heureReveilReglage = heureReveil;
  2045.                 minuteReveilReglage = minuteReveil;
  2046.                 numeroSonnerieReglage = numeroSonnerie;
  2047.                 for (int y = 0; y < 7; y++){
  2048.                   joursReveilActifReglage[y] = joursReveilActif[y];
  2049.                 }
  2050.                 positionReglageReveil = 1;
  2051.               }
  2052.               modeAff = 8;
  2053.               recupeTexte(messageUser1);
  2054.               k = 0;
  2055.               timerBoucle = 675;
  2056.               lcd.clear();
  2057.               break;
  2058. // Bouton 4 --------------------------------------------------------------------------------------------------------------
  2059.             case 4:
  2060. // ---------- Ecran d'affichage quelconque -------------------------------------------------------------------------------
  2061.               if (modeAff <= 3) {
  2062.                 modeAffMem = modeAff;
  2063.                 anneeR = anneeActuel;
  2064.                 moisR = moisActuel;
  2065.                 jourR = jourActuel;
  2066.                 jourSemR = jourSemActuel;
  2067.                 heureR = heureActuel;
  2068.                 minuteR = minuteActuel;
  2069.                 secondeR = 0;
  2070.                 positionR = 1;
  2071.                 cligno = millis();
  2072.                 modeAff = 6;
  2073.                 update_mode = 1;
  2074.                 recupeTexte(messageUser1);
  2075.                 k = 0;
  2076.                 lcd.clear();
  2077. // ---------- Ecran de Réglage du réveil ---------------------------------------------------------------------------------
  2078.               } else if (modeAff == 8 || modeAff == 11){
  2079.                 timerBoucle = 500;
  2080.                 modeAff = modeAffMem;
  2081.                 lcd.clear();
  2082.               } else if (modeAff == 9){
  2083.                 modeAff = modeAffMem;
  2084.                 lcd.clear();
  2085.               }
  2086.               break;
  2087.           }
  2088. // =========================== Mode Réglage ==============================================================================
  2089.         } else if (update_mode == 1) {
  2090.  
  2091.           switch (memoireNumBouton) {
  2092. // Bouton 4 --------------------------------------------------------------------------------------------------------------
  2093.             case 4:
  2094.               modeAff = modeAffMem;
  2095.               update_mode = 0;
  2096.               lcd.clear();
  2097.               break;
  2098.           }
  2099.  
  2100.         }
  2101.  
  2102.       }
  2103. // =========================== Double Clic =============================================================================
  2104.       if (dureePression < 250 ) {
  2105.         if (memoireNumBouton == ancienneMemoireNumBouton) {   // Double clic
  2106.  
  2107.           /*switch (memoireNumBouton){
  2108.             case 4:
  2109.           }*/
  2110.  
  2111.         }
  2112.       }
  2113.     }
  2114.   }
  2115.  
  2116. // ===================================================================================================================
  2117. // =========================== Affichage =============================================================================
  2118. // ===================================================================================================================
  2119.  
  2120.   if (millis() - cycle >= timerBoucle) {                    // toutes les secondes
  2121.     cycle = millis();
  2122.     switch (modeAff) {
  2123.       case 0:
  2124.         //showReveilEcran2();
  2125.         showAll1();                                 // Affichage mode 1
  2126.         break;
  2127.       case 1:
  2128.         showAll2();                                 // Affichage mode 2
  2129.         break;
  2130.       case 2:
  2131.         showAll3();                                 // Affichage mode 3
  2132.         break;
  2133.       case 3:
  2134.         showDefil1();                               // Affichage mode 4
  2135.         break;
  2136.       case 4:
  2137.         showMax();                                  // Affichage mode Max
  2138.         break;
  2139.       case 5:
  2140.         showMin();                                  // Affichage mode Min
  2141.         break;
  2142.       case 6:
  2143.         showNow();                                  // Affichage mode "Réglage"
  2144.         break;
  2145.       case 7:
  2146.         affValidRegl();                             // Affichage mode "Validation Réglage"
  2147.         break;
  2148.       case 8:
  2149.         showReveilEcran1();                         // Affiche le mode de raglage du reveil écran 1
  2150.         break;
  2151.       case 9:
  2152.         validReglageReveil();                       // Affiche le mode de validation du réglage de reveil
  2153.         break;
  2154.       case 10:
  2155.         showAlarme();                               // Affiche le mode de validation du réglage de reveil
  2156.         break;
  2157.       case 11:
  2158.         showReveilEcran2();                         // Affiche le mode de raglage du reveil écran 2
  2159.         break;
  2160.     }
  2161.   }
  2162. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!