Porte automatique pour poulailler version 5-B (Vérin électrique ou Moteur DC 12v)

Description :

Version 4 : Avec moteur PAP

3 modes disponibles et entièrement configurables grâce aux boutons et de l’affichage LCD.

Mode LDR : porte sera pilotée par le capteur de luminosité (LDR) avec option hysteresis.

Mode Manuel : porte sera pilotée par 2 boutons manuellement.

Mode Programmateur : programmer une heure ouverture / fermeture.

Options système :

-Réglage de l’heure directement avec les boutons.

-Mise en veille programmable de l’écran.

Tous les paramètres seront sauvegardés automatiquement sur la RAM en cas de coupure de courant.

 

    Prérequis :

Matériel :

  • 1 x Carte Arduino Uno
  • 2 x Fin de course
  • 1 x LDR photorésistance
  • 1 x Résistance 10 KΩ
  • 3 x Boutons
  • 1 x Ecran LCD 20×4
  • 1 x Module I2C
  • 1 x Vérin électrique ou Moteur DC
  • 1 x L298N
  • 1 x DS1302 Module RTC
  • 1 x Alimentation 12v
  • Fils de connexion
  • 1 x Breadboard

Version IDE :

Bibliothèque :

 

 

Vidéo de démonstration :

 

Schéma de câblage moteur DC :

 

Schéma de câblage vérin électrique :

 

Code :

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

//L298N ///////////////////////////////////////////

// le numéro de la broche ou est branché la sortie IN1 du L298N
int IN1 = 10;
// le numéro de la broche ou est branché la sortie IN2 du L298N
int IN2 = 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 ///////////////////////////////////////////
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  //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; digitalWrite(IN1, 1); digitalWrite(IN2, 0);
  }
  else if (Modedemarche == 3 && Accueil == 7 && EtatBtbas == 1 && digitalRead(fdcbas) == HIGH) {
    Pause = 1; digitalWrite(IN1, 0); digitalWrite(IN2, 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; digitalWrite(IN1, 1); digitalWrite(IN2, 0);
  }
  else if ((Modedemarche == 1 || Modedemarche == 2) && Etattrappe == 0 && digitalRead(fdcbas) == HIGH) {
    Pause = 1; digitalWrite(IN1, 0); digitalWrite(IN2, 1);
  }
  else {
    Moteurrepos ();
    Pause = 0;
  }
}

//Mise au repos moteur PAP ////////////////////////
void Moteurrepos () {
  digitalWrite(IN1, 0);
  digitalWrite(IN2, 0);
}

//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-B");
  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;
  }
}

 


 

