step motor_V4

#include <avr/interrupt.h>
#include <Arduino.h>
//#include <Wire.h>
#include <rgb_lcd.h>
#include <EEPROM.h>
#include <string.h>
#include <avr/sleep.h>

//#define SDA A4
//#define SLC A5
#define NOTE_CS6 1109
#define NOTE_DS6 1245

// Variables globales
const uint8_t VAL_RGB_R = 255;                            // Valeur R pour LED RGB
const uint8_t VAL_RGB_G = 0;                              // Valeur G pour LED RGB
const uint8_t VAL_RGB_B = 0;                              // Valeur B pour LED RGB
const uint8_t PIN_SWITCH = 2;                             // Pin pour l'interrupteur à bascule
const uint8_t PIN_COURANT_COUPURE = 3;                    // Pin pour détecter une coupure de courant
const uint8_t PIN_LED_ROUGE = 5;                          // Pin pour LED PIN_LED_ROUGE
const uint8_t PIN_LED_VERT = 7;                           // Pin pour LED PIN_LED_VERTE
const uint8_t PIN_LED_ORANGE = 6;                         // Pin pour LED PIN_LED_ORANGE
const uint8_t PIN_MOTEUR_DIR = 8;                         // Pin pour la direction du moteur
const uint8_t PIN_MOTEUR_PUL = 9;                         // Pin pour les impulsions du moteur
const uint8_t PIN_MOTEUR_ENA = 10;                        // Pin pour activer/désactiver le moteur
const uint8_t PIN_BUZZER = 11;                            // Pin pour le Buzzer
const uint8_t PIN_POTARD = A0;                            // Pin pour le potentiometre
const int8_t MAX_TASKS = 10;
const uint32_t INTERVAL_BASE = 3130;                      // interval de temps de base de 3130 µS pour une action
const uint32_t INTERVAL_X3 = 9390;                        // 3x l'interval de base, soit 9390 µS pour une action
const uint32_t INTERVAL_X7 = 21910;                       // 7x l'interval de base, soit 21910 µS pour une action
const uint32_t INTERVAL_X78 = 244140;                     // 78x l'interval de base, soit 244140 µS pour une action
const uint32_t INTERVAL_X156 = 488280;                    // 156x l'interval de base, soit 488280 µS pour une action
const uint32_t LIMITEPASMAX = 120000;                     // Nombre maximal de pas du moteur
uint8_t taskId_updateSwitchState;                         // updateSwitchState
uint8_t taskId_checketatSwitch;                           // checketatSwitch
uint8_t taskId_updatePotardAndPWM;                        // updatePotardAndPWM
uint8_t taskId_LCD_Demarage;                              //
uint8_t taskId_LCD_Update_MAIN;                           //
uint8_t taskId_toggle_PIN_MOTOR;                          // toggle_PIN_MOTOR
uint8_t taskId_modulate_PIN_LED_verte;                    // modulate_PIN_LED vert
uint8_t taskId_modulate_PIN_LED_orange;                   // modulate_PIN_LED orange
uint8_t taskId_toggleBuzzer;                              // toggleBuzzer
uint16_t potard;                                          // Valeur du potentiometre
volatile bool blackout = false;                           // Flag pour indiquer une coupure de courant
volatile uint32_t nombreDePas = 0;                        // Compteur de pas du moteur
volatile bool estCoupureCourant;                          // Verifie si il est oportun d'effectuer une sauvegarde lors d'une coupure de courant
bool etatSwitch = false;                                  // État virtuel de l'interupteur, défini sur enclancher (false)
int8_t taskCount = 0;                                     // Compteur pour suivre le nombre de tâches


byte L[8] = { 0b00000, 0b11000, 0b01100, 0b00100, 0b01100, 0b10010, 0b10001, 0b00000 }; // Motif personnalisé pour écran LCD

// Énumération pour les différents états
enum Etat {
  ETAT_DEMARAGE,

