Bonjour probléme de bibliothèque

alain4133 · August 17, 2022, 7:10pm

je suis un débutant j'ai construit un poulailler

il me reste plus que la porte a installé et bien sur c'est automatique et le code viens d'un autre personne.
mais voilas j'ai problème avec
voilas l'erreur qui m'indique aprés avoir verrifé

il me dit

Arduino : 1.8.19 (Windows 10), Carte : "Arduino Uno"

Porte_automatique_pour_poulailler_version_5-A:2:10: fatal error: DS1302.h: No such file or directory

#include <DS1302.h>

      ^~~~~~~~~~

compilation terminated.

exit status 1

DS1302.h: No such file or directory

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

//DS1302 //////////////////////////////////////////
#include <DS1302.h>
DS1302 rtc(7, 6, 5);
Time t;
DS1302_RAM ramBuffer;

//L298N ///////////////////////////////////////////
#include <Stepper.h>
const int stepsPerRevolution = 200;
// Initialise le moteur sur les broches 8 à 11
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

//LCD I2C /////////////////////////////////////////
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);

//Gestion des entrées /////////////////////////////
int Bthaut = A1;       //Pin du Bouton fleche haut
int Btbas = A2;        //Pin du Bouton fleche bas
int Btselect = A3;     //Pin du Bouton select
const int LDR = A0;    //Pin du LDR
const int fdchaut = 3; //Pin du fin de course haut
const int fdcbas = 4;  //Pin du fin de course bas

//Gestion des timers //////////////////////////////
unsigned long timerarduino;
unsigned long previousTime = 0;
unsigned long previousTimer1 = 0;
unsigned long Timer1;
unsigned long Timer1ON = 500;  // Tps clignotement pendant saisie
unsigned long Timer1OFF = 500; // Tps clignotement pendant saisie
bool Timer1Etat;
unsigned long previousTimer2 = 0;
unsigned long Timer2;
unsigned long Timer2ON = 60000; // Utiliser pour decompte pour hysterisis
unsigned long previousTimer3 = 0;
unsigned long Timer3;
unsigned long Timer3ON = 1000; // Utiliser pour decompte pour hysterisis
unsigned long previousTimer4 = 0;
unsigned long Timer4;
unsigned long Timer4ON; // Utiliser pour la mise en veille
unsigned long previousTimer5 = 0;
unsigned long Timer5;
unsigned long Timer5ON = 2000; // Utiliser pour la saisie rapide
unsigned long previousTimer6 = 0;
unsigned long Timer6;
unsigned long Timer6ON = 500; // Utiliser pour la saisie rapide
int TpsAvouverture;
int TpsAvfermeture;
unsigned long TpsAvouverturesec;
unsigned long TpsAvfermeturesec;

//Variable Menu ///////////////////////////////////
int Accueil = 1;       // Ecran Accueil
int Menu;              // Menu Principal
int MenuMdm;           // Menu Mode de Marche
int MenuPara;          // Menu parametres
int MenuParaProg;      // Menu parametres programmateur
int ParaProgHouv;      // Menu parametrage Progr Heure ouverture
int ParaProgHferm;     // Menu parametrage Progr Heure fermeture
int MenuParaLDR;       // Menu parametres LDR
int ParaLDRouv;        // Menu parametrage LDR ouverture
int ParaLDRferm;       // Menu parametrage LDR fermeture
int ParaLDRhysteresis; // Menu parametrage LDR Hysteresis
int MenuSyst;          // Menu systeme
int MenuSystVeille;    // Menu systeme veille
int SystVeilleetat;    // Menu systeme veille etat
int SystVeilleTpsactiv;// Menu systeme veille tps activation
int SystReglheure;     // Menu systeme Reglage Heure


//Variables programme/////////////////////////////
boolean RefreshAffHeure;
boolean RefreshAffEtatTrappeManu;
int Thour;
int Tmin;
int Tsec;
boolean EtatBtselect;
boolean EtatBthaut ;
boolean EtatBtbas;
boolean Etattrappe = 0;
boolean Saisierapide;
boolean Pause;         //Permet de mettre en pause certain affichage temps que moteur activer
int Modedemarche = 1;  //Defini mode de marche (1 = Progr, 2 = LDR, 3 = Manu)
long V_MinOuv = 23;    //Stock valeur Minute pour Progr Minute ouverture
long V_HeureOuv = 11;  //Stock valeur Heure pour Progr Heure ouverture
long V_MinFerm = 23;   //Stock valeur Minute pour Progr Minute fermeture
long V_HeureFerm = 23; //Stock valeur Heure pour Progr Heure fermeture
int V_LDRouv = 800;    //Stock valeur LDR pour ouverture
int V_LDRferm = 700;   //Stock valeur LDR pour fermeture
int V_Hysteresis = 20; //Stock valeur LDR pour Hysterisis
int V_Tsystheure;      //Stock la valeur dans systeme Reglage heure avant SAV
int V_Tsystminute;     //Stock la valeur dans systeme Reglage minute avant SAV
int V_Tsystseconde;    //Stock la valeur dans systeme Reglage seconde avant SAV
int Veille = 0;        // Ecran mise en veille
boolean Etatveille = 0;//Stock etat de la veille (actif ou inactif)
int V_TpsAvveille = 5; //Stock la valeur tps avant mise en veille en sec

byte customChar1[] = {B00000, B00000, B00001, B00001, B00001, B10110, B11000, B10000};
byte customChar2[] = {B00000, B11000, B00100, B10100, B00110, B01000, B00100, B00100};
byte customChar3[] = {B01000, B00111, B00001, B00011, B00000, B00000, B00000, B00000};
byte customChar4[] = {B01000, B10000, B10000, B11000, B00000, B00000, B00000, B00000};

void setup()
{
  Serial.begin(9600);
  //DS1302 //////////////////////////////////////////
  rtc.halt(false);
  // Réglez l'horloge en mode exécution et désactivez la protection en écriture
  rtc.writeProtect(true);
  rtc.setDOW(FRIDAY);        // Set Day-of-Week to FRIDAY
  rtc.setTime(19, 03, 0);     // Set the time to 12:00:00 (24hr format)
  rtc.setDate(22, 8, 2021);   // Set the date to August 6th, 2010
  //LCD I2C /////////////////////////////////////////
  lcd.init(); lcd.backlight();
  lcd.createChar(1, customChar1); lcd.createChar(2, customChar2);
  lcd.createChar(3, customChar3); lcd.createChar(4, customChar4);
  //Declaration des entrées /////////////////////////
  pinMode(Bthaut, INPUT_PULLUP);
  pinMode(Btbas, INPUT_PULLUP);
  pinMode(Btselect, INPUT_PULLUP);
  pinMode(fdchaut, INPUT_PULLUP);
  pinMode(fdcbas, INPUT_PULLUP);
  //L298N ///////////////////////////////////////////
  myStepper.setSpeed(200); //Vitesse de rotation du moteur à 200
  //Lecture et Récupération des valeurs de réglages dans RAM DS1302
  ramBuffer = rtc.readBuffer();
  Serial.println("Lecture de la RAM : ");
  for (int i = 0; i < 31; i++)
  {
    Serial.print(" "); Serial.print(ramBuffer.cell[i]); Serial.print(" ");
  }
  Serial.println(" ");
  LoadSav();
  //Intro ///////////////////////////////////////////
  Intro();
}

