circuit de gestion du temps d’impulsions exernes

Bonjour, j'ai un soucis dans la création de mon projet: je travail avec un arduino MEGA 1280 et cet arduino doit générer une impulsion de 167µs, jusque la tout va bien, mais je veux que cette impulsion de 167µs soit transformée en une impulsion de 14 ms par un circuit externe (qui ne s'occuperai que de cela...) et voila je ne sais pas comment réaliser ce circuit externe surtout que je voudrais que dans la mesure du possible le temps d’impulsion soit réglable....

un exemple pour que vous compreniez ce que je veux exactement: dans le programme de mon arduino un temps est défini = 14 ms puis durant le programme, sur une broche de cet arduino une impulsion de 167µs sera envoyé et elle devra être transformée en une impulsion de 14ms si dans le programme de base 16ms aurait été défini alors l'arduino aurait toujours envoyé son impulsion de 167µs mais elle devra être transformée en une impulsion de 16 ms cette fois ci.

J’espère que c'est assez clair et si tel est le cas avez vous une idée de comment procéder?

Bonjour, tes explications sont assez confuses. Tu parles d'un "circuit externe", moi j'y verai un 2eme Arduino avec un affichage et une possibilite de reglage de l'impulsion de sortie. Boutons poussoirs, encodeur optique, potentiometre, petits cavaliers ou autres ! Maintenent il faut definir les tolerences de detection de l'impulsion de 167uS par l'Aduino2. S'il ne doit pas reagir si l'impulsion fait 166 ou 168uS mais bien si elle en fait 167, alors cela ne va pas etre facile. Si il est declenche par n'importe quelle impulsion, alors c'est facile. Quel est le but de ton application ? Jacques

Bonjour, et merci de ta réponse
alors tu as raison mes explications sont confuses je vais essayer d’être plus clair
en pièce jointe voici un chronogramme de ce que je désire.
Plus important mon circuit externe doit réagir a n’importe quelle impulsion.
Normalement mon arduino MEGA 1280 travail a compter des fronts montants en provenance d’un encodeur rotatif, il s’occupe aussi de l’envoi des ordres au bon moment.
Je m’explique: l’arduino méga compte les fonts montant d’un signal carré a 4000Hz et quand il arrive a 100 (par exemple) il doit ouvrir un injecteur pendant 14ms (l’arduino MEGA doit envoyer une impulsion, peut importe sa durée au final ) et quand mon fameux circuit externe verrai cette imulsion c’est lui qui se chargerai d’ouvrir l’injecteur pendant 14 ms.
je ne peux pas demander a mon arduino MEGA de gérer le temps de l’impulsion en plus car il a déjà beaucoup a faire, c’est pour cela que je veux confier cela a un circuit externe qui serait sous les ordres de mon arduino MEGA 1280.
Pour rajouter en difficulté je voudrais que le temps ou l’injecteur est ouvert soit réglable ( d’environ 2 ms a 50 ms)

l’idée de mettre un autre arduino n’est pas mauvaise, car en plus, je ne l’ai pas précisé, mais j’ai 6 injecteurs a gérer, a la base je voulais faire 6 circuits externes mais avec un arduino il y a peut être possibilité de ne mettre qu’un seul circuit de gestion du temps …

merci de vos réponses

chonogramme convertisseur d'impultion.jpg

croco01: ... c'est lui qui se chargerai d'ouvrir l'injecteur pendant 14 ms. je ne peux pas demander a mon arduino MEGA de gérer le temps de l’impulsion en plus car il a déjà beaucoup a faire, c'est pour cela que je veux confier cela a un circuit externe qui serait sous les ordres de mon arduino MEGA 1280. Pour rajouter en difficulté je voudrais que le temps ou l'injecteur est ouvert soit réglable ( d'environ 2 ms a 50 ms)

l'idée de mettre un autre arduino n'est pas mauvaise, car en plus, je ne l'ai pas précisé, mais j'ai 6 injecteurs a gérer, a la base je voulais faire 6 circuits externes mais avec un arduino il y a peut être possibilité de ne mettre qu'un seul circuit de gestion du temps ....

merci de vos réponses

bonjour si c'est pour obtenir une impulsion calibrée en sortie de 14 ms , un simple monostable basé sur un 555 fera l'affaire

Bonsoir, oui l'idée est bien d'avoir une impulsion calibrée mais variable. Car avec un NE555 certes je pourrais avoir 14 ms a la sortie mais pour changer de durée il faudrait changer de circuit externe (typiquement changer la valeur de la résistance avec un potentiomètre) moi je veux que ce soit l'arduino qui puisse changer la valeur de la durée. A votre avis c'est possible avec un NE555, cela m’arrangerai car ce bon vieux NE555 est pas cher et se trouve partout... bonne soirée

