Question application Tuto machine à états de @J-M-L

International Français
1

Bonjour, le tuto m'a permit de faire quelques projets mais je bloque sur un point.
J'ai dans mon programme void loop qui mène soit à void reglage soit void programme selon l'état haut ou bas d'une entrée.
On sortant de void reglages je ne reviens pas forcement sur etat_programme pour enuméré plus haut.
auriez vous une idée pour quelque soit le dernier etat sur void reglages, lorsque je reviens sur void reglages je reviennes à l'état_réglages ?
Cordialement

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

/*-----ENTREES-ET-SORTIES----*/
int bouton_p1 = 22;
int bouton_p2 = 30;
int clavier_p1 = 28;
int clavier_p2 = 36;
int contact_p1 = 26;
int contact_p2 = 34;
int menus = 38;
int contactrelais_p1 = 24;
int contactrelais_p2 = 32;
int relais_p1 = 49;
int relais_p2 = 51;

/*----VALEURS-RETROECLAIRAGE----*/
const byte retroeclairage = 10;
int retro_bas;
int retro_haut;

/*-----TEMPORISATIONS------*/
int tempo_retro;
int tempo_ouv_p1;
int tempo_ouv_p2;
int verif_blocage_p1;
int verif_blocage_p2;

/*-----LISTING-ETATS-----*/
enum etat : byte {
  BUTTON_NONE,
  BUTTON_UP,
  BUTTON_DOWN,
  BUTTON_LEFT,
  BUTTON_RIGHT,
  BUTTON_SELECT,
  PROGRAMME_DEBUT,
  PROGRAMME_EN_ATTENTE,
  OUVERTURE_P1,
  OUVERTURE_P2,
  PROGRAMME_P1_OUVERTE,
  PROGRAMME_P2_OUVERTE,
  VERIFICATION_P1,
  VERIFICATION_P2,
  REGLAGES_EN_ATTENTE,
  MENU_T_OUV1,
  REGLAGE_T_OUV1,
  MENU_T_OUV2,
  REGLAGE_T_OUV2,
  MENU_T_RETRO,
  REGLAGE_T_RETRO,
  MENU_RETRO_H,
  REGLAGE_RETRO_H,
  MENU_RETRO_B,
  REGLAGE_RETRO_B
  
  
};
etat etat_programme = PROGRAMME_DEBUT;
etat etat_reglages = REGLAGES_EN_ATTENTE;


void setup() {
  lcd.begin(16, 2);
  EEPROM.get(10, tempo_retro);
  EEPROM.get(30, tempo_ouv_p1);
  EEPROM.get(50, tempo_ouv_p2);
  EEPROM.get(70, verif_blocage_p1);
  EEPROM.get(90, verif_blocage_p2);
  EEPROM.get(100, retro_bas);
  EEPROM.get(110, retro_haut);
delay(5000);

  pinMode(bouton_p1, INPUT);
  pinMode(bouton_p2, INPUT);
  pinMode(clavier_p1, INPUT);
  pinMode(clavier_p2, INPUT);
  pinMode(contact_p1, INPUT);
  pinMode(contact_p2, INPUT);
  pinMode(contactrelais_p1, INPUT);
  pinMode(contactrelais_p2, INPUT);
  pinMode(menus, INPUT);
  pinMode(relais_p1, OUTPUT);
  pinMode(relais_p2, OUTPUT);
  lcd.clear();
}

byte getPressedButton() {
  int value = analogRead(A0);
  if (value < 50)
    return BUTTON_RIGHT;
  else if (value < 250)
    return BUTTON_UP;
  else if (value < 380)
    return BUTTON_DOWN;
  else if (value < 550)
    return BUTTON_LEFT;
  else if (value < 850)
    return BUTTON_SELECT;
  else
    return BUTTON_NONE;
}

void loop() {
  if (digitalRead(menus) == HIGH) {
    reglages();
  }
  else {
    if (digitalRead(menus) == LOW) {
      programme_normal();
    }
  }
}