  ETAT_ORIGINE_INITIALIZATION,
  ETAT_ORIGINE_MAIN,

  ETAT_AVANCE_INITIALIZATION,
  ETAT_AVANCE_MAIN,

  ETAT_TRANSITION_AVANCE_TOGGLE,

  ETAT_TOGGLE_MAIN,
  ETAT_TOGGLE_CHECKEXITCONDITION,

  ETAT_TOGGLE_RECUPERATION,

  ETAT_FAIL
};

Etat etatActuel;                                          // Variable stockant l'état actuel du système

struct Task {
    void (*func)();
    uint32_t nextExecution;
    uint32_t interval;
    bool enabled;
};

Task tasks[MAX_TASKS];                                    // Tableau pour stocker les tâches

typedef void (*CallbackFunction)();                       // Définir un type de fonction de rappel

rgb_lcd display;

// Interruption de minuterie pour gérer le signal PWM et compter les pas
ISR(TIMER1_COMPA_vect){
  toggle(PIN_MOTEUR_PUL);                                 // Bascule l'état du pin moteur
  nombreDePas++;                                          // Incrémente le compteur de pas
}

ISR(TIMER0_COMPA_vect) {
  sleep_disable();                                        // Réveiller le MCU
  TIMSK0 &= ~(1 << OCIE0A);                               // désactive  l'interruption de comparaison du Timer0
}

// Sauvegarde les données essentielles dans EEPROM en cas de coupure de courant
void interruptionCoupure() {
  blackout = true;                                        // Indique une coupure de courant
  sleep_disable(); // Réveiller le MCU
  TIMSK0 &= ~(1 << OCIE0A);                               // désactive  l'interruption de comparaison du Timer0
}

// Récupération des données après une coupure de courant
void recuperation() {
    uint32_t step;
    EEPROM.get(0, step);                                  // Récupère le nombre de pas de EEPROM
    nombreDePas = step;
    EEPROM.update(4, false);                              // Indique que la récupération est faite
    enableTask(taskId_LCD_Update_MAIN);
}// Fin de recuperation

//Fonction d'affichage LCD
void LCD_Update_FAIL() {
  display.clear();
  display.setCursor(0, 0);
  display.print("Erreur");
  display.setCursor(0, 1);
  display.print("Veuillez redemarrer");
}

void LCD_Update_DEMARAGE() {
  display.clear();
  display.setCursor(0, 0);
  display.print("Mauvaise position");
  display.setCursor(0, 1);
  display.print("Enclancher l'interrupteur");
}

void LCD_Update_MAIN() {
  static uint32_t lastSteps = -1;
  static uint16_t lastPotValue = -1;

  if (lastSteps != nombreDePas) {
    display.setCursor(1, 1);
    display.print(nombreDePas);
    lastSteps = nombreDePas;
  }

  if (lastPotValue != potard) {
    display.setCursor(10, 1);
    display.print(potard);
    lastPotValue = potard;
  }
}

int scheduleTask(void (*func)(), uint32_t interval, bool enabled) {
    if (taskCount < MAX_TASKS) {
      tasks[taskCount].func = func;
      tasks[taskCount].interval = interval;
      tasks[taskCount].nextExecution = micros() + interval;
      tasks[taskCount].enabled = enabled;
      //tasks[taskCount] = {func, micros() + interval, interval, enabled};
      return taskCount++;                                 // Retourne l'index de la nouvelle tâche
    }
    return -1; // Retourne une valeur d'erreur si le tableau est plein
}