idée qui vaut ce qu’elle vaut :

pourquoi pas des compteurs programmable qui recevraient une horloge dont le facteur de division serait chargé par ta méga et déclenché sur son ordre ?
suis un peu étonné qu’on oublie de plus en plus les logiques TTL ou CMOS…
(surement là, réaction d’un vieux machin ! :wink: :wink: )

bonne soirée,
(tu cherches à gérer l’injection d’un V6 ? :wink: )

Bonsoir, en effet je souhaite gérer l'injection d'un V6, et pour dire la vérité les circuit CMOS et TTL m'ont l'air complexe... moi j'ai pensé a un MCP41100 (un potentiometre numerique) et un NE555 comme on me l'a conseillé. Je pense que c'est une solution qui fonctionne, bien que ça n'a pas l'air d’être la meilleure des solutions car il me faudra 6 NE555 et 6 potentiomètre numérique sans compter les condos, cela fait du monde a souder... je vais essayé de me renseigner sur les circuits CD4XXX et autres mais .... ça va prendre un certain temps Bonne soirée et merci de ta réponse

Salut,

Je pense qu'il manque quelques infos pour donner une réponse précise : est-ce qu'il s'agit bien de "mapper" une impulsion de 167 µS en 14/16 ms, ou bien de faire une conversion de fréquence (du coup f1 = 1000000/167 = 5988 hz en 1000/14 = 71 hz ?)

croco01: Bonsoir, en effet je souhaite gérer l'injection d'un V6, et pour dire la vérité les circuit CMOS et TTL m'ont l'air complexe... moi j'ai pensé a un MCP41100 (un potentiometre numerique) et un NE555 comme on me l'a conseillé. Je pense que c'est une solution qui fonctionne, bien que ça n'a pas l'air d’être la meilleure des solutions car il me faudra 6 NE555 et 6 potentiomètre numérique sans compter les condos, cela fait du monde a souder... je vais essayé de me renseigner sur les circuits CD4XXX et autres mais .... ça va prendre un certain temps Bonne soirée et merci de ta réponse

bonjour alors ton probleme est mal posé expose exactement ce que tu veux

ton impulsion de 167µs est à recurrence fixe ? d'où viendrait l'info d'etalement du creneau de sortie entre 2 et 50 ms ?

croco01: je ne peux pas demander a mon arduino MEGA de gérer le temps de l’impulsion en plus car il a déjà beaucoup a faire, c'est pour cela que je veux confier cela a un circuit externe qui serait sous les ordres de mon arduino MEGA 1280.

En plus je serais curieux de savoir ce que c'est que le "beaucoup à faire", parce que tu pourrais avoir 100 injecteurs à gérer que ça serait tout à fait possible

Avec quelques transistor en commutation et plusieurs résistances tu peux te débrouiller pour simuler une résistance piloter via Arduino pour gérer l'impulsion du 555

Bonjour a tous et merci de vos réponses.
Je vais essayer de répondre a tous le monde mais cela va être difficile…
Alors le but:
mon projet consiste a créer de toute pièce un calculateur moteur. Pour ceux qui l’ignorent ce petit appareil est destiné a gérer le moteur c’est a dire: injecter la bonne quantité de carburant au bon moment et d’allumer au bon moment chaque cylindre.(normalement un calculateur fait bien plus de choses mais moi je me contenterai du minimum)
Bref sur le moteur (un V6 essence 3.0L) il y a une “roue codeuse” ou un encodeur rotatif ? enfin bref je ne sais pas comment ce nomme ce composant mais c’est une roue perforée et en tout les cas cet encodeur est fixé a l’arbre a came donc donne la position des pistons en temps réel.
Cet encodeur fournit un signal carré (propre) de 6000Hz quand le moteur tourne a sa vitesse max et normalement 1000 a 2000Hz.
moi je veux que mon arduino puisse compter les front montants provenant de cet encodeur, et ouvrir les injecteurs (pendant 14ms) au bon moment, puis allumer les 6 cylindres dans le bon ordre.
Ça a l’air délicat ( et ça l’est) mais pour le programme l’encodeur est branché sur une broche d’interruption (broche n°2 sur l’arduino MEGA) et une fonction d’interruption incrémente une variable globale et donc je peux dans ma boucle principale mettre des conditions tel que:
Quand le compteur atteindra la valeur 10 il sera temps d’ouvrir l’injecteur n° 1 pendant les 14 ms
Quand le compteur atteindra la valeur 20 il sera temps d’ouvrir l’injecteur n° 2 pendant 14 ms
Quand le compteur atteindra la valeur 22 il sera temps de donner l’ordre a la bobine de commencer son chargement (car dans pas longtemps on aura besoin d’elle pour une joli étincelle dans le cylindre n°1)

