#include <Arduino.h>


// declaration des pins sur la carte arduino due

const int pwm1 = 2;  // Broche PWM pour le signal PWM 1.
const int pwm2 = 3;  // Broche PWM pour le signal PWM 2.
const int pwm3 = 4; // simulation du signal de synchronisation

// entrées/sorties numeriques
const int synchro = 22;  // Broche pour détecter l'alternance positive du signal sinus.
const int demandeTir = 24 ; // 
const int departTir = 26 ; 
const int defautI = 28 ;
const int defautDriver = 30 ;
const int ledDefaut = 32 ;
const int ledTirPret = 34 ;
const int pciDepartTir = 36 ;
const int calibreUcI = 38 ;
const int commandeS1 = 40 ;
const int pciDefautDriver = 42 ;
const int secondeValidation = 44 ;
const int resetLcdHigh = 46 ;
const int im1LcdLow = 48 ;

//entrées analogiques
const int mesureI1 = A0 ;
const int mesureI2 = A1 ;
const int mesureU  = A2 ;

volatile unsigned long dernierSynchro = 0;
volatile boolean drapSynchro = false;


// Variable pour les params de test : initialisation des variables

int resistance = 1 ; // init de la variable resistance, (modifiable par labview)
int angle = 0 ;  //
int duree = 0 ;
int consigneCourant = 0 ;
int modeTir = 0 ;
int newParams = 0 ;
int valid = 0 ;
bool defaut ;
// variable pour les params 
int unite = 0 ;
int dizaine = 0 ;
int centaine = 0 ;
int millier = 0 ;

// Données à envoyer au periph
  byte dataOkToSend = 'OK';
  byte dataErrorToSend = 'ERROR' ;
  byte receivedData = 0;

// fonction de prise en charge de l'interruption externe : synchro
void interSynchro() {
 if (millis() - dernierSynchro >= 200) {
    dernierSynchro = millis();
    drapSynchro = true;
  }
}

void setup() {

  // config du sens des entrées et sorties
  pinMode(pwm1, OUTPUT);
  pinMode(pwm2, OUTPUT);
  pinMode(synchro, INPUT);
  pinMode(demandeTir, INPUT) ;
  pinMode(departTir, INPUT) ;
  pinMode(defautI, OUTPUT) ;
  pinMode(defautDriver, INPUT) ;
  pinMode(ledDefaut, OUTPUT) ;
  pinMode(ledTirPret, OUTPUT) ;
  pinMode(pciDepartTir, OUTPUT) ;
  pinMode(calibreUcI, OUTPUT) ;
  pinMode(commandeS1, OUTPUT) ;
  pinMode(pciDefautDriver, OUTPUT) ;
  pinMode(secondeValidation, OUTPUT) ;
  pinMode(resetLcdHigh, OUTPUT) ;
  pinMode(im1LcdLow, OUTPUT) ;

  // config du synchro comme interruption externe
  attachInterrupt(digitalPinToInterrupt(synchro), interSynchro,  RISING);

  //Mise à zero des sorties numériques
    digitalWrite(im1LcdLow, LOW);
    digitalWrite(resetLcdHigh, HIGH);
    digitalWrite(defautI, LOW) ;
    digitalWrite(ledDefaut, LOW) ;
    digitalWrite(ledTirPret, LOW) ;
    digitalWrite(pciDepartTir, LOW) ;
    digitalWrite(calibreUcI, LOW) ;
    digitalWrite(commandeS1, LOW) ;
    digitalWrite(pciDefautDriver, LOW) ;
    digitalWrite(secondeValidation, LOW) ;
    digitalWrite(resetLcdHigh, LOW) ;
    analogWrite(pwm1, 0) ;
    analogWrite(pwm2, 0) ;
}

