EEPROM et Machine etat

nemesis47 · November 2, 2025, 6:58pm

Bonjour, j’ai ajouté à mon programme un nouveau void_réglages afin de modifier quelques paramètres.

Je commence par un menu avec un seul paramètre modifiable. Si je le modifie + enregistre c’est en effet pris en compte et modnuméro est bien celui enregistré.

Mais si je fais btn_retour, le paramètre ne s’enregistre pas sur EEPROM mais si je reviens sur le réglage le modnuméro reste sur celui sur lequel j’ai fais btn_retour. Alors c’est pas très grave car en effet l’EEPROM conserve le bon mod mais je trouve cela pas fini.

J’ai ajouté un etat AFFICHAGE MOD mais cela ne résout pas mon soucis. Je dois zapper une étape dans la machine à état. De plus dans le futur je souhaite faire apparaitre le nom du programme plutôt qu’un numéro de mod.

Auriez vous une idée pour solutionner le soucis d’affichage déjà.

#include <EEPROM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 5, 6, 7, 8, 9);

/*-----ENTREES-ET-SORTIES----*/
int horloge = 13;
int intrabox_relais_2 = 15;
int contact_cle = 17;
int boucle_magnetique = 19;
int lecteur_ext = 21;
int lecteur_int = 23;
int bouton_portail = 25;
int bouton_barriere = 27;
int IN9 = 29;
int IN10 = 31;
int ouverture_barriere = 18;
int ouverture_portail = 16;
int Q3 = 14;
const byte contraste = 2;
const byte retroeclairage = 4;

int entree_menus = 22;
int DIP2 = 24;

int btn_haut = 34;
int btn_bas = 36;
int btn_retour = 38;
int btn_valider = 40;

int modnumero;

/*-----LISTING-ETATS-----*/
enum etat : byte {
  PROGRAMME_DEBUT,
  PROGRAMME_EN_ATTENTE,
  PROGRAMME_HORLOGE_INACTIVE,
  PROGRAMME_HORLOGE_ACTIVE,
  PROGRAMME_MAINTENANCE,
  SORTIE_COMMANDE,
  REGLAGES_EN_ATTENTE,
  MENU_MOD,
  AFFICHAGE_MOD,
  REGLAGES_MOD
};
etat etat_programme = PROGRAMME_DEBUT;
etat etat_reglages = REGLAGES_EN_ATTENTE;

void setup() {

  /*ENTREES DE IN1 à IN10*/
  pinMode(horloge, INPUT);
  pinMode(intrabox_relais_2, INPUT);
  pinMode(contact_cle, INPUT);
  pinMode(boucle_magnetique, INPUT);
  pinMode(lecteur_ext, INPUT);
  pinMode(lecteur_int, INPUT);
  pinMode(bouton_portail, INPUT);
  pinMode(bouton_barriere, INPUT);
  pinMode(IN9, INPUT);
  pinMode(IN10, INPUT);

  EEPROM.get(10, modnumero);

  pinMode(btn_haut, INPUT);
  pinMode(btn_bas, INPUT);
  pinMode(btn_valider, INPUT);
  pinMode(btn_retour, INPUT);
  pinMode(entree_menus, INPUT);
  pinMode(DIP2, INPUT);

  /*SORTIES DE Q1 à Q3*/
  pinMode(ouverture_barriere, OUTPUT);
  pinMode(ouverture_portail, OUTPUT);
  pinMode(Q3, OUTPUT);

  /*PINS REGLAGES LCD*/
  pinMode(contraste, OUTPUT);
  pinMode(retroeclairage, OUTPUT);

  /*REGLAGES LCD*/
  analogWrite(contraste, 120);
  analogWrite(retroeclairage, 150);

//////////////////

void reglages() {
  switch (etat_reglages) {

    case REGLAGES_EN_ATTENTE:
      if (digitalRead(entree_menus) == LOW) {
        delay(500);
        loop();
      } else {
        analogWrite(retroeclairage, 200);
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);
        etat_reglages = MENU_MOD;
      }
      break;

    case MENU_MOD:
      lcd.setCursor(0, 0);
      lcd.print("MODES DE        ");
      lcd.setCursor(0, 1);
      lcd.print("FONCTIONNEMENT  ");
      delay(200);

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        delay(200);
      }
      break;

    case AFFICHAGE_MOD:
      lcd.setCursor(0, 0);
      lcd.print("MOD             ");
      EEPROM.get(10, modnumero);
      lcd.setCursor(5, 1);
      etat_reglages = REGLAGES_MOD;
      delay (500);
      break;

    case REGLAGES_MOD:
      lcd.setCursor(0, 0);
      lcd.print("MOD             ");
      lcd.setCursor(5, 1);
      lcd.print(modnumero);


      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        modnumero = modnumero + 1;
        modnumero = constrain(modnumero, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        modnumero = modnumero - 1;
        modnumero = constrain(modnumero, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_valider) == HIGH) {
        EEPROM.put(10, modnumero);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(btn_retour) == HIGH) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("NON ENREGISTRES ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
      }
      break;
  }
}

