step motor_V2

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

#define toggle(x) digitalWrite(x, !digitalRead(x))                            //est une macro qui inverse la valeur logique de la broche
#define potard (map(analogRead(A0), 0, 1023, 11200, 11300))                   //lit la valeur analogique de la broche A0, la mappe entre 11200 et 11300,
//                                                                            //cela permet de définir une plage de valeur pour la vitesse d'avance du moteur.
#define switch 2                                                              //est la broche utilisée pour lire l'état du bouton,

#define pul 9                                                                 // sont les broches utilisées pour controler le moteur pas à pas.
#define dir 8                                                                 //
#define ENA 10                                                                //
#define buz 11                                                                // buzzer
#define NOTE_DS6 1245                                                         //sont des constantes pour les fréquences de notes de musique.
#define NOTE_CS6 1109                                                         //

rgb_lcd lcd;                                                                  //est une librairie personnalisée qui permet de contrôler
//                                                                            //un écran LCD avec des couleurs.
const int colorR = 255;                                                       //sont les couleurs utilisées pour l'affichage de l'écran LCD
const int8_t colorG = 0;                                                         //
const int8_t colorB = 0;                                                         //
//                                                                            // sont les broches utilisées pour les LED de couleur orange, verte et rouge.
const int8_t(orange) = 7;                                                        // broche 7 orange
const int8_t(vert) = 6;                                                          // broche 6 vert
const int8_t(rouge) = 5;                                                         // broche 5 rouge

const int8_t NUM_TIMERS = 7;
const int8_t TIMER_LED_ORANGE = 0;
const int8_t TIMER_LED_VERT = 1;
const int8_t TIMER_LED_ROUGE = 3;
const int8_t TIMER_MOTOR = 2;
const int8_t TIMER_LCD_Origine = 4;
const int8_t TIMER_LCD_avance = 5;
const int8_t TIMER_LCD_toggle = 6;

int i = 0;
int8_t i_sens = 1;

const unsigned long interval = 500;                                          // est l'interval de temps entre deux clignotements des LED en milli-secondes.

unsigned long previousTimers[7];                                             // est un tableau utilisé pour stocker les temps précédents pour chaque tache

unsigned long Nombres_de_pas = 0;                                            // est un compteur qui stocke le nombre de pas effectués par le moteur
unsigned long Nombres_de_pas_max = 120000;                                   // est la limite maximale de pas pour le moteur

bool stat_switch = false;                                                    // est un booléen qui stocke l'état du bouton switch
bool sens = false;                                                           // est un booléen qui stocke le sens de rotation du moteur
bool Signal_PWM = false;                                                      // est un booléen qui active ou désactive le moteur
bool initialisation = false;                                                 // est un booléen qui active ou désactive l'initialisation
bool dir_init = false;                                                       //est un booléen qui stocke l'état de la direction d'initialisation

  byte L[8] = {                                                              //createChar(1, tab);
    0b00000,
    0b11000,
    0b01100,
    0b00100,
    0b01100,
    0b10010,
    0b10001,
    0b00000
    };                                                                       // est un tableau de bytes qui contient la forme pour un caractère personnalisé
//                                                                           // qui sera affiché sur l'écran LCD
ISR(TIMER1_COMPA_vect){                                                      // fonction de service d'interruption qui est appelée lorsque
//                                                                           //le timer 1 atteint une certaine valeur spécifiée.
    if(Signal_PWM == true){
        toggle (pul);                                                        //inverse la valeur logique de la broche
        Nombres_de_pas++;                                                    //incrémente le compteur de pas Nombres_de_pas .
    }
}

void LCD_Origine(){
        // fonction qui gère l'affichage de l'écran LCD lorsque le bouton est relacher
          stat_switch = digitalRead(switch);                                  // lit l'état du bouton et l'écrit dans stat_switch
        //                                                                    //
        OCR1A = potard;                                                       // met à jour la vitesse d'avance avec la valeur de potard
        //                                                                    //
        lcd.clear();                                                          // efface l'écran LCD
        lcd.home();                                                           //
        lcd.print("Origine");                                                 // affichage LCD ligne 1 "programme Origine"
        lcd.setCursor(1, 1);                                                  //
        lcd.print(Nombres_de_pas);                                            // affiche la valeur de Nombres_de_pas
        lcd.setCursor(6, 1);                                                  //
        lcd.print(potard);                                                    // affichage la valauer de potard
        lcd.createChar(1,L);                                                  // affiche un caractère personnalisé sur la seconde ligne.
        lcd.setCursor(11, 1);                                                 //
        lcd.write(byte(1));
}

