Gestion d'un signal carré

Bonjour,
Je souhaiterai gérer le signal de comande des bobines d'allumage, émanant d'un calculateur automobile.
Ce signal est un signal carré, il a une amplitude de 12V (0-12V) et une fréquence variable en fonctionnement de 40 à 300 hertz.

Comme représenté sur le schéma, je voudrais modifier le signal de base suivant 4 modes :

  • mode 1 : le signal reste identique
  • mode 4 : on supprime un niveau haut sur 4
  • mode 3 : on supprime un niveau haut sur 3
  • mode 2 : on supprime un niveau haut sur 2

La selection des différents modes se fait automatiquement en fonction de la réponse d'un capteur analogique (cette partie du projet est ok) suivant cette exemple:

20<valeur<25 ------> mode 2
15<valeur<20 ------> mode 3
10<valeur<15 ------> mode 4
valeur<10 ------> mode1

Suivant le schéma 2 ci-joint, d'origine le primaire des bobines est alimenté (12V continue) par une ligne commune aux 4 bobines.

Ces dernières étant pilotées en séquentielle (une par une), elles ont chacune leur commande (par mise à la masse) réalisée directement par le calcuateur via des transistors internes. Ces lignes sont repérées en 1, 2, 3, 4.
A coté du schéma des bobines se trouve un équivalent des signaux relevés aux bornes 1, 2, 3, 4; phasé suivant l'ordre d'allumage 1-3-4-2.

Je pense :

  • relever le signal de commande global (pour les 4 bobines) par l'intermédiare d'un optocoupleur monté sur l'alimentation (12V) des bobines
  • réliser les coupures par l'intermédiare d'un transistor piloté par l'Arduino

C'est donc pour cette partie que j'ai besoin d'aide, nouveau dans le monde de l'arduino je ne sais pas du tout comment gérer les séquences de gestion des coupures bobines, ni même si l'idée d'utliser un optocoupleur (comme son montage) est opportun.

Merci pour vos réponses

Bonjour
en gros tu veux intercepter les créneaux d'entrées 12V et en forçant en sortie un état bas 0V à la place d'un etat haut 12 V selon le mode choisi ?

çà doit se résoudre assez facilement en jouant avec les interruption sur les flancs montants du signal sortant de l'ECU créneau et en travaillant modulo 4 selon le mode choisi .

Il faut ramener le 12 V en sortie d'ECU à 5V (au autre compatible avec le MCU choisi)
et en sortie du MCU , trés surement un mosfet logic level pour presenter un signal 12V de commande de bobine.
c'est pour simuler un piston en rade ?

Bonjour,
oui le but est de mettre un cylindre off suivant une séquence de comande définie:

011101110...
011011011...
010101010...

je me dis que ça doit être jouable avec "attachInterrupt(0, gestionINT0, RISING);" en comptant les niveaux hauts pour correspondre aux séquences de chaque mode mais je sèche sur la façon de faire.

A chaud et rapide
faire +1 du nb d'allumage dans l'interruption
nballumage modulo 4 ----> renvoi le N° de créneau entre 0 et 3
ensuite qq tests selon mode et le n° de créneau pour le mettre la sortie à HIGH ou LOW

Ok merci,
je vais regarder la fonction "modulo" car je ne connais pas du tout.
Si je comprend bien, une fois rentré dans un des modes:

  • je met OFF le premier niveau haut grace à une fonction appelée par "attachInterrupt(0, gestionINT0, RISING)"

  • je lance un comptage des impulsion ON en fonction du mode et réinitialise la séquence grace au modulo

Je vais essayer d'écrire la suite du programme avec tout ça.

C'est une fonction trés pratique, beaucoup de debutants ne l'utilise pas , justement par ignorance

ecris ton programme et poste le , il y aura toujours qqun pour t'aider/ameliorer ensuite

Bonjour,
J'ai essayé de travailler sur le code, j'ai quelque chose qui fonctionne mais avec quelques bugs...
Je n'ai pas essayé la fonction "modulo".

