/*****************************************************************************************
               CLIGNOTANT, WARNING, FEUX DE RECUL ET FEUX STOP CONSTANT 
******************************************************************************************
Ce programme necessite l'utilisation d'une radio aillant au moins trois voies proportionnelles
Il permet de commander, les clignotants, les feux de detresse, les feux stop,
et  les phares de recul d'un vehicule radiocommande.
   * Si Le pin 0 connecte sur une voie proportionnelle, les clignotants sont actionnes
      a droite ou a gauche en fonction de la position du manche.
   *  Si le pin 0 connecte en parallele avec le servo de direction les clignotants
      sont automatiquement actionnes en fonction de la direction prise.
   * Le pin 1 connecte sur une autre voie libre, commandera les feux de detresse. 
                        ...................................................
  Lorsque le vehicule radiocommande est en marche arriere automatiquement 
  les feux de recul s'allument.
  Lorsque le vehicule passe a l’arret, les feux stop s'allument, jusqu'a ce qu'il redemarre.
                        ...................................................
     Pin 0 connecte en parallele avec la voie direction
     Pin 1 connecte a une voie proportionnelle libre
     Pin 2 connecte en parallele a la voie du variateur
     Pin 7 connecte au feux stop
     Pin 8 connecte au feu de recul
     Pin 9 connecte au clignotant droit
     Pin 10 connect au clignotant gauche
======================================================================================= */
#define signal      0             // voie direction
#define warning     1             // voie complementaire
#define signalv     2             // Voie variateur

#define f_stop      7             // Feux stop sur le pin 2
#define f_recul     8             // Feux de recul sur le pin 1
#define droite      9             // clignotant droit
#define gauche      10            // clignotant droit

int EtatLedd = LOW;               // etat clignotant droit
int EtatLedg = LOW;               // etat clignotant gauche
int EtatLedw = LOW;               // etat warning
int val1;                         // valeur du signal reçu
int valw;                         // valeur du warning reçu
int vallv;                        // Valeur du signalv recepteur
int neutrev;                      // valeur  du neutre
int neutred ;                     // valeur du neutre
int neutrew ;                     // valeur du neutre warning
int x = 100;                      // plage neutre
unsigned long Temps_Precedent = 0;
const long intervale = 300;       // frequence clignotants
const long intervalew = 200;      // frequence warning

//-----------------------------------------------------------------------------------------

void setup() {   
  pinMode(signal, INPUT);            // pin signal en entree
  pinMode(warning, INPUT);           // pin warning en entree
  pinMode(droite, OUTPUT);           // pin led droite en sortie
  pinMode(gauche, OUTPUT);           // pin led gauche en sortie
  pinMode(signalv, INPUT);           // Declare signalv comme une entree
  pinMode(f_recul, OUTPUT);          // Déclare le pin1 (feu de recul) en sortie
  pinMode(f_stop, OUTPUT);           // Declare le pin2 (feux stop) en sortie
  neutred = pulseIn(signal, HIGH);   // saisie du neutre
  neutrew = pulseIn(warning, HIGH);  // saisie du neutre
  neutrev = pulseIn(signalv, HIGH);  // enregistrement du neutre
}
//----------------------------------------------------------------------------------------
void loop()
{
  vallv = pulseIn(signalv, HIGH);  // Lire le signal et de le stocker dans vallv
  if (vallv < neutrev - x)   {    digitalWrite(f_recul, HIGH);  } // Si marche arriere
  else   {    digitalWrite(f_recul, LOW);  }
  if ( vallv < (neutrev + x) && vallv > (neutrev - x) )   {    digitalWrite(f_stop, HIGH);  }
  else { digitalWrite(f_stop, LOW); }

valw = pulseIn(warning, HIGH);     //Lire le signal et de le stocker dans valw
if ( valw > neutrew + x ) { detresse(); } 
 else {direction(); }
}

//-----------------------------------------------------------------------------------------
void direction() {
 
 val1 = pulseIn(signal, HIGH);     //Lire le signal et de le stocker dans val1
 if ( val1 > neutred + x ) { actionadroite(); } 
 else {  digitalWrite(droite, LOW); EtatLedd = LOW; }
 if ( val1 < neutred - x ) { actiongauche(); } 
else {  digitalWrite(gauche, LOW); EtatLedg = LOW; }
}

//------------------------------------------------------------------------------------------
void detresse() {
unsigned long Temps_Actuel = millis();
  if (Temps_Actuel - Temps_Precedent >= intervalew) {
    Temps_Precedent = Temps_Actuel;
    if (EtatLedw == LOW) {      EtatLedw = HIGH;    }
    else {      EtatLedw = LOW;     }
    digitalWrite(droite, EtatLedw);  digitalWrite(gauche, EtatLedw);
  }       
}
//--------------------------------------------------------------------------------------------
void actionadroite() {

unsigned long Temps_Actuel = millis();
  if (Temps_Actuel - Temps_Precedent >= intervale) {
    Temps_Precedent = Temps_Actuel;
    if (EtatLedd == LOW) {      EtatLedd = HIGH;    }
    else {      EtatLedd = LOW;     }
    digitalWrite(droite, EtatLedd);
  }         
}
//---------------------------------------------------------------------------------------------
void actiongauche() {

unsigned long Temps_Actuel = millis();
  if (Temps_Actuel - Temps_Precedent >= intervale) {
    Temps_Precedent = Temps_Actuel;
    if (EtatLedg == LOW) {      EtatLedg = HIGH;    }
    else {      EtatLedg = LOW;     }
    digitalWrite(gauche, EtatLedg);
  }              
}
//*********************************** FIN DE PROGRAMME ***************************************