void setup() {
  Serial.begin(115200);                                   // Démarre la communication série à 115200 bps
  display.begin(16, 2);                                   // Initialise l'écran LCD avec 16 colonnes et 2 lignes
  display.setRGB(VAL_RGB_R, VAL_RGB_G, VAL_RGB_B);        // Définit la couleur de rétroéclairage de l'écran LCD
  display.print("initialization");                        // Affiche le message d'initialisation sur l'écran LCD

  // Configuration des pins pour les LEDs et les sorties
  pinMode(PIN_LED_ORANGE, OUTPUT);                        // Config. la LED orange en sortie
  pinMode(PIN_LED_VERT, OUTPUT);                          // Config. la LED verte en sortie
  pinMode(PIN_LED_ROUGE, OUTPUT);                         // Config. la LED rouge en sortie

  // Configuration des pins pour les entrées
  pinMode(PIN_POTARD, INPUT);                             // Définit le pin A0 comme entrée pour le potentiomètre
  pinMode(PIN_SWITCH, INPUT_PULLUP);                      // Active la résistance de pull-up sur le pin du bouton
  pinMode(PIN_MOTEUR_DIR, OUTPUT);                        // Config. la direction du moteur en sortie
  pinMode(PIN_MOTEUR_PUL, OUTPUT);                        // Config. le pin de pulsation du moteur en sortie
  pinMode(PIN_MOTEUR_ENA, OUTPUT);                        // Config. le pin d'activation du moteur en sortie
  pinMode(PIN_BUZZER, OUTPUT);                            // Config. le pin du buzzer en sortie
  pinMode(PIN_COURANT_COUPURE, INPUT_PULLUP);             // Active la résistance de pull-up pour la coupure de courant

  // Configuration initiale de l'état des sorties
  digitalWrite(PIN_BUZZER, LOW);                          // Éteint le buzzer
  digitalWrite(PIN_SWITCH, HIGH);                         // Initialise le PIN_SWITCH à l'état haut
  digitalWrite(PIN_LED_VERT, HIGH);                       // Allume la LED verte
  digitalWrite(PIN_LED_ORANGE, HIGH);                     // Allume la LED orange
  digitalWrite(PIN_LED_ROUGE, HIGH);                      // Allume la LED rouge

  // Signal sonore d'initialisation
  tone(PIN_BUZZER, NOTE_DS6, 500);                        // Joue un ton sur le buzzer
  delay(500);                                             // Attend 500 ms

  // Éteint toutes les LEDs après le signal sonore
  digitalWrite(PIN_LED_VERT, LOW);                        // Éteint la LED verte
  digitalWrite(PIN_LED_ROUGE, LOW);                       // Éteint la LED rouge
  digitalWrite(PIN_LED_ORANGE, LOW);                      // Éteint la LED orange

  timerPrecedents[TIMER_LED_Vert] = micros();             // Initialise le timer pour la LED verte
  timerPrecedents[TIMER_LED_Orange] = micros();           // Initialise le timer pour la LED Orange

  // Vérifie et récupère l'état de coupure de courant depuis l'EEPROM
  bool spin;
  EEPROM.get(4, spin);                       // Récupère l'état de coupure de courant de l'EEPROM
  estCoupureCourant = spin;

  // Configuration initiale de l'état du système
  etatActuel = (!estCoupureCourant) ? ETAT_DEMARAGE : ETAT_TOGGLE_RECUPERATION;

  // Configuration des interruptions
  attachInterrupt(digitalPinToInterrupt(PIN_COURANT_COUPURE), interruptionCoupure, FALLING); // Interruption sur coupure de courant

  // Configuration des Timer pour le mode CTC (Clear Timer on Compare Match)
  TCCR1A = 0;                                             // Réinitialise TCCR1A pour la configuration
  TCCR1B = (1 << WGM12) | (1 << CS11);                    // Configure le mode CTC et le prescaler pour Timer1

  TCCR0A = (1 << WGM21);                                  // Configure le Timer 0 pour le mode CTC
  TCCR0B = (1 << CS22) | (1 << CS21) | (1 << CS20);       // Prescaler de 1024

  //setupHardware();

  taskId_updateSwitchState = scheduleTask(updateSwitchState, INTERVAL_X7, true);
  taskId_checketatSwitch = scheduleTask(checketatSwitch, INTERVAL_X156, false);
  taskId_updatePotardAndPWM = scheduleTask(updatePotardAndPWM, INTERVAL_X78, false);
  taskId_LCD_Demarage = scheduleTask( [] () {LCD_Update_DEMARAGE(); }, INTERVAL_X78, false);
  taskId_LCD_Update_MAIN = scheduleTask( [] () {LCD_Update_MAIN(); }, INTERVAL_X78, false);
  taskId_toggle_PIN_MOTOR = scheduleTask(toggle_PIN_MOTOR, INTERVAL_BASE, false);
  taskId_modulate_PIN_LED_verte = scheduleTask( [] () {modulate_PIN_LED(PIN_LED_VERT); }, INTERVAL_X3, false);
  taskId_modulate_PIN_LED_orange = scheduleTask([]() { modulate_PIN_LED(PIN_LED_ORANGE); }, INTERVAL_X3, false);
  taskId_toggleBuzzer = scheduleTask(toggleBuzzer, INTERVAL_X78, false);

  updatePotardAndPWM();                               // Initialise le potard

  set_sleep_mode(SLEEP_MODE_PWR_SAVE);                // Définir le mode de sommeil

  updateSwitchState();                                // Initialization de l'état de l'interupteur

  if (!estCoupureCourant){
    enableTask(taskId_LCD_Demarage);
    enableTask(taskId_modulate_PIN_LED_orange);
    enableTask(taskId_toggleBuzzer);
  }else{
    enableTask(taskId_LCD_Update_MAIN);
  }

  delay(800);                                             // Court délai avant d'activer les interruptions
  sei();                                                  // Active les interruptions globales
}

