Reprise de projet, lecture RPM (tours par minute), moteur 4 temps

Non c'est pas compliqué, si tu branche ton voltmètre entre le + de la batterie et le moins sur une des broches du connecteur femelle de l'injection, celle qui te donnera 12V c'est celle que tu doit prendre pour ton RPM.
C'est le même système pour l'allumage si tu as des bobines compact.

bonjour
attention à ce que "tout le monde parle bien de la même chose" 8)

  • ce qui active l'injection (et sa durée) c'est "simplement" la présence d'une DDP de 12V Nom aux bornes de l'injecteur pendant un temps T .

  • Aprés la façon dont cette DDP est effectivement appliquée , çà depend de la techno de commande en puissance
    utilisé par le constructeur

Tout les constructeurs de calculateur d'injection utilise le même principe. C'est la gestion du programme qui change.
Amitiés.
Marcus.

Au moins le sujet est animé! Concrètement, je me suis un peu perdu aussi. Dans le but de récupérer mes tours/min, je reste connecté sur le "jaune" comme j'ai fait hier, ou je passe sur celui entouré en bleu?

Sachant que je vais me servir que d'un seul des 4 primaires

Merci en tout cas!

marcus_95:
Tout les constructeurs de calculateur d'injection utilise le même principe.

Je me mefie des affirmations péremptoires !

ton 1er lien expose un bipolaire NPN en collecteur ouvert

es tu sur et certain "par exemple " qu'aucun constructeur n'utilise un MOSFET N ? :grin:

Je ne voit pas bien les photos de câblage, je pense que tu est bien branché.
Pour être sur fait la manip avec un voltmètre.
Pour un RPM sur l'injection 1 puls correspond a 2 tours (moteur 4 temps) si mes souvenirs sont bons.

je ne peut pas être affirmatif sur les transistors de puissance, par contre sur la commande d'injection oui sur tout les calculateurs Europe, USA et Japon.

marcus_95:
je ne peut pas être affirmatif sur les transistors de puissance, par contre sur la commande d'injection oui sur tout les calculateurs Europe, USA et Japon.

Donc , je pense que tu conviendra comme moi au fait , que l'injection et sa durée , ne resulte que de la presence d'une DDP (12 volts nominal ) simplement aux bornes de l'injecteur pendant un temps T (bien évidemment conditionné par la presence d'une pression positive de carbu amont )

Sur le principe "admis " , c'est plus simple pour "activer" de tirer la puissance en "ouvrant "vers GND

Tout a fait d'accord avec toi sans DDP pas de commande.
Oui on tire la puissance a travers l'injecteur vers le GND.
:wink:

Bon petit test, c'est pas mal on s'approche

Je pense qu'il faut multiplier cette valeur par 2, à 4000 compteur, je suis à 1700/1800 sur l'arduino

Les compteur Suzuki n'étant pas les plus fidèle (sur mon ancienne SV injection k7, 7000 compteur me donnait 6400/6500 reel

Pour 4000 compteur a peu près

Et arduino

suivant ton programme avec l’interruption il faut la faire par changement niveau Haut vers niveau Bas.
J'ai pas regardé ton programme. (je ne suis pas bon en programmation).
:wink:

Je vais essayer, mais je suis super content du résultat !

Avec le code de DFGH je vais essayer d'accelerer le programme

Mais je suis vraiment satisfait ! Merci franchement

Super,
oui Dfgh est très bon en programmation c'est lui qui m'a écrit le programme en assembleur pour mon boitier E85.

Brasiligun:
Je vais essayer, mais je suis super content du résultat !

Avec le code de DFGH je vais essayer d’accélérer le programme

Mais je suis vraiment satisfait ! Merci franchement

:grin:

Pas vraiment bien compris ce que entend par là ?

Pour ce qui est du topic lui même :

  • besoin initialement plutôt bien exposé
  • réponses exposées/commentées

= peu de risque ici , ici de ne pas avoir de réponses "utilisables" ;D

d'autant plus que la "periode EXAM" est teminée 8)

J'ai bien bossé dessus cet aprem, le programme fait exactement ce que je veux!

