#include "EEPROM.h"

// definie les LED digit patterns, from 1 - 7
// 1 = LED on, 0 = LED off, dans cet ordre:
//                74HC595 pin     Q0,Q1,Q2,Q3,Q4,Q5,Q6,Q7 
//                Mapping to      a,b,c,d,e,f,g pour segment LED
byte seven_seg_digits[7] = { B01100000,  // = 1
                              B11011010,  // = 2
                              B11110010,  // = 3
                              B01100110,  // = 4
                              B10110110,  // = 5
                              B10111110,  // = 6
                              B11100000,  // = 7                                                      
                             };
const int capteurG = 4;              //D4 boutton
const int capteurD = 5;              //D5 boutton
const int boutton = 3;               //D3 boutton manuel       
const int troncon  = 8;              //D8 coupure de tronçon
const byte led     = 13;             //led allumée si marquage en cours
int compteur_de_rangs_fais =  1;
unsigned long anti_rebonds = 500; // delai de prise en compte
bool marquage_fait = true;
const int latchPin = 9;  //port ST_CP du 74HC595 
const int clockPin = 10; //port SH_CP du 74HC595
const int dataPin = 11; //port DS du 75HC595

//pour les flancs descendants des capteurs G et D
unsigned long timer_appui_capteurG =    0;   // chrono anti rebonds capteur Gauche
unsigned long timer_appui_capteurD =    0;   // chrono anti rebonds capteur Droite
unsigned long timer_appui_boutton =     0;   // chrono anti rebonds boutton manuel
unsigned long tempo_troncon  = 3000;         // troncon coupe pendant 3 secondes
bool appui_capteurG_valide = false;          // flag de prise en compte de l'action sur capteur Gauche
bool appui_capteurD_valide = false;          // flag de prise en compte de l'action sur le capteur droit
bool appui_boutton_valide = false;            // flag de prise en comte de l'action sur le boutton manuel
bool prise_en_compte_appui_capteurG = false; // pour ne traiter qu'une fois une action sur le capteur Gauche
bool prise_en_compte_appui_capteurD = false; // pour ne traiter qu'une fois une action sur le capteur Droit
bool prise_en_compte_appui_boutton = false;  // pour ne traiter qu'un fois une action sur le boutton manuel

//pour les flancs montants des capteurs G et D
unsigned long timer_relachement_capteurG =    0;   // chrono anti rebonds capteur Gauche
unsigned long timer_relachement_capteurD =    0;   // chrono anti rebonds capteur Droite
unsigned long timer_relachement_boutton = 0;       // chrono anti rebonds boutton manuel
bool relachement_capteurG_valide = false;          // flag de prise en compte de l'action sur capteur Gauche
bool relachement_capteurD_valide = false;          // flag de prise en compte de l'action sur le capteur droit
bool relachement_boutton_valide = false;           // flag de prise en compte de l'action sur le boutton manuel
bool prise_en_compte_relachement_capteurG = false; // pour ne traiter qu'une fois une action sur le capteur Gauche
bool prise_en_compte_relachement_capteurD = false; // pour ne traiter qu'une fois une action sur le capteur Droit
bool prise_en_compte_relachement_boutton = false;  // pour ne traiter qu'une fois une action sur le boutton manuel

void setup() {
  Serial.begin(115200);
  pinMode(troncon, OUTPUT);          // D8, coupure tronçon en sortie
  pinMode(led,OUTPUT);               //D13, témoin marquage en cours si allumée
  pinMode(capteurG, INPUT_PULLUP);   // D4, capteur en entrée
  pinMode(capteurD, INPUT_PULLUP);   // D5, capteur en entrée
  pinMode(boutton, INPUT_PULLUP);    // D3, boutton en entrée
  pinMode(latchPin, OUTPUT);         // latchPin en sortie
  pinMode(clockPin, OUTPUT);         // clockPin en sortie
  pinMode(dataPin, OUTPUT);          // dataPin en sortie  
  Serial.println(F("le tracteur commence le 1er rang "));
}