J'ai fais une "maquette" de fonctionnement, dans le code:

  • j'ai remplacé le signal de l'optocoupleur par un bouton poussoir relié en int0 (j'ai rajouté une led en sortie 8 qui s'allume lors d'un passage de niveau haut, ce, juste pour visualiser ces derniers)

-j'ai remplacé la sortie de commande du transistor par une sortie (9) pilotant une led normalement alimentée (pour un visuel sur le fonctionnement)

Lorsque je simule le "mode4", j'incrémente bien mes interruptions, à la 4eme je coupe momentanément l'alimention de la led en 9 et je réinitialise ma séquence, l'interruption suivante reppart en 1.
Mais voilà, lorsque j'appuie rapidement sur l'interrupteur, l'incrémentation se fait mais ne se réinitialise pas à la 4eme impulsion et passe à 5, puis 6, etc... et là, ça ne fonctionne plus...

Je m'essaie à l'arduino que depuis quelques jours, il y a surement pleins d'erreurs dans le code mais je ne vois pas où...


const int buttonPin = 2;                        //assigne le bouton à la pin2
const int ledPin = 8;                           //assigne la led 1 à la pin8
const int ledPin2 = 9;                          //assigne la led 2 à la pin9

int buttonstate = 0;                            //le bouton est initialement à l'état bas

volatile int comptageImpulsion=0;               //le compteur d'impulsions est initialement à 0


void setup(){
pinMode(buttonPin,INPUT);                       //entree numérique  2 
pinMode(ledPin,OUTPUT);                         //sortie numérique  8 
pinMode(ledPin2,OUTPUT);                        //sortie numérique  9
 
Serial.begin(115200); 
attachInterrupt(0, gestionINT0, RISING);        // attache l'interruption externe n°0 à la fonction gestionINT0()

}


void loop(){

buttonstate = digitalRead(buttonPin);

if (buttonstate == HIGH)                        //si le bouton est à l'état haut
{
digitalWrite(ledPin,HIGH);                      //le courant est envoyé sur la borne 2, la LED  s’allume
}
else 
{
digitalWrite(ledPin,LOW);
}
if (comptageImpulsion == 4)                     //si le comptage d'impulsion est à 4
{
digitalWrite(ledPin2,LOW);                      //le courant est coupé sur la borne 9, la LED  s’éteind
delay (500);                                    //pendant 500ms pour visualiser la coupure
}
if (comptageImpulsion == 4)
{
  (comptageImpulsion = 0);                      //le compteur se réinitialise à 0
}
else 
{
digitalWrite(ledPin2,HIGH);                     //le courant est envoyé sur la borne 9, la LED  s’allume
}

}

void gestionINT0()                              //la fonction appelée par l'interruption externe n°0
{
comptageImpulsion=comptageImpulsion+1;          //incrémente la variable de comptage
Serial.print("Nombre impulsions = ");
Serial.println(comptageImpulsion);              //permet de visualiser le nombre d'impulsion sur le moniteur série
}

Bonjour
ceci explique peut être cela ! :grinning:
teste çà

const int buttonPin = 2;                        //assigne le bouton à la pin2
const int ledPin = 8;                           //assigne la led 1 à la pin8
const int ledPin2 = 9;                          //assigne la led 2 à la pin9

int buttonstate = 0;                            //le bouton est initialement à l'état bas

volatile int comptageImpulsion=0;               //le compteur d'impulsions est initialement à 0


void setup(){
pinMode(buttonPin,INPUT);                       //entree numérique  2 
pinMode(ledPin,OUTPUT);                         //sortie numérique  8 
pinMode(ledPin2,OUTPUT);                        //sortie numérique  9
 
Serial.begin(115200); 
attachInterrupt(0, gestionINT0, RISING);        // attache l'interruption externe n°0 à la fonction gestionINT0()

}


void loop(){

buttonstate = digitalRead(buttonPin);

if (buttonstate == HIGH) {                       //si le bouton est à l'état haut

digitalWrite(ledPin,HIGH);                      //le courant est envoyé sur la borne 2, la LED  s’allume
}

int state= comptageImpulsion  % 4;  // modulo
if (state==3 )                    //Utilisation Modulo si le comptage d'impulsion est le 4éme 
{
digitalWrite(ledPin2,LOW);                      //le courant est coupé sur la borne 9, la LED  s’éteind
delay (500);                                    //pendant 500ms pour visualiser la coupure
}
                      

digitalWrite(ledPin2,HIGH);                     //le courant est envoyé sur la borne 9, la LED  s’allume


}

void gestionINT0()                              //la fonction appelée par l'interruption externe n°0
{
comptageImpulsion=comptageImpulsion+1;          //incrémente la variable de comptage
Serial.print("Nombre impulsions = ");
Serial.println(comptageImpulsion);              //permet de visualiser le nombre d'impulsion sur le moniteur série
}

Merci,
J'ai essayé le code, le probleme précédemment enoncé n'apparait plus, top!
L'incrémentation ne se réinitialise plus mais la coupure répond bien à une séquence définie, elle se produit toutes les "n" impulsions.

Un probleme apparait cependant:
en fonctionnement la sortie passe à l'état bas suivant le "delay" définit, mais au lieu de repasser à l'état haut et y rester jusqu'à la prochaine séquence, la diode scintille suivant un temps d'extinction égale à "delay" et un temps de clarté très court correspondant à.... je ne sais pas...
La sortie 9 ne reppasse à l'état haut qu'à la prochaine impulsion.

Bonjour,
j'ai trouvé une solution et j'ai un code qui fonctionne avec le modulo, j'ai rajouté une action qui réinitialise le comptage à zéro de manière à sortir du "if state ==3":

int state= comptageImpulsion  % 4;               //modulo
if (state==3 )                                   //utilisation Modulo
(comptageImpulsion = 0);                         //on réinitialise comptageImpulsion à 0, dès que "delay" est passé on sort de la fonction "if (state==3 )"
digitalWrite(ledPin2,LOW);                       //l'alimentation  est coupé sur la borne 9, la LED  s’éteind
delay (1000);                                    //pendant 1000ms pour visualiser la coupure
}
                      
