Les motos anglaises d'avant 1983

Code : Tout sélectionner

          //**************************************************************

char ver[] = "Essai interruption 16_02_2017";      // 

          // Au régime moteur de (obligatoirement croissant):          
int Na[] = {0, 500, 600, 700,  800,  900, 1000, 1500, 2000, 3000, 7000, 0}; // Courbe a  (10 valeurs + 2)

          // degrés d'avance vilebrequin correspondant:          
int Anga[] = {0, 1,  8,  12,   12,    8,   12,   20,   22,   28,   28,  0}; //  Courbe a  (10 valeurs)          
          
int Ncyl = 2;                     // Nombre de cylindres (modifiable)
const int AngleCapteur = 360;     // Angle entre la position du capteur Hall et le Point Mort Haut du moteur (MM angle vilebrequin) 45° minimum, avec 360° l'avance + le temps de charge bobine est calculé 1 tour avant

boolean CaptOn = 0;               // Détection du passage au Point Mort Haut moteur à 0° 
                                                                   
           //************Ces valeurs sont eventuellement modifiables*****************
                                             // Ce sont TchargeBob , Ndem
const int Ndem = 170;                        // Régime estimée du moteur entrainé par le demarreur en t/m   MM : const int constante non modifiable                                          
const int TchargeBob = 5000;                 // temps de recharge bobine, ex 7 ms pour bobines Lucas de 3 ohms, 5 ms pour bobine moderne (ex Clio 16S bobine crayon Bosch )

          //***********************Variables du sketch************************************
          
const int Bob = 4;                  // Sortie D4 vers bobine
const int Cible = 2;                // Entrée sur D2 du capteur, R PullUp et interruption
const int Led = 13;                 // Sortie D13 avec la led built-in (interne sur l'Arduino Nano) pour caller le disque par rapport au capteur

float modC1 = 0;                    // MM Correctif pour C1[]

unsigned long D = 0;            // Délai en µs à attendre après la cible pour l'étincelle // MM pas de int ? pas de changement  

int milli_delay = 0;
int micro_delay = 0;

const int tcor = 200;           // Temps de correction en µs du temps de calcul courbe avec 10 valeurs d'avance

unsigned long prec_H  = 0;      // Heure du front précédent en µs    // MM pas de int
unsigned long T  = 0;           // Période en cours    // MM pas de int
unsigned long Tdem  = 0;        // Période correspondante à Ndem, forcée pour le régime de démarrage (au démarreur électrique)  // MM pas de int 

int N1  = 0;                       // Couple N,A de début d'un segment
int Ang1  = 0;                     // Car A1 réservé pour entrée analogique!
int N2  = 0;                       // Couple N,A de fin de segment
int Ang2  = 0;
int*  pN = &Na[0];                 // pointeur au tableau des régimes. Na sera la courbe par défaut    // MM unsigned ? pas de changement
int*  pA = &Anga[0];               // pointeur au tableau des avances. Anga sera la courbe par défaut  // MM unsigned 
float k = 0;                       // Constante pour calcul de l'avance courante
float C1[20];                      // Tableaux des constantes de calcul de l'avance courante 20 cases prévues
float C2[20];                      // Tableaux des constantes de calcul de l'avance courante 20 cases prévues
float Tc[20];                      // Tableau des Ti correspondants au Ni 20 cases prévues
                                   // Si nécessaire, augmenter ces 3 valeurs: Ex C1[30],C2[30],Tc[30]
int Tlim  = 0;                     // Période minimale, limite, pour la ligne rouge
int j_lim = 0;                     // index maxi des N, donc aussi Ang

unsigned long NT  = 0;         // Facteur de conversion entre N et T à Ncyl donné       // MM int unsigned utile ?
           
int AngleCibles = 0;               // Angle entre 2 cibles, 180° pour 4 cyl, 120° pour 6 cyl, est calculé dans le code avec 720 / N cylindres
                                   // Permet d'identifier le premier front et forcer T=Tdem, ainsi que Ibob=1, pour démarrer au premier front
