//Injection_LoggerV2.0_120920
// Version pour Circuit Imprimé I14 sur A4
//Lit les capteurs et la duré d'injection de la paire 1,4.
//Transmet ces données via Bluetooth et possibilté d'enregistrement sur carte SD
//Enregistre TPS - TPSprec pour analyser les accelerations
//et aussi la derivée PapDot   PapDot = ((TPS - TPSprec) / D720) * 1000000; //Dérivée de la position/temps= vitesse
//Polling sur Cible, pas d'IT, avec ou sans attente retombée cible

//Lit les parametres de la carte d'injection
//Nt/mn , Dinj 14 et 32 en µs  ecrits sur une carte SD et affichése sur Sphone, toutes les AffPer secondes
// les 2 modes à entrer au clavier du smartphone

//'l' l_og ( ou bien l_ancer le log) .Le log continuera jusqu'à l'entrée de "a" au clavier
//'a' a_rreter le log

//La carte SD contient un seul fichier texte, NextR.txt qui contient
//une unique valeur,i, le N° du prochain Run.
//Ensuite les fichiers de Run se nomment i.csv, avec i++ à chaque Run, au format Excel

/////////////////////////1 VALEURS AJUSTABLE///////////////////////////
unsigned long AffPer = 1; //Periode de l'affichage sur Sphone en secondes
////////////////////////////////////////////////////////////////

#include"TimerOne.h"
#include <SPI.h>    //Pour carte SD
#include <SD.h>
#include <SoftwareSerial.h>  //Pour Bluetooth BT
File myFile;  //Un objet myFile de type File est créé
SoftwareSerial BT(2, 3); //  RX,TX respectivement vers le HC05/06 à 115200bps

#define Cible   A5 //Cible AàC sur A5
#define I14     A4//Paire d'injecteurs  1 et 4 
#define AP  A3  //Potard angle papillon 
#define AFR  A1 //0 à 5V fourni par sonde Innovate 
#define CS  9 //Chip Select du circuit de carte SD
#define Tmot  A2  //Temperature moteur 
#define Tair  A0  //Temperature air ambiant
#define Vbat  A6  //Temperature air ambiant
#define Tair  A0  //Temperature air ambiant
#define PotCor  A7  //Potard corrige le temps d'injection
#define APumin  40 // unité de AP quand papillons au minimum absolu, 0.3V pour 7805=5V, théorie 61
#define APumax  794  // unité de AP quand papillons au maximum, 3.88V pour 7805=5V

unsigned  long prec_H = 0; //Compteur de µs
float  D720 = 0; // Durée du cycle en cours en µs, 720°vilo, 2 tours
unsigned  long  D14 = 0; //Durée de commande d'injection paire 1/4
unsigned  long  D23 = 0; //Durée de commande d'injection paire 2/3
int N = 0; //N en t/mn
int APu = 0; //AP en unités 0-1023
int  TPS;//Throttle Position Sensor de 0 à 100%
int  TPSprec ;//Throttle Position Sensor precedent
byte  AFRv = 0; //Valeur de AFR entre 74 et 221
int AFRu = 0; //AFR en unités 0-1023
byte  RunF = 0; //Flag etat d'un run: 0pas de run, 1 en cours, 2 en pause
float  Dcum = 0; //Cumul pour calcul durée d'un run.
String  Ligne = ""; //Sera ecrite dans la SD
signed  long Val = 0; //Entier tapé au clavier
int RunNb = 0; //N° de run, toujours croissant, initialisé depuis NextR.txt
String  RunFile = ""; //C'est le nom du fichier contenant le run "RunNb.xls"  ex 21.xls
char carLu; // Stock le car lu
float  AffPerMic = 0;//Periode d'affichage en µs
byte  LogPrem = 1; // Flag de Premier log, pour initialiser la carte SD
unsigned  long CtAff = 0; //Compteur pour affichage
float PapDot = 0; //Dérivée de TPS par rapport au temps, entre 0 et 1000%, mini 25%
//*************************************************************