etc…
vous l’avec compris en comptant les fronts montants je peux envoyer les ordres au bon moment. Cependant je ne peux pas me permettre de ralentir la boucle principale. Prenons un exemple:

Si je demande a mon arduino de gérer les temps d’injection par exemple, quand le compteur aura atteint la valeur 10 l’arduino ouvrira l’injecteur n°1 et attendra 14ms puis le refermera. Supposons que durant ces 14 ms (ou l’arduino est bloqué il ne peut rien faire d’autre, le compteur s’incrémentera car il est sur interruption mais c’est tout) j’ai besoin que l’arduino donne l’ordre a la bobine de se charger, et bien je devrais soit interrompre mon injection, soit attendre la fin de celle ci, ce qui peut être regrettable car l’étincelle arrivera trop tard, un manque de couple sur le vilebrequin ainsi que une grande quantité de gaz imbrûlé enfin bref pas bon du tout…
C’est pour cela que l’arduino ne doit donner que les ordres et laisser la gestion du temps a des circuit externe…
et la je fais appel a vous car je voudrais un circuit, qui, quand il verrai une impulsion provenant de l’arduino ouvrirai l’ injecteurs dont il a la charge, pendant 14 ms.
pour ajouter en difficulté je voudrais je la quantité de carburant soit réglable. donc que l’injecteur reste ouvert plus ou moins longtemps (d’ou la plage de valeur entre 2 et 50 ms)
Pour finir a sa vitesse de rotation maximal le moteur allume chaque cylindre environ 8 fois par seconde
donc l’injecteur doit etre ouvert 8.33 fois (précisément) par seconde.
En clair l’arduino fournira un signal carré de 8.33Hz (8.33 impulsions par secondes) et chaque impulsion devra etre transformée en un temps d’ouverture des injecteurs de 14ms.

Voila vous savez tout de mon projet.
Pour info la quasi totalité des autres soucis ont été plus ou moins réglés (notamment sur la gestion de la bobine HT) il ne reste plus que les injecteurs a gérer, et deux ou trois petit soucis sur le calage de l’allumage mais c’est en bonne voie.

Donc pour résumer:
comment feriez vous pour convertir une impulsion très courte en une impulsion de l’ordre de 14 ms (qui doit être réglable par l’arduino) sachant que cette impulsion va se répéter dans le temps (au maximum a 8.33Hz)

Merci et bonne soirée

Non mais tu te rends pas compte : la charge de travail est minimale pour le µC là ... 14 ms c'est une éternité pour un microcontrôleur à 16 mhz. Je t'assure que tu pourrais piloter 100 cylindres si tu veux ...

