/*
IBT-2 Motor Control Board driven by Arduino.
 
Speed and direction controlled by a potentiometer attached to analog input 0.
One side pin of the potentiometer (either one) to ground; the other side pin to +5V
 
Connection to the IBT-2 board:
IBT-2 pin 1 (RPWM) to Arduino pin 5(PWM)
IBT-2 pin 2 (LPWM) to Arduino pin 6(PWM)
IBT-2 pins 3 (R_EN), 4 (L_EN), 7 (VCC) to Arduino 5V pin
IBT-2 pin 8 (GND) to Arduino GND
IBT-2 pins 5 (R_IS) and 6 (L_IS) not connected
*/
 
int potMoteur;       // potentiometre vitesse moteur
int potG;           // potentiometre % Géneral
int potQ;     // potentiometre débit colle
int delayStart =A3;       // delay avant le debut de cordon en mode continu ou le premier paquet en mode paquet
int delayStop =A4;        // delay avant la fin du cordon en mode continu ou le dernier paquet en mode paquet
int delayinterpaquets =A5;// delay entre deux paquets
int delaytaillepaquets ; 
int memCollage;
int memmoteur;
int memPaquets;
int dStop;
int dInter;
int dStart;

int unSeulStart;

int motor_speed1;


int dTaille = delaytaillepaquets ; 
int reducp;

//int dStart1 = map(dStart, 0, 1023, 0 , 2000);

const int Bp1 = 2;     // Capteur Colle
const int Bp2 = 4 ;      // Selecteur Mode continu ou paquets
int etatBp1; 
int etatBp2; 

int Speed;
 
int RPWM = 5; // Arduino PWM output pin 5; connect to IBT-2 pin 1 (RPWM)
int LPWM = 6; // Arduino PWM output pin 6; connect to IBT-2 pin 2 (LPWM)

int Q = 3; // Sortie PWM 3 ; sur PWM module 0-10v
 
void setup()
{
  //------------------------------------------------------------Entrées / Sortie
  pinMode(Q, OUTPUT);
  pinMode(RPWM, OUTPUT);
  pinMode(LPWM, OUTPUT);
  pinMode(Bp1, INPUT); // le bouton 1 est une entrée
  pinMode(Bp2, INPUT); // le bouton 1 est une entrée

  etatBp1 = HIGH; //Bp1 est relaché 
  etatBp2 = HIGH; //Bp2 est relaché 
  memCollage = HIGH; //collage est arreté de base 
  memmoteur = HIGH; // moteur est arreté de base
  unSeulStart = HIGH;
  memPaquets = HIGH;


  //--------------------------------------------------------------Serial.Print------------------------
  Serial.begin(115200); //Initialise la communication entre le PC et Arduino
 Serial.println("Regul_3_Potar_V3_delayX3");  
  Serial.println("Wait..."); 
  delay(1000);
  Serial.println("OK");
}
 
void loop()
{
  etatBp1 = digitalRead(Bp1); // lire état Bp1
  etatBp2 = digitalRead(Bp2);
  //potG = map(potG, 0, 1023, 0, 100);           // potar General en 100%
    

  // int potMoteur = analogRead(potG);
  // int potG = analogRead(Pot_G);
  //int potQ = analogRead(A2);
  // int dStart = analogRead(delayStart);       
  // int dStop = analogRead(delayStop);        
  //int dInter = analogRead(delayinterpaquets);
  // int dTaille = delaytaillepaquets ; 
  // int motor_speed1;
 // int reducp;
   
  //dStart = map(dStart, 0, 1023, 0 , 2000);
  //dStop = map(dStop, 0, 1023, 0 , 2000);
  // dInter = map(dStart, 0, 1023, 0 , 2000);
  
 // motor_speed1 = map(potMoteur, 0, 1023, 0, 255); // potar moteur 0-255
 //potQ = map (potQ, 0, 1023, 0,255);           // potar colle 0-255
//reducp = potG/10 ;

 //-------------------------------------------------------------Action du Potar G sur les autres potar

 //motor_speed1 = motor_speed1 * (255 - reducp) / 255; // ne pas utiliser celui la 
 // motor_speed1 = (motor_speed1 * potG)/100; // utiliser celui la 
 //potQ = (potQ * potG)/100;

//---------------------------------------------------------------Condition ajouté pour le BP1 action sur la colle
if (etatBp2 == HIGH)
  {
Continu(); // appel fonction continue
marcheMoteur();

    }
     else
     {
      Paquets();// appel fonction Paquets
      }
//----------------------------------------------------------------------Fonctions----------------------------------
}