fdufnews · November 2, 2025, 7:22pm

Cet appel à loop() c'est pas propre.
Je suppose que tu es arrivé là en venant de loop() et tu sautes à loop() du coup il y a une adresse de retour qui va rester sur la pile. Fais ça plusieurs fois et tu auras un beau plantage difficile à trouver.

Pour régler ton problème, il faudrait sauver le modnumero courant lorsque tu commences la procédure et le récupérer si tu abandonnes la procédure sans sauvegarder.

nemesis47 · November 2, 2025, 7:32pm

Bonjour, voulez dire que à chaque btn_haut ou bas je dois sauver le modnumero dans EEPROM?

fdufnews · November 2, 2025, 8:27pm

Mais non, l'EEPROM ne doit contenir que des saisies qui ont été validées.

Lorsque tu entres dans REGLAGES_MOD modnumero a une certaine valeur.
Tu sauves modnumero dans une variable locale sauvmod, par exemple.
Si tu appuies sur haut ou bas tu vas modifier modnumero.
Si tu appuies sur retour pour abandonner les modifications il faut que modnumero retrouve la valeur qu'il avait avant et donc tu lui remets cette valeur qui a été sauvées dans sauvmod.

J-M-L · November 3, 2025, 10:55am

Si le bouton reste LOW, effectivement il y aura plusieurs appels récursif qui pourraient planter sur plus de place dans la pile, mais si on lâche le bouton au bout de quelques secondes (le delay(500) aidant à ne pas empiler trop vite) les appels se dépileront et il n'y aura rien qui traine sur la pile.

main()
    ⎣ loop()             // appel normal
        ⎣ loop()         // le bouton est appuyé, appel récursif
            ⎣ loop()     // le bouton est toujours appuyé, appel récursif
         fin while ⎦     // on dépile
   fin while ⎦           // on dépile
   ⎦                        // retour à main
    ⎣ loop()             // appel normal (bouton non appuyé)
    ⎣ loop()             // appel normal (bouton non appuyé)
    ⎣ loop()             // appel normal (bouton non appuyé)
    ⎣ loop()             // appel normal (bouton non appuyé)

fdufnews · November 3, 2025, 1:18pm

Si, si parce qu'il y a ça dans la fonction reglages() qui fait qu'on ne sort pas par les "voies naturelles" donc on ne dépile rien.

nemesis47:

