Porte automatique de poulailler v4

Description :

Ce projet permet d’automatiser l’ouverture et la fermeture d’un poulailler pour protéger vos poules des prédateurs sans effort quotidien. Articulé autour d’une carte Arduino, d’une horloge temps réel (RTC) et d’un capteur de lumière (LDR), il offre une gestion intelligente et sécurisée de l’accès à votre cheptel.

Le système propose trois modes de fonctionnement pour s’adapter à tous vos besoins :

• Mode LDR (Automatique) : Le capteur mesure la luminosité ambiante. La porte s’ouvre dès que le soleil se lève et se ferme au crépuscule, selon des seuils de lumière que vous pouvez régler vous-même dans le menu.
• Mode Programmateur (Horaire) : Pour plus de précision, vous pouvez définir des heures précises d’ouverture et de fermeture (par exemple : ouverture à 08h00 et fermeture à 21h30), indépendamment de la météo.
• Mode Manuel : Ce mode vous redonne le contrôle total. À l’aide des boutons physiques (Monter/Descendre), vous pouvez piloter le moteur à votre guise.

Vidéo de démonstration :

Schéma de câblage :

Code :

// --- DÉFINITION DES BROCHES (PINS) ---
const int Bouton_Monter = A1;       // Broche du bouton flèche haut
const int Bouton_Descendre = A2;    // Broche du bouton flèche bas
const int Bouton_Toggle_Mode = A3;  // Broche du bouton sélection/menu
const int LDR = A0;                 // Broche du capteur de luminosité (LDR)
const int FIN_HAUT = 3;             // Broche du capteur fin de course porte ouverte
const int FIN_BAS = 4;              // Broche du capteur fin de course porte fermée

// --- PARAMÈTRES DE LUMINOSITÉ ---
int val_LDR_ouverture = 700;  // Seuil de lumière pour ouvrir la porte
int val_LDR_fermeture = 500;  // Seuil d'obscurité pour fermer la porte

// --- CONTRÔLE MOTEUR (L298N) ---
const int IN1 = 8;  // Signal de pilotage moteur - Sens 1
const int IN2 = 9;  // Signal de pilotage moteur - Sens 2

// --- ÉCRAN LCD I2C ---
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);  // Adresse 0x27, 20 colonnes, 4 lignes

// --- HORLOGE TEMPS RÉEL (RTC DS1302) ---
#include <DS1302.h>
DS1302_RAM ramBuffer;  // Buffer pour la mémoire RAM du module RTC
DS1302 rtc(7, 6, 5);   // Pins CE, IO, CLK
Time t;                // Structure pour stocker l'heure actuelle

// --- VARIABLES DE GESTION DU SYSTÈME ---
int ancienMode = -1;  // Utilisé pour rafraîchir l'affichage lors d'un changement de mode

// Variables de navigation dans les menus
int menu = 1;
int modedemarche = 4;  // 2=LDR, 3=Prog, 4=Manuel
int menumodemarche = 1;
int menuprogrammateur = 1;
int menuldr = 1;

// Variables de programmation horaire
long heureouverture = 23;
long minouverture = 59;
long heurefermeture = 0;
long minfermeture = 1;

boolean etatporte = 0;  // 1 = doit s'ouvrir, 0 = doit se fermer

// Caractères personnalisés pour le LCD
byte tiretbas[8] = { 31, 0, 0, 0, 0, 0, 0, 0 };  // Barre de soulignement
byte egal[8] = { 0, 0, 31, 0, 31, 0, 0, 0 };     // Symbole égal (=)

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

  // Configuration des entrées avec résistance de tirage interne
  pinMode(Bouton_Monter, INPUT_PULLUP);
  pinMode(Bouton_Descendre, INPUT_PULLUP);
  pinMode(Bouton_Toggle_Mode, INPUT_PULLUP);
  pinMode(FIN_HAUT, INPUT_PULLUP);
  pinMode(FIN_BAS, INPUT_PULLUP);

  // Initialisation RTC
  rtc.halt(false);
  rtc.writeProtect(true);  // Protection contre l'écriture par défaut

  // Initialisation forcée de l'heure (Exemple au 24/05/2020)
  rtc.setDOW(FRIDAY);
  rtc.setTime(02, 22, 0);
  rtc.setDate(24, 05, 2020);

  // Initialisation LCD
  lcd.init();
  lcd.backlight();
  lcd.createChar(0, tiretbas);
  lcd.createChar(1, egal);

  // Chargement des paramètres sauvegardés en RAM du DS1302
  ramBuffer = rtc.readBuffer();

  // Debug : vérification de la RAM sur le moniteur série
  Serial.print("RAM : ");
  for (int i = 0; i < 10; i++) {
    Serial.print(ramBuffer.cell[i]);
    Serial.print(" ");
  }
  Serial.println();

  // Si la cellule 0 contient 99, cela signifie qu'une config existe déjà
  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];

    // Recomposition des valeurs LDR (stockées sur 2 bytes)
    val_LDR_ouverture = word(ramBuffer.cell[7], ramBuffer.cell[6]);
    val_LDR_fermeture = word(ramBuffer.cell[9], ramBuffer.cell[8]);
  }
}