void programme_normal() {
  static unsigned long lancement_retro;
  static unsigned long lancement_blocage_p1;
  static unsigned long lancement_blocage_p2;

  switch (etat_programme) {


    case PROGRAMME_DEBUT:
      analogWrite(retroeclairage, retro_haut);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("   EN ATTENTE   ");
      lcd.setCursor(0, 1);
      lcd.print(" D'UNE COMMANDE ");
      digitalWrite(relais_p1, LOW);
      digitalWrite(relais_p2, LOW);
      lancement_retro = millis();
      etat_programme = PROGRAMME_EN_ATTENTE;
      break;


    case PROGRAMME_EN_ATTENTE:
      if (millis() - lancement_retro >= tempo_retro) {
        analogWrite(retroeclairage, retro_bas);
        etat_programme = PROGRAMME_EN_ATTENTE;
      }
      if (digitalRead(bouton_p1) == HIGH) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("BOUTON          ");
        lcd.setCursor(0, 1);
        lcd.print("PORTE 1         ");
        delay (1000);
        etat_programme = OUVERTURE_P1;
      }
      if (digitalRead(clavier_p1) == HIGH) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("CLAVIER         ");
        lcd.setCursor(0, 1);
        lcd.print("PORTE 1         ");
        delay (1000);
        etat_programme = OUVERTURE_P1;
      }
      if (digitalRead(bouton_p2) == HIGH) {
        digitalWrite(relais_p2, LOW);
        digitalWrite(relais_p1, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("BOUTON          ");
        lcd.setCursor(0, 1);
        lcd.print("PORTE 2         ");
        delay (1000);
        etat_programme = OUVERTURE_P2;
      }
      if (digitalRead(clavier_p2) == HIGH) {
        digitalWrite(relais_p2, LOW);
        digitalWrite(relais_p1, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("CLAVIER         ");
        lcd.setCursor(0, 1);
        lcd.print("PORTE 1         ");
        delay (1000);
        etat_programme = OUVERTURE_P2;
      }
      if ((digitalRead(contact_p1) == LOW) || (digitalRead(contactrelais_p1) == LOW)) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ANOMALIE        ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P1    ");
        delay (500);
        etat_programme = VERIFICATION_P1;
      }
      if ((digitalRead(contact_p2) == LOW) || (digitalRead(contactrelais_p2) == LOW)) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        analogWrite(retroeclairage, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ANOMALIE        ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P2    ");
        delay (500);
        etat_programme = VERIFICATION_P2;
      }
      break;

    case OUVERTURE_P1:
      digitalWrite(relais_p1, HIGH);
      digitalWrite(relais_p2, LOW);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("OUVERTURE      ");
      lcd.setCursor(0, 1);
      lcd.print("PORTE 1         ");
      delay (tempo_ouv_p1);
      etat_programme = PROGRAMME_P1_OUVERTE;
      break;

    case OUVERTURE_P2:
      digitalWrite(relais_p2, HIGH);
      digitalWrite(relais_p1, LOW);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("OUVERTURE      ");
      lcd.setCursor(0, 1);
      lcd.print("PORTE 2         ");
      delay (tempo_ouv_p2);
      etat_programme = PROGRAMME_P2_OUVERTE;

      break;

    case PROGRAMME_P1_OUVERTE:
      if ((digitalRead(contact_p1) == HIGH) && (digitalRead(contactrelais_p1) == HIGH)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(contact_p1) == LOW) || (digitalRead(contactrelais_p1) == LOW)) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ATTENTE         ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P1    ");
        delay (500);
      }
      break;

  case PROGRAMME_P2_OUVERTE:
      if ((digitalRead(contact_p2) == HIGH) && (digitalRead(contactrelais_p2) == HIGH)) {
        etat_programme = PROGRAMME_DEBUT;
      }
      if ((digitalRead(contact_p2) == LOW) || (digitalRead(contactrelais_p2) == LOW)) {
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ATTENTE         ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P2    ");
        delay (500);
      }
      break;

    case VERIFICATION_P1:
    if ((digitalRead(contact_p1) == LOW) || (digitalRead(contactrelais_p1) == LOW)){
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ANOMALIE        ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P1    ");
        delay (500);
    }
    else {
      etat_programme = PROGRAMME_DEBUT;
    }
      break;

  case VERIFICATION_P2:
    if ((digitalRead(contact_p2) == LOW) || (digitalRead(contactrelais_p2) == LOW)){
        digitalWrite(relais_p1, LOW);
        digitalWrite(relais_p2, LOW);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ANOMALIE        ");
        lcd.setCursor(0, 1);
        lcd.print("FERMETURE P2    ");
        delay (500);
    }
    else {
      etat_programme = PROGRAMME_DEBUT;
    }
      break;
  }

}