digitalWrite(ledPin2,HIGH);                      //l'alimentation est envoyé sur la borne 9, la LED  s’allume
}

Merci encore.
Je vais pouvoir ajouter la partie du code ou la sélection des modes est dictée par un capteur analogique.

OK
le principal c'est que tu a maintenant bien compris l'usage du modulo :wink:

Bonjour,
oui mer ci je pense a voir compris le modulo, j'ai en tout cas réussi a dupliquer l'exemple et à faire fonctionner les autres modes.

Cependant, comme énoncé dans mon premier message, je souhaiterai que le fonctionnement général dispose de 4 modes:

  • mode 1 : le signal reste identique
  • mode 4 : on supprime un niveau haut sur 4
  • mode 3 : on supprime un niveau haut sur 3
  • mode 2 : on supprime un niveau haut sur 2

chaque mode étant sélectionné suivant la réponse d'un capteur analogique, tel que:

20<valeur<25 ------> mode 2
15<valeur<20 ------> mode 3
10<valeur<15 ------> mode 4
valeur<10 ------> mode1

Je souhaiterai ajouter une fonction qui permette de faire en sorte que:

  • lorsque le système a fonctionné en mode 2, il fasse automatiquement une séquence en mode 3, puis une séquence en mode 4 avant de retourner à la normale

  • lorsque le système a fonctionné en mode 3, il fasse automatiquement une séquence en mode 4 avant de retourner à la normale

ce, de façon a obtenir un retour au fonctionnement normal "plus soft".

Mais voilà, je n'ai aucune idée de la fonction à utiliser, de la façon de faire, ni même de l'architecture à donner au code.

bonjour
Il faut déjà différencier le mode one shot ou enchainé (BP/selecteur,autres)

hello
par curiosité, tu veux vraiment faire tourner un moteur 4 temps en supprimant des allumages ?
donc en laissant faire des compressions qui "n'explosent pas" ?
quelque soit les séquences de suppression d'allumage que tu vas programmer, qu'en est il des gazs comprimés qui sont ensuite expulsés dans l’échappement ? n'y a t'il pas un risque de les voir exploser dans l'échappement ?