void loop() {

  //enableTask(updateSwitchState);

  switch (etatActuel) {
    case ETAT_DEMARAGE:
      if(!etatSwitch) {
        etatActuel = ETAT_ORIGINE_INITIALIZATION;
      }else{

        //LCD_Update_DEMARGE(display);

        //modulate_PIN_LED(PIN_LED_ORANGE);

        //toggleBuzzer

      }
      break;
    case ETAT_ORIGINE_INITIALIZATION:
      // Initialisations pour l'état d'origine
      origine_initialization();
      etatActuel = ETAT_ORIGINE_MAIN;                        // Définit l'état à ORIGINE
      break;
    case ETAT_ORIGINE_MAIN:

      //modulate_PIN_LED(PIN_LED_VERT);

      //LCD_Update_ORIGINE(display);

      //updatePotardAndPWM

      if(etatSwitch) {
        etatActuel = ETAT_AVANCE_INITIALIZATION;
      }
      break;
    case ETAT_AVANCE_INITIALIZATION:
      // Initialisations pour l'état d'avance
      avance_initialization();
      etatActuel = ETAT_AVANCE_MAIN;                         // Définit l'état à AVANCE
      break;
    case ETAT_AVANCE_MAIN:
      //Verifie si le programme doit s'arreter en urgence
      checketatFail();

      //LCD_Update_AVANCE(display);

      //toggle_PIN_MOTOR

      if(nombreDePas >= LIMITEPASMAX || !etatSwitch) {
        etatActuel = ETAT_TRANSITION_AVANCE_TOGGLE;
      }
      break;
    case ETAT_TRANSITION_AVANCE_TOGGLE:
      // Vérifie la condition de sortie de l'état d'avance
      transition_avance_toggle();

      etatActuel = ETAT_TOGGLE_MAIN;                         // Définit l'état à TOGGLE
      break;
    case ETAT_TOGGLE_MAIN:
      //Verifie si le programme doit s'arreter en urgence
      checketatFail();

      //LCD_Update_TOGGLE(display);

      //toggle_PIN_MOTOR

      //checketatSwitch

      if(nombreDePas == 0){
        etatActuel = ETAT_TOGGLE_CHECKEXITCONDITION;
      }
      break;
    case ETAT_TOGGLE_CHECKEXITCONDITION:
      // Vérifie la condition de sortie de l'état de toggle
      toggle_checkexitcondition();

      etatActuel = (etatSwitch) ? ETAT_AVANCE_INITIALIZATION : ETAT_ORIGINE_INITIALIZATION;
      break;
    case ETAT_TOGGLE_RECUPERATION:
      recuperation();                                   // Appelle la fonction de récupération en cas de coupure

      etatActuel = ETAT_TRANSITION_AVANCE_TOGGLE;
      break;
    case ETAT_FAIL:
      // Exécute la séquence d'arrêt d'urgence
      checketatFail();

      break;
    default: // ETAT_FAIL:
      // Exécute la séquence d'arrêt d'urgence
      etatActuel = ETAT_FAIL;
      break;
  }

  manageTasks();

}//Fin de la boucle loop