Cet article a 14 commentaires

  1. Lecoanet

    Bonjour
    J ai 69 ans , ayant quelques connaissances en électronique mis pas en programmation, je me suis mis à arduino . Voulant réaliser une porte poulailler,je suis tombé sur votre site qui est très bien et où l on apprend beaucoup même pour des novices comme moi.
    J ai donc voulu réaliser votre projet version 5-B que j ai réussi malgré quelques difficultés .A l heure actuelle le système marche très bien . Mais j aimerais vous soumettre un petit problème .
    On ne peut travailler qu en mode programme ou en mode LDR .
    Ce que j aurais souhaité c est que l on puisse ouvrir tous les matins en programment une heure et fermer le soir avec la LDR . Ceci afin d éviter d ouvrir trop tôt le matin en été (coq qui chante).
    Je pense que pour vous tout est réalisable .Dans l attente de vous lire je tiens encore à vous féliciter et à continuer à nous faire aimer ARDUINO

    Cordialement

    1. steven

      Bonjour,

      Merci pour le commentaire, ça fait plaisir et ça m’encourage à continuer.
      L’idée est pas mal, je la garde pour effectuer une version future.
      Il va falloir malheureusement être un peu patient, car j’ai décidé de mettre à jour mon site internet pour augmenter sa performance et cela me demande actuellement pas mal de temps.
      Mais je compte bien, très prochainement faire de nouvelles versions.

      Cordialement

  2. Henri

    Bonjour,
    J’ai recherché pendant quelques temps un programme pour gérer une porte de poulailler automatiquement, Je suis arrivé sur votre site qui m’a tout de suite intéressé étant donné les explications précises dans les vidéos.
    J’ai donc testé les premières versions pour comprendre le fonctionnement pour arriver à la version 5B.
    Je tiens à vous remercier pour votre travail très professionnel qui permet à des débutants comme moi d’évoluer et de passer de bons moments durant l’hiver (je suis retraité).
    Comme j’ai cherché à comprendre le fonctionnement du programme, j’ai trouvé 2 petites erreurs provenant certainement d’un « copier coller »:
    Ligne 1252 « s AvOuv. » à remplacer par « s AvFer. »
    Ligne 1351 « // mise au repos moteur PAP// » à remplacer par « // mise au repos moteur courant continu// »

    Cordialement

    1. steven

      Bonjour,
      Merci pour ce retour positif, ça fait plaisir et donne envie de continuer.
      Effectivement, j’ai fait un copier-coller entre les 2 versions, car le code est identique sauf pour les moteurs, je ferais la correction de ces petites erreurs merci.
      Cordialement,

  3. Turnoff

    Bonjour; je souhaitais faire ce dispositif, j’ai beaucoup piétiné seul sur place. Puis je suis tombé sur votre site WEB, le sourire m’est revenu. J’ai débuté progressivement…Les morceaux de la version 5 sont difficiles à appréhendés. J’ai beaucoup appris en refaisant les diagrammes de transitions entre les menus. Ensuite comme je ne trouvais pas exactement les mêmes composants, il a fallu accommoder puis broder.Donc module Horloge DS3221, Afficheur LCD20x4, actionneur linéaire nichois, alimentation par panneau solaire et accumulateur Li-on récupéré.( Avec le panneau solaire pas besoin de LDR). Toujours 3 modes, manuel, Time-Prog, et Solaire. Le mode solaire à été réaménagé , je n’ai pas bien compris le système d’hystérésis, pour m’en passer, le mode solaire reprend le mode Time-Prog, ou les temps sont ajustés aux heures de lever et de coucher du soleil observées. Je travail maintenant(mal) sur l’adjonction du WiFi et le contrôle par Internet/Android.
    je ne suis pas capable de faire un site comme le votre et si vous pensez que cela puisse être d’un quelconque intérêt je suis disposer à vous soumettre mon travail. Encore merci et bravo.

    1. steven

      Bonjour,
      Merci pour ce retour.
      Le mode hystérésis a pour but de supprimer les détections intempestives sur le capteur LDR.
      Avant si on mettez le doigt sur le capteur LDR la porte se fermer instantanément, maintenant, il faut laisser le doigt un certain temps avant que la porte se ferme.
      Je suis preneur de votre travail juste par curiosité.
      Votre panneau solaire et accumulateur arrivent à faire fonctionner le système en autonomie ?
      Cordialement,

  4. Turnoff

    Bonjour, merci de m’avoir répondu. Le dispositif est en service en Anjou, depuis fin Avril en mode « Solaire » (=LDR)Les poules l’ont de suite adopté. Donc 2mois c’est encore peu. L’autonomie est plus que suffisante en ces saisons, il faut attendre l’hiver pour savoir si mes estimations restent correctes. De jour, le « BMS » coupe la recharge assez rapidement et le système est alors en veille sur le pnx solaire; il était bien calé sur les éphémérides au solstice d’été.
    je ne sais pas comment vous transmettre un quelconque document autrement que d’écrire sur ce tchat? Vous avez mon e-mail, peut-être pourriez m’y donner un lien pour ce faire? Mais ce n’est pas important… Je vous donnerais des nouvelles cet hiver. Encore bravo et merci…

  5. Turnoff

    Après relecture de mon premier message, je m’aperçois qu’il est peu être maladroit. Je voulais juste dire que je vous suis très reconnaissant pour votre partage, et, s’il y a un quelconque intérêt, je souhaitais en retour partager, par dette envers vous et pas uniquement profiter. Impossible ici de poster une quelconque photo ou bien même la notice d’emploi qui résume bien.

  6. André

    Bonjour, je trouve votre projet très intéressant, c’est exactement ce que je recherchais, je suis novice en programmation . j’ai des messages d’erreur a la compilation que je ne comprend pas.
    j’ai inclus la bibliothèque Ds 1302
    – DS 1302 does not name a type , did you mean Ds 1302, j’ai donc mis le ‘s ‘en minuscule.
    -en suite j’ai un message ‘Time’ does not name a type , et la je suis bloqué, si vous avez un conseil a me donner je vous en remercie.
    Encore bravos pour tout ce travail.

    1. steven

      Bonjour,
      Le problème vient sûrement de la bibliothèque que vous avez installée.
      Cela ne doit pas être la bonne version.
      Cordialement,

  7. patcatcat

    Bonjour Steven,
    Belle réalisation et beau programme!
    J’ai réalisé aussi une porte de poulailler avec LDR, mais je n’en suis pas satisfait à 100% pour les raisons suivantes : les fortes variations de luminosités qu’il peut y avoir ( moyenne montagne sud de la France) malgré la temporisation, la difficulté de réglages des seuils et l’humeur des volatiles….
    J’ai observé le fonctionnement et le comportements des poules sur plusieurs mois et j’en ai déduit que l’idéal serait l’ouverture et la fermeture réglés sur les levers et couchers de soleil grâces au éphémérides. Avec un décalage d’au moins 30mn le soir (crépuscule astronomique)
    Avec les éphémérides ont est certain que la fermetures se fera lorsque toutes les poules seront rentrées, car c’est surtout la fermeture qui pose problème.
    Il y a des programmes (arduino) de calculs des éphémérides fait par Bricoleau (https://forum.arduino.cc/t/calcul-ephemeride-precis-lever-et-coucher-de-soleil/266532) ou ChPr (https://forum.arduino.cc/t/bibliotheque-pour-suivi-et-ephemerides-du-soleil/436157) mais je ne suis pas suffisamment costaud en programmation pour intégré et faire fonctionner entre elles ses fonctions (RTC, éphémérides etc.).
    Un plus serait l’installation d’une cellule de détection de présence de poule sous la porte pour éviter un écrasement (vécu) retardant le fermeture.
    Une version 6-A serait bienvenue!
    Cordialement
    patcatcat

    1. steven

      Merci pour votre retour
      Je vais étudier votre proposition et regarder toutes ces informations sur les éphémérides.
      Il y aura bien une version 6.
      Je recueille le maximum de proposition et j’essayerais de faire tout ça pour cette fin d’année.
      Cordialement,

  8. patcatcat

    Eh bien je vais suivre avec attention, et si je peux aider….
    La porte auto de mon poulailler
    L;’ouverture se fait avec un lève vitre de voiture (complet glissière et câbles) moteur courant continu 12V. et glissières chariot à bille à l’opposé (initialement glissière à billes de tiroir mais fonctionnement verticale perfectible).
    Monté /descente : Inversion par relai double pour arduino
    Contrôle de la vitesse : Contrôleur de vitesse du moteur 6V-90V ,15A à courant continu avec bouton rotatif
    Alimentation par capteur solaire, régulateur et batterie 12V plomb (voiture).
    Alimentation 5V : Conertisseur DC/DC 12V 5V 3A + sortie USB (non utilisé)

    Converti

  9. Barnard

    Bonjour,
    J’ai suivi vos conseils et suis parvenu à faire fonctionner votre script. Je rencontre cependant un problème : le montage fonctionne nickel en manuel, la porte s’arrête en montée ou en descente dès qu’elle rencontre un fin de course. En revanche en mode « programmateur » la porte passe son temps à remonter et redescendre dès qu’elle rencontre un fin de course (le moteur ne se coupe que lorsque l’on appuie en même temps sur les deux « fin de course » ) Auriez-vous une piste ? D’avance je vous remercie.

Laisser un commentaire