void reglages() {
  switch (etat_reglages) {

    case REGLAGES_EN_ATTENTE:
      if (digitalRead(entree_menus) == LOW) {
        delay(500);
        loop(); //               <<<<===========================
      } else {

J-M-L · November 3, 2025, 6:31pm

Ce que je veux dire c'est que la loop() ne boucle pas par magie, c'est une fonction comme une autre, elle boucle simplement parce que main() l'appelle en boucle.

effectivement ce n'est pas top d'appeler loop() dans ce case, et on va empiler des appels récursivement, mais si la loop à un moment ne passe plus dans l'appel à réglages(), on va dépiler tranquillement et il ne restera rien sur la pile. (bien sûr si on fait trop d'appels récursifs, ça va planter).

nemesis47 · November 9, 2025, 2:56pm

Bonjour et merci pour vos retours.

Juste concernant l’appel de loop() je ne me souviens plus pourquoi mais je ne l’ai pas mise par hasard. J’ai une première version qui tourne sans soucis depuis 2 ans chez un cobaye. Donc je me pencherais dessus plus tard pour éviter le plantage.

Concernant les réglages, j’ai modifié le code, vous me direz si il y a plus propre.

Par contre lorsque entrées_menus devient LOW, j’ai besoin d’activer une entrée boucle_magnetique par exemple pour utiliser le programme (normal inverse ou full). Comme si etat_programme n’est pas PROGRAMME DEBUT..

#include <EEPROM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 5, 6, 7, 8, 9);

/*-----ENTREES-ET-SORTIES----*/
int horloge = 13;
int intrabox_relais_2 = 15;
int contact_cle = 17;
int boucle_magnetique = 19;
int lecteur_ext = 21;
int lecteur_int = 23;
int bouton_portail = 25;
int bouton_barriere = 27;
int IN9 = 29;
int IN10 = 31;
int ouverture_barriere = 18;
int ouverture_portail = 16;
int Q3 = 14;
const byte contraste = 2;
const byte retroeclairage = 4;

int entree_menus = 22;
int DIP2 = 24;

int btn_haut = 34;
int btn_bas = 36;
int btn_retour = 38;
int btn_valider = 40;

int modnumero;
int modtempnum;

/*-----LISTING-ETATS-----*/
enum etat : byte {
  PROGRAMME_DEBUT,
  PROGRAMME_EN_ATTENTE,
  PROGRAMME_HORLOGE_INACTIVE,
  PROGRAMME_HORLOGE_ACTIVE,
  PROGRAMME_MAINTENANCE,
  SORTIE_COMMANDE,
  REGLAGES_EN_ATTENTE,
  MENU_MOD,
  AFFICHAGE_MOD,
  REGLAGES_MOD
};
etat etat_programme = PROGRAMME_DEBUT;
etat etat_reglages = REGLAGES_EN_ATTENTE;

void setup() {

  /*ENTREES DE IN1 à IN10*/
  pinMode(horloge, INPUT);
  pinMode(intrabox_relais_2, INPUT);
  pinMode(contact_cle, INPUT);
  pinMode(boucle_magnetique, INPUT);
  pinMode(lecteur_ext, INPUT);
  pinMode(lecteur_int, INPUT);
  pinMode(bouton_portail, INPUT);
  pinMode(bouton_barriere, INPUT);
  pinMode(IN9, INPUT);
  pinMode(IN10, INPUT);

  EEPROM.get(10, modnumero);

  pinMode(btn_haut, INPUT);
  pinMode(btn_bas, INPUT);
  pinMode(btn_valider, INPUT);
  pinMode(btn_retour, INPUT);
  pinMode(entree_menus, INPUT);
  pinMode(DIP2, INPUT);

  /*SORTIES DE Q1 à Q3*/
  pinMode(ouverture_barriere, OUTPUT);
  pinMode(ouverture_portail, OUTPUT);
  pinMode(Q3, OUTPUT);

  /*PINS REGLAGES LCD*/
  pinMode(contraste, OUTPUT);
  pinMode(retroeclairage, OUTPUT);

  /*REGLAGES LCD*/
  analogWrite(contraste, 120);
  analogWrite(retroeclairage, 150);

  /*DEMARRAGE LDC*/
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Gestionnaire     ");
  delay(800);
  lcd.setCursor(0, 1);
  lcd.print("Multi-Commandes ");
  delay(1000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("GMC             ");
  delay(800);
  lcd.setCursor(0, 1);
  lcd.print("v2.02           ");
  delay(1500);
  lcd.clear();
}


void loop() {
  if (digitalRead(entree_menus) == HIGH) {
    reglages();
  } else {
    if (modnumero == 1) {
      programme_normal();
    }
    if (modnumero == 2) {
      programme_inverse();
    }
    if (modnumero == 3) {
      programme_full();
    }
  }
}

void programme_normal() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, 150);
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);

      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void programme_inverse() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, 150);
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);

      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void programme_full() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, 150);
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);

      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void reglages() {
  switch (etat_reglages) {

    case REGLAGES_EN_ATTENTE:
      if (digitalRead(entree_menus) == LOW) {
        delay(500);
        loop();
      } else {
        analogWrite(retroeclairage, 200);
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);
        etat_reglages = MENU_MOD;
      }
      break;

    case MENU_MOD:
      lcd.setCursor(0, 0);
      lcd.print("MODES DE        ");
      lcd.setCursor(0, 1);
      lcd.print("FONCTIONNEMENT  ");
      delay(200);

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = AFFICHAGE_MOD;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        delay(200);
      }
      break;

    case AFFICHAGE_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");
      EEPROM.get(10, modnumero);
      modtempnum = modnumero;
      etat_reglages = REGLAGES_MOD;
      delay (400);
      break;

    case REGLAGES_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");
      
      if (modtempnum == 1) {
        lcd.setCursor(0, 1);
        lcd.print("Normal          ");
        }
      
      if (modtempnum == 2) {
        lcd.setCursor(0, 1);
        lcd.print("Inverse         ");
        }

      if (modtempnum == 3) {
        lcd.setCursor(0, 1);
        lcd.print("Complet         ");
        }  

      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        modtempnum = modtempnum + 1;
        modtempnum = constrain(modtempnum, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        modtempnum = modtempnum - 1;
        modtempnum = constrain(modtempnum, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_valider) == HIGH) {
        modnumero = modtempnum;
        EEPROM.put(10, modnumero);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(btn_retour) == HIGH) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("NON ENREGISTRES ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
      }
      break;
  }
}