void loop() {
  
  // Ici appel de la fonction de reception des params et test de leurs validités 
  // Il est en commentaire , à activité 
  //reception() ; 

  //transmission_trame() ; // Appel de la fonction de la reponse après et verification des params 

  // parametres arbitraires de test (à enlever pour le prog definitif)
  int angle = 5;    // Angle d'enclenchement en ms normalement entre 0 et 10.
  int duree = 5000;  // Durée en millisecondes.
  int courant = 512; // Courant de référence (0-1023).

// variable pciDefautDriver pour surtensionn ou soustension de l'alim de la carte driver
  while( digitalRead(defautDriver) == HIGH){ 
    analogWrite(pwm1, 0);  // pas de génération de pwm
    analogWrite(pwm1, 0);

    digitalWrite(pciDefautDriver, HIGH); //info pci du defaut
    digitalWrite(ledDefaut, HIGH) ; // led de signalisation du defaut driver

    digitalWrite(pciDepartTir, LOW) ;
    digitalWrite(commandeS1, LOW) ;
    digitalWrite(ledTirPret, LOW) ;
    digitalWrite(calibreUcI, LOW) ;
  }
  digitalWrite(pciDefautDriver, LOW); //info pci fin de defaut
  digitalWrite(ledDefaut, LOW) ; // led de signalisation fin de defaut driver

  digitalWrite(ledTirPret, HIGH) ; // info que l on peut tirer
  digitalWrite(commandeS1, HIGH) ; // fermeture S1 de securité

  if(resistance = 1){ // application du calibre de courant 
    digitalWrite(calibreUcI, HIGH) ;
  }
  else{digitalWrite(calibreUcI, LOW);}

  if(digitalRead(departTir) == HIGH && digitalRead(demandeTir) == HIGH){ // si pci informe q'un tir est pret
    if(digitalRead(defautDriver) == LOW){ // si pas de defaut driver
        
      digitalWrite(pciDepartTir, HIGH) ; // informe pci du depart du tir

      //lancement du tir
      lanceArretTir(angle, duree, courant); // lancement et arret du tir selon les paramètres

      // remise à  zero des indicateur led
      digitalWrite(pciDepartTir, LOW) ; 
      digitalWrite(commandeS1, LOW) ;
      digitalWrite(ledTirPret, LOW) ;
      digitalWrite(calibreUcI, LOW) ;
      delay(5000);                   // on attend 5 seconde avant de pouvoir lancer un autre tir
    }
  }
  digitalWrite(pciDepartTir, LOW);
}

// fonction de lancement et arret du tir 
void lanceArretTir(int angle, int duree, int courant) {
  
  
  while (drapSynchro) {

    unsigned long startTime = millis(); // compteur de temps de depart pour la duree de test
    unsigned long endTime = startTime + duree; //
    unsigned long endTime1 = startTime + angle;

    int arretTimerAngle = 0 ;
    while (millis() < endTime) {
      while(millis() < endTime1){
        analogWrite(pwm1, 0);
        analogWrite(pwm2, 0);
      }
    
      analogWrite(pwm1, 50); // 50 correspond à microseconde ; avec une fréquence de 2500 hz, avec une resolution de 8 bits 
      analogWrite(pwm2, 50); //
    }
    analogWrite(pwm1, 0);  // Arrêt de la génération des signaux PWM à la fin de la durée du tir
    analogWrite(pwm1, 0);
    
    drapSynchro = false ;
  }
}

  
  // Reception et validation des params 
