//Injection_LoggerV3.2_250121

//Outre ses deux fonctions essentielles, l'enregistrement de runs sur carte SD et affichage au Sphone,
//le Logger pilote PotAffectLog, liaison sur 3 bits vers le Nano d'injection.

//Un potentiomètre d'entrée de données peut être utilisé pour differents reglages par le Nano d'injection
//Celui ci lit en permanence  PotAffectLog controlé par le Logger, comparable à un aiguillage

//L'utilisateur via le clavier du Sphone peut donc modifier dynamiquement l'affectation du potar
byte  PotAffectLog = 7;//Pas de potar
//6 variation de  la duréed'injection Dinj
//5 selection d'un mode d'injection parmi  cinq
//4 pour varier PapDotPla %/s
//3 pour varier CorAccMax
//2 pour varier NcycleAcc
//1 pour varier DelSeq  délai avant injection Sequentielle 4213
//0 pour varier Dinj de + ou - DinjDel ms, par potar

//Connecté en parallèle sur le Nano d'injection, il lit:
//Temps, Nt/mn ,Angle pap deg,  Dinj I4 µs,PapDot %/s, AFR, Vbat, Tmot deg, Tair deg
//CotPot,Mode,PapDotPla,CorAccMax, Ncycle
//Transmet ces données via Bluetooth et possibilté d'enregistrement sur carte SD
//Affiche sur Sphone, toutes les AffPer secondes
//Les 8 modes à entrer au clavier du smartphone en minuscule
//'l' l_og (  l_ancer le log) .Le log continuera jusqu'à l'entrée de "a" au clavier
//'a' A_rreter le log
//'6'richesse modifiée  en %
//'5' mode d'injection, 5 phasages possibles
//'4' PapDotPla en acceleration plafonnement de la vitesse du papillon
//'3' CorMaxAcc en acceleration correction maximale en %
//'2' Ncycle en acceleration nombre de cycles enrichis
//'1' DelSeq delai de l'injection en mode sequentiel
//'0' DinjDel de + à - 3ms sur Dinj selon le potar
//La carte SD contient NextR.txt le seul fichier .txt. 
//NextR.txt contient uniquement le N° du prochain Run.
//Ensuite les fichiers de Run se nomment i.csv, avec i++ à chaque Run, au format Excel

//PapDot, vitesse du papillon, est la dérivé: position/temps= vitesse = ((TPS - TPSprec) / D720) * 1000000;
//Polling sur Cible, pas d'IT