void loop() {
  int valeurLDR = analogRead(LDR);  // Lecture capteur lumière

  // --- GESTION DU BOUTON SÉLECTION (MENUS) ---
  if (digitalRead(Bouton_Toggle_Mode) == 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;
      ancienMode = -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;
      ancienMode = -1;
      sauvegarde();
    }
    //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;
      ancienMode = -1;
    }
    //Menu / Programmateur / Conf.LDR / Passer Conf.LDR à Accueil
    else if (menu == 6 && menumodemarche == 1 && menuldr == 4 && menuprogrammateur == 1) {
      menu = 1;
      menuldr = 1;
      ancienMode = -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(Bouton_Toggle_Mode) == LOW) {
    }
    lcd.clear();
  }

  // --- GESTION DU BOUTON BAS (NAVIGATION & RÉGLAGES) ---
  if (digitalRead(Bouton_Descendre) == LOW) {
    delay(200);
    //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;
      }
    }

    // Action Manuelle : Fermer la porte tant qu'on appuie et que le fin de course n'est pas atteint
    if (menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1) {
      while (digitalRead(Bouton_Descendre) == LOW && digitalRead(FIN_BAS) == HIGH) {
        fermerPorte();
        affichagemenu1();
      }
      affichagemenu1();
    }
  }

  // --- GESTION DU BOUTON HAUT (NAVIGATION & RÉGLAGES) ---
  if (digitalRead(Bouton_Monter) == LOW) {
    delay(200);
    //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;
      }
    }

    // Action Manuelle : Ouvrir la porte tant qu'on appuie et que le fin de course n'est pas atteint
    if (menu == 1 && menumodemarche == 1 && menuprogrammateur == 1 && modedemarche == 4 && menuldr == 1) {
      while (digitalRead(Bouton_Monter) == LOW && digitalRead(FIN_HAUT) == HIGH) {
        ouvrirPorte();
        affichagemenu1();
      }
      affichagemenu1();
    }
  }

  // --- AFFICHAGE DES DIFFÉRENTS MENUS (SWITCH CASES) ---
  //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;
  }

  // --- LOGIQUE AUTOMATIQUE : MODE LDR ---
  if (valeurLDR >= val_LDR_ouverture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1 && menuldr == 1) {
    etatporte = 1;  // Demande ouverture
  }
  if (valeurLDR <= val_LDR_fermeture && modedemarche == 2 && menuprogrammateur == 1 && menu == 1 && menuldr == 1) {
    etatporte = 0;  // Demande fermeture
  }
  // Exécution mouvement LDR
  while (etatporte == 1 && digitalRead(FIN_HAUT) == HIGH && modedemarche == 2 && menu == 1) {
    ouvrirPorte();
  }
  while (etatporte == 0 && digitalRead(FIN_BAS) == HIGH && modedemarche == 2 && menu == 1) {
    fermerPorte();
  }

  // --- LOGIQUE AUTOMATIQUE : 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;

  // Cas où l'ouverture est avant la fermeture dans la journée
  if (ouverturesec < fermeturesec && modedemarche == 3 && menu == 1) {
    if (heuresec > ouverturesec && heuresec < fermeturesec && modedemarche == 3 && menu == 1) {
      etatporte = 1;
    } else {
      etatporte = 0;
    }
  }

  // Cas où la période d'ouverture chevauche minuit
  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;
    }
  }

  // Exécution mouvement Programmateur
  while (etatporte == 1 && digitalRead(FIN_HAUT) == HIGH && modedemarche == 3 && menu == 1) {
    ouvrirPorte();
  }
  while (etatporte == 0 && digitalRead(FIN_BAS) == HIGH && modedemarche == 3 && menu == 1) {
    fermerPorte();
  }

  // Arrêt du moteur si aucune action n'est requise
  moteurrepos();
}