void loop()
{
  int valeurLDR = analogRead(LDR);
  timerarduino = millis();
  //Ecran Accueil ///////////////////////////////////
  switch (Accueil) {
    case 0:
      break;
    case 1:
      lcd.clear(); Accueil++;
      break;
    case 2:
      lcd.setCursor(0, 1); lcd.print("Mode :");
      lcd.setCursor(0, 2); lcd.print("Trappe :");
      Accueil++;
      break;
    case 3:
      if (Modedemarche == 1) {
        Accueil = 4 ; RefreshAffHeure = 0;
      }
      else if (Modedemarche == 2) {
        Accueil = 5; RefreshAffHeure = 0;
      }
      else if (Modedemarche == 3) {
        Accueil = 6; RefreshAffHeure = 0;
      }
      break;
    case 4:
      lcd.setCursor(7, 1); lcd.print("Programmateur");
      lcd.setCursor(0, 3); lcd.print("Ouv ");
      if (V_HeureOuv < 10) {
        lcd.setCursor(4, 3); lcd.print("0");
        lcd.setCursor(5, 3); lcd.print(V_HeureOuv);
      }
      else {
        lcd.setCursor(4, 3); lcd.print(V_HeureOuv);
      }
      lcd.setCursor(6, 3); lcd.print(":");
      if (V_MinOuv < 10) {
        lcd.setCursor(7, 3); lcd.print("0");
        lcd.setCursor(8, 3); lcd.print(V_MinOuv);
      }
      else {
        lcd.setCursor(7, 3);
        lcd.print(V_MinOuv);
      }
      lcd.setCursor(11, 3); lcd.print("Fer");
      if (V_HeureFerm < 10) {
        lcd.setCursor(15, 3); lcd.print("0");
        lcd.setCursor(16, 3); lcd.print(V_HeureFerm);
      }
      else {
        lcd.setCursor(15, 3);
        lcd.print(V_HeureFerm);
      }
      lcd.setCursor(17, 3); lcd.print(":");
      if (V_MinFerm < 10) {
        lcd.setCursor(18, 3); lcd.print("0");
        lcd.setCursor(19, 3); lcd.print(V_MinFerm);
      }
      else {
        lcd.setCursor(18, 3); lcd.print(V_MinFerm);
      }
      Accueil = 7;
      break;
    case 5:
      lcd.setCursor(7, 1); lcd.print("LDR");
      lcd.setCursor(0, 3); lcd.print("Ouv.: ");
      lcd.setCursor(6, 3); lcd.print(V_LDRouv);
      lcd.setCursor(11, 3); lcd.print("Fer.: ");
      lcd.setCursor(17, 3); lcd.print(V_LDRferm);
      Accueil = 7;
      break;
    case 6:
      lcd.setCursor(7, 1); lcd.print("Manuel");
      Accueil = 7;
      break;
    case 7:
      if (Modedemarche == 2) {
        if (Pause == 0) {
          AffValeurLDR(valeurLDR); AffEtatTrappeLDR();
        }
        GestionTrappeLDR(); GestionTrappeAuto(); EcrVeille();
      }
      if (Modedemarche == 1) {
        if (Pause == 0) {
          GestionTrappeProg(); AffEtatTrappeProg();
        }
        GestionTrappeAuto(); EcrVeille();
      }
      if (Modedemarche == 3) {
        GestionTrappeManu(); AffEtatTrappeManu(); EcrVeille();
      }
      AffHeure();
      break;
    default:
      break;
  }

  //Menu principal///////////////////////////////////
  switch (Menu) {
    case 0:
      break;
    case 1:
      lcd.clear(); Menu++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("------- Menu -------");
      lcd.setCursor(0, 1); lcd.print("Mode de marche");
      lcd.setCursor(0, 2); lcd.print("Parametres");
      lcd.setCursor(0, 3); lcd.print("Systeme");
      Menu++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1);
      lcd.print (" ");
      break;
    case 6:
      lcd.clear(); Menu = 8;
      break;
    case 7:
      lcd.setCursor(0, 0); lcd.print("------- Menu -------");
      lcd.setCursor(0, 1); lcd.print("Mode de marche");
      lcd.setCursor(0, 2); lcd.print("Parametres");
      lcd.setCursor(0, 3); lcd.print("Systeme");
      Menu = 5;
      break;
    case 8:
      lcd.clear(); Menu++;
      break;
    case 9:
      lcd.setCursor(0, 0); lcd.print("------- Menu -------");
      lcd.setCursor(0, 1); lcd.print("Retour");
      Menu = 11;
      break;
    case 10:
      Menu = 7;
      break;
    case 11:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu mode de marche//////////////////////////////
  switch (MenuMdm) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuMdm++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
      lcd.setCursor(0, 1); lcd.print("Programmateur");
      lcd.setCursor(0, 2); lcd.print("LDR");
      lcd.setCursor(0, 3); lcd.print("Manuel");
      MenuMdm++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    case 6:
      lcd.clear();
      MenuMdm = 8;
      break;
    case 7:
      lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
      lcd.setCursor(0, 1); lcd.print("Programmateur");
      lcd.setCursor(0, 2); lcd.print("LDR");
      lcd.setCursor(0, 3); lcd.print("Manuel");
      MenuMdm = 5;
      break;
    case 8:
      lcd.clear();
      MenuMdm++;
      break;
    case 9:
      lcd.setCursor(0, 0); lcd.print("-- Mode de marche --");
      lcd.setCursor(0, 1); lcd.print("Retour");
      MenuMdm = 11;
      break;
    case 10:
      MenuMdm = 7;
      break;
    case 11:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu parametres /////////////////////////////////
  switch (MenuPara) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuPara++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("---- Parametres ----");
      lcd.setCursor(0, 1); lcd.print("Programmateur");
      lcd.setCursor(0, 2); lcd.print("LDR");
      lcd.setCursor(0, 3); lcd.print("Retour");
      MenuPara++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu Parametres programmateur////////////////////
  switch (MenuParaProg) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuParaProg++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("-- Programmateur ---");
      lcd.setCursor(0, 1); lcd.print("Heure ouverture");
      lcd.setCursor(0, 2); lcd.print("Heure fermeture");
      lcd.setCursor(0, 3); lcd.print("Retour");
      MenuParaProg++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu parametrage Progr Heure ouverture///////////
  switch (ParaProgHouv) {
    case 0:
      break;
    case 1:
      lcd.clear(); ParaProgHouv++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("- Heure ouverture --");
      lcd.setCursor(9, 2); lcd.print(":");
      if (V_MinOuv < 10) {
        lcd.setCursor(10, 2); lcd.print("0");
        lcd.setCursor(11, 2); lcd.print(V_MinOuv);
      }
      else {
        lcd.setCursor(10, 2); lcd.print(V_MinOuv);
      }
      ParaProgHouv++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_HeureOuv < 10) {
            lcd.setCursor(7, 2); lcd.print("0");
            lcd.setCursor(8, 2); lcd.print(V_HeureOuv);
          }
          else {
            lcd.setCursor(7, 2); lcd.print(V_HeureOuv);
          }
        }
        else {
          lcd.setCursor(7, 2); lcd.print("  ");
        }
      }
      break;
    case 4:
      if (V_HeureOuv < 10) {
        lcd.setCursor(7, 2); lcd.print("0");
        lcd.setCursor(8, 2); lcd.print(V_HeureOuv);
      }
      else {
        lcd.setCursor(7, 2); lcd.print(V_HeureOuv);
      }
      previousTimer1 = timerarduino;
      ParaProgHouv++;
      break;
    case 5:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_MinOuv < 10) {
            lcd.setCursor(10, 2); lcd.print("0");
            lcd.setCursor(11, 2); lcd.print(V_MinOuv);
          }
          else {
            lcd.setCursor(10, 2); lcd.print(V_MinOuv);
          }
        }
        else {
          lcd.setCursor(10, 2); lcd.print("  ");
        }
      }
      break;
    default:
      break;
  }

  //Menu parametrage Progr Heure fermeture///////////
  switch (ParaProgHferm) {
    case 0:
      break;
    case 1:
      lcd.clear(); ParaProgHferm++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("- Heure fermeture --");
      lcd.setCursor(9, 2); lcd.print(":");
      if (V_MinFerm < 10) {
        lcd.setCursor(10, 2); lcd.print("0");
        lcd.setCursor(11, 2); lcd.print(V_MinFerm);
      }
      else {
        lcd.setCursor(10, 2); lcd.print(V_MinFerm);
      }
      ParaProgHferm++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_HeureFerm < 10) {
            lcd.setCursor(7, 2); lcd.print("0");
            lcd.setCursor(8, 2); lcd.print(V_HeureFerm);
          }
          else {
            lcd.setCursor(7, 2); lcd.print(V_HeureFerm);
          }
        }
        else {
          lcd.setCursor(7, 2); lcd.print("  ");
        }
      }
      break;
    case 4:
      if (V_HeureFerm < 10) {
        lcd.setCursor(7, 2); lcd.print("0");
        lcd.setCursor(8, 2); lcd.print(V_HeureFerm);
      }
      else {
        lcd.setCursor(7, 2); lcd.print(V_HeureFerm);
      }
      ParaProgHferm++;
      break;
    case 5:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_MinFerm < 10) {
            lcd.setCursor(10, 2); lcd.print("0");
            lcd.setCursor(11, 2); lcd.print(V_MinFerm);
          }
          else {
            lcd.setCursor(10, 2); lcd.print(V_MinFerm);
          }
        }
        else {
          lcd.setCursor(10, 2); lcd.print("  ");
        }
      }
      break;
    case 6:
      break;
    default:
      break;
  }

  //Menu parametres LDR /////////////////////////////
  switch (MenuParaLDR) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuParaLDR++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("------- LDR --------");
      lcd.setCursor(0, 1); lcd.print("Valeur ouverture");
      lcd.setCursor(0, 2); lcd.print("Valeur fermeture");
      lcd.setCursor(0, 3); lcd.print("Hysteresis");
      MenuParaLDR++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    case 6:
      lcd.clear();
      MenuParaLDR = 8;
      break;
    case 7:
      lcd.setCursor(0, 0); lcd.print("------- LDR --------");
      lcd.setCursor(0, 1); lcd.print("Valeur ouverture");
      lcd.setCursor(0, 2); lcd.print("Valeur fermeture");
      lcd.setCursor(0, 3); lcd.print("Hysteresis");
      MenuParaLDR = 5;
      break;
    case 8:
      lcd.clear();
      MenuParaLDR++;
      break;
    case 9:
      lcd.setCursor(0, 0); lcd.print("------- LDR --------");
      lcd.setCursor(0, 1); lcd.print("Retour");
      MenuParaLDR = 11;
      break;
    case 10:
      MenuParaLDR = 7;
      break;
    case 11:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu parametrage LDR ouverture///////////////////
  switch (ParaLDRouv) {
    case 0:
      break;
    case 1:
      lcd.clear(); ParaLDRouv++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("-- LDR ouverture ---");
      ParaLDRouv++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat || Saisierapide) {
          if (V_LDRouv < 100 && V_LDRouv > 9) {
            lcd.setCursor(8, 2); lcd.print(" ");
            lcd.setCursor(9, 2); lcd.print(V_LDRouv);
          }
          else if (V_LDRouv < 10) {
            lcd.setCursor(8, 2); lcd.print("  ");
            lcd.setCursor(10, 2); lcd.print(V_LDRouv);
          }
          else {
            lcd.setCursor(8, 2); lcd.print(V_LDRouv);
          }
        }
        else {
          lcd.setCursor(8, 2); lcd.print("   ");
        }
      }
      break;
    default:
      break;
  }

  //Menu parametrage LDR fermeture //////////////////
  switch (ParaLDRferm) {
    case 0:
      break;
    case 1:
      lcd.clear(); ParaLDRferm++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("-- LDR fermeture ---");
      ParaLDRferm++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino; Timer1Etat = !Timer1Etat;
        if (Timer1Etat || Saisierapide) {
          if (V_LDRferm < 100 && V_LDRferm > 9) {
            lcd.setCursor(8, 2); lcd.print(" ");
            lcd.setCursor(9, 2); lcd.print(V_LDRferm);
          }
          else if (V_LDRferm < 10) {
            lcd.setCursor(8, 2); lcd.print("  ");
            lcd.setCursor(10, 2); lcd.print(V_LDRferm);
          }
          else {
            lcd.setCursor(8, 2); lcd.print(V_LDRferm);
          }
        }
        else {
          lcd.setCursor(8, 2); lcd.print("   ");
        }
      }
      break;
    default:
      break;
  }

  //Menu parametrage LDR Hysteresis /////////////////
  switch (ParaLDRhysteresis) {
    case 0:
      break;
    case 1:
      lcd.clear(); ParaLDRhysteresis++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print ("-- LDR hysteresis --");
      lcd.setCursor(11, 2); lcd.print ("min");
      ParaLDRhysteresis++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat || Saisierapide) {
          if (V_Hysteresis < 100 && V_Hysteresis > 9) {
            lcd.setCursor(7, 2); lcd.print(" ");
            lcd.setCursor(8, 2); lcd.print(V_Hysteresis);
          }
          else if (V_Hysteresis < 10) {
            lcd.setCursor(7, 2); lcd.print("  ");
            lcd.setCursor(9, 2); lcd.print(V_Hysteresis);
          }
          else {
            lcd.setCursor(7, 2); lcd.print(V_Hysteresis);
          }
        }
        else {
          lcd.setCursor(7, 2); lcd.print("   ");
        }
      }
      break;
    default:
      break;
  }

  //Menu Systeme ////////////////////////////////////
  switch (MenuSyst) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuSyst++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("----- Systeme ------");
      lcd.setCursor(0, 1); lcd.print("Reglage heure");
      lcd.setCursor(0, 2); lcd.print("Gest. Veille");
      lcd.setCursor(0, 3); lcd.print("Retour");
      MenuSyst++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print (" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu systeme Reglage Heure //////////////////////
  switch (SystReglheure) {
    case 0:
      break;
    case 1:
      lcd.clear();
      V_Tsystheure = t.hour; V_Tsystminute = t.min; V_Tsystseconde = t.sec;
      SystReglheure++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("-- Heure systeme ---");
      lcd.setCursor(8, 2); lcd.print(":");
      if (V_Tsystminute < 10) {
        lcd.setCursor(9, 2); lcd.print("0");
        lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
      }
      else {
        lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
      }
      lcd.setCursor(11, 2); lcd.print(":");
      if (V_Tsystseconde < 10) {
        lcd.setCursor(12, 2); lcd.print("0");
        lcd.setCursor(13, 2); lcd.print(V_Tsystseconde);
      }
      else {
        lcd.setCursor(12, 2); lcd.print(V_Tsystseconde);
      }
      SystReglheure++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_Tsystheure < 10) {
            lcd.setCursor(6, 2); lcd.print("0");
            lcd.setCursor(7, 2); lcd.print(V_Tsystheure);
          }
          else {
            lcd.setCursor(6, 2); lcd.print(V_Tsystheure);
          }
        }
        else {
          lcd.setCursor(6, 2); lcd.print("  ");
        }
      }
      break;
    case 4:
      if (V_Tsystheure < 10) {
        lcd.setCursor(6, 2); lcd.print("0");
        lcd.setCursor(7, 2); lcd.print(V_Tsystheure);
      }
      else {
        lcd.setCursor(6, 2); lcd.print(V_Tsystheure);
      }
      SystReglheure++;
      break;
    case 5:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_Tsystminute < 10) {
            lcd.setCursor(9, 2); lcd.print("0");
            lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
          }
          else {
            lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
          }
        }
        else {
          lcd.setCursor(9, 2); lcd.print("  ");
        }
      }
      break;
    case 6:
      if (V_Tsystminute < 10) {
        lcd.setCursor(9, 2); lcd.print("0");
        lcd.setCursor(10, 2); lcd.print(V_Tsystminute);
      }
      else {
        lcd.setCursor(9, 2); lcd.print(V_Tsystminute);
      }
      SystReglheure++;
      break;
    case 7:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (V_Tsystseconde < 10) {
            lcd.setCursor(12, 2); lcd.print("0");
            lcd.setCursor(13, 2); lcd.print(V_Tsystseconde);
          }
          else {
            lcd.setCursor(12, 2); lcd.print(V_Tsystseconde);
          }
        }
        else {
          lcd.setCursor(12, 2); lcd.print("  ");
        }
      }
      break;
    default:
      break;
  }

  //Menu systeme veille /////////////////////////////
  switch (MenuSystVeille) {
    case 0:
      break;
    case 1:
      lcd.clear(); MenuSystVeille++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("----- Veille  ------");
      lcd.setCursor(0, 1); lcd.print("Etat");
      lcd.setCursor(0, 2); lcd.print("Tps av. activation");
      lcd.setCursor(0, 3); lcd.print("Retour");
      MenuSystVeille++;
      break;
    case 3:
      lcd.setCursor(19, 3); lcd.print(" ");
      lcd.setCursor(19, 1); lcd.print("<");
      lcd.setCursor(19, 2); lcd.print(" ");
      break;
    case 4:
      lcd.setCursor(19, 1); lcd.print(" ");
      lcd.setCursor(19, 2); lcd.print("<");
      lcd.setCursor(19, 3); lcd.print(" ");
      break;
    case 5:
      lcd.setCursor(19, 2); lcd.print(" ");
      lcd.setCursor(19, 3); lcd.print("<");
      lcd.setCursor(19, 1); lcd.print(" ");
      break;
    default:
      break;
  }

  //Menu systeme veille etat //////////////////
  switch (SystVeilleetat) {
    case 0:
      break;
    case 1:
      lcd.clear(); SystVeilleetat++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print("--- Veille Etat ----");
      SystVeilleetat++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      }
      else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino; Timer1Etat = !Timer1Etat;
        if (Timer1Etat) {
          if (Etatveille) {
            lcd.setCursor(6, 2); lcd.print(" Actif ");
          }
          else {
            lcd.setCursor(6, 2); lcd.print("Inactif");
          }
        }
        else {
          lcd.setCursor(6, 2); lcd.print("       ");
        }
      }
      break;
    default:
      break;
  }
  //Menu systeme veille Tps av. activation //////////
  switch (SystVeilleTpsactiv) {
    case 0:
      break;
    case 1:
      lcd.clear(); SystVeilleTpsactiv++;
      break;
    case 2:
      lcd.setCursor(0, 0); lcd.print(" Tps av. Act Veille ");
      lcd.setCursor(11, 2); lcd.print("sec");
      SystVeilleTpsactiv++;
      break;
    case 3:
      if (Timer1Etat) {
        Timer1 = Timer1OFF;
      } else {
        Timer1 = Timer1ON;
      }
      if ((timerarduino - previousTimer1) > Timer1) {
        previousTimer1 = timerarduino;
        Timer1Etat = !Timer1Etat;
        if (Timer1Etat || Saisierapide) {
          if (V_TpsAvveille < 100 && V_TpsAvveille > 9) {
            lcd.setCursor(7, 2); lcd.print("  ");
            lcd.setCursor(8, 2); lcd.print(V_TpsAvveille);
          }
          else if (V_TpsAvveille < 10) {
            lcd.setCursor(7, 2); lcd.print("  ");
            lcd.setCursor(9, 2); lcd.print(V_TpsAvveille);
          }
          else {
            lcd.setCursor(7, 2); lcd.print(V_TpsAvveille);
          }
        }
        else {
          lcd.setCursor(7, 2); lcd.print ("   ");
        }
      }
      break;
    default:
      break;
  }
  ///////////////////////////////////////////////////

  //Gestion des boutons /////////////////////////////
  if (digitalRead(Bthaut) == LOW && EtatBthaut == 0) {
    EtatBthaut = 1; NavBthaut();
  }
  if (digitalRead(Btbas) == LOW && EtatBtbas == 0) {
    EtatBtbas = 1; NavBtbas();
  }
  if (digitalRead(Btselect) == LOW && EtatBtselect == 0) {
    EtatBtselect = 1; navmenuboutonselect();
  }
  if (digitalRead(Bthaut) == LOW && EtatBthaut == 1) {
    if ((timerarduino - previousTimer5) > Timer5ON) {
      NavBthautrapide(); Saisierapide = 1;
    }
  }
  if (digitalRead(Btbas) == LOW && EtatBtbas == 1) {
    if ((timerarduino - previousTimer5) > Timer5ON) {
      NavBtbasrapide(); Saisierapide = 1;
    }
  }
  if (digitalRead(Bthaut) == HIGH && digitalRead(Btbas) == HIGH) {
    previousTimer5 = timerarduino; Saisierapide = 0;
  }
  if (digitalRead(Bthaut) == HIGH) {
    EtatBthaut = 0;
  }
  if (digitalRead(Btbas) == HIGH) {
    EtatBtbas = 0;
  }
  if (digitalRead(Btselect) == HIGH) {
    EtatBtselect = 0;
  }
}