/////////////////////////1 VALEURS AJUSTABLE///////////////////////////
unsigned long AffPer = 2; //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 I4     A4//Injecteur 4
#define AP  A3  //Potar angle papillon 
#define AFR  A1 //0 à 5V fourni par sonde lambda large bande Innovate 
#define CS  9 //Chip Select du circuit de carte SD
#define Smot A2  //Sonde de temperature moteur, entrée analogique
#define Sair  A0  //Sonde de température air ambiant, entrée analogique
#define Vbat  A6  //Batterie
#define PotCor  A7  //Potar 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
#define Vp5 4.8 //En V, tension réelle de valeur théorique +5V pour convertisseur analogique
#define Rtm  1000  //Resistance talon sonde température moteur, en ohms
#define Rta  1000  //Resistance talon sonde température air, en ohms
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  Dinj4 = 0; //Durée de commande d'injection  Inj4
int N = 0; //N en t/mn
int APu = 0; //AP en unités 0-1023
float  TPS;//Throttle Position Sensor de 0 à 100%
float  TPSprec ;//Throttle Position Sensor precedent
byte  AFRv = 0; //Valeur de AFR entre 74 et 221
int AFRu = 0; //AFR en unités 0-1023
int PotCoru = 0; //PotCor en unités 0-1023
int Vbatu = 0; //Vbat en unités 0-1023
int Vmu  = 0; //temp mot  en unités 0-1023
int Vau  = 0; //temp air  en unités 0-1023
float Vmv  = 0; //V temp mot  en volts
float Vav  = 0; //V temp air  en unités 0-1023
float Vbatterie = 0;  //A partir de Vbat
float CorTmot = 100; //en % correctif temperature moteur
float CorTair = 100; //en % correctif temperature air
float CorPot  = 1; //correctif modulation de l'injection par potard ex 50 à 120%
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
float CtAff = 0; //Compteur pour affichage
float PapDot = 0; //Dérivée de TPS par rapport au temps, entre 0 et 1000%, mini 25%
float Rm  = 0; //Resistance de la sonde Tmoteur, en ohms
float Ra  = 0; //Resistance de la sonde Tair, en ohms
int DegM  = 0; // Température moteur en degrès
int DegA  = 0; // Température air en degrès
unsigned long Temps = 0; //le temps durant le run
unsigned long Hdr = 0; //Heure début de run en ms
char CarSD;//car relu de la carte SD
unsigned long   CtC = 0;//Compteur de car relus
byte InjMode = 1; // 1 Semi-sequentielle 14/23,2 Batch
//3 Semi-sequentielle 13/42,4 Sequentielle 3421,5 Sequentielle 4213
float CorAcc = 1; // correctif type pompe de reprise durant une acceleration
int PapDotPla = 0; //Vitesse d'ouverture papillon en %/s , au delà Plafonnement de CorAcc à CorAccMax, ex 250
byte CorAccMax = 0; //Plafonnement de la correction d'acceleration en %, ex 130
byte NCycleAcc = 0; //Nombre  de cycles enrichis pendant une acceleration, ex 20
byte  DelSeq  = 0;  //En Sequentielle 4213, délai avant injection de I4
byte  FAffEcran = 1; //Flag pour l'affichage de l'écran, alterne 0/1 en entrant 'p'age au clavier
float DinjDel = 0;  //Delta + ou - 3ms par potar sur Dinj, code 0
String Header = ""; //les noms de colonne
//*********Fonctions**********************
void setup()  /////////////////////////////////////////////////////
{
  Serial.begin(115200);  //Pour moniteur PC
  Serial.println("Hello");  Serial.println();
  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("p   pour geler/relancer l'affichage"));
  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(I4, INPUT); //Gate de l'IGBT
  pinMode(4, OUTPUT); //Ces 3 entrée pilotées  pour affecter le potar
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  digitalWrite(4, 1); digitalWrite(5, 1); digitalWrite(6, 1); //PotAffecLog=7
  AffPerMic = AffPer * 1000000; //Periode d'affichage en µs
}
void  AffEcran()//Sur Sphone et PC//////////////////////////////////////
{
  if (FAffEcran == 0)return;    //Demandé par utilisateur
  CtAff = CtAff + D720; //cumul de l'attente  pour afficher l'écran
  if (CtAff >= AffPerMic)
  { //Afficher toutes les AffPer secondes et selon la valeur de PotAffectLog
    CtAff = 0;    //La première ligne en exergue dépend de PotAffectLog
    BT.println();
    BT.print(F("Code    ")); BT.println(PotAffectLog);
    switch (PotAffectLog)   
    { case  7: break;   //Pas de potar
      case  6: BT.print(F("Durée injection  CorPot %   ")); BT.println(CorPot); break;

      case 4 : BT.print(F("Accel  PapDotPla %/s              ")); BT.println(PapDotPla); break;
      case 3 : BT.print(F("Accel  CorAccMax %                ")); BT.println(CorAccMax); break;
      case 2 : BT.print(F("Accel  NCycleAcc                  ")); BT.println(NCycleAcc); break;
      case 1 : BT.print(F("Sequentielle 4213  DelSeq deg     ")); BT.println(DelSeq); break;
      case 0 : BT.print(F("DinjDel  mics                     ")); BT.println(DinjDel); break;
      case 5 : switch (InjMode)
        { case 1: BT.println(F("                  Semi-Sequentielle 14--23")); break;
          case 2: BT.println(F("                  Batch")); break;
          case 3: BT.println(F("                  Semi-Sequentielle 13--42")); break;
          case 4: BT.println(F("                  Sequentielle 3421")); break;
          case 5: BT.println(F("                  Sequentielle 4213")); break;
          default :  Serial.println(); BT.println(); Serial.println("?"); BT.println("??"); delay(3000);  //Erreur
        }
        //     default :  Serial.println(); BT.println(); Serial.println("??"); BT.println("??"); delay(3000);  //Erreur
    }
    //  Le reste de l'affichage est indépendant de PotAffectLog
    BT.println();
    BT.print(F("N t/mn    ")); BT.println(N);
    BT.print(F("Angle Pap %                ")); BT.println(TPS);
    BT.print(F("Dinj 4 mics    ")); BT.println(Dinj4);
    BT.print(F("AFR                                    ")); BT.println(AFRv);
    BT.print(F("PapDot %/s  ")); BT.println(PapDot);
    BT.print(F("Vbatterie V   ")); BT.println(Vbatterie);
    BT.print(F("Tmot deg   ")); BT.println(DegM);
    BT.print(F("Tair deg   ")); BT.println(DegA);
    BT.print(F("CorPot    ")); BT.println(CorPot);
    BT.print(F("InjMode    ")); BT.println(InjMode);
    BT.print(F("PapDotPla %/s   ")); BT.println(PapDotPla);
    BT.print(F("CorAccMax  %  ")); BT.println(CorAccMax);
    BT.print(F("NCycleAcc   ")); BT.println(NCycleAcc);
    BT.print(F("DelSeq deg    ")); BT.println(DelSeq);
    BT.print(F("DinjDel  mics ")); BT.println(DinjDel);
    BT.print(F("Dernier Run   ")); BT.print(RunNb);   //N° de run
    BT.print(F(" Taille  ")); BT.println(CtC);
  }
}
void  AffouLog()  //Lecture de toutes les entrées, affichage de l'écran ou stockage SD//////////
{ while (digitalRead(Cible) == 1); //attente du passage à 0 de la cible
  D720 = micros() - prec_H; // Cible arrivée, durée de 2 tours vilo = 1 tour AàC
  prec_H = micros(); //Nouvelle heure de reference
  N = 120000000 / D720; //N en t/mn
  Lec_AP(); //Position des papillon, TPS en %
  LecDinj4(); //Temps d'activité de la gate de l' IGBT pourI4
  Lec_AFR();
  Lec_Vbat();
  LecTmot();
  LecTair();  //Trop long
  LecPotCor();
  if (RunF == 1) //Run en cours
  { PrepLigneSD();  // On selectionne  les  valeurs à enregistrer suivant PotAffecLog
    myFile.println(Ligne);  //Ecrire la carte SD, sans la fermer
    Dcum = Dcum + D720; //Pour afficher la duree en fin de run
    Temps = millis() - Hdr; //Temps ecoulé en ms depuis le debut du run
  }
  else  AffEcran();   // Toutes les AffPerMic µs afficher le Sphone
  TPSprec = TPS; //Noter precedent
  while (digitalRead(Cible) == 0);//Option:oui ou non attendre fin du 0 de la cible c'estpareil!
}
void  Dialog()///////// Lit le clavier du Sphone//////////////////////////////////////////////
{ 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;  //Arret du run en cours
    case  'l': LogPrep(); break; //Lance un run
    case  '7': digitalWrite(4, 1); digitalWrite(5, 1); digitalWrite(6, 1); PotAffectLog = 7; break;
    case  '6': digitalWrite(4, 1); digitalWrite(5, 1); digitalWrite(6, 0); PotAffectLog = 6; break;
    case  '5': digitalWrite(4, 1); digitalWrite(5, 0); digitalWrite(6, 1); PotAffectLog = 5; break;
    case  '4': digitalWrite(4, 1); digitalWrite(5, 0); digitalWrite(6, 0); PotAffectLog = 4; break;
    case  '3': digitalWrite(4, 0); digitalWrite(5, 1); digitalWrite(6, 1); PotAffectLog = 3; break;
    case  '2': digitalWrite(4, 0); digitalWrite(5, 1); digitalWrite(6, 0); PotAffectLog = 2; break;
    case  '1': digitalWrite(4, 0); digitalWrite(5, 0); digitalWrite(6, 1); PotAffectLog = 1; break;
    case  '0': digitalWrite(4, 0); digitalWrite(5, 0); digitalWrite(6, 0); PotAffectLog = 0; break;
    case  'p': if (FAffEcran == 0)FAffEcran = 1; else FAffEcran = 0;  break;    //Page affichée ou non
    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)) {       // 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);  //1v correspond à 2.92 points d'AFR + 7.4
  AFRv = map(AFRu, 0, 1023, 74, 221); // AFR valeur  entre 7.4 et 22.1
}
void  Lec_AP()///////////Angle papillons////////////////////////////////////////
{ APu = analogRead(AP); //Position papillons Throttle Position Sensor en %
  TPS = map(APu, APumin, APumax, 0, 100); // TPS 0 à 100%
  PapDot = ((TPS - TPSprec) / D720) * 1000000; //Dérivée de la position/temps= vitesse
}
void  LecDinj4()/////////Durée injection Inj4///////////////////////////////////////////
{ while (digitalRead(I4) == 0); //Attente gate = 1, injecteurs 4 ON
  Dinj4 = micros(); // Noter l'heure
  while (digitalRead(I4) == 1); //Attente gate = 0, injecteurs 4 OFF
  Dinj4 = micros() - Dinj4; // Durée
}
void  Lec_Vbat()//////////////////////////////////
{ Vbatu  = analogRead(Vbat);
  Vbatterie =  Vbatu * 0.0153; // Pont diviseur de 10k et 4.7k
}
void   LecPotCor()////////////////////////////////////////////
//L'attribution du potar dépend du logger via PotAffecLog, valeur entrée au clavier
{ //Serial.print("LecPotCor   PotAffecLog   "); Serial.println(PotAffecLog);
  PotCoru = analogRead(PotCor);//dans tous les cas on lit la valeur de pot
  switch (PotAffectLog) //Selon la valeur entrée au clavier
  {
    case  7: break; //Pas de potar
    case  6:  if (PotCoru > 10)CorPot =  map(PotCoru, 0, 1023, 70, 130) / 100.; break; //Le pot module Dinj
    case  5:  if (PotCoru < 20) {
        InjMode = 1;  //Le pot sert à choisir entre 5 modes d'injections
        break;
      }
      if (PotCoru < 300) {
        InjMode = 2;
        break;
      }
      if (PotCoru < 600) {
        InjMode = 3;
        break;
      }
      if (PotCoru < 900) {
        InjMode = 4;
        break;
      }
      InjMode = 5; break;

    case  4: PapDotPla = map(PotCoru, 0, 1023, 200, 500); break; //en %/s plafond pour acc
    case  3: CorAccMax = map(PotCoru, 0, 1023, 110, 200); break; //en % d'enrichissement pour acc
    case  2: NCycleAcc = map(PotCoru, 0, 1023, 10, 100); break; //nombre de cycles enrichis en acc
    case  1: InjMode = 5; DelSeq = map(PotCoru, 0, 1023, 0, 180); break; //En Sequentielle4213 délai avant injection en degrès
    case  0: DinjDel = map(PotCoru, 0, 1023, 0, 6000); DinjDel = DinjDel - 3000; break; //Correction Dinj en µs, + à - 3000µs
  }
  //  Serial.print("LecPotCorsortie   CorPot  "); Serial.println(CorPot);
  //  Serial.print("LecPotCorsortie   InjMode "); Serial.println(InjMode);
}
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();
  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();
}
void  LecTair()/////////////////////////////////////////////
{ CorTair = 1;
  Vau = analogRead(Sair); //De 0 à 1023
  Vav = (float)Vau * (Vp5 / 1023); //Convertir en V
  Ra = (float)Vav * (Rta / (Vp5 - Vav)); //R du capteur
  if (Ra >= 1050)DegA = (float)((3453 - Ra) / 55.7);//Première droite
  else
  {
    DegA = (float)((1662 - Ra) / 13.6);//Seconde droite
  }
}
void  LecTmot()/////////////////////////////////////////////
{ CorTmot = 1;
  Vmu = analogRead(Smot); //De 0 à 1023
  Vmv = (float)Vmu * (Vp5 / 1023); //Convertir en V
  Rm = (float)Vmv * (Rtm / (Vp5 - Vmv)); //R du capteur
  if (Rm >= 1500)DegM = (float)((4880 - Rm) / 110.);// Première droite
  else
  {
    if (Rm >= 500)DegM = (float)((2700 - Rm) / 40.);//Deuxième droite
    else
    {
      DegM = (float)((1257 - Rm) / 12.8);          //Troisième droite
    }
  }
}
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();//
  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       www.loutrel.org");
  myFile.println("; ");  //Leading blank line
  PrepHeader();
  myFile.println(Header);// ensuite les lignes seront ajoutées par EcrireLigne()
  Dcum = 0; //Calcul de la durée
  Hdr = millis(); //Heure de début de run
  Temps = millis() - Hdr; //Temps ecoulé en ms depuis le debut du run
  RunF = 1; //Demarre Run
  delay(1000);
}
void   PrepLigneSD()   //  Variable selon PotAffecLog
{
  if (PotAffectLog == 7) // Pas de potar, on log le minimum  soit 7 valeurs
    Ligne = String(Temps) + ";" + String(N) + ";" + String(TPS) + ";"  + String(Dinj4) + ";" +  String(AFRv) + ";" + String(DegM) + ";" + String(DegA)   ;
  else if ((PotAffectLog == 6) || (PotAffectLog == 0)) // On varie Dinj 9 valeurs
    Ligne = String(Temps) + ";" + String(N) + ";" + String(TPS) + ";"   + String(Dinj4) + ";" +  String(AFRv) + ";" +   String(DegM) + ";" + String(DegA) + ";" + String(CorPot) + ";" +  String(DinjDel) ;
  else if ((PotAffectLog == 5) || (PotAffectLog == 1)) //On varie le mode d'injection 7 valeurs
    Ligne = String(Temps) + ";" + String(N) + ";" + String(TPS) + ";"   + String(Dinj4) + ";" +  String(AFRv) + ";" +  String(InjMode) + ";" + String(DelSeq)  ;
  else if ((PotAffectLog == 4) || (PotAffectLog == 3) || (PotAffectLog == 2)) //On varie les paramètres d'accélération 9 valeurs
    Ligne = String(Temps) + ";" + String(N) + ";" + String(TPS) + ";"   + String(Dinj4) + ";" +  String(AFRv) + ";" + String(PapDot) + ";" + String(PapDotPla) + ";" + String(CorAccMax) + ";" + String(NCycleAcc) ;
}
void  PrepHeader()     // Header variable selon PotAffectLog
{ //Maxi String header = "Temps ms;Nt/mn ;TPS %;Dinj4 mics;AFR;PapDot %/s;Vbatterie V;Tmot deg;Tair deg;CorPot %;InjMode;PapDotPla %/s;CorAccMax %;NCycleAcc; DelSeq deg;DinjDel mics";// les entêtes de colonnes
  if ((PotAffectLog == 7))             //Pas de potar, on log le minimum
    Header = "Temps ms;Nt/mn ;TPS %;Dinj4 mics;AFR;Tmot deg;Tair deg;";// 7 entêtes de colonnes
  else if ((PotAffectLog == 6) || (PotAffectLog == 0))             // On varie Dinj 9 valeurs
    Header = "Temps ms;Nt/mn ;TPS %;Dinj4 mics;AFR;Tmot deg;Tair deg;CorPot %;DinjDel mics";// les entêtes de colonnes
  else if ((PotAffectLog == 5) || (PotAffectLog == 1)) //On varie le mode d'injection 7 valeurs
    Header = "Temps ms;Nt/mn ;TPS %;Dinj4 mics;AFR;InjMode; DelSeq deg";// les entêtes de colonnes
  else if ((PotAffectLog == 4) || (PotAffectLog == 3) || (PotAffectLog == 2)) //On varie les paramètres d'accélération 9 valeurs
    Header = "Temps ms;Nt/mn ;TPS %;Dinj4 mics;AFR;PapDot %/s;PapDotPla %/s;CorAccMax %;NCycleAcc";// les entêtes de colonnes
}
void  RunTerminer()////////////////////////////////////////////////////////////
{
  myFile.close();//Enregistre le fichier sur SD
  delay(100);
  myFile = SD.open(RunFile);  //Le reouvrir pour compter les car
  while (myFile.available())
  { //La relire en entier
    CarSD = myFile.read(); CtC++;//Compter les car
    //     Serial.write(myFile.read());// Recopie la ligne courante ************
  }
  myFile.close();//End of File encountered, stop reading****************
  delay(1000);
  RunF = 0; //Pas de run en cours
}
void loop() //////////////////////////////////////////////////////////////////////////
{ AffouLog();// Sur Sphone ou carte SD
  Dialog(); //Voir si un car tapé au clavier
}
//**********************************************
//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();
//    }
//  }
//}