void AffLigne()//Sur Sphone et PC//////////////////////////////////////
{ //Serial.println("****Essais injection Logger****"); BT.println("****Essais injection Logger****");
  Serial.println(); BT.println();
  Serial.print(F("N t/mn    ")); Serial.println(N);
  BT.print(F("N t/mn    ")); BT.println(N);
  Serial.print(F("Angle Pap %    ")); Serial.println(TPS);
  BT.print(F("Angle Pap %    ")); BT.println(TPS);
  Serial.print(F("Dinj1/4 mics    ")); Serial.println(D14);
  BT.print(F("Dinj1/4 mics    ")); BT.println(D14);
  //  Serial.print(F("Dinj2/3 mics    ")); Serial.println(D23);
  BT.print(F("PapDot   ")); BT.println(PapDot);
  // Serial.print(F("DinjCor mics    ")); Serial.println(DinjCor);
  // BT.print(F("DinjCor mics    ")); BT.println(DinjCor);
  //  Serial.print(F("AFR    ")); Serial.println(AFRv);
  BT.print(F("AFR    ")); BT.println(AFRv);
  BT.print(F(" Dernier Run N°  ")); BT.println(RunNb);   //N° de run
}
void  Dialog()///////////////////////////////////////////////////////
{ if (BT.available() <= 0)return; //Pas de car de dialogue tapé, sortir
  carLu = BT.read();//Lire le car tapé
  char carS = carLu; //Sauver ce car
  while (BT.available() != 0)carLu = BT.read(); //Purge
  BT.println(carS);
  switch (carS)  //d pour Durée, a pour Arret, l pour Log sans specifier de durée
  {
    case  'a': RunTerminer(); break;
    case  'l': LogPrep(); break; //Lance un run de durée par défaut
    default : Serial.println(); BT.println(); Serial.println("?"); BT.println("?"); delay(3000);  //Erreur
  }
}
void  InitSDcard()/////////////////////////////////
{ Serial.print(F("Initializing SD card..."));
  BT.println(F("Initialisation de la carte SD"));
  if (!SD.begin(CS)) {       //SD.begin(4) = 1 , Chip Select = 1 si carte OK***************************
    Serial.println(F("initialization failed!"));
    BT.println(F("Initialisation impossible, vérifier la carte SD"));
    BT.println(F("Relancer le programme"));
    while (1); //Rester bloqué ici
  }
  else {
    BT.println(F("initialization OK"));
    Serial.println(F("initialization OK"));
  }
  delay(2000);
  // Créer le fichier des numeros de log s'il n'existe pas
  if (SD.exists("NextR.txt") ) { //*************************************
    Serial.println(F("NextR.txt exists."));
    BT.println(F("NextR.txt exists."));
  } else {
    myFile = SD.open("NextR.txt", FILE_WRITE);//Le creer
    myFile.println(String( 1) );//Avec RunNb =1
    myFile.close();
  }
  LogPrem = 0; //Pour ne pas revenir dans cette fonction
}
void  Lec_AFR()///////////////////////////////////////////
{ AFRu = analogRead(AFR);
  AFRv = map(AFRu, 0, 1023, 74, 221); // AFR valeur  entre 7.4 et 22.1
}
void  Lec_AP()///////////////////////////////////////////////////
{ APu = analogRead(AP); //Position papillons Throttle Position Sensor en %
  TPS = map(APu, APumin, APumax, 0, 100); // TPS 0 à 100%
}
void  LecD14()////////////////////////////////////////////////////
{ while (digitalRead(I14) == 0); //Attente gate = 1, injecteurs 1/4 ON
  D14 = micros(); // Noter l'heure
  while (digitalRead(I14) == 1); //Attente gate = 0, injecteurs 1/4 OFF
  D14 = micros() - D14; // Durée
}
void  LecRunNb()/////////////////////////////////////////////////////
{ //Lire depuis  NextR.txt le numero  RunNb du prochain Run
  myFile = SD.open("NextR.txt");//Ouvert pour lecture seulemnt et non  WRITE
  char carLu; // Stock le car lu
  String  L = ""; //Accumule les car reçus de la carte SD
  if (myFile) {
    while (myFile.available()) {
      carLu = myFile.read();//Lecture de 1 car
      delay(100);   //Indispensable ?
      if ((carLu == 13 ) || (carLu == 10)) break;//Sortir
      L = L + carLu; //cumuler
    }
    RunNb = L.toInt();//Conversion en entier de la chaine de caractères
  }
  myFile.close();
}
void  LogPrep()////////////////////////////////////////////////////////////
{
  if (LogPrem == 1)InitSDcard(); //Initialiser la carte SD, bloquera si problème
  //Lire le numero de run RunNb, seul enregistrement du fichier NextR.txt
  LecRunNb();//
  SD.remove("NextR.txt");//MàJ du N° de run, effacer l'ancien fichier
  // car on veut écrire en première position
  myFile = SD.open("NextR.txt", FILE_WRITE);//Le recreer
  myFile.println(String(RunNb + 1) );//Avec RunNb++
  myFile.close();
  Serial.print("Lancement du  Run   "); Serial.println(RunNb);
  BT.print("Lancement du  Run   "); BT.println(RunNb);
  BT.println("Run en cours"); Serial.println("Run en cours");
  delay(3000);
  //Création du nouveau fichier pour le run qui démarre, d'abord son nom, ex "21.xls"
  RunFile = String(RunNb) + ".csv";//Composer le nom du fichier run à demarrer
  myFile = SD.open(RunFile, FILE_WRITE);
  myFile.println("                            INJECTION Alpine A110 1600S");
  myFile.println("; ; ; ; ; ; ; ");  //Leading blank line
  //   String header = "Nt/mn ;TPS en %;D14 mics;D23 mics;Cor mics ;AFR ";// les entêtes de colonnes
  String header = "Nt/mn ;TPS en %;D14 mics;PapDot;AFR  ";// les entêtes de colonnes
  myFile.println(header);// ensuite les lignes seront ajoutées par EcrireLigne()
  Dcum = 0; //Calcul de la durée
  RunF = 1; //Demarre Run
  delay(1000);
}
void  PrepLigne()  //Lecture de toutes les entrées, affichage ou stockage//////////////////////////////////
{ while (digitalRead(Cible) == 1); //Pendant l'attente du passage à 0 de la cible, on test:
  D720 = micros() - prec_H; // Durée de 2 tours vilo = 1 tour AàC
  prec_H = micros(); //Nouvelle heure de reference
  N = 120000000 / D720; //N en t/mn doublé car les lectures de 14 et 23 prend trop de temps!
  Lec_AP(); //Position des papillon, TPS en %
  LecD14(); //Temps d'activité de la gate des IGBT pour les injecteurs
  //  LecD23();
  Lec_AFR();
  PapDot = ((TPS - TPSprec) / D720) * 1000000; //Dérivée de la position/temps= vitesse
  CtAff = CtAff + D720; //cumul les temps
  if (CtAff >= AffPerMic) { //Afficher toutes les AffPer secondes
    CtAff = 0;
    AffLigne();
  }
  //  Ligne = String(N) + ";" + String(TPS) + ";" + String(D14) + ";" + String(D23) + ";" + String(DinjCor) + ";" + String(AFRv);
  if (RunF == 1) //Run en cours
  { Ligne = String(N) + ";" + String(TPS) + ";"   + String(D14) + ";" +  String(PapDot) + ";" + String(AFRv) + ";";
    myFile.println(Ligne);  //Ecrire la carte SD
    Dcum = Dcum + D720; //Pour afficher la duree en fin de run
    Dialog(); //Voir si arret demandé
  }
  TPSprec = TPS; //Noter precedent
  while (digitalRead(Cible) == 0);//Option:oui ou non attendre fin du 0 de la cible c'estpareil!
}
void  RunTerminer()////////////////////////////////////////////////////////////
{
  BT.println(F("Run termine: numero et duree en s  ")); Serial.println(F("Run termine: numero et duree en s   "));
  BT.println(RunNb); Serial.println(RunNb);
  BT.println(Dcum / 1000000); Serial.println(Dcum / 1000000);
  myFile.close();//Enregistre le fichier des lignes
  delay(1000);
  RunF = 0; //Pas de run en cours
}
//void  Tst_BT()    //Ceci est un test de BT, à lancer depuis setup()///////////////////
//{ int BTdata = 0;
//  //**************Vers PC
//  Serial.println("Bonjour ");
//  Serial.println("Le caractere entre sur l'Android doit se retrouver ci dessous");
//  //***************Vers module
//  BT.println(" ");
//  BT.println(" ");
//  BT.println("Bonjour sur Android");
//  BT.println(" ");
//  BT.println("HC05, la led doit clignoter 2 flash, 1s Off, 2flash...");
//  BT.println(" ");
//  BT.println("HC06, led On fixe");
//  BT.println("");
//  BT.println("Entrer un caractere ");
//  BT.println("S'il se retouve sur le PC, tout va bien...");
//  while (1)
//  { if (BT.available()) //Car pret en entrée sur Serie soft?
//    { BTdata = BT.read(); //oui, le clavier Android BT a émis un car
//      BT.println(" ");//Aller à la ligne sur sphone
//      Serial.write(BTdata);//ecrire le car sur le PC
//      Serial.println();
//    }
//  }
//}
void setup()  /////////////////////////////////////////////////////
{
  Serial.begin(115200);  //Pour moniteur PC
  BT.begin(115200);  //Pour Sphone, Bluetooth
  BT.println(F("****************************"));
  BT.println(F("Logger pour injection Alpine 1600S")); Serial.println(F("Hello world"));
  BT.println(F("****************************"));
  // Tst_BT(); //Boucle infinie pour test liaison BT
  BT.println(F("l   pour Lancer le log"));
  BT.println(F("a   pour  Arreter le log"));
  delay(5000);
  pinMode(Cible, INPUT_PULLUP); //Vient du capteur Hall
  pinMode(I14, INPUT); //Gate de l'IGBT
 // pinMode(Led, OUTPUT); //Suit les injections
  AffPerMic = AffPer * 1000000; //Periode d'affichage en µs
  //  while(1)    AffLigne();// Serial.println(digitalRead(Cible));
}
void loop() //////////////////////////////////////////////////////////////////////////
{ PrepLigne();
  Dialog();
}