//Gestion de la Trappe par Programmateur //////////
void GestionTrappeProg() {
  unsigned long ouverturesec = (V_MinOuv * 60) + (V_HeureOuv * 3600);
  unsigned long fermeturesec = (V_MinFerm * 60) + (V_HeureFerm * 3600);
  t = rtc.getTime();
  long hour = t.hour; long min = t.min; long sec = t.sec;
  unsigned long heuresec = (min * 60) + (hour * 3600) + sec;
  if (ouverturesec < fermeturesec && Modedemarche == 1) {
    if (heuresec > ouverturesec && heuresec < fermeturesec) {
      Etattrappe = 1;
    }
    else {
      Etattrappe = 0;
    }
  }
  if (ouverturesec > fermeturesec && Modedemarche == 1) {
    if ((heuresec > ouverturesec && heuresec > fermeturesec) || (heuresec < ouverturesec && heuresec < fermeturesec)) {
      Etattrappe = 1;
    }
    if (heuresec > fermeturesec && heuresec < ouverturesec) {
      Etattrappe = 0;
    }
  }
}

//Gestion de la Trappe par le LDR /////////////////
void GestionTrappeLDR() {
  int valeurLDR = analogRead(LDR);
  if (valeurLDR > V_LDRouv && Etattrappe == 0 && Modedemarche == 2) {
    if (TpsAvouverture == 0 && TpsAvouverturesec == 0) {
      TpsAvouverture = V_Hysteresis; previousTimer2 = timerarduino;
      TpsAvouverturesec = V_Hysteresis * 60; previousTimer3 = timerarduino;
    }
    else {
      if ((timerarduino - previousTimer2) > Timer2ON) {
        previousTimer2 = timerarduino; TpsAvouverture--;
      }
      if ((timerarduino - previousTimer3) > Timer3ON) {
        previousTimer3 = timerarduino; TpsAvouverturesec--;
      }
    }
    if (TpsAvouverturesec == 0) {
      lcd.setCursor(9, 2); lcd.print("           ");
      Etattrappe = 1;
    }
  }
  else {
    TpsAvouverture = 0; TpsAvouverturesec = 0;
  }
  if (valeurLDR < V_LDRferm && Etattrappe == 1 && Modedemarche == 2) {
    if (TpsAvfermeture == 0 && TpsAvfermeturesec == 0) {
      TpsAvfermeture = V_Hysteresis; previousTimer2 = timerarduino;
      TpsAvfermeturesec = V_Hysteresis * 60; previousTimer3 = timerarduino;
    }
    else {
      if ((timerarduino - previousTimer2) > Timer2ON) {
        previousTimer2 = timerarduino; TpsAvfermeture--;
      }
      if ((timerarduino - previousTimer3) > Timer3ON) {
        previousTimer3 = timerarduino; TpsAvfermeturesec--;
      }
    }
    if (TpsAvfermeturesec == 0 ) {
      lcd.setCursor(9, 2); lcd.print("           ");
      Etattrappe = 0;
    }
  }
  else {
    TpsAvfermeture = 0; TpsAvfermeturesec = 0;
  }
}

//Affichage Etat Trappe en Mode Manu /////
void AffEtatTrappeManu() {
  if (digitalRead(Bthaut) == LOW && RefreshAffEtatTrappeManu == 0) {
    lcd.setCursor(9, 2); lcd.print("       ");
    RefreshAffEtatTrappeManu = 1;
  }
  if (digitalRead(Btbas) == LOW && RefreshAffEtatTrappeManu == 0) {
    lcd.setCursor(9, 2); lcd.print("       ");
    RefreshAffEtatTrappeManu = 1;
  }
  if (digitalRead(Bthaut) == HIGH && digitalRead(Btbas) == HIGH) {
    RefreshAffEtatTrappeManu = 0;
  }
  if (digitalRead(fdchaut) == LOW && digitalRead(Btbas) == HIGH) {
    lcd.setCursor(9, 2); lcd.print("Ouverte");
  }
  if (digitalRead(fdcbas) == LOW && digitalRead(Bthaut) == HIGH) {
    lcd.setCursor(9, 2); lcd.print("Fermer ");
  }
}

//Affichage Etat Trappe en Mode Programmateur /////
void AffEtatTrappeProg() {
  if (Etattrappe == 1 && digitalRead(fdchaut) == LOW) {
    lcd.setCursor(9, 2); lcd.print("Ouverte");
  }
  if (Etattrappe == 0 && digitalRead(fdcbas) == LOW) {
    lcd.setCursor(9, 2); lcd.print("Fermer ");
  }
}

//Affichage Etat Trappe en Mode LDR ///////////////
void AffEtatTrappeLDR() {
  if (TpsAvfermeturesec == 0 && TpsAvouverturesec == 0 && TpsAvouverture == 0 && Etattrappe == 1 && TpsAvfermeture == 0 && digitalRead(fdchaut) == LOW) {
    lcd.setCursor(9, 2); lcd.print("Ouverte    ");
  }
  if (TpsAvfermeturesec == 0 && TpsAvouverturesec == 0 && TpsAvfermeture == 0 && Etattrappe == 0 && TpsAvouverture == 0 && digitalRead(fdcbas) == LOW) {
    lcd.setCursor(9, 2);  lcd.print("Fermer     ");
  }
  if (TpsAvouverture > 1) {
    if (TpsAvouverture < 100 && TpsAvouverture > 9) {
      lcd.setCursor(9, 2); lcd.print(" ");
      lcd.setCursor(10, 2); lcd.print(TpsAvouverture);
    }
    else if (TpsAvouverture < 10) {
      lcd.setCursor(9, 2); lcd.print("  ");
      lcd.setCursor(11, 2); lcd.print(TpsAvouverture);
    }
    else {
      lcd.setCursor(9, 2); lcd.print(TpsAvouverture);
    }
    lcd.setCursor(12, 2); lcd.print("m AvOuv.");
  }
  if (TpsAvouverturesec < 60 && TpsAvouverturesec != 0) {
    if (TpsAvouverturesec < 100 && TpsAvouverturesec > 9) {
      lcd.setCursor(9, 2); lcd.print(" ");
      lcd.setCursor(10, 2); lcd.print(TpsAvouverturesec);
    }
    else if (TpsAvouverture < 10) {
      lcd.setCursor(9, 2); lcd.print("  ");
      lcd.setCursor(11, 2); lcd.print(TpsAvouverturesec);
    }
    else {
      lcd.setCursor(9, 2); lcd.print(TpsAvouverturesec);
    }
    lcd.setCursor(12, 2); lcd.print("s AvOuv.");
  }
  if (TpsAvfermeture > 1) {
    lcd.setCursor(0, 2); lcd.print("Trappe : ");
    if (TpsAvfermeture < 100 && TpsAvfermeture > 9) {
      lcd.setCursor(9, 2); lcd.print(" ");
      lcd.setCursor(10, 2); lcd.print(TpsAvfermeture);
    }
    else if (TpsAvfermeture < 10 && TpsAvfermeture > 0) {
      lcd.setCursor(9, 2); lcd.print("  ");
      lcd.setCursor(11, 2); lcd.print(TpsAvfermeture);
    }
    else if (TpsAvfermeture < 1) {
      lcd.setCursor(9, 2); lcd.print("            ");
    }
    else {
      lcd.setCursor(9, 2); lcd.print(TpsAvfermeture);
    }
    lcd.setCursor(12, 2);  lcd.print("m AvFer.");
  }
  if (TpsAvfermeturesec < 60 && TpsAvfermeturesec != 0) {
    if (TpsAvfermeturesec < 100 && TpsAvfermeturesec > 9) {
      lcd.setCursor(9, 2); lcd.print(" ");
      lcd.setCursor(10, 2); lcd.print(TpsAvfermeturesec);
    }
    else if (TpsAvfermeture < 10) {
      lcd.setCursor(9, 2); lcd.print("  ");
      lcd.setCursor(11, 2); lcd.print(TpsAvfermeturesec);
    }
    else {
      lcd.setCursor(9, 2); lcd.print(TpsAvfermeturesec);
    }
    lcd.setCursor(12, 2); lcd.print("s AvOuv.");
  }
}