void loop() {

if(micros()>(DepartPiston+14000) digitalWrite(piston,LOW);

}

void Interruption() {

digitalWrite(piston,HIGH);
DepartPiston=micros();

}

Et encore ça c'est la méthode Arduino, si on commence à taper dans la manip directe de timer et de registre t'es précis à la µs ...

croco01: ... Bref sur le moteur (un V6 essence 3.0L) il y a une "roue codeuse" ou un encodeur rotatif ? enfin bref je ne sais pas comment ce nomme ce composant mais c'est une roue perforée et en tout les cas cet encodeur est fixé a l'arbre a came donc donne la position des pistons en temps réel. ...

Bonsoir t'inquiete pas , je ne suis pas ici le specialiste des ECU , mais beaucoup savent ce que cela englobe 8) Roue codeuse ou encodeur rotatif , ok ça peut etre la "meme chose" :grin:

cet "encodeur" (liens vers le "truc" ? :grin: ) delivre une info absolue ? , relative ? , signal en quadrature ? , ? En l'etat de tes recherches comment determine tu avec ce "capteur" son point zero, quelle resolution en ° le capteur ?

Bonsoir, merci de vos réponses demain je vous posterai un bout du programme que j'ai déjà edfectué vous pourrez sûrement m aider. Sinon mon encodeur est situé sous la tête de Delco, difficile de trouver des infos sur son fonctionnement sur Internet et il en parlent très peu dans la revu technique.,.. Quoi qu'il en soit c'est une roue d'un diamètre de 50 mm avec 120 perforations ( une seule piste) Chose importante pour pouvoir caler l allumage ils ont prévu une discontinuité dans la répartition des trous tout autour de la roue ) il manque quelques trous ce qui permet d'avoir une impulsion un peu plus longue à chaque tour. Cette roue est fixée à l'arbre à came (donc elle tourne 2 fois moins vite que le vilebrequin. Quand le régime moteur est à 6000 tr/min alors cet encodeur tourne à 3000tr/min (vitesse Max) sinon pour son branchement étant donné qu'il y a 4 fil j'ai pu trouver comment il se branche et visualiser le signal avec une carte d acquisition ( signal carré avec de beau fonts montants) Sinon mon arduino détecte bien les fronts montants et normalement ( mais je vérifierai ) il ne rate pas.

sinon vous me dite que l arduino pourrais gérer les temps.... Je n'ai pas trouvé de solutions viable pour programmer cela... Vous pourrez sûrement m'éclairer quand vous aurez vu mon programme . Bonne soirée et merci

Souvent ce sont des capteurs inductifs (en tout cas sur ma jaguar c'est ça) ou des fourches infrarouges (c'est ce que j'ai sur ma 307 d'après ce que j'ai compris du garagiste quand il m'a fait mon volant moteur ...)

Moi je n’y connais rien en ECU mais ce que je peux c’est qu’une période d’horloge à 16 MHz fait 62,5 ns
Devant 14 ms il y a de la mar:ge pour réaliser plein d’instructions !

Justement c’est le plein d’instructions qu’il faut quantifier.
Pllutôt que de se faire des nœuds préventifs au cerveau écris ce qu’il faut faire et ensuite il sera temps de contrôler si cela ralenti trop le micro, ce dont tout le monde doute.

Mes 1cts

Bonjour, alors voilà si apparemment le micro contrôleur ne sera pas surchargé alors il faut lui faire gérer les temps. Voici les contraintes a respecter: L arduino doit gérer les 6 injecteur (avec un temps d'ouverture variable pour injecter plus ou moins d'essence) Et il doit gérer l allumage: cela consiste a charger une bobine pendant 1,3 ms (précisément) et déconnecter cette bobine au bout de ce temps . Quand la bobine se retrouvera déconnectée il se produira une étincelle instantanément. Donc le cycle est le suivant; D'abord il faut réperer le point 0 ( pour caler l allumage ) 2) il faut commencer a compter les fronts montants en sachant qu au bout de 120 fronts montant le vilbrequin aura fait un tour. 3) il faut injecter l essence dans les cylindres: Selon une séquence définie ( par exemple quand le compteur arrive à 10 fronts montants on sait qu'il faut injecter le premier cylindre ...etc. ) Pareil pour l'allumage sauf qu'il faut de rappeler de charger la bobine 1,3ms avant le moment ou on veut l étincelle ( soit 12° avant le PMH a 4000 tr/min régime moteur) Moi j'avais prévu de faire incrémenter une variable globale par une fonction d interruption et dans ma boucle principale mettre une simple condition Si le compteur =10 alors envoyer une impulsion sur broche 3 ( qui commendera l'injecteur pendant x ms)

Mais sinon comment dois je procéder pour que l arduino gère les temps en plus?

Merci et bonne journée

PS: je vous poste mon code ce soir ça la je suis au boulot.

croco01: Mais sinon comment dois je procéder pour que l arduino gère les temps en plus?

Je te l'ai posté mis quelques posts avant ...

Bonjour, j’ai regardé le programme que tu as publié et sauf erreur, je ne vois pas comment tu déclenche l’injection.
Mon injecteur doit être déclenché périodiquement et pendant 14 ms.
Dans mon programme de base je remet a zéro mon compteur quand il arrive a 240. (car le vilebrequin a fait 2 tours et donc le cycle peut recommencer)
et donc je peux établir la séquence a générer ( avec une vitesse variable selon la fréquence des fronts montants)

//---------------------------------fonction LOOP---------------------------------------------------


 //-------------------------------RAZ de l'horloge: pour que 0 <horloge <240 ---------------------- 
  if (compteur = 240){
    compteur = 0;
  }
 //-----------------------------------------Fin RAZ horloge---------------------------------------



if (comptage % 10 == 0) { 
    digitalWrite(BrInjecteur1, HIGH); // envoi une impulsion sur broche 1 (injecteur 1)
  } else { // sinon
   digitalWrite(BrTinjecteur, LOW); //fin de l'impulsion
  }

//pareil pour les 5 autres injecteurs....


//---------------------------------FONCTION D'INTERUPTION---------------------------------------
void comptage(){
  
  
  
  compteur= compteur+1;
  
  
}//-------------------------------FIN FONCTION D'INTERUPTION------------------------------------

Qu’en pensez vous?
Sachant que j’ai la bobine a charger 1,3 ms avant l’étincelle… donc si je dois allumer le premier cylindre quand le compteur atteint la valeur 10 il faut que je prévoie d’envoyer le signal de charge 1,3 ms avant ce moment.
Merci et bonne journée