J-M-L · November 9, 2025, 3:10pm

Juste en parcourant le code (qui est bien structuré), je trouve qu'il y a beaucoup de répétitions. Chaque programme (normal, inverse, full) fait quasiment la même chose, ce qui alourdit le code.

Sinon l’usage intensif de delay() bloque le microcontrôleur, ce qui peut poser problème si vous ajoutez des fonctions nécessitant des réponses rapides.

Vous avez aussi bcp de code dupliqué pour les affichages, vous pourriez passer par une fonction, par exemple

void afficherLCD(const char* ligne1, const char* ligne2 = "", unsigned long delaiMs = 0) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(ligne1);
  if (ligne2[0] != '\0') {
    lcd.setCursor(0, 1);
    lcd.print(ligne2);
  }
  if (delaiMs != 0)  delay(delaiMs);
}

avec cette fonction, votre code qui fait

if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }

deviendrait

if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
  digitalWrite(ouverture_portail, HIGH);
  afficherLCD("HORLOGE OFF     ", "DETECTION BOUCLE", 200);
  etat_programme = SORTIE_COMMANDE;
}
if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
  digitalWrite(ouverture_portail, HIGH);
  afficherLCD("HORLOGE OFF     ", "LECTEUR INT     ", 200);
  etat_programme = SORTIE_COMMANDE;
}
if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
  digitalWrite(ouverture_portail, HIGH);
  afficherLCD("HORLOGE OFF     ", "LECTEUR EXT     ", 200);
  etat_programme = SORTIE_COMMANDE;
}
if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
  digitalWrite(ouverture_portail, HIGH);
  afficherLCD("HORLOGE OFF     ", "CDE INTRATONE   ", 200);
  etat_programme = SORTIE_COMMANDE;
}
if (digitalRead(contact_cle) == LOW) {
  digitalWrite(ouverture_barriere, LOW);
  digitalWrite(ouverture_portail, LOW);
  afficherLCD("MODE MAINTENANCE");
  etat_programme = PROGRAMME_MAINTENANCE;
}

c'est moins lourd à lire.

J-M-L · November 9, 2025, 3:14pm

Vous pourriez essayer de remplacer ce bloc :

if (digitalRead(entree_menus) == LOW) {
  delay(500);
  loop();
}

par quelque chose comme :

if (digitalRead(entree_menus) == LOW) {
  etat_reglages = REGLAGES_EN_ATTENTE;
  return; // <========
}

Ainsi, le programme sort de la fonction de réglages et reprend la logique normale.

avec la fonction précédente, ça donnerait un truc comme ça:

void reglages() {
  if (digitalRead(entree_menus) == LOW) {
    etat_reglages = REGLAGES_EN_ATTENTE;
    return;
  }

  switch (etat_reglages) {

    case REGLAGES_EN_ATTENTE:
      analogWrite(retroeclairage, 200);
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);
      etat_reglages = MENU_MOD;
      break;

    case MENU_MOD:
      afficherLCD("MODES DE", "FONCTIONNEMENT", 200);

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = AFFICHAGE_MOD;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        etat_reglages = REGLAGES_EN_ATTENTE;
        return;
      }
      break;

    case AFFICHAGE_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");
      EEPROM.get(10, modnumero);
      modtempnum = modnumero;
      etat_reglages = REGLAGES_MOD;
      delay(400);
      break;

    case REGLAGES_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");

      if (modtempnum == 1) {
        lcd.setCursor(0, 1);
        lcd.print("Normal          ");
      } else if (modtempnum == 2) {
        lcd.setCursor(0, 1);
        lcd.print("Inverse         ");
      } else if (modtempnum == 3) {
        lcd.setCursor(0, 1);
        lcd.print("Complet         ");
      }

      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        modtempnum = constrain(modtempnum + 1, 1, 3);
        lcd.clear();
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        modtempnum = constrain(modtempnum - 1, 1, 3);
        lcd.clear();
      }

      if (digitalRead(btn_valider) == HIGH) {
        modnumero = modtempnum;
        EEPROM.put(10, modnumero);
        afficherLCD("REGLAGES", "ENREGISTRES", 1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(btn_retour) == HIGH) {
        afficherLCD("REGLAGES", "NON ENREGISTRES", 1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(entree_menus) == LOW) {
        etat_reglages = REGLAGES_EN_ATTENTE;
        return;
      }
      break;
  }
}

nemesis47 · November 9, 2025, 3:23pm

Merci pour votre retour, je vais lire tout ça, mais concernant les programmes normal / inverse et complet, en effet ce sont pour le moment des copier coller. Inverse et complet n’ont pour le moment aucun intérêt.

J-M-L · November 9, 2025, 3:51pm

OK - ceci explique cela

nemesis47 · November 9, 2025, 4:38pm

Je ne dois pas savoir l’intégrer correctement. Cela ne fonctionne pas.

Voici le code modifié

#include <EEPROM.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 5, 6, 7, 8, 9);

/*ENTREES DE IN1 à IN10*/
int horloge = 13;
int intrabox_relais_2 = 15;
int contact_cle = 17;
int boucle_magnetique = 19;
int lecteur_ext = 21;
int lecteur_int = 23;
int bouton_portail = 25;
int bouton_barriere = 27;
int IN9 = 29;
int IN10 = 31;

/*SORTIES DE Q1 à Q3*/
int ouverture_barriere = 18;
int ouverture_portail = 16;
int Q3 = 14;

/*PINS REGLAGES LCD*/
const byte contraste = 2;
const byte retroeclairage = 4;

/*DIP SWITCH ET BOUTONS*/
int entree_menus = 22;
int DIP2 = 24;
int btn_haut = 34;
int btn_bas = 36;
int btn_retour = 38;
int btn_valider = 40;

/*VARIABLES REGLABLES*/
/*MODES*/
int modtempnum;
int modnumero;
/*RETRO ECLAIRAGE*/
int retroreg;
int valretro;
/*CONTRASTE*/
int contrastereg;
int valcontraste;

/*-----LISTING-ETATS-----*/
enum etat : byte {
  PROGRAMME_DEBUT,
  PROGRAMME_EN_ATTENTE,
  PROGRAMME_HORLOGE_INACTIVE,
  PROGRAMME_HORLOGE_ACTIVE,
  PROGRAMME_MAINTENANCE,
  SORTIE_COMMANDE,
  REGLAGES_EN_ATTENTE,
  MENU_MOD,
  AFFICHAGE_MOD,
  REGLAGES_MOD,
  MENU_RETRO,
  AFFICHAGE_RETRO,
  REGLAGES_RETRO,
  MENU_CONTRASTE,
  AFFICHAGE_CONTRASTE,
  REGLAGES_CONTRASTE
};
etat etat_programme = PROGRAMME_DEBUT;
etat etat_reglages = REGLAGES_EN_ATTENTE;