Je ferai une petite vidéo, équipé sur la moto que ça soit plus parlant pour vous

Quand je disais accélérer le programme, je voulais dire avoir mes acquisition RPM refresh plus rapidement pour transmettre à mon relais les bonnes informations le plus vite possible

J'ai modifié une ligne du code de DFGH, j'ai changé la ligne avec la valeur 10 par 3 (avec 2 aucuns résultats exploitables)

Ça marche carrément bien!

{
  if (compteur_injections==1){premiere_injection=micros();}
  if (compteur_injections>=10)

<- remplacé par 3

  {
    memo_compteur_injections=compteur_injections;
    compteur_injections=0;
    rpm=((60000000/((micros()-premiere_injection)/(memo_compteur_injections-2)))*2);

  }
}

Le coup de la période exam je n'ai pas trop compris :stuck_out_tongue: Tu parles peut-être de jeune bachelier qui posent des questions en mode désespérés :stuck_out_tongue: J'ai eu ma licence cette année, mais malheureusement, pas d'arduino ou de choses qui s'en approchent au programme

Je reposterai demain en fin de soirée ou Lundi mon montage ainsi que le code, avec une vidéo du montage en action que ça soit parlant. Et je suis toujours preneur de bon conseils ou d'optimisation de code

En tout cas, merci à tous d'être intervenus!

Rebonjour! J'ai du partir plus vite que prévu pour le boulot dans une autre région, je n'ai pas eu l'occasion de vous poster une petite vidéo du montage :sob:

Je rentre enfin demain dans ch'nord, et je vais pouvoir m'y remettre. J'en ai profité pour chopper un relais plus rapide, je me servais d'un Omron G5V1 (commutation entre 3 et 7ms), là, j'ai choppé un relais reed, un Celduc D31B3100 (commutation rebond inclus 1 - 1,5ms)

Le montage sera bien plus vif et performant!

Le but de tout ceci:

Lire le régime moteur: ok
Réussir à couper l'allumage du véhicule, sans le faire caler et en restant invisible au yeux de l'ECU: ok
Décaler le rupteur sur demande: ok

Maintenant, j'ai des doute concernant mon optimisation,

Le but est bien de lire mes RPM en continu, et quant le moteur arrive au seuil, 4000 Tr/min pour l'exemple, l'arduino allume mon relais, puis le coupe pour que la moto remonte à 4000, re-coupure et ainsi de suite

Petit exemple, pour rendre notre cas parlant:

Voila le code:

//Definition des variables
volatile byte compteur_injections = 0;
byte memo_compteur_injections = 0;
unsigned long premiere_injection = 0;
int rpm = 0;


int injecteur_Pin = 2; // Signal d'un injecteur
const int ignitionCoilPin =  6; // pin de controle du relais/shifter


int launch = 4000; // Decalage rupteur a: XXXX tr/min
int step = 25 * 1000; // stepper


void setup()
{
  Serial.begin(115200);
  attachInterrupt(0, comptage_injections, RISING);
  premiere_injection = micros();
  pinMode(2, INPUT_PULLUP);

  pinMode(ignitionCoilPin, OUTPUT);
  pinMode(LED_BUILTIN, OUTPUT); //Led interne, juste pour contrôler le fonctionnement

  digitalWrite(ignitionCoilPin, LOW); //Niveau BAS = fonctionnement normal de la moto, pas de coupure au démarrage 
  digitalWrite(LED_BUILTIN, LOW);
}


void loop()
{
  readRpm();
  Serial.println(rpm);

  if (rpm >= launch)
  {
    // cut power to ignition coil for some milliseconds.
    digitalWrite(ignitionCoilPin, HIGH);
    digitalWrite(LED_BUILTIN, HIGH);
    delayMicroseconds(step);

    digitalWrite(ignitionCoilPin, LOW);
    digitalWrite(LED_BUILTIN, LOW);
    delayMicroseconds(step);
  }
}