float uspardegre = 0;

unsigned long Vitesse = 0;     // vitesse en cours              // MM pas de int ? pas de changement
unsigned long Delaideg = 0;    // µs/deg pour calcul avance     // MM pas de int
                                                               
unsigned long Stop_temps_Etincelle = 0;          // MM ajout de = 0  (pas utile !)           
unsigned long Tempsecoule = 0;                   // MM temps écoulé entre étincelle et top capteur                    
long AvanceMoteur = 0;                           // MM calcul avance moteur pour sortie série, initialisation à 0, nombre signé l'avance peut-être négative


                  //********************LES FONCTIONS*************************

void  CalcD ()    //  Calcul délai avant étincelle, avance totale
  {                                          // Noter que T1>T2>T3...  
  
   for (byte j = 1; j <= j_lim; j++)           // On commence par T la plus longue et on remonte, tant que j < limite on augmente j + 1  MM en byte
  {        
    if  (T >=  Tc[j]) {                      // Si T période en cours supérieure ou égal à j tableau des Ti et Ni
                                             // on a trouvé le bon segment de la courbe d'avance 
    D =  float((T * ( C1[j] - modC1 ) + C2[j]) - tcor - TchargeBob);   // MM Essai calcul de D temps de l'avance à l'allumage - temps de charge bobine et T correction temps de calcul

  if (D < 6500) 
  {  
  delayMicroseconds(D);                 // Attendre D, MM si D (avance totale) est inférieure à 6500 µs (il y a de la marge avec maxi 16383 µs) le délai D est directement en µs
  }
  
  else {                                  // MM sinon si Dsum est égal ou supérieur à 6500 µs, convertir Dsum en ms et µs avec milli delay et micro delay 
  milli_delay = ((D/1000)-2);             // car problèmes avec delayMicroseconds si Dsum > 14 ms! Currently, the largest value that will produce an accurate delay is 16383 µs  
  micro_delay = (D-(milli_delay*1000));   // MM milli delay c'est Dsum en us / 1000 (-2) et micro delay c'est le reste en µs de Dsum - milli delay
  
  delay(milli_delay);                     // MM délai en ms à attendre avant alimenation bobine et étincelle pour avoir l'avance à l'allumage programmée
  delayMicroseconds(micro_delay);         // MM délai en µs à attendre avant alimenation bobine et étincelle pour avoir l'avance à l'allumage programmée 

      break;
   }
  }
 }
}

                  
void  Etincelle ()           // Charger la bobine en l'alimentant pendant T recharge Bobine et la couper pour avoir l'étincelle d'allumage
{                                                                
  digitalWrite(Bob, 1);                     // MM établir le courant
  delayMicroseconds(TchargeBob);            // MM charger (alimenter) les bobines pendant le temps de charge déterminé : "TchargeBob" en µs (ex 5 ms)   
  digitalWrite(Bob, 0);                     // Couper le courant, donc étincelle (allumage)
  
  Stop_temps_Etincelle = micros();          // Pour calcul des temps
}