void setup() {

  /*ENTREES DE IN1 à IN10*/
  pinMode(horloge, INPUT);
  pinMode(intrabox_relais_2, INPUT);
  pinMode(contact_cle, INPUT);
  pinMode(boucle_magnetique, INPUT);
  pinMode(lecteur_ext, INPUT);
  pinMode(lecteur_int, INPUT);
  pinMode(bouton_portail, INPUT);
  pinMode(bouton_barriere, INPUT);
  pinMode(IN9, INPUT);
  pinMode(IN10, INPUT);

  /*SORTIES DE Q1 à Q3*/
  pinMode(ouverture_barriere, OUTPUT);
  pinMode(ouverture_portail, OUTPUT);
  pinMode(Q3, OUTPUT);

  /*DIP SWITCH ET BOUTONS*/
  pinMode(btn_haut, INPUT);
  pinMode(btn_bas, INPUT);
  pinMode(btn_valider, INPUT);
  pinMode(btn_retour, INPUT);
  pinMode(entree_menus, INPUT);
  pinMode(DIP2, INPUT);

  /*PINS REGLAGES LCD*/
  pinMode(contraste, OUTPUT);
  pinMode(retroeclairage, OUTPUT);

  /*REGLAGES LCD*/
  analogWrite(contraste, 120);
  analogWrite(retroeclairage, 150);

  /*ADRESSES EEPROM*/
  EEPROM.get(10, modnumero);
  EEPROM.get(20, valretro);
  EEPROM.get(30, valcontraste);

  /*DEMARRAGE LCD*/
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Gestionnaire     ");
  delay(800);
  lcd.setCursor(0, 1);
  lcd.print("Multi-Commandes ");
  delay(1000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("GMC             ");
  delay(800);
  lcd.setCursor(0, 1);
  lcd.print("v2.02           ");
  delay(1500);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("       AFI      ");
  delay(800);
  lcd.setCursor(0, 1);
  lcd.print(" 05 56 61 62 91 ");
  delay(5000);
  lcd.clear();
}


void loop() {
  EEPROM.get(20, valretro);
  EEPROM.get(30, valcontraste);
  analogWrite(retroeclairage, valretro);
  analogWrite(contraste, valcontraste);

  if (digitalRead(entree_menus) == HIGH) {
    reglages();
  } else {
    if (modnumero == 1) {
      programme_normal();
    }
    if (modnumero == 2) {
      programme_inverse();
    }
    if (modnumero == 3) {
      programme_full();
    }
  }
}

void programme_normal() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);
      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void programme_inverse() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, 150);
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);

      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void programme_full() {

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, 150);
      lcd.clear();
      digitalWrite(ouverture_barriere, LOW);
      digitalWrite(ouverture_portail, LOW);

      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == LOW)) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, HIGH);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        etat_programme = PROGRAMME_HORLOGE_INACTIVE;
      }
      if ((digitalRead(contact_cle) == HIGH) && (digitalRead(horloge) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        etat_programme = PROGRAMME_HORLOGE_ACTIVE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_INACTIVE:
      if (digitalRead(horloge) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == LOW) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_portail, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE OFF     ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_HORLOGE_ACTIVE:
      if (digitalRead(horloge) == LOW) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(boucle_magnetique) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_int) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(lecteur_ext) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if ((digitalRead(horloge) == HIGH) && (digitalRead(intrabox_relais_2) == HIGH)) {
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("HORLOGE ON      ");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(contact_cle) == LOW) {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        etat_programme = PROGRAMME_MAINTENANCE;
      }
      break;


    case PROGRAMME_MAINTENANCE:
      if (digitalRead(contact_cle) == HIGH) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if (digitalRead(boucle_magnetique) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("DETECTION BOUCLE");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_int) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR INT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(lecteur_ext) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("LECTEUR EXT     ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(intrabox_relais_2) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("CDE INTRATONE   ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_portail) == HIGH) {
        digitalWrite(ouverture_portail, HIGH);
        digitalWrite(ouverture_barriere, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON PORTAIL  ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      if (digitalRead(bouton_barriere) == HIGH) {
        digitalWrite(ouverture_portail, LOW);
        digitalWrite(ouverture_barriere, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("MODE MAINTENANCE");
        lcd.setCursor(0, 1);
        lcd.print("BOUTON BARRIERE ");
        delay(200);
        etat_programme = SORTIE_COMMANDE;
      }
      break;


    /*-----Programme permettant de sortir après une commande-------*/
    case SORTIE_COMMANDE:
      if ((digitalRead(boucle_magnetique) == LOW) && (digitalRead(lecteur_int) == LOW) && (digitalRead(lecteur_ext) == LOW) && (digitalRead(intrabox_relais_2) == LOW) && (digitalRead(bouton_portail) == LOW) && (digitalRead(bouton_barriere) == LOW)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      break;
  }
}


void reglages() {
  switch (etat_reglages) {

    case REGLAGES_EN_ATTENTE:
      if (digitalRead(entree_menus) == LOW) {
        delay(500);
        /*loop();*/
        return;
      } 
      else {
        digitalWrite(ouverture_barriere, LOW);
        digitalWrite(ouverture_portail, LOW);
        etat_reglages = MENU_MOD;
      }
      break;

    case MENU_MOD:
      lcd.setCursor(0, 0);
      lcd.print("MODES DE        ");
      lcd.setCursor(0, 1);
      lcd.print("FONCTIONNEMENT  ");
      delay(200);

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = AFFICHAGE_MOD;
        delay(200);
      }

      if (digitalRead(btn_bas) == HIGH) {
        lcd.clear();
        etat_reglages = MENU_RETRO;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        delay(200);
      }
      break;

    case AFFICHAGE_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");
      EEPROM.get(10, modnumero);
      modtempnum = modnumero;
      etat_reglages = REGLAGES_MOD;
      delay(400);
      break;

    case REGLAGES_MOD:
      lcd.setCursor(0, 0);
      lcd.print("Mode :          ");

      if (modtempnum == 1) {
        lcd.setCursor(0, 1);
        lcd.print("Normal          ");
      }

      if (modtempnum == 2) {
        lcd.setCursor(0, 1);
        lcd.print("Inverse         ");
      }

      if (modtempnum == 3) {
        lcd.setCursor(0, 1);
        lcd.print("Complet         ");
      }

      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        modtempnum = modtempnum + 1;
        modtempnum = constrain(modtempnum, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        modtempnum = modtempnum - 1;
        modtempnum = constrain(modtempnum, 1, 3);
        lcd.clear();
        etat_reglages = REGLAGES_MOD;
      }

      if (digitalRead(btn_valider) == HIGH) {
        modnumero = modtempnum;
        EEPROM.put(10, modnumero);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(btn_retour) == HIGH) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("NON ENREGISTRES ");
        delay(1500);
        etat_reglages = MENU_MOD;
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        return;
      }
      break;

    case MENU_RETRO:
      lcd.setCursor(0, 0);
      lcd.print("VALEUR DU       ");
      lcd.setCursor(0, 1);
      lcd.print("RETRO-ECLAIRAGE ");
      delay(200);

      if (digitalRead(btn_haut) == HIGH) {
        lcd.clear();
        etat_reglages = MENU_MOD;
        delay(200);
      }

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = AFFICHAGE_RETRO;
        delay(200);
      }

      if (digitalRead(btn_bas) == HIGH) {
        lcd.clear();
        etat_reglages = MENU_CONTRASTE;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        return;
      }
      break;

    case AFFICHAGE_RETRO:
      lcd.setCursor(0, 0);
      lcd.print("Retro-ecl :     ");
      EEPROM.get(20, valretro);
      retroreg = valretro;
      etat_reglages = REGLAGES_RETRO;
      delay(400);
      break;

    case REGLAGES_RETRO:
      lcd.setCursor(0, 0);
      lcd.print("Retro-ecl :     ");
      lcd.setCursor(12, 1);
      lcd.print(retroreg/25*10);
      lcd.setCursor(15, 1);
      lcd.print("%");

      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        retroreg = retroreg + 10;
        retroreg = constrain(retroreg, 25, 250);
        lcd.clear();
        etat_reglages = REGLAGES_RETRO;
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        retroreg = retroreg - 10;
        retroreg = constrain(retroreg, 25, 250);
        lcd.clear();
        etat_reglages = REGLAGES_RETRO;
      }

      if (digitalRead(btn_valider) == HIGH) {
        valretro = retroreg;
        EEPROM.put(20, valretro);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_RETRO;
      }

      if (digitalRead(btn_retour) == HIGH) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("NON ENREGISTRES ");
        delay(1500);
        etat_reglages = MENU_RETRO;
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
      }
      break;

      case MENU_CONTRASTE:
      lcd.setCursor(0, 0);
      lcd.print("VALEUR DU       ");
      lcd.setCursor(0, 1);
      lcd.print("CONTRASTE       ");
      delay(200);

      if (digitalRead(btn_haut) == HIGH) {
        lcd.clear();
        etat_reglages = MENU_RETRO;
        delay(200);
      }

      if (digitalRead(btn_valider) == HIGH) {
        lcd.clear();
        etat_reglages = AFFICHAGE_CONTRASTE;
        delay(200);
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        delay(200);
      }
      break;

    case AFFICHAGE_CONTRASTE:
      lcd.setCursor(0, 0);
      lcd.print("Contraste :     ");
      EEPROM.get(30, valcontraste);
      contrastereg = valcontraste;
      etat_reglages = REGLAGES_CONTRASTE;
      delay(400);
      break;

    case REGLAGES_CONTRASTE:
      lcd.setCursor(0, 0);
      lcd.print("Contraste :     ");
      lcd.setCursor(12, 1);
      lcd.print(contrastereg/25*10);
      lcd.setCursor(15, 1);
      lcd.print("%");

      if (digitalRead(btn_haut) == HIGH) {
        delay(200);
        contrastereg = contrastereg + 10;
        contrastereg = constrain(contrastereg, 25, 250);
        lcd.clear();
        etat_reglages = REGLAGES_CONTRASTE;
      }

      if (digitalRead(btn_bas) == HIGH) {
        delay(200);
        contrastereg = contrastereg - 10;
        contrastereg = constrain(contrastereg, 25, 200);
        lcd.clear();
        etat_reglages = REGLAGES_CONTRASTE;
      }

      if (digitalRead(btn_valider) == HIGH) {
        valcontraste = contrastereg;
        EEPROM.put(30, valcontraste);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_CONTRASTE;
      }

      if (digitalRead(btn_retour) == HIGH) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("NON ENREGISTRES ");
        delay(1500);
        etat_reglages = MENU_CONTRASTE;
      }

      if (digitalRead(entree_menus) == LOW) {
        lcd.clear();
        etat_reglages = REGLAGES_EN_ATTENTE;
        return;
      }
      break;
  }
}