void reglages() {

  switch (etat_reglages) {
    case REGLAGES_EN_ATTENTE:
      analogWrite(retroeclairage, retro_haut);
      delay (500);

      if (digitalRead(menus) == LOW) {
        delay (500);
        loop();
      }
      else {
        etat_reglages = MENU_T_OUV1;
      }
      break;

    case MENU_T_OUV1:
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(0, 1);
      lcd.print("PORTE 1         ");
      delay (200);

      if (getPressedButton() == BUTTON_RIGHT) {
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV1;
      }
      if (getPressedButton() == BUTTON_DOWN) {
        lcd.clear();
        etat_reglages = MENU_T_OUV2;
      }
      if (getPressedButton() == BUTTON_SELECT) {
        lcd.clear();
        delay (500);
        loop();
      }
      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

    case REGLAGE_T_OUV1:
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(14, 1);
      lcd.print(tempo_ouv_p1 / 1000);

      if (getPressedButton() == BUTTON_UP) {
        delay (200);
        tempo_ouv_p1 = tempo_ouv_p1 + 1000;
        tempo_ouv_p1 = constrain(tempo_ouv_p1, 1000, 60000);
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV1;
      }

      if (getPressedButton() == BUTTON_DOWN) {
        delay (200);
        tempo_ouv_p1 = tempo_ouv_p1 - 1000;
        tempo_ouv_p1 = constrain(tempo_ouv_p1, 1000, 60000);
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV1;
      }

      if (getPressedButton() == BUTTON_LEFT) {
        EEPROM.put(30, tempo_ouv_p1);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_T_OUV1;
      }

      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

    case MENU_T_OUV2:
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(0, 1);
      lcd.print("PORTE 2         ");
      delay (200);

      if (getPressedButton() == BUTTON_UP) {
        lcd.clear();
        etat_reglages = MENU_T_OUV1;
      }

      if (getPressedButton() == BUTTON_RIGHT) {
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV2;
      }
      if (getPressedButton() == BUTTON_DOWN) {
        lcd.clear();
        etat_reglages = MENU_T_RETRO;
      }
      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

    case REGLAGE_T_OUV2:
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(14, 1);
      lcd.print(tempo_ouv_p2 / 1000);

      if (getPressedButton() == BUTTON_UP) {
        delay (200);
        tempo_ouv_p2 = tempo_ouv_p2 + 1000;
        tempo_ouv_p2 = constrain(tempo_ouv_p2, 1000, 60000);
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV2;
      }

      if (getPressedButton() == BUTTON_DOWN) {
        delay (200);
        tempo_ouv_p2 = tempo_ouv_p2 - 1000;
        tempo_ouv_p2 = constrain(tempo_ouv_p2, 1000, 60000);
        lcd.clear();
        etat_reglages = REGLAGE_T_OUV2;
      }

      if (getPressedButton() == BUTTON_LEFT) {
        EEPROM.put(50, tempo_ouv_p2);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_T_OUV2;
      }

      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

case MENU_T_RETRO:
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(0, 1);
      lcd.print("RETRO-ECLAIRAGE ");
      delay (200);

      if (getPressedButton() == BUTTON_UP) {
        lcd.clear();
        etat_reglages = MENU_T_OUV2;
      }

      if (getPressedButton() == BUTTON_RIGHT) {
        lcd.clear();
        etat_reglages = REGLAGE_T_RETRO;
      }
      if (getPressedButton() == BUTTON_DOWN) {
        lcd.clear();
        etat_reglages = MENU_RETRO_H;
      }
      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

      case REGLAGE_T_RETRO:
      lcd.setCursor(0, 0);
      lcd.print("TEMPORISATION   ");
      lcd.setCursor(13, 1);
      lcd.print(tempo_retro / 1000);

      if (getPressedButton() == BUTTON_UP) {
        delay (200);
        tempo_retro = tempo_retro + 1000;
        tempo_retro = constrain(tempo_retro, 1000, 120000);
        lcd.clear();
        etat_reglages = REGLAGE_T_RETRO;
      }

      if (getPressedButton() == BUTTON_DOWN) {
        delay (200);
        tempo_retro = tempo_retro - 1000;
        tempo_retro = constrain(tempo_retro, 1000, 120000);
        lcd.clear();
        etat_reglages = REGLAGE_T_RETRO;
      }

      if (getPressedButton() == BUTTON_LEFT) {
        EEPROM.put(10, tempo_retro);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_T_RETRO;
      }

      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

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

      if (getPressedButton() == BUTTON_UP) {
        lcd.clear();
        etat_reglages = MENU_T_RETRO;
      }

      if (getPressedButton() == BUTTON_RIGHT) {
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_H;
      }
      if (getPressedButton() == BUTTON_DOWN) {
        lcd.clear();
        etat_reglages = MENU_RETRO_B;
      }
      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

      case REGLAGE_RETRO_H:
      lcd.setCursor(0, 0);
      lcd.print("VALEUR ACTIVE   ");
      lcd.setCursor(13, 1);
      lcd.print(retro_haut);

      if (getPressedButton() == BUTTON_UP) {
        delay (200);
        retro_haut = retro_haut + 1;
        retro_haut = constrain(retro_haut, 150, 255);
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_H;
      }

      if (getPressedButton() == BUTTON_DOWN) {
        delay (200);
        retro_haut = retro_haut - 1;
        retro_haut = constrain(retro_haut, 150, 255);
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_H;
      }

      if (getPressedButton() == BUTTON_LEFT) {
        EEPROM.put(110, retro_haut);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_RETRO_H;
      }

      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

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

      if (getPressedButton() == BUTTON_UP) {
        lcd.clear();
        etat_reglages = MENU_RETRO_H;
      }

      if (getPressedButton() == BUTTON_RIGHT) {
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_B;
      }
      if (getPressedButton() == BUTTON_DOWN) {
        lcd.clear();
        etat_reglages = MENU_RETRO_B;
      }
      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;

      case REGLAGE_RETRO_B:
      lcd.setCursor(0, 0);
      lcd.print("VALEUR PASSIVE  ");
      lcd.setCursor(13, 1);
      lcd.print(retro_bas);

      if (getPressedButton() == BUTTON_UP) {
        delay (200);
        retro_bas = retro_bas + 1;
        retro_bas = constrain(retro_bas, 0, 100);
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_B;
      }

      if (getPressedButton() == BUTTON_DOWN) {
        delay (200);
        retro_bas = retro_bas - 1;
        retro_bas = constrain(retro_bas, 0, 100);
        lcd.clear();
        etat_reglages = REGLAGE_RETRO_B;
      }

      if (getPressedButton() == BUTTON_LEFT) {
        EEPROM.put(100, retro_bas);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("    REGLAGES    ");
        lcd.setCursor(0, 1);
        lcd.print("   ENREGISTRES  ");
        delay(1500);
        etat_reglages = MENU_RETRO_B;
      }

      if (digitalRead(menus) == LOW) {
        lcd.clear();
        delay (500);
        loop();
      }
      break;
      
  }
}
2