void LCD_avance(){
          // fonction qui gère l'affichage de l'écran LCD lorsque le moteur tourne
        Signal_PWM = true;                                                    // met à jour la Signal_PWM pour activer le moteur

        lcd.clear();                                                         // efface l'écran LCD
        lcd.home();                                                          //
        lcd.print("Programme");                                              // affiche "Programme" et "Lambda" sur la première ligne
        lcd.setCursor(10, 0);                                                //
        lcd.print("Lambda");                                                 //
        lcd.setCursor(1, 1);                                                 //
        lcd.print(Nombres_de_pas);                                           // affiche la valeur de Nombres_de_pas sur la seconde ligne
        lcd.setCursor(10, 1);                                                //
        lcd.print(potard);                                                   // affiche des informations sur la position et la vitesse sur la seconde ligne.
        lcd.createChar(1,L);                                                 //
        lcd.setCursor(15, 1);                                                //
        lcd.write(byte(1));                                                  //
        }

void LCD_toggle(){ // fonction qui gère l'affichage alternatif de l'écran LCD entre l'affichage de la position actuelle et l'affichage de la position cible

        lcd.clear();                                                         // efface l'écran LCD
        lcd.home();                                                          //
        lcd.print("toggle");                                                 // affichage LCD ligne 1 "toggle"
        lcd.setCursor(10, 0);                                                //
        lcd.print("Lambda");                                                 //
        lcd.setCursor(1, 1);                                                 //
        lcd.print(Nombres_de_pas);                                           // affiche la position actuelle et la position cible sur la première ligne
        lcd.setCursor(10, 1);                                                //
        lcd.print(potard);                                                   // affiche des informations sur la position et la vitesse sur la seconde ligne.
        lcd.createChar(1,L);                                                 //
        lcd.setCursor(15, 1);                                                //
        lcd.write(byte(1));                                                  //
        stat_switch = digitalRead(switch);                                   // lit l'état du bouton et l'écrit dans stat_switch
        digitalWrite(rouge, LOW);
}

void setup(){
    Serial.begin(115200);                                                       // ça pulse à 115 200 Hertz
    lcd.begin(16, 2);                                                           // set up the LCD's number of columns and rows:
    lcd.setRGB(colorR, colorG, colorB);                                         //
    lcd.print("initialization");                                                // Print a message to the LCD.

    pinMode(orange, OUTPUT);                                                    // LED orange
    pinMode(vert, OUTPUT);                                                      // LED vert
    pinMode(rouge, OUTPUT);                                                     // LED rouge

    pinMode(A0, INPUT);                                                         // potentiomètre A0
    pinMode(switch, INPUT_PULLUP);                                              // configurer la pin 8 comme sortie pour contrôler la direction du moteur
    pinMode(dir, OUTPUT);                                                       // direction du moteur
    pinMode(pul, OUTPUT);                                                       // vitesse du moteur la frecence est de ~177.77hz
    pinMode(ENA, OUTPUT);                                                       // frein du moteur >> relaché à l'état haut<< mode automatique à l'état bas>>
    pinMode(buz, OUTPUT);                                                       // Buzzer en sortie 10 s'appel buz

    digitalWrite(buz, LOW);                                                     // broche 10 buzzer
    digitalWrite(switch, HIGH);                                                 // bouton sur OFF

    digitalWrite(vert, HIGH);                                                   // eteint LED vert
    digitalWrite(orange, HIGH);                                                 // allumer LED temoin orange fixe
    digitalWrite(rouge, HIGH);                                                  // eteint LED rouge

    tone(buz, NOTE_DS6, 500);

    delay(500);                                                                 // 1 seconde


    digitalWrite(vert, LOW);                                                    // eteint LED vert
    digitalWrite(rouge, LOW);                                                   // eteint LED rouge
    digitalWrite(orange, LOW);                                                  // allumer LED temoin orange fixe


    previousTimers[TIMER_LCD_toggle] = micros();                                // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_LCD_avance] = micros();                                // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_LCD_Origine] = micros();                               // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_LED_ORANGE] = millis();                                // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_LED_VERT] = millis();                                  // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_LED_ROUGE] = micros();                                 // initialiser les valeurs à l'heure courante
    previousTimers[TIMER_MOTOR] = micros();                                     // initialiser les valeurs à l'heure courante

    TCCR1A = 0;                                                                 // configurer Timer1 pour utiliser l'OCR en mode CTC
    TCCR1B = (1 << WGM12) | (1 << CS11);

    OCR1A = potard;                                                             // configurer le registre de comparaison de sortie pour un certain nombre de pas

    TIMSK1 |= (1 << OCIE1A);                                                    // activer l'interruption associée à OCR1A

    delay(800);                                                                 // attend un peu

    sei();                                                                      // activer les interruptions globales
}