J-M-L · November 9, 2025, 4:45pm

pourquoi delay(500) ?

nemesis47 · November 9, 2025, 4:53pm

Pour éviter des rebonds selon le type d’interrupteur servant à entrées_menus mais en le retirant c’est idem

    case REGLAGES_EN_ATTENTE:
      if (digitalRead(entree_menus) == LOW) {
        /*delay(500);*/
        /*loop();*/
        return;

J-M-L · November 9, 2025, 5:00pm

Pour que ça fonctionne comme prévu, il faut que dès que vous sortez de la fonction, etat_reglages soit mis à un état qui permette à loop() ou à la logique principale de continuer avec etat_programme intact.

je ne sais pas si ça fait du sens mais un truc comme

if (digitalRead(entree_menus) == LOW) {
  etat_reglages = REGLAGES_FINI; // ou un état qui indique sortie vers le programme normal
  return;
}

nemesis47 · November 9, 2025, 5:03pm

J-M-L:

Vous avez aussi bcp de code dupliqué pour les affichages, vous pourriez passer par une fonction, par exemple

void afficherLCD(const char* ligne1, const char* ligne2 = "", unsigned long delaiMs = 0) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(ligne1);
  if (ligne2[0] != '\0') {
    lcd.setCursor(0, 1);
    lcd.print(ligne2);
  }
  if (delaiMs != 0)  delay(delaiMs);
}