void sevenSegWrite(byte digit) {  // afficher un nombre sur l'affichage numérique à segments
 
  digitalWrite(latchPin, LOW);  // définit le latchPin sur un potentiel bas, avant d'envoyer des données
     
  shiftOut(dataPin, clockPin, LSBFIRST, seven_seg_digits[digit]);  // les données d'origine (modèle binaire)
 
  digitalWrite(latchPin, HIGH);   // définit le latchPin sur un potentiel élevé, après l'envoi de données

}
 

void loop() {
  timer();                                           //pour les anti-rebonds des entrées
  if (((appui_capteurG_valide) || (appui_capteurD_valide) || (appui_boutton_valide))       //si un des deux capteurs ou boutton est actionné
      || ((appui_capteurG_valide) && (appui_capteurD_valide))) { //ou si les deux capteurs sont actionnés ensemble
    compteur_de_rangs_fais++; //totalise les rangs faits
    if (compteur_de_rangs_fais >= 8) {
      compteur_de_rangs_fais = 1;
    }
    appui_capteurG_valide = false;
    appui_capteurD_valide = false;
    appui_boutton_valide = false;
    Serial.print(F("compteur_de_rangs_fais = ")); Serial.print(compteur_de_rangs_fais); Serial.print(F("__demi tour__"));
    //Serial.print(F("compteur_de_rangs_fais %4 =  ")); Serial.print(compteur_de_rangs_fais % 4);
    marquage_fait = false;
  }
  if (marquage_fait == false)
  {
    if ((compteur_de_rangs_fais % 6) == 4)
    {
      digitalWrite(troncon, HIGH);
      digitalWrite(led,HIGH);
      Serial.print(F("__c'est le debut du  ")); Serial.print(compteur_de_rangs_fais = 4); Serial.print(F(" eme rang"));
      Serial.println(F("********marquage en cours  ")); //Serial.print(digitalRead(troncon));
      marquage_fait = true;
    }
    else {
      digitalWrite(troncon, LOW);
      digitalWrite(led,LOW);
      //Serial.print(F("**pas de marquage "));
    }
  }
  if (byte digit = compteur_de_rangs_fais)
   {
      sevenSegWrite(compteur_de_rangs_fais);
  }
}
void timer() {
  // ***************** filtre antirebonds sur appui sur capteurG ( flanc descendant ) ***********************
  if (digitalRead(capteurG) == HIGH )
  {
    timer_appui_capteurG = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du capteurG
    prise_en_compte_appui_capteurG = false;
  }
  if ((digitalRead(capteurG) == LOW )                                  //si le capteurG est actionné
      && (millis() > timer_appui_capteurG)
      && (prise_en_compte_appui_capteurG == false))                                    //depuis 200ms
  {
    prise_en_compte_appui_capteurG = true;
    appui_capteurG_valide = true;                                           //on valide l'action sur le capteurG
    timer_appui_capteurG = millis() + anti_rebonds;                         //Serial.print("capteurG_actionne__");
    Serial.print("fin du rang, suiveur gauche releve__");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    appui_capteurG_valide = false;                                             //on ne valide pas l'action sur le capteurG
  }
  // ***************** filtre antirebonds sur appui sur capteurD ( flanc descendant ) ***********************
  if (digitalRead(capteurD) == HIGH )
  {
    timer_appui_capteurD   = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du capteurG
    prise_en_compte_appui_capteurD = false;
  }
  if ((digitalRead(capteurD) == LOW)                                   //si le capteurG est actionné
      && (millis() > timer_appui_capteurD )                                      //depuis 200ms
      && (prise_en_compte_appui_capteurD == false))
  {
    prise_en_compte_appui_capteurD = true;
    appui_capteurD_valide  = true;                                             //on valide l'action sur le capteurG
    timer_appui_capteurD   = millis() + anti_rebonds;
    //Serial.print("capteurD_actionne__");
    Serial.print("fin du rang, suiveur droit releve__");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    appui_capteurD_valide = false;                                             //on ne valide pas l'action sur le capteurG
  }

// ***************** filtre antirebonds sur appui sur boutton manuel ( flanc descendant ) ***********************
  if (digitalRead(boutton) == HIGH )
  {
    timer_appui_boutton   = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du boutton
    prise_en_compte_appui_boutton = false;
  }
  if ((digitalRead(boutton) == LOW)                                   //si le boutton est actionné
      && (millis() > timer_appui_boutton )                                      //depuis 200ms
      && (prise_en_compte_appui_boutton == false))
  {
    prise_en_compte_appui_boutton = true;
    appui_boutton_valide  = true;                                             //on valide l'action sur le boutton
    timer_appui_boutton   = millis() + anti_rebonds;
    //Serial.print("boutton_actionne__");
    Serial.print(" +1 en manuel ");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    appui_boutton_valide = false;                                             //on ne valide pas l'action sur le capteurG
  }
  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ les flancs montants

  // ***************** filtre antirebonds sur relachement du capteurG ( flanc montant ) ***********************
  if (digitalRead(capteurG) == LOW )
  {
    timer_relachement_capteurG = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du capteurG
    prise_en_compte_relachement_capteurG = false;
  }
  if ((digitalRead(capteurG) == HIGH )                                  //si le capteurG est actionné
      && (millis() > timer_relachement_capteurG)
      && (prise_en_compte_relachement_capteurG == false))                                    //depuis 200ms
  {
    prise_en_compte_relachement_capteurG = true;
    relachement_capteurG_valide = true;                                           //on valide l'action sur le capteurG
    timer_relachement_capteurG = millis() + anti_rebonds;
    //Serial.println("capteurG_relache ");
    Serial.println("fin demi tour__suiveur gauche descendu au sol__roule vers bout du champ");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    relachement_capteurG_valide = false;                                             //on ne valide pas l'action sur le capteurG
  }
  // ***************** filtre antirebonds sur relachement du capteurD ( flanc montantant ) ***********************
  if (digitalRead(capteurD) == LOW )
  {
    timer_relachement_capteurD   = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du capteurG
    prise_en_compte_relachement_capteurD = false;
  }
  if ((digitalRead(capteurD) == HIGH)                                   //si le capteurG est actionné
      && (millis() > timer_relachement_capteurD )                                      //depuis 200ms
      && (prise_en_compte_relachement_capteurD == false))
  {
    prise_en_compte_relachement_capteurD = true;
    relachement_capteurD_valide  = true;                                             //on valide l'action sur le capteurG
    timer_relachement_capteurD   = millis() + anti_rebonds;
    //Serial.println("capteurD_relache ");
    Serial.println("fin demi tour__suiveur droit descendu au sol__roule vers bout du champ");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    relachement_capteurD_valide = false;                                             //on ne valide pas l'action sur le capteurG
  }

// ***************** filtre antirebonds sur relachement du boutton ( flanc montantant ) ***********************
  if (digitalRead(boutton) == LOW )
  {
    timer_relachement_boutton   = millis() + anti_rebonds;                      //on alloue 200ms pour la prise en compte du boutton
    prise_en_compte_relachement_boutton = false;
  }
  if ((digitalRead(boutton) == HIGH)                                   //si le boutton est actionné
      && (millis() > timer_relachement_boutton )                                      //depuis 200ms
      && (prise_en_compte_relachement_boutton == false))
  {
    prise_en_compte_relachement_boutton = true;
    relachement_boutton_valide  = true;                                             //on valide l'action sur le boutton
    timer_relachement_boutton   = millis() + anti_rebonds;
    //Serial.println("capteurD_relache ");
  }
  else                                                               //sinon, le temps alloué n'est pas dépassé
  {
    relachement_boutton_valide = false;                                             //on ne valide pas l'action sur le boutton
  }
}