Lecture RPM moteur et activation relais avec retard à l'enclenchement et au déclenchement

Bonjour à toutes et à tous ;),

Je viens vers vous car j’ai besoin d’aide pour un projet que j’ai développé pour ma moto.
Toute la partie électronique et hardware est installée sur la moto et fonctionne très bien sur la base d’un Arduino Nano V3.
Le principe est assez simple, j’intercepte les signaux des sondes lambda, et à l’aide d’un pont diviseur de résistances placé dans la boucle de celles-ci et actionné par des relais reed suivant le régime moteur j’en fausse la valeur pour enrichir l’injection d’essence dans la plage de fonctionnement voulue.
Le programme fonctionne presque parfaitement mais la seule chose que je n’arrive pas à faire marcher est le retard à l’enclenchement et au déclenchement de mes relais.
La temporisation ne fonctionne qu’une seule fois, après un reset ou le download du programme sur la carte Arduino.
Donc pour le moment mes relais s’actionnent bien au régime moteur voulu mais instantanément. Je n’arrive pas à trouver où est le problème. J’ai fait beaucoup de programmation d’automates programmables (PLC) pour moderniser et fiabiliser des lignes de fabrication dans le cadre de mon boulot mais toujours en Ladder avec de temps à autres quelques instructions en list également. Je n’ai aucuns soucis avec les types de variables, les types d’opérateurs, etc… mais je n’ai jamais écrit en C, C++ ou autres langages.
de ce type. Je joins mon programme.
Pouvez vous m’aider svp.

[code]
/*
  Ce programme calcule le nombre de tours par minute du moteur
  et active des sorties TOR en fonction de celui-ci.
  Les sorties sont activées avec un retard donné.
*/

const int pinCapteur = 2;               // Signal bobine d'allumage sur pin 2
unsigned int tour;                      // nombre de tour à prendre en compte pour la mesure
unsigned long temps;                    // temps pour mesure de la vitesse de rotation moteur
unsigned long trmin;                    // Variable interne du nombre de tours/min
const int relay_1 = 5;                  // pin de controle du relais sortie lambda 1 shift
const int relay_2 = 6;                  // pin de controle du relais sortie lambda 2 shift
const int dashboard_led_green = 4;      // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
const int dashboard_led_red = 3;        // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
int delayOn = 2000;                     // retard pour coup de gaz à l'arrêt (lorsque l'on met un coup de gaz assez bref à l'arrêt)
int delayOff = 3000;                    // retard pour changement de vitesses (lorsque le régime moteur retombe pendant le changement de rapports)
unsigned long previousMillisOn = 0;     // Variable pour calcul tempo On
unsigned long previousMillisOff = 0;    // Variable pour calcul tempo Off
unsigned long currentMillis = millis(); // Variable pour calcul des tempos