Merci, c’est parfait pour y voir plus clair. On est d’accord que je dois placer void afficher LCD avant le setup ?

J-M-L · November 9, 2025, 5:12pm

Oui si vous voulez respecter le C++, il faut que la fonction soit définie avant qu'elle soit utilisée.

Cela dit, dans un .ino - l'IDE avant de compiler va générer ce qu'on appelle des "forward declaration", c'est à dire qu'il va trouver toutes les fonctions et mettre leur déclaration en début de fichier, donc même si c'est tout à la fin, ça va fonctionner.

➜ Le mieux et le plus propre c'est effectivement de mettre cela avant le setup() en effet

nemesis47 · November 9, 2025, 5:23pm

Concernant le fait qu’en sortant des réglages je ne vois pas HORLOGE ON ne peut pas venir du fait que des case portent le même nom?

J-M-L · November 9, 2025, 5:37pm

??

Je lis sur mon iPhone donc pas simple de voir tout le code, mais vous ne pouvez pas avoir plusieurs case avec le même nom, ça ne compilerait pas.
Que voulez vous dire par là ?

Topic		Replies	Views
Menu pour réglages des paramètres, besoin d'aide Français	14	1779	November 21, 2021
Question application Tuto machine à états de @J-M-L Français	5	303	April 25, 2024
I2C problème d'affichage sur 1ière ligne Français	19	228	May 20, 2026
Définition de fonction non autorisé Français	23	302	April 26, 2026
Programmateur horaire modifié Français	4	130	April 22, 2026

EEPROM et Machine etat

Related topics