Tu repositionnes l'état à ce que tu veux, apres l'appel de la fonction ?

3

J'ai déplacé la question dans le forum principal, le tuto n'est pas vraiment l'endroit pour discuter un code particulier.

pourquoi y-a-t'il deux variables d'état ? pouvez vous poster le schéma des transitions d'état ?
Dans l'absolu si vous avez deux variables, celle que vous ne touchez pas conservera son ancienne valeur.

petite note à part concernant les tempos:

/*-----TEMPORISATIONS------*/
int tempo_retro;
int tempo_ouv_p1;
int tempo_ouv_p2;
int verif_blocage_p1;
int verif_blocage_p2;

Un int sur une MEGA sera limité à 32767 et quand je vois

tempo_retro = constrain(tempo_retro, 1000, 120000);

je me dis que vous estimez que ça peut monter à 120000.

➜ ce serait donc mieux de les déclarer en unsigned long qu'en int (ou éventuellement en long car vous faites des soustractions).

4

Dans loop() tu appelles reglages() et dans reglages() tu fais des appels à loop(). Ce n'est pas une très bonne idée. Cela va empiler des adresses de retour qui ne seront jamais dépiler et tu vas finir par saturer la RAM.
Telle que ta fonction est codée il suffirait de ne rien faire et de laisser la fonction se terminer naturellement puisqu'elle va revenir dans loop() d'où elle avait été appelée.