void setup() {

  Serial.begin(115200);
  temps = micros();
  trmin = 0;
  tour = 0;
  currentMillis = 0;
  pinMode(pinCapteur, INPUT_PULLUP);          // Définition pinCapteur comme entrée Pullup
  attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
  pinMode(relay_1, OUTPUT);                   // Définition relay_1 comme sortie
  pinMode(relay_2, OUTPUT);                   // Définition relay_2 comme sortie
  pinMode(dashboard_led_green, OUTPUT);       // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  pinMode(dashboard_led_red, OUTPUT);         // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
  pinMode(LED_BUILTIN, OUTPUT);               // Led interne, juste pour contrôler le fonctionnement
  digitalWrite(LED_BUILTIN, LOW);             // Led interne au niveau bas
  digitalWrite(relay_1, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 1 (riche)
  digitalWrite(relay_2, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 2 (riche)
  digitalWrite(dashboard_led_green, LOW);     // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  digitalWrite(dashboard_led_red, HIGH);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
}

const int n = 20;                             // Nombre de mesures à faire pour la moyenne
const int nbrFrontMontantParTour = 2;         // Nombre de signaux d'allumage ou d'injection par tour

void program_Lean() {

  unsigned long currentMillis = millis();
  if (currentMillis > previousMillisOn + delayOn) {
    Serial.println("Lean");
    digitalWrite(relay_1, HIGH);               // la broche relay 1 passe au niveau haut (fonctionnement normal lambda 1 pauvre)
    digitalWrite(relay_2, HIGH);               // la broche relay 2 passe au niveau haut (fonctionnement normal lambda 2 pauvre)
    digitalWrite(dashboard_led_green, HIGH);   // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
    digitalWrite(dashboard_led_red, LOW);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
    digitalWrite(LED_BUILTIN, HIGH);           // La led 13 passe au niveau haut
    previousMillisOn = currentMillis;
  }
}

void program_Rich() {

  unsigned long currentMillis = millis();
  if (currentMillis > previousMillisOff + delayOff) {
    Serial.println("Rich");
    digitalWrite(relay_1, LOW);                // la broche relay 1 passe au niveau bas (fonctionnement décalé lambda 1 riche)
    digitalWrite(relay_2, LOW);                // la broche relay 2 passe au niveau bas (fonctionnement décalé lambda 2 riche)
    digitalWrite(dashboard_led_green, LOW);    // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
    digitalWrite(dashboard_led_red, HIGH);     // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
    digitalWrite(LED_BUILTIN, LOW);            // La led 13 passe au niveau bas
    previousMillisOff = currentMillis;
  }
}
void loop() {

  if (tour >= nbrFrontMontantParTour * n) {     //si le moteur à fait n tour

    detachInterrupt(digitalPinToInterrupt(pinCapteur));
    trmin = ((unsigned long)12000000 * n) / (micros() - temps);
    temps = micros();
    Serial.println(trmin);
    tour = 0;
    attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);

    if (trmin >= 3250)
      program_Lean();                          // Appel du sous programme program_Lean

    if (trmin <= 3000)
      program_Rich();                          // Appel du sous programme program_Rich
  }
}

void nouveauTourInterrupt()
{
  tour++;
}

[/code]

Bonjour.

Si je comprends bien, après une fois "n" tours, tu vas dans "program_lean" ou "program_rich" comme prévu, mais si le regime change ensuite il n'y a pas de changement de program, c'est bien ça?

Se donner du mal pour consommer plus d'essence ?
Tu es resté au XXème siècle ?

edit:
j’ai corrigé un risque de disfonctionnement et j’ai remplacé le 1er code par le 2eme

hello
c’est ok, testé. la bascule est autour de 540 tr
quelque chose à voir avec le E85?

/*
  /*
  Ce programme calcule le nombre de tours par minute du moteur
  et active des sorties TOR en fonction de celui-ci.
  Les sorties sont activées avec un retard donné.
*/

const int pinCapteur                   = 2;        // Signal bobine d'allumage sur pin 2
unsigned int tour                      = 0;        // nombre de tour à prendre en compte pour la mesure
unsigned long temps                    = 0;;       // temps pour mesure de la vitesse de rotation moteur
unsigned long trmin                    = 0;;       // Variable interne du nombre de tours/min
const int relay_1                      = 5;        // pin de controle du relais sortie lambda 1 shift
const int relay_2                      = 6;        // pin de controle du relais sortie lambda 2 shift
const int dashboard_led_green          = 4;        // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
const int dashboard_led_red            = 3;        // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
int delayOn                            = 2000;     // retard pour coup de gaz à l'arrêt (lorsque l'on met un coup de gaz assez bref à l'arrêt)
int delayOff                           = 3000;     // retard pour changement de vitesses (lorsque le régime moteur retombe pendant le changement de rapports)
unsigned long previousMillisOn         = 0;        // Variable pour calcul tempo On
unsigned long previousMillisOff        = 0;        // Variable pour calcul tempo Off
unsigned long currentMillis            = millis(); // Variable pour calcul des tempos
boolean premier_passage_Lean           = true;
boolean premier_passage_Rich           = true;
boolean deuxieme_passage_Lean          = true;
boolean deuxieme_passage_Rich          = true;
void setup() {

  Serial.begin(115200);
  temps = micros();
  trmin = 0;
  tour = 0;
  currentMillis = 0;
  pinMode(pinCapteur, INPUT_PULLUP);          // Définition pinCapteur comme entrée Pullup
  attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
  pinMode(relay_1, OUTPUT);                   // Définition relay_1 comme sortie
  pinMode(relay_2, OUTPUT);                   // Définition relay_2 comme sortie
  pinMode(dashboard_led_green, OUTPUT);       // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  pinMode(dashboard_led_red, OUTPUT);         // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
  pinMode(LED_BUILTIN, OUTPUT);               // Led interne, juste pour contrôler le fonctionnement
  digitalWrite(LED_BUILTIN, LOW);             // Led interne au niveau bas
  digitalWrite(relay_1, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 1 (riche)
  digitalWrite(relay_2, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 2 (riche)
  digitalWrite(dashboard_led_green, LOW);     // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  digitalWrite(dashboard_led_red, HIGH);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
}

const int n = 20;                             // Nombre de mesures à faire pour la moyenne
const int nbrFrontMontantParTour = 2;         // Nombre de signaux d'allumage ou d'injection par tour

void program_Lean()
{
  if (premier_passage_Lean)
  {
    previousMillisOn = millis();
    premier_passage_Lean = false;
    premier_passage_Rich  = true;
    deuxieme_passage_Rich = true;
  }
  if (deuxieme_passage_Lean)
  { 
    Serial.println("Lean deb tempo 2S");
    if (millis() > previousMillisOn + delayOn) //2000
    {
      Serial.println("Lean fin tempo");
      digitalWrite(relay_1, HIGH);               // la broche relay 1 passe au niveau haut (fonctionnement normal lambda 1 pauvre)
      digitalWrite(relay_2, HIGH);               // la broche relay 2 passe au niveau haut (fonctionnement normal lambda 2 pauvre)
      digitalWrite(dashboard_led_green, HIGH);   // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
      digitalWrite(dashboard_led_red, LOW);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
      digitalWrite(LED_BUILTIN, HIGH);           // La led 13 passe au niveau haut
      premier_passage_Lean  = false;
      deuxieme_passage_Lean = false;
    }
  }
}
void program_Rich()
{
  if (premier_passage_Rich)
  {
    previousMillisOff = millis();
    premier_passage_Rich = false;
    premier_passage_Lean  = true;
    deuxieme_passage_Lean = true;
  }
  if (deuxieme_passage_Rich)
  {
    Serial.println("Rich deb tempo 3S");
    if (millis() > previousMillisOff + delayOff) //3000
    {
      Serial.println("Rich fin tempo");
      digitalWrite(relay_1, LOW);                // la broche relay 1 passe au niveau bas (fonctionnement décalé lambda 1 riche)
      digitalWrite(relay_2, LOW);                // la broche relay 2 passe au niveau bas (fonctionnement décalé lambda 2 riche)
      digitalWrite(dashboard_led_green, LOW);    // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
      digitalWrite(dashboard_led_red, HIGH);     // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
      digitalWrite(LED_BUILTIN, LOW);            // La led 13 passe au niveau bas
      premier_passage_Rich  = false;
      deuxieme_passage_Rich = false;
    }
  }
}
void loop() 
{
  if (tour >= nbrFrontMontantParTour * n) {     //si le moteur à fait n tour
    cli();
    trmin = ((unsigned long)12000000 * n) / (micros() - temps);
    temps = micros();
    // Serial.println(trmin);
    tour = 0;
    sei();

    if (trmin >= 3250)
      program_Lean();                          // Appel du sous programme program_Lean

    if (trmin <= 3000)
      program_Rich();                          // Appel du sous programme program_Rich
  }
}

void nouveauTourInterrupt()
{
  tour++;
}

Bonjour à tous et merci pour votre aide,

Je ne suis pas encore familier du forum donc je n'ai pas trouver comment répondre directement à une personne en citant son post. sorry. :roll_eyes:

Je voudrais expliquer pourquoi et dans quel but je fais cette modification sur ma moto.
Les normes anti pollution sont devenues tellement drastiques que la majorité des motos récentes tourne avec un mélange air/essence trop pauvre en essence. Un moteur tournant trop pauvre à tendance à cogner, surchauffer, perd en efficacité, et s'use prématurément. De plus en plus de motards se plaignent que leur moto "récente" à tendance à donner des a-coups moteur quand ils roulent sur un filet de gaz à très basse vitesse. Ma moto roule très bien mais quand je suis en agglomération à régime stabilisé et sous les 3000tr/min elle cogne assez fort et c'est désagréable. Dans un premier temps j'ai fait un montage (fixe) destiné à biaiser les sondes lambda avec des résistances et un potentiomètre. Ce montage à vraiment rendu ma moto beaucoup plus agréable sous les 3000tr (Le moteur tourne dans du velours et ne claque plus). J'aurais pu laisser ça tel quel mais le problème c'est que j’enrichis le mélange sur toute la plage d'utilisation et je vais augmenter ma consommation pour rien. C'est là qu'intervient l'Arduino qui me permet d'enrichir le mélange en dessous de 3250tr/min. Au dessus de ce régime mon moteur retrouve son réglage d'origine et ne consomme ni ne pollue plus.

Petite explication pour résumer

  • Quand je roule à très basse vitesse sous 3000tr, fonctionnement enrichi pour gommer les a-coups
  • Lorsque je dépasse 3250tr et après (delayOn) je bascule en mode normal donc conso et comportement normal
  • Quand mon régime redescend sous 3000tr et après (delayOff) je reviens en mode enrichi (j'ai mis 250t de zone morte pour ne pas avoir d'enclenchement intempestif autour du seuil)

dfgh:
edit:
j’ai corrigé un risque de disfonctionnement et j’ai remplacé le 1er code par le 2eme

hello
c’est ok, testé. la bascule est autour de 540 tr
quelque chose à voir avec le E85?

/*

/*
 Ce programme calcule le nombre de tours par minute du moteur
 et active des sorties TOR en fonction de celui-ci.
 Les sorties sont activées avec un retard donné.
*/

const int pinCapteur                   = 2;        // Signal bobine d’allumage sur pin 2
unsigned int tour                      = 0;        // nombre de tour à prendre en compte pour la mesure
unsigned long temps                    = 0;;       // temps pour mesure de la vitesse de rotation moteur
unsigned long trmin                    = 0;;       // Variable interne du nombre de tours/min
const int relay_1                      = 5;        // pin de controle du relais sortie lambda 1 shift
const int relay_2                      = 6;        // pin de controle du relais sortie lambda 2 shift
const int dashboard_led_green          = 4;        // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
const int dashboard_led_red            = 3;        // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
int delayOn                            = 2000;     // retard pour coup de gaz à l’arrêt (lorsque l’on met un coup de gaz assez bref à l’arrêt)
int delayOff                           = 3000;     // retard pour changement de vitesses (lorsque le régime moteur retombe pendant le changement de rapports)
unsigned long previousMillisOn         = 0;        // Variable pour calcul tempo On
unsigned long previousMillisOff        = 0;        // Variable pour calcul tempo Off
unsigned long currentMillis            = millis(); // Variable pour calcul des tempos
boolean premier_passage_Lean           = true;
boolean premier_passage_Rich           = true;
boolean deuxieme_passage_Lean          = true;
boolean deuxieme_passage_Rich          = true;
void setup() {

Serial.begin(115200);
 temps = micros();
 trmin = 0;
 tour = 0;
 currentMillis = 0;
 pinMode(pinCapteur, INPUT_PULLUP);          // Définition pinCapteur comme entrée Pullup
 attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
 pinMode(relay_1, OUTPUT);                   // Définition relay_1 comme sortie
 pinMode(relay_2, OUTPUT);                   // Définition relay_2 comme sortie
 pinMode(dashboard_led_green, OUTPUT);       // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
 pinMode(dashboard_led_red, OUTPUT);         // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
 pinMode(LED_BUILTIN, OUTPUT);               // Led interne, juste pour contrôler le fonctionnement
 digitalWrite(LED_BUILTIN, LOW);             // Led interne au niveau bas
 digitalWrite(relay_1, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 1 (riche)
 digitalWrite(relay_2, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 2 (riche)
 digitalWrite(dashboard_led_green, LOW);     // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
 digitalWrite(dashboard_led_red, HIGH);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
}

const int n = 20;                             // Nombre de mesures à faire pour la moyenne
const int nbrFrontMontantParTour = 2;         // Nombre de signaux d’allumage ou d’injection par tour

void program_Lean()
{
 if (premier_passage_Lean)
 {
   previousMillisOn = millis();
   premier_passage_Lean = false;
   premier_passage_Rich  = true;
   deuxieme_passage_Rich = true;
 }
 if (deuxieme_passage_Lean)
 {
   Serial.println(“Lean deb tempo 2S”);
   if (millis() > previousMillisOn + delayOn) //2000
   {
     Serial.println(“Lean fin tempo”);
     digitalWrite(relay_1, HIGH);               // la broche relay 1 passe au niveau haut (fonctionnement normal lambda 1 pauvre)
     digitalWrite(relay_2, HIGH);               // la broche relay 2 passe au niveau haut (fonctionnement normal lambda 2 pauvre)
     digitalWrite(dashboard_led_green, HIGH);   // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
     digitalWrite(dashboard_led_red, LOW);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
     digitalWrite(LED_BUILTIN, HIGH);           // La led 13 passe au niveau haut
     premier_passage_Lean  = false;
     deuxieme_passage_Lean = false;
   }
 }
}
void program_Rich()
{
 if (premier_passage_Rich)
 {
   previousMillisOff = millis();
   premier_passage_Rich = false;
   premier_passage_Lean  = true;
   deuxieme_passage_Lean = true;
 }
 if (deuxieme_passage_Rich)
 {
   Serial.println(“Rich deb tempo 3S”);
   if (millis() > previousMillisOff + delayOff) //3000
   {
     Serial.println(“Rich fin tempo”);
     digitalWrite(relay_1, LOW);                // la broche relay 1 passe au niveau bas (fonctionnement décalé lambda 1 riche)
     digitalWrite(relay_2, LOW);                // la broche relay 2 passe au niveau bas (fonctionnement décalé lambda 2 riche)
     digitalWrite(dashboard_led_green, LOW);    // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
     digitalWrite(dashboard_led_red, HIGH);     // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
     digitalWrite(LED_BUILTIN, LOW);            // La led 13 passe au niveau bas
     premier_passage_Rich  = false;
     deuxieme_passage_Rich = false;
   }
 }
}
void loop()
{
 if (tour >= nbrFrontMontantParTour * n) {     //si le moteur à fait n tour
   cli();
   trmin = ((unsigned long)12000000 * n) / (micros() - temps);
   temps = micros();
   // Serial.println(trmin);
   tour = 0;
   sei();

if (trmin >= 3250)
     program_Lean();                          // Appel du sous programme program_Lean

if (trmin <= 3000)
     program_Rich();                          // Appel du sous programme program_Rich
 }
}

void nouveauTourInterrupt()
{
 tour++;
}

Bonjour dfgh,
Un grand merci pour ton aide,
j’ai trouvé comment répondre directement…Ne rigolez pas tous hahaha :grin: :grinning: :grin:

Je vais aller faire un essais sur ma moto et je reviens vers toi.

J’ai aussi une petite vidéo que je vais essayer de poster

Au fait, tu m'avais demandé si c'était en rapport avec la E85. Non c'est simplement un problème de réglage trop pauvre d'origine :wink:

pierbout:
Bonjour.

Si je comprends bien, après une fois "n" tours, tu vas dans "program_lean" ou "program_rich" comme prévu, mais si le regime change ensuite il n'y a pas de changement de program, c'est bien ça?

Bonjour pierbout,

Merci pour ton intérêt, n tours est là pour calculer une moyenne de ma vitesse de rotation moteur. De ce coté là tout fonctionne bien et mes changements d'état relais aussi et au bon régime moteur. La seule chose qui ne fonctionne pas sont les tempos. Le programme fonctionne comme ci la valeur prédéfinie des tempos était à 0

biggil:
Se donner du mal pour consommer plus d'essence ?
Tu es resté au XXème siècle ?

Non pas du tout !!!
Je pourrais laisser un montage fixe qui enrichirait sur toute la plage d'utilisation et à ce moment là je consommerais plus.
Mais ce n'est pas le cas puisque plus de 90% du temps je suis sur route où le moteur tourne avec son AFR d'origine !!!

Hello dfgh,

Un tout grand merci pour ton programme ci-dessous !
Il fonctionne parfaitement :money_mouth_face: :money_mouth_face:

C’est un plaisir d’avoir pu bénéficier de ton expertise et ton aide.
Merci, merci et encore merci :slight_smile:

/*
  /*
  Ce programme calcule le nombre de tours par minute du moteur
  et active des sorties TOR en fonction de celui-ci.
  Les sorties sont activées avec un retard donné.
*/

const int pinCapteur                   = 2;        // Signal bobine d'allumage sur pin 2
unsigned int tour                      = 0;        // nombre de tour à prendre en compte pour la mesure
unsigned long temps                    = 0;;       // temps pour mesure de la vitesse de rotation moteur
unsigned long trmin                    = 0;;       // Variable interne du nombre de tours/min
const int relay_1                      = 5;        // pin de controle du relais sortie lambda 1 shift
const int relay_2                      = 6;        // pin de controle du relais sortie lambda 2 shift
const int dashboard_led_green          = 4;        // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
const int dashboard_led_red            = 3;        // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
int delayOn                            = 2000;     // retard pour coup de gaz à l'arrêt (lorsque l'on met un coup de gaz assez bref à l'arrêt)
int delayOff                           = 3000;     // retard pour changement de vitesses (lorsque le régime moteur retombe pendant le changement de rapports)
unsigned long previousMillisOn         = 0;        // Variable pour calcul tempo On
unsigned long previousMillisOff        = 0;        // Variable pour calcul tempo Off
unsigned long currentMillis            = millis(); // Variable pour calcul des tempos
boolean premier_passage_Lean           = true;
boolean premier_passage_Rich           = true;
boolean deuxieme_passage_Lean          = true;
boolean deuxieme_passage_Rich          = true;
void setup() {

  Serial.begin(115200);
  temps = micros();
  trmin = 0;
  tour = 0;
  currentMillis = 0;
  pinMode(pinCapteur, INPUT_PULLUP);          // Définition pinCapteur comme entrée Pullup
  attachInterrupt(digitalPinToInterrupt(pinCapteur), nouveauTourInterrupt, RISING);
  pinMode(relay_1, OUTPUT);                   // Définition relay_1 comme sortie
  pinMode(relay_2, OUTPUT);                   // Définition relay_2 comme sortie
  pinMode(dashboard_led_green, OUTPUT);       // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  pinMode(dashboard_led_red, OUTPUT);         // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
  pinMode(LED_BUILTIN, OUTPUT);               // Led interne, juste pour contrôler le fonctionnement
  digitalWrite(LED_BUILTIN, LOW);             // Led interne au niveau bas
  digitalWrite(relay_1, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 1 (riche)
  digitalWrite(relay_2, LOW);                 // Niveau BAS = fonctionnement décalé de la lambda 2 (riche)
  digitalWrite(dashboard_led_green, LOW);     // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
  digitalWrite(dashboard_led_red, HIGH);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
}

const int n = 20;                             // Nombre de mesures à faire pour la moyenne
const int nbrFrontMontantParTour = 2;         // Nombre de signaux d'allumage ou d'injection par tour

void program_Lean()
{
  if (premier_passage_Lean)
  {
    previousMillisOn = millis();
    premier_passage_Lean = false;
    premier_passage_Rich  = true;
    deuxieme_passage_Rich = true;
  }
  if (deuxieme_passage_Lean)
  { 
    Serial.println("Lean deb tempo 2S");
    if (millis() > previousMillisOn + delayOn) //2000
    {
      Serial.println("Lean fin tempo");
      digitalWrite(relay_1, HIGH);               // la broche relay 1 passe au niveau haut (fonctionnement normal lambda 1 pauvre)
      digitalWrite(relay_2, HIGH);               // la broche relay 2 passe au niveau haut (fonctionnement normal lambda 2 pauvre)
      digitalWrite(dashboard_led_green, HIGH);   // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
      digitalWrite(dashboard_led_red, LOW);      // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
      digitalWrite(LED_BUILTIN, HIGH);           // La led 13 passe au niveau haut
      premier_passage_Lean  = false;
      deuxieme_passage_Lean = false;
    }
  }
}
void program_Rich()
{
  if (premier_passage_Rich)
  {
    previousMillisOff = millis();
    premier_passage_Rich = false;
    premier_passage_Lean  = true;
    deuxieme_passage_Lean = true;
  }
  if (deuxieme_passage_Rich)
  {
    Serial.println("Rich deb tempo 3S");
    if (millis() > previousMillisOff + delayOff) //3000
    {
      Serial.println("Rich fin tempo");
      digitalWrite(relay_1, LOW);                // la broche relay 1 passe au niveau bas (fonctionnement décalé lambda 1 riche)
      digitalWrite(relay_2, LOW);                // la broche relay 2 passe au niveau bas (fonctionnement décalé lambda 2 riche)
      digitalWrite(dashboard_led_green, LOW);    // LED verte affichage tableau de bord (fonctionnement à 14,7 pour 1)
      digitalWrite(dashboard_led_red, HIGH);     // LED rouge affichage tableau de bord (fonctionnement à 13,6 pour 1)
      digitalWrite(LED_BUILTIN, LOW);            // La led 13 passe au niveau bas
      premier_passage_Rich  = false;
      deuxieme_passage_Rich = false;
    }
  }
}
void loop() 
{
  if (tour >= nbrFrontMontantParTour * n) {     //si le moteur à fait n tour
    cli();
    trmin = ((unsigned long)12000000 * n) / (micros() - temps);
    temps = micros();
    // Serial.println(trmin);
    tour = 0;
    sei();

    if (trmin >= 3250)
      program_Lean();                          // Appel du sous programme program_Lean

    if (trmin <= 3000)
      program_Rich();                          // Appel du sous programme program_Rich
  }
}

void nouveauTourInterrupt()
{
  tour++;
}

:slight_smile: voilà un homme heureux

merci du retour :slight_smile:

Tu n'as pas essayé de mettre des bougies irridium ? J'avais un peu le même problème et je l'ai réglé comme ça.

dfgh:
:slight_smile: voilà un homme heureux

merci du retour :slight_smile:

Ha oui, j'ai essayé de trouver la solution pendant des heures mais rien à faire. Ton aide m'a vraiment fait plaisir. J'avais parlé de poster une vidéo mais je n'est pas de compte Youtube ou autre donc je ne sais pas où l'héberger.

JiPe38:
Tu n'as pas essayé de mettre des bougies irridium ? J'avais un peu le même problème et je l'ai réglé comme ça.

Intéressant, sur quelle moto avais tu ce problème ?
Tu avais bien des a-coups, pas des ratés d'allumage !

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.