void origine_initialization(){
  disableTask(taskId_LCD_Demarage);
  display.clear();
  display.setCursor(0, 0);
  display.print("Origine");
  display.setCursor(0, 1);
  display.print("Pas: ");
  disableTask(taskId_modulate_PIN_LED_orange);
  disableTask(taskId_toggleBuzzer);
  digitalWrite(PIN_LED_ORANGE, LOW);                  // Éteint la LED orange
  digitalWrite(PIN_LED_VERT, LOW);                    // Éteint la LED verte
  digitalWrite(PIN_LED_ROUGE, HIGH);                  // Allume la LED rouge
  digitalWrite(PIN_MOTEUR_ENA, HIGH);                 // Désactive le frein du moteur
  tone(PIN_BUZZER, NOTE_CS6, 80);                     // Joue la note CS6
  delay(100);                                         // Pause de 100ms
  tone(PIN_BUZZER, NOTE_DS6, 80);                     // Joue la note DS6
  delay(100);                                         // Pause de 100ms
  tone(PIN_BUZZER, NOTE_DS6, 160);                    // Joue la note DS6 plus longue
  delay(250);                                         // Pause de 250ms
  digitalWrite(PIN_LED_ROUGE, LOW);                   // Éteint la LED rouge
  enableTask(taskId_modulate_PIN_LED_verte);
  enableTask(taskId_updatePotardAndPWM);
}

void avance_initialization(){
  display.clear();
  display.setCursor(0, 0);
  display.print("Avance");
  display.setCursor(0, 1);
  display.print("Lambda: ");
  disableTask(taskId_modulate_PIN_LED_verte);
  disableTask(taskId_updatePotardAndPWM);
  estCoupureCourant = true;                               // Réinitialise l'indicateur de coupure de courant
  digitalWrite(PIN_MOTEUR_DIR, LOW);                      // Définit le sens de rotation du moteur
  digitalWrite(PIN_MOTEUR_ENA, LOW);                      // Active le moteur
  noInterrupts();                                         // Désactiver les interruptions pendant la configuration
  TIMSK1 |= (1 << OCIE1A);                                // Active l'interruption de comparaison du Timer1, Active le signal PWM
  interrupts();                                           // Réactiver les interruptions
  digitalWrite(PIN_LED_VERT, HIGH);                       // Allume la LED verte
  digitalWrite(PIN_LED_ORANGE, LOW);                      // Éteint la LED orange
  digitalWrite(PIN_LED_ROUGE, LOW);                       // Éteint la LED rouge
}

void transition_avance_toggle(){
  display.clear();
  display.setCursor(0, 0);
  display.print("Toggle");
  display.setCursor(0, 1);
  display.print("Lambda: ");
  digitalWrite(PIN_LED_VERT, LOW);                        // Éteint la LED verte
  noInterrupts();                                         // Désactiver les interruptions pendant la configuration
  OCR1A = INTERVAL_BASE;
  interrupts();                                           // Réactiver les interruptions
  digitalWrite(PIN_MOTEUR_DIR, HIGH);                     // Change le sens de rotation du moteur
  digitalWrite(PIN_MOTEUR_ENA, LOW);                      // Active le moteur
  //enableTask(taskId_toggle_PIN_MOTOR);
  enableTask(taskId_checketatSwitch);
}