//Affichage Valeur LDR ////////////////////////////
int AffValeurLDR (int valeurLDR) {
  if (valeurLDR < 1000 && valeurLDR > 99) {
    lcd.setCursor(16, 0); lcd.print(" ");
    lcd.setCursor(17, 0); lcd.print(valeurLDR);
  }
  else if (valeurLDR < 100 && valeurLDR > 9) {
    lcd.setCursor(16, 0); lcd.print("  ");
    lcd.setCursor(18, 0); lcd.print(valeurLDR);
  }
  else if (valeurLDR < 10) {
    lcd.setCursor(16, 0); lcd.print("   ");
    lcd.setCursor(19, 0); lcd.print(valeurLDR);
  }
  else {
    lcd.setCursor(16, 0); lcd.print(valeurLDR);
  }
}

//Affichage de l'heure ////////////////////////////
void AffHeure() {
  t = rtc.getTime();
  if (RefreshAffHeure == 0) {
    Thour = t.hour; Tmin = t.min; Tsec = t.sec;
    lcd.setCursor(2, 0); lcd.print(":");
    lcd.setCursor(5, 0); lcd.print(":");
  }

  if (Thour != t.hour || RefreshAffHeure == 0 ) {
    Thour = t.hour;
    if (t.hour < 10) {
      lcd.setCursor(0, 0); lcd.print("0");
      lcd.setCursor(1, 0); lcd.print(t.hour);
    }
    else {
      lcd.setCursor(0, 0); lcd.print(t.hour);
    }
  }
  if (Tmin != t.min || RefreshAffHeure == 0 ) {
    Tmin = t.min;
    if (t.min < 10) {
      lcd.setCursor(3, 0); lcd.print("0");
      lcd.setCursor(4, 0); lcd.print(t.min);
    }
    else {
      lcd.setCursor(3, 0); lcd.print(t.min);
    }
  }
  if (Tsec != t.sec || RefreshAffHeure == 0 ) {
    Tsec = t.sec;
    if (t.sec < 10) {
      lcd.setCursor(6, 0); lcd.print("0");
      lcd.setCursor(7, 0); lcd.print(t.sec);
    }
    else {
      lcd.setCursor(6, 0); lcd.print(t.sec);
    }
    RefreshAffHeure = 1;
  }
}

//Gestion de la Trappe en Mode Manu ///////////////
void GestionTrappeManu() {
  if (Modedemarche == 3 && Accueil == 7 && EtatBthaut == 1 && digitalRead(fdchaut) == HIGH) {
    Pause = 1; myStepper.step(1);
  }
  else if (Modedemarche == 3 && Accueil == 7 && EtatBtbas == 1 && digitalRead(fdcbas) == HIGH) {
    Pause = 1; myStepper.step(-1);
  }
  else {
    Moteurrepos ();
    Pause = 0;
  }
  if (digitalRead(fdchaut) == LOW) {
    Etattrappe = 1;
  }
  if (digitalRead(fdcbas) == LOW) {
    Etattrappe = 0;
  }
}

//Gestion de la Trappe en Mode Auto ///////////////
void GestionTrappeAuto() {
  if ((Modedemarche == 1 || Modedemarche == 2) && Etattrappe == 1 && digitalRead(fdchaut) == HIGH) {
    Pause = 1; myStepper.step(1);
  }
  else if ((Modedemarche == 1 || Modedemarche == 2) && Etattrappe == 0 && digitalRead(fdcbas) == HIGH) {
    Pause = 1; myStepper.step(-1);
  }
  else {
    Moteurrepos ();
    Pause = 0;
  }
}

//Mise au repos moteur PAP ////////////////////////
void Moteurrepos () {
  digitalWrite (8, LOW); digitalWrite (9, LOW);
  digitalWrite (10, LOW); digitalWrite (11, LOW);
}

//Sauvegarde Heures sur DS1302 ////////////////////
void SavHeure () {
  rtc.writeProtect(false);
  rtc.setTime(V_Tsystheure, V_Tsystminute, V_Tsystseconde);
  delay(50);
  rtc.writeProtect(true);
}

//Sauvegarde sur RAM DS1302 ///////////////////////
void Sav () {
  rtc.writeProtect(false);
  byte v_1LDRouverture = lowByte(V_LDRouv); byte v_2LDRouverture = highByte(V_LDRouv);
  byte v_1LDRfermeture = lowByte(V_LDRferm); byte v_2LDRfermeture = highByte(V_LDRferm);
  byte v_1LDRhysteresis = lowByte(V_Hysteresis); byte v_2LDRhysteresis = highByte(V_Hysteresis);
  byte v_1V_TpsAvveille = lowByte(V_TpsAvveille); byte v_2V_TpsAvveille = highByte(V_TpsAvveille);
  ramBuffer.cell[0] = 99; ramBuffer.cell[1] = Modedemarche;
  ramBuffer.cell[2] = V_HeureOuv; ramBuffer.cell[3] = V_MinOuv;
  ramBuffer.cell[4] = V_HeureFerm; ramBuffer.cell[5] = V_MinFerm;
  ramBuffer.cell[6] = v_1LDRouverture; ramBuffer.cell[7] = v_2LDRouverture;
  ramBuffer.cell[8] = v_1LDRfermeture; ramBuffer.cell[9] = v_2LDRfermeture;
  ramBuffer.cell[10] = v_1LDRhysteresis; ramBuffer.cell[11] = v_2LDRhysteresis;
  ramBuffer.cell[12] = Etattrappe; ramBuffer.cell[13] = Etatveille;
  ramBuffer.cell[14] = v_1V_TpsAvveille; ramBuffer.cell[15] = v_2V_TpsAvveille;

  rtc.writeBuffer(ramBuffer);
  ramBuffer = rtc.readBuffer();
  rtc.writeProtect(true);
  Serial.println("Sauvegarde sur RAM");
  for (int i = 0; i < 31; i++)
  {
    Serial.print(" "); Serial.print(ramBuffer.cell[i]); Serial.print(" ");
  }
  Serial.println(" ");
}

//Chargement de la RAM DS1302 /////////////////////
void LoadSav() {
  if (ramBuffer.cell[0] == 99) {
    Modedemarche = ramBuffer.cell[1]; V_HeureOuv = ramBuffer.cell[2];
    V_MinOuv = ramBuffer.cell[3]; V_HeureFerm = ramBuffer.cell[4];
    V_MinFerm = ramBuffer.cell[5];
    byte V_1LDRouv = ramBuffer.cell[6]; byte V_2LDRouv = ramBuffer.cell[7];
    byte V_1LDRferm = ramBuffer.cell[8]; byte V_2LDRferm = ramBuffer.cell[9];
    byte V_1Hysteresis = ramBuffer.cell[10]; byte V_2Hysteresis = ramBuffer.cell[11];
    Etattrappe = ramBuffer.cell[12]; Etatveille = ramBuffer.cell[13];
    byte V_1V_TpsAvveille = ramBuffer.cell[14]; byte V_2V_TpsAvveille = ramBuffer.cell[15];
    V_LDRouv = word(V_2LDRouv, V_1LDRouv); V_LDRferm = word(V_2LDRferm, V_1LDRferm);
    V_Hysteresis = word(V_2Hysteresis, V_1Hysteresis);
    V_TpsAvveille = word(V_2V_TpsAvveille, V_1V_TpsAvveille);
  }
}

//Gestion Navigation Bouton Bas ///////////////////
void NavBtbas() {
  if (Menu > 0) {
    if (Menu > 10) {
      Menu = 1;
    } else {
      Menu++;
    }
  }
  if (MenuMdm > 0) {
    if (MenuMdm > 10) {
      MenuMdm = 1;
    } else {
      MenuMdm++;
    }
  }
  if (MenuPara > 0) {
    if (MenuPara > 4) {
      MenuPara = 3;
    } else {
      MenuPara++;
    }
  }
  if (MenuParaProg > 0) {
    if (MenuParaProg > 4) {
      MenuParaProg = 3;
    } else {
      MenuParaProg++;
    }
  }
  if (MenuParaLDR > 0) {
    if (MenuParaLDR > 10) {
      MenuParaLDR = 1;
    } else {
      MenuParaLDR++;
    }
  }
  if (MenuSyst > 0) {
    if (MenuSyst > 4) {
      MenuSyst = 2;
    } else {
      MenuSyst++;
    }
  }
  if (MenuSystVeille > 0) {
    if (MenuSystVeille > 4) {
      MenuSystVeille = 2;
    } else {
      MenuSystVeille++;
    }
  }
  if (SystVeilleetat == 3) {
    Etatveille = !Etatveille;
  }
  if (SystVeilleTpsactiv == 3) {
    if (V_TpsAvveille < 4) {
      V_TpsAvveille = 180;
    } else {
      V_TpsAvveille--;
    }
  }
  if (ParaProgHouv == 3) {
    if (V_HeureOuv < 1) {
      V_HeureOuv = 23;
    } else {
      V_HeureOuv--;
    }
  }
  if (ParaProgHouv == 5) {
    if (V_MinOuv < 1) {
      V_MinOuv = 59;
    } else {
      V_MinOuv--;
    }
  }
  if (ParaProgHferm == 3) {
    if (V_HeureFerm < 1) {
      V_HeureFerm = 23;
    } else {
      V_HeureFerm--;
    }
  }
  if (ParaProgHferm == 5) {
    if (V_MinFerm < 1) {
      V_MinFerm = 59;
    } else {
      V_MinFerm--;
    }
  }
  if (ParaLDRouv == 3) {
    if (V_LDRouv < 1) {
      V_LDRouv = 999;
    } else {
      V_LDRouv--;
    }
  }
  if (ParaLDRferm == 3) {
    if (V_LDRferm < 1) {
      V_LDRferm = 999;
    } else {
      V_LDRferm--;
    }
  }
  if (ParaLDRhysteresis == 3) {
    if (V_Hysteresis < 1) {
      V_Hysteresis = 999;
    } else {
      V_Hysteresis--;
    }
  }
  if (SystReglheure == 3) {
    if (V_Tsystheure < 1) {
      V_Tsystheure = 23;
    } else {
      V_Tsystheure--;
    }
  }
  if (SystReglheure == 5) {
    if (V_Tsystminute < 1) {
      V_Tsystminute = 59;
    } else {
      V_Tsystminute--;
    }
  }
  if (SystReglheure == 7) {
    if (V_Tsystseconde < 1) {
      V_Tsystseconde = 59;
    } else {
      V_Tsystseconde--;
    }
  }
}