je vais poster le code tel qu'il est aujourd'hui, c'est vrai que ma question n'est pas bien formulée.

dfgh
oui, en simplifiant c'est un peu le but.
Les coupures d'allumage sont légions aujourd'hui, que ce soit dans la moto ou dans l'auto. De prime abord utilisées dans le milieu de la compétition, elles sont également utilisées dans les véhicules sportifs.

Quelques exemple:

  • les shifters des motos, utilisés pour permettre de monter les rapports sans toucher à l'embrayage ni à l'accélérateur. Les coupures ainsi générées permettent, sur un délai très court "d'annuler" le couple en sortie moteur et facilitent ainsi le "crabotage" des vitesses.

  • le mode "launch control" ou "procédure de départ" qui permet de limiter le régime à une valeur définie tout en ayant l'accélérateur à fond.

  • les simples limiteurs de régime des moteurs essence...

Les exemples et applications sont extrêmement nombreux...

Il y a même le mode "ALS" pour Anti Lag System, qui, sur les moteurs suralimentés permet de décaler l'allumage en mettant du retard lors de la montée des vitesses, de façon à volontairement créer une combustion en dehors de l'enceinte thermique du moteur, juste en amont de la turbine du turbo, ce, dans le but de le faire tourner plus vite et ainsi bénéficier d'un effet "boost".

Donc, oui pour revenir à ta question, les gaz peuvent bruler dans l'échappement mais le risque n'est pas "important" d'un point de vue mécanique. Lors de l'ouverture de la ou des soupape(s) d'échappement, les gaz comprimés se détendent et ne s'enflamment qu'au contact de l'échappement chaud... la vitesse de combustion n'est pas importante et les risque de détérioration restes faibles... il est important de différencier la détente des gaz simplement comprimés, de la détente des gaz issue de la combustion sous pression...

Je vulgarise énormément, car cette partie thermodynamique fait partie de mon métier, je pourrait en parler des heures mais ce n'est pas le sujet.

Désolé du hors sujet.

Oui , çà permet d’être une bonne base commune

J'imagine que c'est très passionnant ? :wink:

ok, merci de tes éclaircissements.
pour le shifter, nous sommes dans l'ordre de quelques millisecondes.
avec le but de ne pas mettre les flancs des dents des pignons en charge et passer les vitesses sans débrayer.
mais sur la ligne de départ, "mettre les gazs" pour ne pas monter dans les tours.............,
quel régime moteur sur la ligne?
le gain apporté est réel ou c'est du théorique?

Oui avec un shifter on coupe « quelques » millisecondes…
sur une superbike 4 cylindres type sceamer calé à 180 degrés, avec un régime max limité (par coupure d’allumage aussi) à 15000tr/min, si tu monte tes rapports à 13000 tr/min tu coupe environ 50ms (en moyenne)… avec 2 allumages par tour ça te donne 26000 allumages par minute soit un allumage toutes les 2,3ms avec 50ms ça fait quelques coupures…

hello., ou en es tu dans ton système de coupures d'allumages?

ai prévu un selecteur de mode et un BP (et en attente de détails sur une sonde analogique).

si BP actionné, lecture du mode sur le sélecteur. si sélecteur à zéro, lecture sonde analogique
tant que BP actionné, le moteur est bridé selon le mode du sélecteur ou de la sonde.
au relachement du BP, le moteur reprends ses allumages progressivement en décrémentant les modes
avec 10 allumages par mode ( par exemple). l'action sur la led/bobine est identique à la durée de la commande envoyée par l'ECU quelque soit la fréquence de celle ci .

les copies d'écran ci joint ont été réalisée à 160 hertz avec un générateur de fréquences.
trace 0 est la fréquence de 160HZ, le mode est 4 et copie faite juste pendant le relachement du BP
image 1


image 2

image3

image4

est ce bien ce que tu cherches à faire ?