void  Init ()              // Elaboration du point d'avance dans la cartographie

  { 
  AngleCibles = 720 / Ncyl;                      // Ex : 720° pour 1 ou 2 cylindres (à étincelle perdue), 180° pour 4 cylindres, et 120° pour 6 cylindres
  NT = 120000000 / Ncyl;                         // Facteur de conversion Nt/mn en T µs

                                                 // T temps entre 2 étincelles soit 720°  1° = 1/6N
  Tdem = NT / Ndem;                              // Période pour le régime de démarrage

  N1  = 0; Ang1 = 0;                             // Toute courbe part de  0
  int i = 0;                                     // locale mais valable hors du FOR
  pN++; pA++;                                    // sauter le premier élément de tableau, toujours = 0
  for (i  = 1; *pN != 0; i++)                    // i pour les C1,C2 et Tc. Arrêt quand régime = 0.
                                                 // pN est une adresse (pointeur) qui pointe au tableau N. Le contenu pointé est *pN
  { N2 = *pN; Ang2 = *pA;                        // recopier les valeurs pointées dans N2 et Ang2
  k = float(Ang2 - Ang1) / float(N2  - N1);      // K = Angle 2 - Angle 1 / N2 - N1 (régime N2 - N1)
   
    C1[i] = float(AngleCapteur - Ang1 + k * N1) / float(AngleCibles);  // C1 = Angle Capteur - Angle 1 + k x N1 / Angle cible
    C2[i] = -  float(NT * k) / float(AngleCibles);        
    Tc[i] = float(NT / N2);     
    N1 = N2; Ang1 = Ang2;                        // fin de ce segment, début du suivant
    pN++; pA++;                                  // Pointer à l'élément suivant de chaque tableau   
  }
  j_lim = i - 1;                                 // Revenir au dernier couple entré
  Tlim  = Tc[j_lim];                             // Ligne rouge, limite du régime moteur maxi autorisé
  }


void setup()                ///////////while (1); delay(1000);////////////////
{
  Serial.begin(115200);         // Ligne suivante, 3 Macros du langage C
  Serial.println(__FILE__); Serial.println(__DATE__); Serial.println(__TIME__);
  Serial.println(ver);
  
  if (Ncyl < 2) Ncyl = 2;          // On assimile le mono cylindre au bi, avec une étincelle perdue
  
  pinMode(Cible, INPUT_PULLUP);    // Entrée capteur essai interruption sur D2, front montant (résistance pullup)
  pinMode(Bob, OUTPUT);            // Sortie sur D4 controle du courant dans la bobine
  pinMode(Led, OUTPUT);            // pour signaler le calage du capteur lors de la mise au point

  CaptOn = 0;                      // MM détection PMH à 0°

  Init();                          // Executée une fois au démarrage et à chaque changement de courbe (option multi-courbes d'avance)

  attachInterrupt(0, ISR_Pmh, RISING); // MM essai interruption front montant à la fin de la cible à 0° PMH
}


void  ISR_Pmh ()    ////////////////// Essai interruption pour Calcul temps T entre chaque top du capteur moteur
{  
   T = micros() - prec_H;           // MM calculer T = temps en microsecondes depuis le début - heure précédente
   prec_H = micros();               // heure précédente = heure actuelle en microseconde
    
   CaptOn = 1;                      // MM détection passage cible au PMH
}


void CalculT ()   //////////////// Calcul du temps T entre chaque Top du capteur Hall de la cible
{
  if (T >= Tdem) 
  {
  Etincelle();                       // MM allumage instantané sans avance calculée
  CaptOn = 0;
  }
  
  else if (T < Tdem && T > Tlim)
  { 
  CalcD();                           // Calcul de l'avance à l'allumage avec le temps de charge Bobine
  Etincelle();                       // fonction Etincelle donc allumage moteur
  CaptOn = 0;
  }

  else 
  {
  CaptOn = 0;
  }
}   


void loop() 
{
   if (CaptOn == 1)                 // MM essai interruption mesure de T, détection passage au PMH du capteur alors calcul T ,avance et étincelle
   {   
   CalculT();
   }   
  while (digitalRead(Cible) == HIGH);        // MM boucle tant que : capteur actif de la cible
  digitalWrite(Led,HIGH);                    // MM Allumage Led de calage statique tant que la cible est présente, et extinction en fin de cible donc à 0° Point Mort Haut moteur

  while (digitalRead(Cible) == LOW);         // MM boucle tant que : capteur non actif de la cible
  digitalWrite(Led,LOW);                     // MM extinction LED de calage statique quand la cible est absente 
}