//Gestion Navigation Bouton HAUT ///////////////////
void NavBthaut() {
  if (Menu > 0) {
    if (Menu == 3) {
      Menu = 8;
    } else {
      Menu--;
    }
  }
  if (MenuMdm > 0) {
    if (MenuMdm == 3) {
      MenuMdm = 8;
    } else {
      MenuMdm--;
    }
  }
  if (MenuPara > 0) {
    if (MenuPara == 3) {
      MenuPara = 5;
    } else {
      MenuPara--;
    }
  }
  if (MenuParaProg > 0) {
    if (MenuParaProg == 3) {
      MenuParaProg = 5;
    } else {
      MenuParaProg--;
    }
  }
  if (MenuParaLDR > 0) {
    if (MenuParaLDR == 3) {
      MenuParaLDR = 8;
    } else {
      MenuParaLDR--;
    }
  }
  if (MenuSyst > 0) {
    if (MenuSyst == 3) {
      MenuSyst = 5;
    } else {
      MenuSyst--;
    }
  }
  if (MenuSystVeille > 0) {
    if (MenuSystVeille == 3) {
      MenuSystVeille = 5;
    } else {
      MenuSystVeille--;
    }
  }
  if (SystVeilleetat == 3) {
    Etatveille = !Etatveille;
  }
  if (SystVeilleTpsactiv == 3) {
    if (V_TpsAvveille > 179) {
      V_TpsAvveille = 3;
    } else {
      V_TpsAvveille++;
    }
  }
  if (ParaProgHouv == 3) {
    if (V_HeureOuv > 22) {
      V_HeureOuv = 0;
    } else {
      V_HeureOuv++;
    }
  }
  if (ParaProgHouv == 5) {
    if (V_MinOuv > 58) {
      V_MinOuv = 0;
    } else {
      V_MinOuv++;
    }
  }
  if (ParaProgHferm == 3) {
    if (V_HeureFerm > 22) {
      V_HeureFerm = 0;
    } else {
      V_HeureFerm++;
    }
  }
  if (ParaProgHferm == 5) {
    if (V_MinFerm > 58) {
      V_MinFerm = 0;
    } else {
      V_MinFerm++;
    }
  }
  if (ParaLDRouv == 3) {
    if (V_LDRouv > 998) {
      V_LDRouv = 0;
    } else {
      V_LDRouv++;
    }
  }
  if (ParaLDRferm == 3) {
    if (V_LDRferm > 998) {
      V_LDRferm = 0;
    } else {
      V_LDRferm++;
    }
  }
  if (ParaLDRhysteresis == 3) {
    if (V_Hysteresis > 998) {
      V_Hysteresis = 0;
    } else {
      V_Hysteresis++;
    }
  }
  if (SystReglheure == 3) {
    if (V_Tsystheure > 22) {
      V_Tsystheure = 0;
    } else {
      V_Tsystheure++;
    }
  }
  if (SystReglheure == 5) {
    if (V_Tsystminute > 58) {
      V_Tsystminute = 0;
    } else {
      V_Tsystminute++;
    }
  }
  if (SystReglheure == 7) {
    if (V_Tsystseconde > 58) {
      V_Tsystseconde = 0;
    } else {
      V_Tsystseconde++;
    }
  }
}

//Gestion Navigation Bouton Select ////////////////
void navmenuboutonselect() {
  if (Accueil > 0 && Veille == 0) {
    Accueil = 0; Menu = 1;
  }
  if (Menu == 3) {
    Menu = 0; MenuMdm = 1;
  }
  if (Menu == 4) {
    Menu = 0; MenuPara = 1;
  }
  if (Menu == 5) {
    MenuSyst = 1; Menu = 0;
  }
  if (Menu == 11) {
    Accueil = 1; Menu = 0;
  }
  if (MenuMdm == 3) {
    Modedemarche = MenuMdm - 2; MenuMdm = 0; Menu = 1; Sav();
  }
  if (MenuMdm == 4) {
    Modedemarche = MenuMdm - 2; MenuMdm = 0; Menu = 1; Sav();
  }
  if (MenuMdm == 5) {
    Modedemarche = MenuMdm - 2;
    MenuMdm = 0; Menu = 1; Sav();
  }
  if (MenuMdm == 11) {
    MenuMdm = 0; Menu = 1;
  }
  if (MenuPara == 5) {
    MenuPara = 0; Menu = 1;
  }
  if (MenuPara == 3) {
    MenuPara = 0; MenuParaProg = 1;
  }
  if (MenuPara == 4) {
    MenuPara = 0; MenuParaLDR = 1;
  }
  if (MenuParaLDR == 11) {
    MenuParaLDR = 0; MenuPara = 1;
  }
  if (MenuSyst == 3) {
    MenuSyst = 0; SystReglheure = 1;
  }
  if (MenuSyst == 4) {
    MenuSyst = 0; MenuSystVeille = 1;
  }
  if (MenuSyst == 5) {
    MenuSyst = 0; Menu = 1;
  }
  if (MenuSystVeille == 3) {
    MenuSystVeille = 0; SystVeilleetat = 1;
  }
  if (MenuSystVeille == 4) {
    MenuSystVeille = 0; SystVeilleTpsactiv = 1;
  }
  if (MenuSystVeille == 5) {
    MenuSystVeille = 0; MenuSyst = 1;
  }
  if (SystVeilleetat == 3) {
    SystVeilleetat = 0; MenuSystVeille = 1; Sav();
  }
  if (SystVeilleTpsactiv == 3) {
    SystVeilleTpsactiv = 0; MenuSystVeille = 1; Sav();
  }
  if (MenuParaProg == 3) {
    MenuParaProg = 0; ParaProgHouv = 1;
  }
  if (MenuParaProg == 4) {
    MenuParaProg = 0; ParaProgHferm = 1;
  }
  if (MenuParaProg == 5) {
    MenuParaProg = 0; MenuPara = 1;
  }
  if (ParaProgHouv == 3) {
    ParaProgHouv = 4;
  }
  if (ParaProgHouv == 5) {
    MenuParaProg = 1; ParaProgHouv = 0; Sav();
  }
  if (ParaProgHferm == 3) {
    ParaProgHferm = 4;
  }
  if (ParaProgHferm == 5) {
    MenuParaProg = 1; ParaProgHferm = 0; Sav();
  }
  if (MenuParaLDR == 3) {
    MenuParaLDR = 0; ParaLDRouv = 1;
  }
  if (MenuParaLDR == 4) {
    MenuParaLDR = 0; ParaLDRferm  = 1;
  }
  if (MenuParaLDR == 5) {
    MenuParaLDR = 0; ParaLDRhysteresis = 1;
  }
  if (ParaLDRouv == 3) {
    MenuParaLDR = 1; ParaLDRouv = 0; Sav();
  }
  if (ParaLDRferm == 3) {
    MenuParaLDR = 1; ParaLDRferm = 0; Sav();
  }
  if (ParaLDRhysteresis == 3) {
    MenuParaLDR = 1; ParaLDRhysteresis = 0; Sav();
  }
  if (SystReglheure == 3) {
    SystReglheure = 4;
  }
  if (SystReglheure == 5) {
    SystReglheure = 6;
  }
  if (SystReglheure == 7) {
    SavHeure(); SystReglheure = 0; MenuSyst = 1;
  }
}
//Gestion Navigation Bouton HAUT rapide ////////////
void NavBthautrapide() {
  if ((timerarduino - previousTimer6) > Timer6ON) {
    if (ParaLDRouv == 3) {
      if (V_LDRouv > 988) {
        V_LDRouv = 0;
      } else {
        V_LDRouv = V_LDRouv + 10;
      }
    }
    if (ParaLDRferm == 3) {
      if (V_LDRferm > 988) {
        V_LDRferm = 0;
      } else {
        V_LDRferm = V_LDRferm + 10;
      }
    }
    if (ParaLDRhysteresis == 3) {
      if (V_Hysteresis > 988) {
        V_Hysteresis = 0;
      } else {
        V_Hysteresis = V_Hysteresis + 10;
      }
    }
    if (SystVeilleTpsactiv == 3) {
      if (V_TpsAvveille > 169) {
        V_TpsAvveille = 3;
      } else {
        V_TpsAvveille = V_TpsAvveille + 10;
      }
    }
    previousTimer6 = timerarduino;
  }
}
//Gestion Navigation Bouton BAS rapide  ////////////
void NavBtbasrapide() {
  if ((timerarduino - previousTimer6) > Timer6ON) {
    if (ParaLDRouv == 3) {
      if (V_LDRouv < 11) {
        V_LDRouv = 999;
      } else {
        V_LDRouv = V_LDRouv - 10;
      }
    }
    if (ParaLDRferm == 3) {
      if (V_LDRferm < 11) {
        V_LDRferm = 999;
      } else {
        V_LDRferm = V_LDRferm - 10;
      }
    }
    if (ParaLDRhysteresis == 3) {
      if (V_Hysteresis < 11) {
        V_Hysteresis = 999;
      } else {
        V_Hysteresis = V_Hysteresis - 10;
      }
    }
    if (SystVeilleTpsactiv == 3) {
      if (V_TpsAvveille < 14) {
        V_TpsAvveille = 180;
      } else {
        V_TpsAvveille = V_TpsAvveille - 10;
      }
    }
    previousTimer6 = timerarduino;
  }
}


void Intro() {
  lcd.home();
  lcd.setCursor(1, 0); lcd.write(1);
  lcd.setCursor(2, 0); lcd.write(2);
  lcd.setCursor(1, 1); lcd.write(3);
  lcd.setCursor(2, 1); lcd.write(4);
  lcd.setCursor(6, 0); lcd.print("DomoPoule");
  lcd.setCursor(5, 1); lcd.print("Version.5-A");
  lcd.setCursor(0, 3); lcd.print("  www.robdomo.com   ");
  delay(2000);
}

//Gestion Mise en veille Ecran/////////////////////
void EcrVeille() {
  Timer4ON = V_TpsAvveille * 1000;
  if (((timerarduino - previousTimer4) > Timer4ON) && Accueil == 7 && Etatveille == 1) {
    lcd.noBacklight(); Veille = 1;
  }
  if (EtatBtselect == 1 || EtatBthaut == 1 || EtatBtbas == 1 || Accueil != 7) {
    lcd.backlight(); previousTimer4 = timerarduino;
    Veille = 0;
  }
}

68tjs · August 17, 2022, 7:34pm

Bonjour,

Pour utiliser une bibliothèque, en l'occurrence celle du DS1302, il ne suffit pas d'écrire
#include <ds1302.h>

Déjà une bibliothèque, sauf très rare exception, ne se limite pas au seul ichier d'entête : l'extension .h provient de "header" qui veut dire entête en anglais. Le plus important est le ou les fichiers cpp qui contiennent le code.

Tu n'as pas installé la bibliothèque dans les règles de l'art et le compilateur ne trouve pas les fichiers dont il a besoin.

Utilises le gestionnaire de bibliothèque de l'IDE pour installer automatiquement la bibliothèque.
L'installation manuelle est possible, surtout pour des bibliothèques exotiques, mais en automatique, tu es sûr que c'est fait dans les règles.