/*
  void reception(){
  
  while(digitalRead(csPin) == HIGH);
  // Réception des octets du maître SPI
  String donneeReçu = "";

  while (SPI.available()) {
    char caractereReçu = (char)SPI.transfer(0);
    donneeReçu += caractereReçu ;
  }
  //test de validation des params 
  int k = 0 ;
  switch (k) 
	{
		case 1: 	if(donneeReçu [k]== '$') 											// reception de $ (debut de trame)
					{k++;}
	 				else
					{k=1;									
					break;}

		case 2:		if(donneeReçu [k]== 'M') 											// reception du carractere M sinon envoie Erreur		
					{k++;}
					else 
					{valid = 0 ;									// Envoie message erreur
					break;}

		case 3:		if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						modeTir = (donneeReçu [k]- 0);
						k++;
						if (modeTir > 2)
						{
							valid = 0 ;								// Envoie message erreur
							break;
						}
					}
					else
					{valid = 0 ;									// Envoie message erreur
					break;}

		case 4:		if(donneeReçu [k]== 'I') 											// reception du carractere I sinon envoie Erreur		
					{k++;}
					else 
					{valid = 0 ;									// Envoie message erreur
					break;}

		case 5:		if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						m = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 6:		if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						c = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 7:		if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						d = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 8:		if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						u = (donneeReçu [k]- 0);
						k++;
						consigneCourant = ((m*1000)+(c*100)+(d*10)+u);
					}
					else
					{valid = 0 ;
					break;}
		
		case 9:		if(donneeReçu [k]== 'A') 											// reception du carractere A sinon envoie Erreur		
					{k++;}
					else 
					{valid = 0 ;									// Envoie message erreur
					break; 	}

		case 10:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						c = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 11:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						d = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 12:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						u = (donneeReçu [k]- 0);
						k++;
						angle= ((c*100)+(d*10)+u);
					}
					else
					{valid = 0 ;
					break;}

		case 13:	if(donneeReçu [k]== 'D') 											// reception du carractere D sinon envoie Erreur		
					{k++;}
					else 
					{valid = 0 ;									// Envoie message erreur
					break; }

		case 14:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						m = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 15:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						c = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 16:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						d = (donneeReçu [k]- 0);
						k++;
					}
					else
					{valid = 0 ;
					break;}

		case 17:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))						// reception d'un nombre (0 a 9)
					{	
						u = (donneeReçu [k]- 0);
						k++;
						duree = ((m*1000)+(c*100)+(d*10)+u);
					}
					else
					{valid = 0 ;
					break;}

		case 18:	if(donneeReçu [k]== 'R') 		// reception du carractere R sinon envoie Erreur		
					{k++;}
					else 
					{valid = 0 ;										// Envoie message erreur
					break; }

		case 19:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))							// reception d'un nombre (0 a 9)
					{	
						resistance = (donneeReçu [k]- 0);
						k++;
					}
					break;

		case 20:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))							// reception d'un nombre (0 a F)
					{	
						d = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 0x41) && (donneeReçu [k]<= 0x46))
						{
							d = (donneReçu [k] -0x40) +0x09;
						}
						else
						{valid = 0 ;}
					}
					k++;
					break;

		case 21:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))							// reception d'un nombre (0 a F)
					{	
						u = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 0x41) && (donneeReçu [k]<= 0x46))
						{
							u = (donneeReçu [k] -0x40)+0x09;
						}
						else
						{valid = 0 ;}
					}
					RchecksumI = (d*0x10)+u;
					k++;
					break;

		case 22:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))							// reception d'un nombre (0 a F)
					{	
						d = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 0x41) && (donneeReçu [k]<= 0x46))
						{
							d = (donneeReçu [k] -0x40)+0x09;
						}
						else
						{valid = 0 ;}
					}
					k++;
					break;

		case 23:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 9))							// reception d'un nombre (0 a F)
					{	
						u = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 0x41) && (donneeReçu [k]<= 0x46))
						{
							u = (donneeReçu [k] -0x40)+0x09;
						}
						else
						{valid = 0 ;}
					}
					RchecksumA = (d*0x10)+u;
					k++;
					break;

		case 24:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 10))							// reception d'un nombre (0 a F)
					{	
						d = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 10) && (donneeReçu [k]<= 15))
						{
							d = (donneeReçu [k] -0x40) + 0x09;
						}
						else
						{valid = 0 ;}
					}
					k++;
					break;

		case 25:	if((donneeReçu [k]>= 0) && (donneeReçu [k]<= 0x39))							// reception d'un nombre (0 a F)
					{	
						u = (donneeReçu [k]- 0);
					}
					else
					{
						if ((donneeReçu [k]>= 0x41) && (donneeReçu [k]<= 0x46))
						{
							u = (donneeReçu [k] -0x40)+0x09;
              valid = 1 ;
						}
						else
						{valid = 0 ;}
					}
  }

// fonction de transmission de donnée 
// cette fonction permet d'envoyer un 'OK' pour signfier la bonne reception des params correctes ou un message 'ERROR'
void transmission_trame(int valid){
  // on test tout simplement l'état de valid , et en fonction on envois
  // soit 'ERROR' ou 'OK'
  if(valid == 0){

    digitalWrite(csPin, LOW);
    // Chaîne de caractères à envoyer
    String message = "ERROR";

    // Convertission de la chaîne de caractères en tableau d'octets (bytes)
    byte lesOctets[message.length()];
    message.getBytes(lesOctets, message.length());

    // Envoie des octets via SPI
    for (int i = 0; i < message.length(); i++) {
      SPI.transfer(lesOctets[i]);
    }

    // Désactivation du périphérique SPI après l'envoi
    digitalWrite(csPin, HIGH);
    delay(1000);
  }

  else if(valid == 1){
    digitalWrite(csPin, LOW);
    // Chaîne de caractères à envoyer
    String message = "OK";

    // Convertission de la chaîne de caractères en tableau d'octets (bytes)
    byte lesOctets[message.length()];
    message.getBytes(lesOctets, message.length());

    // Envoie des octets via SPI
    for (int i = 0; i < message.length(); i++) {
      SPI.transfer(lesOctets[i]);
    }

    // Désactivation du périphérique SPI après l'envoi
    digitalWrite(csPin, HIGH);
    delay(1000);
  }
}
*/