void Paquets(){

//-----------------------------------------------------définition mode paquet---------------------------


  delaytaillepaquets = 1000; // donne le temps qui defini la taille du paquet

marcheMoteur();// démarrage Moteur-----
collagePaquets();
  
}

void Continu(){
//-----------------------------------------------------définition  mode continu---------------------------


  marcheMoteur();
  collageContinu();                // et on active le mode collage continu

}

void collageContinu(){ //-----------------------------------------------------définition du mode collage continu---------------------------

Serial.println("---------------------------------------------------------");
Serial.println("Mode collageContinu");
Serial.println("---------------------------------------------------------");

if (etatBp1 == HIGH)//--------------------------------------Si Bp1 est relaché

 {  //------------------------------------------------si bp deja relaché on ne fait rien de plus 
    Serial.println("Bp relaché attendre");
    if(memCollage == HIGH){ // si collage est inactif

      Serial.println("collage deja arreté");
    }
    else {//-----------------------------------------sinon si le bouton était actif on arrete la colle

      fdelayStop(); // attendre ... milliseconde avant d'arreter la colle régulé
      Serial.println("delai Stop: ");
      Serial.println(dStop);
      arretColle();  // 0 Bar pour la colle
      memCollage=HIGH;
      Serial.println("on arrete la colle=> 0 BAR");
      Serial.println("---------------------------------------------------------");
    }


  }//--------------------------------------------------si le Bp1 est appuyé
   else
   {
      if(memCollage == HIGH){//------------------------------si il était relaché on démarre la colle 
      Serial.println("Bouton actif");
      memCollage=LOW;
      Serial.println("mémoire collage actif");
      fdelayStart(); // attendre ... milliseconde avant de demarrer la colle régulé
    
      debitColle(); // sinon on utilise la valeur potQ pour donner la valeur de Pression
      Serial.println(" on démarre la colle => 0-6 BAR régulé par potQ");
      }
        else{//------------------------------------------------si il était deja actif on ne fait rien de plus
          Serial.println(" collage deja actif on ne fait rien de plus");
          Serial.println("---------------------------------------------------------");
    }
  }
  delay((2000)); //delai pour serial.print

}

void collagePaquets(){ //-----------------------------------------------------définition du mode collage continu---------------------------

Serial.println("---------------------------------------------------------");
Serial.println("Mode collagePaquets");
Serial.println("---------------------------------------------------------");

if (etatBp1 == HIGH)//--------------------------------------Si Bp1 est relaché

 {  //------------------------------------------------si bp deja relaché on ne fait rien de plus 
    Serial.println("Aucune Présence");
    if(memCollage == HIGH){                   // si collage est inactif
      unSeulStart=HIGH;
      Serial.println("COLLE deja sur OFF");
      Serial.println("---------------------------------------------------------");
    }
    else {//-----------------------------------------sinon si le bouton était actif on arrete la colle
      dernierPaquets();
      fdelayStop();                         // attendre ... milliseconde avant d'arreter la colle régulé
      Serial.println("delai Stop: ");
      Serial.println(dStop);
      dernierPaquets();
      unSeulStart=HIGH;
    }
                                                          // MANQUE MOTEUR

  }//--------------------------------------------------si le Bp1 est appuyé
   else
   {
    if(memCollage == HIGH){//------------------------------si il était relaché on démarre la colle 
      Serial.println("Présence Profil");
      marcheMoteur();
      reglagePaquets();
}
    
    
    else{//------------------------------------------------si il était deja actif on ne fait rien de plus
    Serial.println(" collage deja actif on ne fait rien de plus");
    }
  }
  delay((2000)); //delai pour serial.print

}