Note : En réalité, le fichier qui est transmis au compilateur ne se limite pas aux fonctions du fichier ino. Ce qui est transmis au compilateur est un vrai fichier cpp qui respecte la norme du cpp.
On trouve facilement des tutos d'initiation au cpp.
La lecture d'un tuto de cpp très basique te permettrait de mieux comprendre et au final de gagner du temps.

vileroi · August 17, 2022, 9:05pm

Page: Les bonnes pratiques du Forum Francophone - International / Français - Arduino Forum
il est entre autre dit: Utilisez un titre explicite !

alain4133 · August 18, 2022, 12:44pm

bonjour 68tjs

merci pour ta réponse .
j'ai fait tu ma dit décompressé le fichier zipp

mais toujours le même résultat.
je te joint le dossier zipp au cas ou

merci

LiquidCrystal_I2C-master(8).zip (8,6 Ko)
https://robdomo.com/projets-diy/projets-robdomo/porte-poulailler-automatique/porte-automatique-pour-poulailler-version-4/

jpbbricole · August 18, 2022, 1:34pm

Bonjour alain4133

Dans l'IDE Arduino tu va au gestionnaire de bibliothèques

Tu recherches DS1302

Tu dois avoir le bouton installer, si ce n'est pas le cas, c'est que la bibliothèque est déjà installée et tu dois avoir quelque chose comme ceci

Cordialement
jpbbricole

68tjs · August 18, 2022, 2:43pm

@alin4133
C'est que j'ai appelé installer automatiquement à partir du gestionnaire de bibliothèque.

Idem pour les cartes :
Les mots des fonctions "dites Arduino" sont les mêmes pour toutes les cartes, mais ce qu'il y a à l'intérieur d'une fonction, digitalWrite par exemple, est propre à chaque microcontrôleur.
Seules les cartes très basiques sont installées d'office.

Dès que tu veux utiliser une carte plus évoluée, il faut l'installer.
Cela évite de remplir les disques avec des fichiers qui ne serviront jamais.

Il faut être curieux et découvrir les possibilités de l'IDE en n'ayant pas peur de cliquer dans les menus pour voir.

Une possibilité très utile est l'indentation automatique (Ctrl T).
Si tu ne connais pas, écris du code avec toutes les lignes alignées à gauche.
Fais <Ctrl T> et tu remarqueras que le code devient bien plus lisible, s'il est plus lisible, tu feras moins d'erreur et si tu le publies avec une question, davantage de personne le liront.

alain4133 · August 19, 2022, 8:31am

bonjour à vous tous

j'ai suivis vos conseils
je suis toujours au même point

bon là rien ne vas c'est toujours pareil que puis je faire

merci à vous

jpbbricole · August 19, 2022, 9:02am

Bonjour alain4133

Mets une copie de l'erreur:

A+
Cordialement
jpbbricole

alain4133 · August 19, 2022, 9:20am

voilas
le résultas

désolé de vous dérangé encore une fois

#include <Ds1302.h>

int boutonhaut = A1; //broche du Bouton fleche haut
int boutonbas = A2; //broche du Bouton fleche bas
int boutonselect = A3; //broche du Bouton select
const int LDR = A0; // broche du LDR
const int fdchaut = 3; // broche du fin de course haut
const int fdcbas = 4; // broche du fin de course bas
int val_LDR_ouverture = 400; // valeur luminosité minimum pour ouverture
int val_LDR_fermeture = 100; // valeur luminosité minimum pour fermeture

#include <DS1302.h>
DS1302 lcd(0x27,20,4); 

#include <DS1302.h>

DS1302 rtc(7, 6, 5);
Time t;

#include <Stepper.h>
const int stepsPerRevolution = 200;
// Initialise le moteur sur les broches 8 à 11
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

int menu = 1;
int modedemarche = 4;
int menumodemarche = 1;
int menuprogrammateur = 1;
int menuldr = 1;
long heureouverture = 23;
long minouverture = 59;
long heurefermeture = 0;
long minfermeture = 1;
boolean etatporte = 0;
int nbcyclerefresh = 10; //Nb de cycle progr. avant rafraichissement LCD
unsigned int refreshLDRms;
int refrechchgetat = 0;
byte tiretbas[8] = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,};
byte egal[8] = {B00000,B00000,B11111,B00000,B11111,B00000,B00000,};

void setup() {
  Serial.begin(9600);

  myStepper.setSpeed(200); //Vitesse de rotation du moteur à 200
  
  pinMode(boutonhaut, INPUT_PULLUP);
  pinMode(boutonbas, INPUT_PULLUP);
  pinMode(boutonselect, INPUT_PULLUP);
  pinMode(fdchaut, INPUT_PULLUP);
  pinMode(fdcbas, INPUT_PULLUP);
  
  rtc.halt(false);
  
  //Active = false Desactive = true la protection en ecriture pour mettre à jour heure et la date
  rtc.writeProtect(true);
  rtc.setDOW(FRIDAY);        // Jour a FRIDAY
  rtc.setTime(02, 22, 0);    // Heure a 15:14:00 (format sur 24 heure)
  rtc.setDate(24, 05, 2020);   // Date  au 28 juin 2020 
  /////////////////////////////////////

  lcd.init();                     
  lcd.backlight();
  lcd.createChar(0, tiretbas);
  lcd.createChar(1, egal);
  
  //Récupération des valeurs de réglages dans RAM DS1302
  ramBuffer=rtc.readBuffer();
  Serial.println("Lecture de la RAM : ");
  for (int i=0; i<31; i++)
  {
    Serial.print(" ");
    Serial.print(ramBuffer.cell[i]);
    Serial.print(" ");
  }
  Serial.println(" ");
  if(ramBuffer.cell[0] == 99){
    modedemarche = ramBuffer.cell[1];
    heureouverture = ramBuffer.cell[2];
    minouverture = ramBuffer.cell[3];
    heurefermeture = ramBuffer.cell[4];
    minfermeture = ramBuffer.cell[5];
    byte v_1LDRouverture = ramBuffer.cell[6];
    byte v_2LDRouverture = ramBuffer.cell[7];
    byte v_1LDRfermeture = ramBuffer.cell[8];
    byte v_2LDRfermeture = ramBuffer.cell[9];
    val_LDR_ouverture = word(v_2LDRouverture, v_1LDRouverture); 
    val_LDR_fermeture = word(v_2LDRfermeture, v_1LDRfermeture);   
  } 
}