void toggle_checkexitcondition(){
  disableTask(taskId_checketatSwitch);
  noInterrupts();                                         // Désactiver les interruptions pendant la configuration
  TIMSK1 &= ~(1 << OCIE1A);                               // Désactive l'interruption de comparaison du Timer1, Désactive le signal PWM
  interrupts();                                           // Réactiver les interruptions
  estCoupureCourant = false;                              // Réinitialise l'indicateur de coupure de courant
  digitalWrite(PIN_LED_ORANGE, LOW);                      // Éteint la LED orange
  digitalWrite(PIN_LED_VERT, LOW);                        // Éteint la LED verte
}

//sauvgarde les données importante si coupure detecter, arrete le programme
void checketatFail() {
  if(blackout || etatActuel == ETAT_FAIL){
    noInterrupts();                                       // Désactive les interruptions
    bool spin =  estCoupureCourant;
    uint32_t step = nombreDePas;
    EEPROM.update(0, step);                               // Sauvegarde le nombre de pas
    EEPROM.update(4, spin);                               // Réinitialise le flag de coupure de courant
    digitalWrite(PIN_MOTEUR_PUL, LOW);                    // Désactive les impulsions
    digitalWrite(PIN_MOTEUR_ENA, HIGH);                   // Désactive le frein du moteur
    digitalWrite(PIN_LED_ROUGE, HIGH);                    // Allume la LED d'urgence
    LCD_Update_FAIL();
    tone(PIN_BUZZER, NOTE_CS6, 1000);                     // Joue la note CS6

    while(true) {
      delay(4294967295);                                  // Bloque le système indéfiniment
    }                                                     // Boucle d'arrêt d'urgence
  }
}

void manageTasks() {
  uint32_t currentTime = micros();
  uint32_t nextTaskTime = INTERVAL_X156; //Temps de la tache la plus longue, par securité ce sera la durée maximal

  // Parcourir les tâches pour trouver la plus proche et exécuter si nécessaire
  for (int i = 0; i < taskCount; i++) {
    if (tasks[i].enabled) {
      if (currentTime >= tasks[i].nextExecution) {
        tasks[i].func();  // Exécuter la fonction
        tasks[i].nextExecution = currentTime + tasks[i].interval;  // Planifier la prochaine exécution
      }
      if (tasks[i].nextExecution < nextTaskTime) {
        nextTaskTime = tasks[i].nextExecution;
      }
    }
  }

  // Calculer le temps d'attente
  uint32_t timeToWait = nextTaskTime - currentTime;
  if (timeToWait > 800) {
    // Calculer le nombre de ticks nécessaires pour le Timer 2
    uint16_t timerTicks = min(255, timeToWait / 4);  // 4 est le nombre d'µs par tick avec un prescaler de 1024 à 16 MHz

    noInterrupts(); // Désactiver les interruptions pendant la configuration
    OCR0A = timerTicks;  // Définir la valeur pour comparaison A
    TIMSK0 |= (1 << OCIE0A);  // Activer l'interruption Timer 0 Compare Match A
    interrupts(); // Réactiver les interruptions

    sleep_mode();  // Dormir jusqu'à la prochaine interruption du timer
  } else if (timeToWait > 300) {
    delayMicroseconds(timeToWait); // Un tres court délai
  }else{

  }
}

void enableTask(int8_t taskIndex) {
    if (taskIndex >= 0 && taskIndex < taskCount) {
        tasks[taskIndex].enabled = true;
        tasks[taskIndex].nextExecution = micros() + tasks[taskIndex].interval;  // Réinitialise le timing
    }
}