void marcheMoteur() { //marcheMoteur();

if (memmoteur == HIGH){
    
    potMoteur = analogRead(A0);
    potG = analogRead(A1);
    potG = map(potG, 0, 1023, 0, 100);
    motor_speed1 = map(potMoteur, 0, 1023, 0, 255); // potar moteur 0-255
    motor_speed1 = (motor_speed1 * potG)/100;
       
    analogWrite(RPWM, motor_speed1);
    Serial.print("motor_speed1 : ");
    Serial.println(motor_speed1);
    analogWrite(LPWM, 0);
    memmoteur = LOW;
      Serial.println("Moteur ON");

}else{
  Serial.println("Moteur Reste sur ON ");
}
}

void arretMoteur(){

  analogWrite(RPWM, 0);
  analogWrite(LPWM, 0);
  memmoteur = HIGH;
  Serial.println("Moteur OFF");
}

void fdelayStop() { 
  dStop = analogRead(delayStop);
dStop = map(dStop, 0, 1023, 0 , 2000);
Serial.print("délai stop: ");
    Serial.print(dStop);
    Serial.println(" mS ");
delay(dStop);
}

void fdelayStart() { 
  
  dStart = analogRead(delayStart);
  dStart = map(dStart, 0, 1023, 0 , 2000);
  Serial.print("délai start: ");
    Serial.print(dStart);
    Serial.println(" mS ");
  delay(dStart);
}



void fdInter() {
  
  dInter = analogRead(delayinterpaquets);
  dInter = map(dInter, 0, 1023, 0 , 2000);
  Serial.print("délai inter paquets: ");
    Serial.print(dInter);
    Serial.println(" mS ");
  delay(dStart);
}

void ftempsTaillePaquets() {
  
  delaytaillepaquets = 1500;
  
  Serial.print("délai taille paquets: ");
    Serial.print(delaytaillepaquets);
    Serial.println(" mS ");
    delay(delaytaillepaquets);
}


void debitColle(){
  potG = analogRead(A1);
  potG = map(potG, 0, 1023, 0, 100);

  potQ = analogRead(A2);
  potQ = map (potQ, 0, 1023, 0,255);
  potQ = (potQ * potG)/100;

  analogWrite(Q, potQ);
  Serial.print("potQ : ");
    Serial.println(potQ);
  memCollage = LOW;
  Serial.println("Colle ON ");

}


void reglagePaquets(){
    
    if(unSeulStart==HIGH){ // memCollage'est le premier Paquet donc on met un délai Start
    Serial.println("memCollage'est le premier Paquet donc on met un délai Start");
    unSeulStart = LOW; // on passe un seulStart a actif
    fdelayStart();                //délai avant de mettre le premier paquet
    arretMoteur();                //Arret Moteur
    debitColle();                  // On colle
    ftempsTaillePaquets();        // on met un paquets
    arretColle();            // on arrete la colle
    marcheMoteur();               // Go moteur
    fdInter();                    // on attend entre deux paquets

    }

      else 
      {Serial.println("memCollage est sur LOW donc on enchaine avec les paquets suivant");
        arretMoteur();                //Arret Moteur
        ftempsTaillePaquets();        // on met un paquets
        arretColle();            // on arrete la colle
        marcheMoteur();               // Go moteur
        fdInter();                    // on attent 
    }

}

void dernierPaquets(){

  Serial.println("Dernier paquets");
    ftempsTaillePaquets();  // on met un paquets
    arretMoteur();
    arretColle();
    unSeulStart = HIGH;
    memCollage = HIGH;
    marcheMoteur;
}

void arretColle(){
  analogWrite(Q, 0);
  Serial.println("Colle OFF");
  memCollage = HIGH;
}




/* Serial.print("potMoteur : ");
    Serial.println(potMoteur);
    Serial.println(".........");
    

    Serial.print("potG :");
    Serial.println(potG);
    Serial.println(".........");
    
    Serial.print("motor_speed1 : ");
    Serial.println(motor_speed1);
    Serial.println(".........");

    Serial.print("potQ : ");
    Serial.println(potQ);
    Serial.println(".........");
    
    delay(500); //delai affichage 

    */

 
 
 /* Speed = map(potMoteur, 0, 1023, 0, 255);
    analogWrite(RPWM, Speed);
    analogWrite(LPWM, 0);
Serial.print(sensorValue);
Serial.print("...");
Serial.println(Speed);
*/

//potG = map(potMoteur, 0, , 0, potValue2);

//analogWrite(Q, potQ);

 //0-10v = potQ