void loop() {
  int valeurLDR = analogRead(LDR);
  //Gestion du bouton select
  if (digitalRead(boutonselect) == LOW){ 
    //Entrer dans le Menu de Accueil
    if(menu == 1){
      menu = 2;  
    }
    //Menu / Entrer dans Mode de marche
    else if(menu == 2 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menumodemarche = modedemarche;
    }
    //Menu / Entrer dans Programmateur
    else if(menu == 3 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menuprogrammateur = 2;
    }
    //Menu / Entrer dans LDR
    else if(menu == 4 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 6;
      menuldr = 2;
    }
    //Menu / Accueil
    else if(menu == 5 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
      menu = 1;
    }
    //Menu / Mode de marche / Selection du Mode de marche et retour
    else if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      modedemarche = menumodemarche;
      menumodemarche = 1;
      menu = 1;
      sauvegarde();
      if(modedemarche == 2){
        affichageautomatique(valeurLDR);
        refreshLDRms = nbcyclerefresh + 1;  
      }
    }
    //Menu / Programmateur / Conf.Programmateur / Selection heure ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 2){
      menuprogrammateur = 5;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage heure ouverture au reglage min ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 5){
      menuprogrammateur = 6;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage min ouverture à Conf.Programmateur
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 6){
      menuprogrammateur = 2;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.Programmateur / Selection heure fermeture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 3){
      menuprogrammateur = 7;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage heure fermeture au reglage min fermeture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 7){
      menuprogrammateur = 8;
    }
    //Menu / Programmateur / Conf.Programmateur / Passer reglage min fermeture à Conf.Programmateur
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 8){
      menuprogrammateur = 3;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.Programmateur / Passer Conf.Programmateur à Accueil
    else if(menu == 6 && menumodemarche == 1 && menuldr == 1 && menuprogrammateur == 4){
      menu = 1;
      menuprogrammateur = 1;
    }
    //Menu / Programmateur / Conf.LDR / Passer Conf.LDR à Accueil
    else if(menu == 6 && menumodemarche == 1 && menuldr == 4 && menuprogrammateur == 1){
      menu = 1;
      menuldr = 1;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 2 && menuprogrammateur == 1){
      menuldr = 5;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture
    else if(menu == 6 && menumodemarche == 1 && menuldr == 3 && menuprogrammateur == 1){
      menuldr = 6;
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR ouverture à Conf.LDR
    else if(menu == 6 && menumodemarche == 1 && menuldr == 5 && menuprogrammateur == 1){
      menuldr = 2;
      sauvegarde();
    }
    //Menu / Programmateur / Conf.LDR / Reglage valeur LDR fermeture à Conf.LDR
    else if(menu == 6 && menumodemarche == 1 && menuldr == 6 && menuprogrammateur == 1){
      menuldr = 3;
      sauvegarde();
    }
    while (digitalRead(boutonselect) == LOW){
    }
    lcd.clear();
  } 
  //Gestion du bouton bas
  if (digitalRead(boutonbas) == LOW){
    //Navigation dans Menu//
    if(menu != 6 && menu != 1){
      if(menu > 1 && menu < 5 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
        menu++;  
      }
      else{
        menu = 2;
      }
    }
    //Navigation dans  Mode de marche//
    if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      if(menu == 6 && menumodemarche > 1 && menumodemarche < 4){
        menumodemarche++;  
      }
      else{
        menumodemarche = 2;
      }
    }
    //Navigation dans Conf.Programmateur//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur != 1 && menuprogrammateur < 5 && menuldr == 1){
      if(menu == 6 && menuprogrammateur > 1 && menuprogrammateur < 4){
        menuprogrammateur++;  
      }
      else{
        menuprogrammateur = 2;
      }
    }
    //Navigation dans LDR//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr != 1 && menuldr < 5){
      if(menu == 6 && menuldr > 1 && menuldr < 4){
        menuldr++;  
      }
      else{
        menuldr = 2;
      }
    }
    //Reglage LDR ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 5){
      if(val_LDR_ouverture > 2){
        val_LDR_ouverture--;  
      }
    }
    //Reglage LDR fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 6){
      if(val_LDR_fermeture > 2){
        val_LDR_fermeture--;  
      }
    }
    //Reglage heure ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 5 && menuldr == 1){
      if(heureouverture > 0){
        heureouverture--;  
      }
      else{
        heureouverture = 23;
      }
    }
    //Reglage min ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 6 && menuldr == 1){
      if(minouverture > 0){
        minouverture--;  
      }
      else{
        minouverture = 59;
      }
    }
    //Reglage heure fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 7 && menuldr == 1){
      if(heurefermeture > 0){
        heurefermeture--;  
      }
      else{
        heurefermeture = 23;
      }
    }
    //Reglage min fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 8 && menuldr == 1){
      if(minfermeture > 0){
        minfermeture--;  
      }
      else{
        minfermeture = 59;
      }
    }
    
    if(menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1){
      while(digitalRead(boutonbas) == LOW && digitalRead(fdcbas) == HIGH){
        myStepper.step(-1);
      } 
      affichagemenu1(); 
    }
    while (digitalRead(boutonbas) == LOW){
    }
    lcd.clear();
  }
  //Gestion du bouton haut
  if (digitalRead(boutonhaut) == LOW){
    //Navigation dans Menu//
    if(menu != 6 && menu != 1){
      if(menu < 6 && menu > 2 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 1){
        menu--;  
      }
      else{
        menu = 5;
      }
    }
    //Navigation dans  Mode de marche//
    if(menu == 6 && menumodemarche != 1 && menuprogrammateur == 1 && menuldr == 1){
      if(menu == 6 && menumodemarche < 5 && menumodemarche > 2){
        menumodemarche--;  
      }
      else{
        menumodemarche = 4;
      }
    }
    //Navigation dans Conf.Programmateur//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur != 1 && menuprogrammateur < 5 && menuldr == 1){
      if(menu == 6 && menuprogrammateur < 5 && menuprogrammateur > 2){
        menuprogrammateur--;  
      }
      else{
        menuprogrammateur = 4;
      }
    }
    //Navigation dans LDR//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr != 1 && menuldr < 5){
      if(menu == 6 && menuldr < 5 && menuldr > 2){
        menuldr--;  
      }
      else{
        menuldr = 4;
      }
    }
    //Reglage LDR ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 5){
      if(val_LDR_ouverture < 1022){
        val_LDR_ouverture++;  
      }
    }
    //Reglage LDR fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 1 && menuldr == 6){
      if(val_LDR_fermeture < 1022){
        val_LDR_fermeture++;  
      }
    }
    //Reglage heure ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 5 && menuldr == 1){
      if(heureouverture < 23){
        heureouverture++;  
      }
      else{
        heureouverture = 0;
      }
    }
    //Reglage min ouverture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 6 && menuldr == 1){
      if(minouverture < 59){
        minouverture++;  
      }
      else{
        minouverture = 0;
      }
    }
    //Reglage heure fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 7 && menuldr == 1){
      if(heurefermeture < 23){
        heurefermeture++;  
      }
      else{
        heurefermeture = 0;
      }
    }
    //Reglage min fermeture//
    if(menu == 6 && menumodemarche == 1 && menuprogrammateur == 8 && menuldr == 1){
      if(minfermeture < 59){
        minfermeture++;  
      }
      else{
        minfermeture = 0;
      }
    }
    if(menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1){
      while(digitalRead(boutonhaut) == LOW && digitalRead(fdchaut) == HIGH){
        myStepper.step(1);
      } 
      affichagemenu1(); 
    }
    
    while (digitalRead(boutonhaut) == LOW){
    }
    lcd.clear();
  } 
    
  //Menu  
  switch (menu) {
  case 1:   
    affichagemenu1();
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Mode de marche     <");
    lcd.setCursor(0, 1);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Mode de marche      ");
    lcd.setCursor(0, 1);
    lcd.print ("Programmateur      <");
    lcd.setCursor(0, 2);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Mode de marche      ");
    lcd.setCursor(0, 1);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR                <");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print ("Mode de marche      ");
    lcd.setCursor(0, 1);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour             <");
    break;
  case 6:
    break;  
  }
  
  //Menu mode marche
  switch (menumodemarche) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                <");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur      <");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Select. Mode :");
    lcd.setCursor(0, 1);
    lcd.print ("LDR                 ");
    lcd.setCursor(0, 2);
    lcd.print ("Programmateur       ");
    lcd.setCursor(0, 3);
    lcd.print ("Manuel             <");
    break;
  }
  
  //Menu programmateur
  switch (menuprogrammateur) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture    <");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture     ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture     ");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture    <");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. Programmateur");
    lcd.setCursor(0, 1);
    lcd.print ("Heure ouverture     ");
    lcd.setCursor(0, 2);
    lcd.print ("Heure fermeture     ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour             <");
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print ("Heure ouverture");
    if(heureouverture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heureouverture);
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heureouverture); 
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minouverture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minouverture);
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minouverture);
    } 
    break;
  case 6:
    lcd.setCursor(0, 0);
    lcd.print ("Heure ouverture");
    if(heureouverture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heureouverture);
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heureouverture);  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minouverture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minouverture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minouverture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }  
    break; 
  case 7:
    lcd.setCursor(0, 0);
    lcd.print ("Heure fermeture");
    if(heurefermeture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heurefermeture);
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heurefermeture); 
      lcd.setCursor(7, 3);
      lcd.write(byte(0));
      lcd.setCursor(8, 3);
      lcd.write(byte(0));  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minfermeture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minfermeture);
    }
    else{
      lcd.setCursor(10, 2);
    lcd.print (minfermeture);
    } 
    break;
  case 8:
    lcd.setCursor(0, 0);
    lcd.print ("Heure fermeture");
    if(heurefermeture < 10){
      lcd.setCursor(7, 2);
      lcd.print ("0");
      lcd.setCursor(8, 2);
      lcd.print (heurefermeture);
    }
    else{
      lcd.setCursor(7, 2);
      lcd.print (heurefermeture);  
    }
    lcd.setCursor(9, 2);
    lcd.print (":");
    if (minfermeture < 10){
      lcd.setCursor(10, 2);
      lcd.print ("0");
      lcd.setCursor(11, 2);
      lcd.print (minfermeture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(10, 2);
      lcd.print (minfermeture);
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
      lcd.setCursor(11, 3);
      lcd.write(byte(0));
    } 
    break;   
  }
  
  //Menu LDR
  switch (menuldr) {
  case 1:
    break;
  case 2:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture      <");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture       ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 3:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture      <");
    lcd.setCursor(0, 3);
    lcd.print ("Retour              ");
    break;
  case 4:
    lcd.setCursor(0, 0);
    lcd.print ("Conf. LDR");
    lcd.setCursor(0, 1);
    lcd.print ("LDR ouverture       ");
    lcd.setCursor(0, 2);
    lcd.print ("LDR fermeture       ");
    lcd.setCursor(0, 3);
    lcd.print ("Retour             <");
    break;
  case 5:
    lcd.setCursor(0, 0);
    lcd.print ("Val. LDR ouverture");
    lcd.setCursor(8, 2);
    lcd.print (val_LDR_ouverture);
    lcd.setCursor(8, 3);
    if(val_LDR_ouverture < 10){
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
    }
    else if(val_LDR_ouverture > 9 && val_LDR_ouverture < 100){
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
      lcd.setCursor(9, 3);
      lcd.write(byte(0));
    }
    else{
      lcd.setCursor(8, 3);
      lcd.write(byte(0));
      lcd.setCursor(9, 3);
      lcd.write(byte(0));
      lcd.setCursor(10, 3);
      lcd.write(byte(0));
    }
    break;
  case 6:
      lcd.setCursor(0, 0);
      lcd.print ("Val. LDR fermeture");
      lcd.setCursor(8, 2);
      lcd.print (val_LDR_fermeture);
      lcd.setCursor(8, 3);
      if(val_LDR_fermeture < 10){
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
      }
      else if(val_LDR_fermeture > 9 && val_LDR_fermeture < 100){
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
        lcd.setCursor(9, 3);
        lcd.write(byte(0));
      }
      else{
        lcd.setCursor(8, 3);
        lcd.write(byte(0));
        lcd.setCursor(9, 3);
        lcd.write(byte(0));
        lcd.setCursor(10, 3);
        lcd.write(byte(0));
      }
    break;    
  }
  
  //Gestion ouverture et fermeture si en Mode LDR
  if(valeurLDR >= val_LDR_ouverture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1  && menuldr == 1){
      etatporte = 1;
    }
  if(valeurLDR <= val_LDR_fermeture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1  && menuldr == 1){
      etatporte = 0;
    } 
  if(modedemarche == 2  && menuldr == 1 && menu == 1 && menuprogrammateur == 1 && (refreshLDRms > nbcyclerefresh || refrechchgetat == !etatporte)){
    if(modedemarche == 2  && menuldr == 1 && menu == 1 && menuprogrammateur == 1){
      refrechchgetat = etatporte;
      affichageautomatique(valeurLDR);
    }
  } 
  while(etatporte == 1 && digitalRead(fdchaut) == HIGH && modedemarche == 2 && menu == 1){
    myStepper.step(1);
  }
  while(etatporte == 0 && digitalRead(fdcbas) == HIGH && modedemarche == 2 && menu == 1){
    myStepper.step(-1);
    }
  refreshLDRms++;
  
  //Gestion ouverture et fermeture si en Mode programmateur
  unsigned long ouverturesec = (minouverture*60) + (heureouverture*3600);
  unsigned long fermeturesec = (minfermeture*60) + (heurefermeture*3600);
  t = rtc.getTime();
  long hour = t.hour;
  long min = t.min;
  long sec = t.sec;
  unsigned long heuresec = (min*60) + (hour*3600) + sec;
  if(ouverturesec < fermeturesec && modedemarche == 3 && menu == 1){
    if(heuresec > ouverturesec && heuresec < fermeturesec  && modedemarche == 3 && menu == 1){
        etatporte = 1;
      }
    else{
        etatporte = 0;
      }
  }
  if(ouverturesec > fermeturesec && modedemarche == 3 && menu == 1){
    if(modedemarche == 3 && menu == 1 && (heuresec > ouverturesec && heuresec > fermeturesec)||(heuresec < ouverturesec && heuresec < fermeturesec)){
        etatporte = 1;
      }
    if(heuresec > fermeturesec && heuresec < ouverturesec  && modedemarche == 3 && menu == 1){
        etatporte = 0;
      }
  }
  while(etatporte == 1 && digitalRead(fdchaut) == HIGH && modedemarche == 3 && menu == 1){
    myStepper.step(1);
  }
  while(etatporte == 0 && digitalRead(fdcbas) == HIGH && modedemarche == 3 && menu == 1){
    myStepper.step(-1);
    }
  
  //Mise au repos du moteur PAP
  moteurrepos();  
}

void affichagemenu1(){
  affichageheure();
    if(modedemarche == 2){
      lcd.setCursor(5, 1);
      lcd.print ("Mode : LDR        "); 
      lcd.setCursor(0, 3);
      lcd.print ("Ouv.");
      lcd.setCursor(4, 3);
      lcd.write(byte(1));
      lcd.setCursor(5, 3);
      lcd.print(val_LDR_ouverture);
      lcd.setCursor(11, 3);
      lcd.print ("Fer.");
      lcd.setCursor(15, 3);
      lcd.write(byte(1));
      lcd.setCursor(16, 3);
      lcd.print(val_LDR_fermeture);
    }
    else if (modedemarche == 3){
      lcd.setCursor(0, 2);
      lcd.print ("H. ouverture : ");
      if(heureouverture < 10){
        lcd.setCursor(15, 2);
        lcd.print ("0");
        lcd.setCursor(16, 2);
        lcd.print (heureouverture);
      }
      else{
        lcd.setCursor(15, 2);
        lcd.print (heureouverture);  
      }
      lcd.setCursor(17, 2);
      lcd.print (":");
      if (minouverture < 10){
        lcd.setCursor(18, 2);
        lcd.print ("0");
        lcd.setCursor(19, 2);
        lcd.print (minouverture);
      }
      else{
        lcd.setCursor(18, 2);
        lcd.print (minouverture);
      } 
      lcd.setCursor(0, 3);
      lcd.print ("H. fermeture : ");
      if(heurefermeture < 10){
        lcd.setCursor(15, 3);
        lcd.print ("0");
        lcd.setCursor(16, 3);
        lcd.print (heurefermeture);
      }
      else{
        lcd.setCursor(15, 3);
        lcd.print (heurefermeture);  
      }
      lcd.setCursor(17, 3);
      lcd.print (":");
      if (minfermeture < 10){
        lcd.setCursor(18, 3);
        lcd.print ("0");
        lcd.setCursor(19, 3);
        lcd.print (minfermeture);
      }
      else{
        lcd.setCursor(18, 3);
        lcd.print (minfermeture);
      }
      lcd.setCursor(0, 1);
      lcd.print ("Mode : Programmateur");
    }
    else if (modedemarche == 4){
      lcd.setCursor(3, 1);
      lcd.print ("Mode : Manuel");
      lcd.setCursor(0,2);
      lcd.print("Pos. porte : ");  
      if(digitalRead(fdchaut) == LOW){
       lcd.setCursor(13,2);
       lcd.print("Ouverte");  
      }
      else if(digitalRead(fdcbas) == LOW){
        lcd.setCursor(13,2);
        lcd.print("Fermer "); 
      }
      else{
        lcd.setCursor(13,2);
        lcd.print(" ...   ");
      }
      lcd.setCursor(0,3);
      lcd.print("Bouton : ");
      if (digitalRead(boutonselect) == LOW){
        lcd.setCursor(9,3);
        lcd.print("Monter  ");
      }
      else if (digitalRead(boutonbas) == LOW){
        lcd.setCursor(9,3);
        lcd.print("Descente");
      }
      else{
        lcd.setCursor(9,3);
        lcd.print("Repos   ");  
      }
    }  
}