A noter, l'enum etats mélange un peu les choses, il y a des états mais aussi des constantes utilisées pour définir les boutons appuyés.
Tu as manifestement 2 machines à états avec des états différents il aurait été plus rigoureux de créer 2 enum différents pour les états des 2 machines. Cela évite, par exemple, d'affecter accidentellement l'état d'une machine à l'autre.
Exemple

enum etatsMachine1 {STOP_M1, ETAT1_M1,ETAT2_M1, ETAT3_M1};
enum etatsMachine2 {STOP_M2, ETAT1_M2,ETAT2_M2, ETAT3_M2};

etatsMachine1 etatM1 = STOP_M1;
etatsMachine2 etatM2 = STOP_M2;

void setup() {
  etatM1 = ETAT1_M2;

}

void loop() {
  // put your main code here, to run repeatedly:

}

Le code ci-dessus va générer une erreur à la compilation

/tmp/.arduinoIDE-unsaved2024323-4059-h1usqr.2oakr/sketch_apr23a/sketch_apr23a.ino: In function 'void setup()':
/tmp/.arduinoIDE-unsaved2024323-4059-h1usqr.2oakr/sketch_apr23a/sketch_apr23a.ino:8:12: error: cannot convert 'etatsMachine2' to 'etatsMachine1' in assignment
   etatM1 = ETAT1_M2;
            ^~~~~~~~

exit status 1

Compilation error: cannot convert 'etatsMachine2' to 'etatsMachine1' in assignment
5

Bonjour et merci pour vos réponses.

Pour résumer dans programme_normal c'est le programme en fonction alors que reglages ne sert qu'aux reglages suite au positionnement du cavalier sur la carte.

Mon soucis était que en retirant le cavalier et donc en sortant de reglages au lieu d'aller à l'état Programme_début comme mentionné j'allais sur le dernier état utilisé dans programme_normal.

J'ai solutionné provisoirement car j'ignore si c'est propre en appelant directement l'etat Programme_début du programme normal lorsque le cavalier est retirer et que donc je me trouve en reglages. J'ai fais la même chose depuis programme_normal en insérant le cavalier j'appelle directement l'état reglages_en_attente.

Concernant int je peux le remplacer simplement par long. Cela ne demande pas d'autres changements?

A vrai dire je ne me suis pas penche sur int.long...etc

Fdufnews, je comprends votre séparation et qui paraît plus propre et logique cependant ma "bidouille" de passer vers un état dans un void serait toujours fonctionnelle?

Merci à vous

6

Si le cavalier peut être retiré et remis à tout moment ce devrait être pris en compte our chaque état et il ne devrait y avoir qu’une seule machine à etat.
Pour revenir là où on en était précédemment il faut bien sûr mémoriser le contexte lors de la transition (une variable etatPrecedent par exemple - un peu comme on utilise une variable pour mémoriser millis() lors d’une transition).

7

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.