// --- FONCTION D'AFFICHAGE DE L'ÉCRAN D'ACCUEIL ---
void affichagemenu1() {
  char buffer[21];
  t = rtc.getTime();
  sprintf(buffer, "%02d:%02d:%02d", t.hour, t.min, t.sec);
  lcd.setCursor(6, 0);
  lcd.print(buffer);

  if (modedemarche == 2) {  // --- MODE LDR ---
    if (modedemarche != ancienMode) {
      lcd.setCursor(5, 1);
      lcd.print("Mode : LDR         ");
      sprintf(buffer, "Ouv%c%-4d  Fer%c%-4d", 1, val_LDR_ouverture, 1, val_LDR_fermeture);
      lcd.setCursor(1, 3);
      lcd.print(buffer);
    }
    ancienMode = modedemarche; 
    sprintf(buffer, "Val. LDR %c %-4d", 1, analogRead(LDR));
    lcd.setCursor(3, 2);
    lcd.print(buffer);
  }

  else if (modedemarche == 3) {  // --- MODE PROGRAMMATEUR ---
    if (modedemarche != ancienMode) {
      lcd.setCursor(0, 1);
      lcd.print("Mode : Programmateur");
      sprintf(buffer, "Ouv. : %02ld:%02ld      ", heureouverture, minouverture);
      lcd.setCursor(0, 2);
      lcd.print(buffer);
      sprintf(buffer, "Fer. : %02ld:%02ld      ", heurefermeture, minfermeture);
      lcd.setCursor(0, 3);
      lcd.print(buffer);
    }
    ancienMode = modedemarche;  
  }

  else if (modedemarche == 4) {  // --- MODE MANUEL ---
    if (modedemarche != ancienMode) {
      lcd.setCursor(3, 1);
      lcd.print("Mode : Manuel   ");
    }
    ancienMode = modedemarche;  
    // Position porte
    lcd.setCursor(0, 2);
    lcd.print("Pos. porte : ");
    if (digitalRead(FIN_HAUT) == LOW) lcd.print("Ouverte");
    else if (digitalRead(FIN_BAS) == LOW) lcd.print("Fermee ");
    else lcd.print("...    ");

    // État boutons
    lcd.setCursor(0, 3);
    lcd.print("Bouton : ");
    if (digitalRead(Bouton_Monter) == LOW) lcd.print("Monter  ");
    else if (digitalRead(Bouton_Descendre) == LOW) lcd.print("Descente");
    else lcd.print("Repos   ");
  }
}

  // --- FONCTION DE SAUVEGARDE EN RAM RTC ---
void sauvegarde() {
  rtc.writeProtect(false);
  ramBuffer.cell[0] = 99; // Marqueur de données valides
  ramBuffer.cell[1] = modedemarche;
  ramBuffer.cell[2] = heureouverture;
  ramBuffer.cell[3] = minouverture;
  ramBuffer.cell[4] = heurefermeture;
  ramBuffer.cell[5] = minfermeture;
  // Décomposition des int 16bits en deux bytes 8bits
  ramBuffer.cell[6] = lowByte(val_LDR_ouverture);
  ramBuffer.cell[7] = highByte(val_LDR_ouverture);
  ramBuffer.cell[8] = lowByte(val_LDR_fermeture);
  ramBuffer.cell[9] = highByte(val_LDR_fermeture);
  rtc.writeBuffer(ramBuffer);
  rtc.writeProtect(true);
  Serial.print("RAM Save OK: ");
  for (int i = 0; i < 10; i++) {
    Serial.print(ramBuffer.cell[i]);
    Serial.print(" ");
  }
  Serial.println();
}

// --- FONCTIONS DE PILOTAGE DU MOTEUR ---
void ouvrirPorte() {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
}

void fermerPorte() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
}

void moteurrepos() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
}