int affichageautomatique (int valeurLDR){
  lcd.setCursor(3,2);
  lcd.print("Val. LDR "); 
  lcd.setCursor(11,2);
  lcd.write(byte(1) );
  if(valeurLDR < 100){
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);
    lcd.setCursor(15,2); 
    lcd.print("   ");
  }
  else if(valeurLDR >= 100 && valeurLDR < 1000){
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);
    lcd.setCursor(16,2); 
    lcd.print("   ");
  }
  else{
    lcd.setCursor(13,2); 
    lcd.print(valeurLDR);    
  } 
  refreshLDRms = 0;     
}

//Affichage de l'heure
void affichageheure(){
  t = rtc.getTime();
  String hour;
  String min;
  String sec;
  hour = String(t.hour);
  min = String(t.min);
  sec = String(t.sec);
  
  if(t.hour<10)
  {
    hour = "0"+hour;
    lcd.setCursor(6, 0);
    lcd.print (hour+":");
  }else
  {
    lcd.setCursor(6, 0);
    lcd.print (hour+":");
  }
  if(t.min<10)
  {
    min = "0"+min;
    lcd.setCursor(9, 0);
    lcd.print (min+":");
  }else
  {
    lcd.setCursor(9, 0);
    lcd.print (min+":");
  }
  if(t.sec<10)
  {
    sec = "0"+sec;
    lcd.setCursor(12, 0);
    lcd.print (sec);
  }else
  {
    lcd.setCursor(12, 0);
    lcd.print (sec);
  }
}

//Sauvegarde sur RAM DS1302
void sauvegarde (){
  rtc.writeProtect(false);
  int valeurLDRouverture = val_LDR_ouverture; 
  byte v_1LDRouverture = lowByte(valeurLDRouverture); 
  byte v_2LDRouverture = highByte(valeurLDRouverture); 
  int valeurLDRfermeture = val_LDR_fermeture; 
  byte v_1LDRfermeture = lowByte(valeurLDRfermeture); 
  byte v_2LDRfermeture = highByte(valeurLDRfermeture); 
  ramBuffer.cell[0] = 99;
  ramBuffer.cell[1] = modedemarche;
  ramBuffer.cell[2] = heureouverture;
  ramBuffer.cell[3] = minouverture;
  ramBuffer.cell[4] = heurefermeture;
  ramBuffer.cell[5] = minfermeture;
  ramBuffer.cell[6] = v_1LDRouverture;
  ramBuffer.cell[7] = v_2LDRouverture;
  ramBuffer.cell[8] = v_1LDRfermeture;
  ramBuffer.cell[9] = v_2LDRfermeture;
  rtc.writeBuffer(ramBuffer); 
  ramBuffer=rtc.readBuffer();
  rtc.writeProtect(true);
  Serial.println("Sauvegarde sur RAM");
  for (int i=0; i<31; i++)
  {
    Serial.print(" ");
    Serial.print(ramBuffer.cell[i]);
    Serial.print(" ");
  }
  Serial.println(" ");
}

//Mise au repos du moteur PAP
void moteurrepos (){
   digitalWrite (8, LOW);
   digitalWrite (9, LOW);  
   digitalWrite (10, LOW);
   digitalWrite (11, LOW);  
}

alain4133 · August 19, 2022, 9:43am

Arduino : 1.8.19 (Windows 10), Carte : "Arduino Uno"





















Porte_automatique_pour_poulailler_version_4:13:1: error: 'DS1302' does not name a type; did you mean 'Ds1302'?

 DS1302 lcd(0x27,20,4);

 ^~~~~~

 Ds1302

Porte_automatique_pour_poulailler_version_4:17:1: error: 'DS1302' does not name a type; did you mean 'Ds1302'?

 DS1302 rtc(7, 6, 5);

 ^~~~~~

 Ds1302

Porte_automatique_pour_poulailler_version_4:18:1: error: 'Time' does not name a type

 Time t;

 ^~~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'void setup()':

Porte_automatique_pour_poulailler_version_4:52:3: error: 'rtc' was not declared in this scope

   rtc.halt(false);

   ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino:52:3: note: suggested alternative: 'getc'

   rtc.halt(false);

   ^~~

   getc

Porte_automatique_pour_poulailler_version_4:56:14: error: 'FRIDAY' was not declared in this scope

   rtc.setDOW(FRIDAY);        // Jour a FRIDAY

              ^~~~~~

Porte_automatique_pour_poulailler_version_4:61:3: error: 'lcd' was not declared in this scope

   lcd.init();

   ^~~

Porte_automatique_pour_poulailler_version_4:67:3: error: 'ramBuffer' was not declared in this scope

   ramBuffer=rtc.readBuffer();

   ^~~~~~~~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'void loop()':

Porte_automatique_pour_poulailler_version_4:185:5: error: 'lcd' was not declared in this scope

     lcd.clear();

     ^~~

Porte_automatique_pour_poulailler_version_4:282:5: error: 'lcd' was not declared in this scope

     lcd.clear();

     ^~~

Porte_automatique_pour_poulailler_version_4:379:5: error: 'lcd' was not declared in this scope

     lcd.clear();

     ^~~

Porte_automatique_pour_poulailler_version_4:388:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(0, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:436:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(0, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:472:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(0, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:644:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(0, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:749:3: error: 't' was not declared in this scope

   t = rtc.getTime();

   ^

Porte_automatique_pour_poulailler_version_4:749:7: error: 'rtc' was not declared in this scope

   t = rtc.getTime();

       ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino:749:7: note: suggested alternative: 'getc'

   t = rtc.getTime();

       ^~~

       getc

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'void affichagemenu1()':

Porte_automatique_pour_poulailler_version_4:784:7: error: 'lcd' was not declared in this scope

       lcd.setCursor(5, 1);

       ^~~

Porte_automatique_pour_poulailler_version_4:800:7: error: 'lcd' was not declared in this scope

       lcd.setCursor(0, 2);

       ^~~

Porte_automatique_pour_poulailler_version_4:852:7: error: 'lcd' was not declared in this scope

       lcd.setCursor(3, 1);

       ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'int affichageautomatique(int)':

Porte_automatique_pour_poulailler_version_4:886:3: error: 'lcd' was not declared in this scope

   lcd.setCursor(3,2);

   ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'void affichageheure()':

Porte_automatique_pour_poulailler_version_4:911:3: error: 't' was not declared in this scope

   t = rtc.getTime();

   ^

Porte_automatique_pour_poulailler_version_4:911:7: error: 'rtc' was not declared in this scope

   t = rtc.getTime();

       ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino:911:7: note: suggested alternative: 'getc'

   t = rtc.getTime();

       ^~~

       getc

Porte_automatique_pour_poulailler_version_4:922:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(6, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:926:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(6, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:932:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(9, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:936:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(9, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:942:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(12, 0);

     ^~~

Porte_automatique_pour_poulailler_version_4:946:5: error: 'lcd' was not declared in this scope

     lcd.setCursor(12, 0);

     ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino: In function 'void sauvegarde()':

Porte_automatique_pour_poulailler_version_4:953:3: error: 'rtc' was not declared in this scope

   rtc.writeProtect(false);

   ^~~

C:\Users\Alain\AppData\Local\Temp\7zO4C95C712\Porte_automatique_pour_poulailler_version_4\Porte_automatique_pour_poulailler_version_4.ino:953:3: note: suggested alternative: 'getc'

   rtc.writeProtect(false);

   ^~~

   getc

Porte_automatique_pour_poulailler_version_4:960:3: error: 'ramBuffer' was not declared in this scope

   ramBuffer.cell[0] = 99;

   ^~~~~~~~~

exit status 1

'DS1302' does not name a type; did you mean 'Ds1302'?



Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

jpbbricole · August 19, 2022, 9:49am

Une partie de ton problème est ici

#include <DS1302.h>
DS1302 lcd(0x27,20,4);

C'est, je pense, sensé être le paramétrage de ton affichage i2C.
Je te laisse voire.

Cordialement
jpbbricole

terwal · August 19, 2022, 9:59am

@jpbbricole je n'ai pas compris ce que tu voulais dire.

Le problème ne vient il pas que dans le fichier d'en-tête, la classe est Ds1302 et non DS1302?

hbachetti · August 19, 2022, 10:11am

A mon avis, la librairie utilisée par la personne en question n'est pas celle que tu as installée.
Deux exemples :

la classe s'appelle DS1302, alors que celle de ta librairie s'appelle Ds1302
une méthode setDOW() est utilisée dans son code, alors que la librairie Ds1302 ne l'implémente pas

Si tu fais une recherche de DS1302 et setDOW tu tombes là dessus :
http://www.rinkydinkelectronics.com/library.php?id=5
Récupère le .zip et installe le à l'aide du menu Croquis / Inclure une bibliothèque / Ajouter la bibliothèque .ZIP

68tjs · August 19, 2022, 10:19am

Si tu ouvres les fichiers de la bibliothèque, le nom de l'objet qui est déclaré, c'est DS1302 ou Ds1302 ?

Mis trop de temps pour appuyer sur envoi.

Henri a été plus rapide.

hbachetti · August 19, 2022, 10:24am

Voici le code du post #1 :

Et celui du post #9:

Pourquoi avoir renommé LiquidCrystal_I2C en DS1302 ?

alain4133 · August 19, 2022, 10:34am

pour faire des essais

alain4133 · August 19, 2022, 10:39am

celas fait plusieurs jour que je suis dessus pas tout le temps j'ai regardé les tutos et autre comprend pas désolé on peut pas être bon en tout et mauvais en rien j'ai acheté tout les composants fait les branchement entre eux l’écran s'allume mais c'est tout.

je connais bien mon métier (bâtiment) mais là je craque

alors voilas je vais tous vous renvoyé
le code
et me dire se que je doit faire

hbachetti · August 19, 2022, 11:05am

J'ai expliqué en #13 et #15. Inutile de renvoyer le code.

terwal · August 19, 2022, 11:27am

ok merci Hbachetti.

alain4133 · August 19, 2022, 12:15pm

donc la je fait quoi

merci

Topic		Replies	Views
Erreur dans la compilation Français	5	995	May 6, 2021
Erreurs de compilation Français	3	666	May 6, 2021
Utilisation de la bibliothèque I2Cmaster Français	11	79	March 4, 2025
Problème de compilation Français	23	7858	May 6, 2021
Problème de compilation Français	4	1058	May 6, 2021

Bonjour probléme de bibliothèque

Related topics