void loop(){

    //Origine
    if(stat_switch == false && Nombres_de_pas == 0 && sens == false){

        while(!initialisation) {
        digitalWrite(orange, LOW);                                               // eteint LED orange
        digitalWrite(vert, LOW);                                                 // eteint LED vert
        digitalWrite(ENA, HIGH);                                                 // moteur libre
        digitalWrite(rouge, HIGH);                                               // allumer une LED rouge
        tone(buz, NOTE_CS6, 80);                                                 // note de musique
        delay(100);                                                              // attend un peu
        tone(buz, NOTE_DS6, 80);                                                 // note de musique
        delay(100);                                                              // attend un peu
        tone(buz, NOTE_DS6, 160);                                                // note de musique
        Signal_PWM = false;                                                       //ordre d'arret du moteur
        initialisation = true;                                                   // Ne recommence pas
        delay(250);                                                              // attend un peu
        digitalWrite(rouge, LOW);                                                // eteint une LED rouge
        }

         if (micros() - previousTimers[TIMER_LCD_Origine] >= 250006) {
          // effectuer une action toute les 250ms appel void LCD_Origine()
           previousTimers[TIMER_LCD_Origine] = micros();                         //mise à jour avec la valeur actuelle de millis()

          LCD_Origine();                                                         //appel void LCD_Origine()
         }
          // gère la mise à jour de l'intensité de la LED rouge pour créer un effet de clignotement.
        if(micros() - previousTimers[TIMER_LED_ROUGE] > 10014){
          //                                                                     //
            analogWrite(rouge, i);                                               // régler l'intensité de la LED rouge en fonction de la valeur de la variable i
            i = i + i_sens;                                                      //incrémente ou décrémente la valeur de i en fonction de la valeur de i_sens
            if(i>=255){
              i_sens = -1;                                                       //est -1 pour diminuer l'intensité de la LED rouge.
            }
            if(i<=0){
              i_sens = 1;                                                        //est 1 augmenter l'intensité de la LED rouge.
            }
          previousTimers[TIMER_LED_ROUGE] = micros();                            //
        }

      }

    //gère l'"avance" du moteur vérifit l'état du bouton ou si le nombre maximum de pas a été atteint, et met à jour l'affichage LCD.
    while (Nombres_de_pas < Nombres_de_pas_max && stat_switch == true && sens == false){

        while(dir_init == false){
         digitalWrite(dir, LOW);                      // Tache sens de rotation
         digitalWrite(vert, HIGH);                    // allumer LED temoin vert fix
         digitalWrite(orange, LOW);                   // eteindre une LED orange
         digitalWrite(rouge, LOW);                    // eteindre une LED rouge
         lcd.clear();                                 // on efface tout
         lcd.home();                                  // retour à la ligne
         lcd.print("Programme");                      // affichage LCD ligne 1 "programme principale"
         lcd.setCursor(1, 1);                         //
         lcd.print(Nombres_de_pas);                   //
         digitalWrite(ENA, LOW);                      // moteur sous tention
         dir_init = true;
        }


         if (micros() - previousTimers[TIMER_LCD_avance] >= 177797) {
          // effectuer une action pour le LCD et pour la moteur en marche avant
           previousTimers[TIMER_LCD_avance] = micros();                         //mise à jour avec la valeur actuelle de millis()

          LCD_avance();                                                         //appel void LCD_avance()
         }

        // Vérifier si l'utilisateur a appuyé sur le bouton
        if(digitalRead(switch) == LOW) {
         stat_switch = false;                                                   // mise à jour de l'état du bouton
         //                                                                     // Signal_PWM fin de la tache avance
          digitalWrite(vert, LOW);                                              // éteindre la LED verte.
          lcd.clear();                                                          // on efface tout
          lcd.home();                                                           // retour à la ligne
          lcd.print("toggle");                                                  //
          sens = true;                                                          //changement du sens de rotation
          Signal_PWM = false;                                                    //ordre d'arret du moteur
        }
        //                                                                      //
        //Signal_PWM de fin de la tâche d'avance: si le nombre de pas dépasse le nombre maximum de pas défini, mettre fin à la tâche d'avance
        else if(Nombres_de_pas >= Nombres_de_pas_max) {
          digitalWrite(vert, LOW);                                              //
          lcd.clear();                                                          // on efface tout
          lcd.home();                                                           // retour à la ligne
          lcd.print("toggle");                                                  //
          sens = true;                                                          //changement du sens de rotation
          Signal_PWM = false;                                                    //ordre d'arret du moteur
        }
    }
    // toggle gère l'initialisation de la direction du moteur, l'affichage sur l'écran LCD, la mise à jour du nombre de pas,
    // vérification de la position du moteur et l'état des LED vertes ou oranges en fonction de l'état du bouton.
    if( sens == true && Nombres_de_pas > 0){

        if (dir_init == true) {                                                 // Initialisation de la direction du moteur en marche arrière
         digitalWrite(dir, HIGH);                                                //
         digitalWrite(rouge, LOW);                                               //
         digitalWrite(ENA, LOW);                                                 // Mise sous tension du moteur pour la marche arrière
         dir_init = false;                                                       // Mise à jour de la variable dir_init
         lcd.clear();                                                            // pour indiquer que la direction du moteur a été initialisée.
         lcd.home();                                                             // retour à la ligne
         lcd.print("toggle");                                                    // Mise à jour de l'affichage LCD pour afficher "toggle"
         lcd.setCursor(1, 1);                                                    //
         lcd.print(Nombres_de_pas);                                              // Mise à jour du nombre de pas restant
        }

        if (micros() - previousTimers[TIMER_LCD_toggle] >= 298820) {           //
          // effectuer une action pour la LCD_toggle                            //
          previousTimers[TIMER_LCD_toggle] = micros();                         //mise à jour avec la valeur actuelle de millis()
          //                                                                   //
          LCD_toggle();                                                        // appel void LCD_toggle
        }

        else if (micros() - previousTimers[TIMER_MOTOR] >= 3347) {             //
         // effectuer une action pour le moteur en marche arrière toggle        //
         previousTimers[TIMER_MOTOR] = micros();                                //mise à jour avec la valeur actuelle de micros()
         //                                                                     //
         toggle (pul);                                                          //fait tourner le moteur en vitesse rapide
         Nombres_de_pas--;                                                      //Met à jour le positionnement du moteur
        }

      // fin de la tache recule et arrêt des LEDs orange et verte lorsque le nombre de pas atteint 0.
      if(Nombres_de_pas == 0) {                                               //
        sens = false;                                                          //
        initialisation = false;                                                //
        digitalWrite(orange, LOW);                                              //
        digitalWrite(vert, LOW);                                                //
     }

      if (stat_switch == true) {                                              //
        digitalWrite(orange, LOW);                                              //
        millis();                                                               //

        if (millis() - previousTimers[TIMER_LED_VERT] >= interval) {            //
         // effectuer une action pour la LED vert                               //
         previousTimers[TIMER_LED_VERT] = millis();                             //mise à jour avec la valeur actuelle de millis()
         //                                                                     //
          toggle(vert);                                                         //
        }
     }
     else {
        digitalWrite(vert, LOW);                                                //
        millis();                                                               //
         //                                                                     //
         if (millis() - previousTimers[TIMER_LED_ORANGE] >= interval) {         //
          // effectuer une action pour la LED orange                            //
           previousTimers[TIMER_LED_ORANGE] = millis();                         //mise à jour avec la valeur actuelle de millis()
          //                                                                    //
           toggle(orange);                                                      //
         }
     }
    }

}