void disableTask(int8_t taskIndex) {
    if (taskIndex >= 0 && taskIndex < taskCount) {
        tasks[taskIndex].enabled = false;
    }
}

/*/ Exécute une fonction à intervalle régulier basé sur un timer
void checkTimerAndUpdate(uint16_t &previousTime, uint32_t intervalAction, CallbackFunction func) {
  if (micros() - previousTime >= intervalAction ) {
    previousTime = micros();                              // Réinitialise le temps précédent
    func();                                               // Appelle la fonction passée en paramètre
  }
}// Fin de checkTimerAndUpdate*/

//Fonction de mise à jour de potard et de la fréquence du PWM du moteur
void updatePotardAndPWM() {
  uint16_t newPotard = map(analogRead(PIN_POTARD), 0, 1023, 11200, 11300); // Map la lecture analogique à la plage désirée
  if (newPotard != potard) {                              // Vérifie si la valeur a changé
    potard = newPotard;                                   // Met à jour la variable globale potard
    noInterrupts();                                       // Désactive les interruptions
    OCR1A = potard;                                       // Met à jour la fréquence de la pin pul, la vitesse du moteur
    interrupts();                                         // Réactiver les interruptions
  }
}// Fin de updatePotardAndPWM

// Met à jour l'état de l'interrupteur
void updateSwitchState() {
    if (digitalRead(PIN_SWITCH) != etatSwitch) {          // Verifie si l'interupteur à bascule à changer
      etatSwitch = !etatSwitch;                           // Bascule l'état en utilisant la valeur pointée
    }
}// Fin de updateSwitchState

// Fait varier la luminosité de la LED Rouge
void modulate_PIN_LED(uint8_t ledPin) {
  static uint8_t i = 1;                                   // Initialise l'intensité de la LED
  static bool estIncrement = true;                        // Initialise la direction de l'incrémentation
  analogWrite(ledPin, i);                                 // Applique la luminosité à la LED
  i = estIncrement ? i + 1 : i - 1;                       // Incrémente ou décrémente la luminosité
  if(i == 255 || i == 0) {                                // Verifie si i est arrivé au extremiter
    estIncrement = !estIncrement;                         // Inverse la direction si les limites sont atteintes
  }
}// Fin de modulate_PIN_LED

// Fonction pour basculer l'état d'une broche
void toggle(int8_t pin) {
    digitalWrite(pin, !digitalRead(pin));                 // Bascule l'état de la broche
} // Fin de toggle

void toggleLEDVert() {
    toggle(PIN_LED_VERT);
}

void toggleLEDOrange() {
    toggle(PIN_LED_ORANGE);
}

// Exécute une action LED en fonction de l'état de l'interrupteur
void checketatSwitch() {
    CallbackFunction func = etatSwitch ? toggleLEDVert : toggleLEDOrange;
    if (digitalRead(etatSwitch ? PIN_LED_VERT : PIN_LED_ORANGE) == HIGH) {
        digitalWrite(etatSwitch ? PIN_LED_VERT : PIN_LED_ORANGE, LOW);
    }
    func();
}// Fin de checkTimerBasedOnState

// Actionne le moteur et décompte les pas
void toggle_PIN_MOTOR() {
  toggle(PIN_MOTEUR_PUL);                                 // Bascule le pin du moteur
  noInterrupts();                                         // Désactive les interruptions
  nombreDePas--;                                          // Décrémente le compteur de pas
  interrupts();                                           // Réactive les interruptions
}// Fin de toggle_PIN_MOTOR

//tone utilise le Timer2
void toggleBuzzer() {
  static bool isActive = true;
  if (isActive) {
    noTone(PIN_BUZZER);                                   // Arrête le son pendant 84 millisecondes
    isActive = false;                                     //
  } else {
    tone(PIN_BUZZER, NOTE_DS6, 160);                      // Joue la note DS6 pendant 160 millisecondes
    isActive = true;
  }
}