//Fonctions
void readRpm() {
  if (compteur_injections == 1) {
    premiere_injection = micros();
  }
  if (compteur_injections >= 3)
  {
    memo_compteur_injections = compteur_injections;
    compteur_injections = 0;
    rpm = ((60000000 / ((micros() - premiere_injection) / (memo_compteur_injections - 2)))) * 2;
  }
}

void comptage_injections()
{
  compteur_injections++;
}

Voyez-vous une quelconque amélioration/optimisation de code encore possible? Mais je suis certain que ce nouveau relais va justement me permettre d'être beaucoup plus "agressif" et rapide dans mon contrôle d'allumage

Je pense également, que le fait des faire delayMicroSeconds(step) n'est peut-etre pas judicieux, en lisant ceci

Le but de ma dernière démarche, est de garder le maximum de vitesse d'execution

Merci! :smiling_imp:

hello
un code pour démarrer la discussion
j'ai volontairement utilisé un "while", car je pense que pendant la coupure, il est inutile de continuer à compter le régime moteur.

#define  injecteur                     2 //signal à capter et compter  
#define  relais_coupure                6 //relais coupure allumage
#define  led_relais                   13 //led témoin etat relais
volatile byte compteur_injections =    0;//compteur du signal à capter
byte memo_compteur_injections     =    0;//memorisation du compteur
int seuil                         = 4000;//seuil de la coupure d'allumage
unsigned long premiere_injection  =    0;//debut premiere injection
unsigned long deb_tempo           =    0;//debiut tempo cde relais coupure
unsigned long tempo               =   25;//durée de la coupure par relais
void setup()
{
  attachInterrupt(0, comptage_injections, RISING);
  premiere_injection=micros();
  pinMode(2,INPUT_PULLUP);
  pinMode(relais_coupure, OUTPUT);
  pinMode(led_relais, OUTPUT); //Led interne, juste pour contrôler le fonctionnement

  digitalWrite(relais_coupure, LOW); //Niveau BAS = fonctionnement normal de la moto, pas de coupure au démarrage 
  digitalWrite(led_relais, LOW);
}
 
void loop()
{
  if (compteur_injections==1){premiere_injection=micros();}
  if (compteur_injections>=10)
  {
    memo_compteur_injections=compteur_injections;
    compteur_injections=0;
    if(((60000000/((micros()-premiere_injection)/(memo_compteur_injections-2)))*2)>seuil)
    {
      cli();                                //si compteur > seuil, on arrete de compter le regime moteur
      deb_tempo=millis();                   //on saisit le temps
      while((millis()-deb_tempo)<tempo)     //et tant que le temps est < tempo
      digitalWrite(relais_coupure, HIGH);   //on colle le relais de coupure de l'allumage
      digitalWrite(led_relais, HIGH);       //on allume la led temoin de l'etat du relais
      };                                    //le temps "tempo" est passé
      digitalWrite(relais_coupure, LOW);    //on relache le relais de coupure d'allumage
      digitalWrite(led_relais, LOW);        //on eteint la led temoin de l'etat du relais
      sei();                                //on autorise à nouveau le comptage du regime moteur
  }
}

void comptage_injections()
{
  compteur_injections++;
}

Bonjour dfgh,

Superbe démarche! Je ne connaissais pas du tout cli() et sei(). C'est la que je vois la différence, je sais "bidouiller" dans mon coin mais t'es vraiment un monstre dans le domaine :astonished:

Je m'étais permis après ta toute 1ère version, de faire une légère modif pour accélérer au mieux l’acquisition des RPM. J'avais du modifier le if (compteur_injections>=10) en if (compteur_injections>=3)

Avec le 10 l’acquisition était avec l'ancienne forme, un peu trop molle, et avec le 3 c'était vraiment pas mal (avec un 2 plus aucun résultats). Penses-tu qu'avec ta nouvelle proposition, je vais devoir faire la même petite modif ou comme la méthode est différente, la réactualisation des RPM sera plus vive?

En tout cas un grand merci, je suis toujours en Normandie, je rentre ce soir et je suis pressé d'essayer en vrai

hello
tu fais la même modif que celle que tu avais déjà faite.
bon courage et reviens nous dire...