Allumage électronique à 20€ !

Ici nous parlons de motos anglaises classiques.
Nous ne sommes ni un club ni une association. Ce site est le travail d'amis passionnés qui partagent leurs connaissances dans la convivialité et la tolérance. Ce site est ouvert à tous mais pour des raisons de transparence vous devez vous inscrire !!
Le site est gratuit et il grandit si chacun participe, vous pouvez tous participer soit par une page album sur votre moto, soit par un sujet technique lors d’une réparation, soit en scannant un catalogue …… Vous avez, ici, la possibilité de ne pas être un simple consommateur mais un acteur, merci de donner un peu de votre temps …

Modérateurs : Pachi, gigi, Tricati, Bertrand, rickman, Yeti

Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Une option de plus !

Grâce à Philippe Loutrel qui l'a mis sur son programme, j'ai ajouté multi-étincelles à bas régime (3 allumages pour le moment).
J'y avais pensé en lisant que par ex BMW faisait du multi-étincelles en particulier au démarrage et au ralenti, accessoirement ça peut permettre comme le dit Philippe d’empêcher les bougies de se noyer à bas régime en cas de carburation un peu trop riche.
Ça peut être utile pour nos motos, c'est une option supplémentaire que l'on peut donc enlever, même le régime limite (supérieur) est réglable par exemple 1500 tr/mn, au-dessus ça ne sert pas forcément et le temps peut manquer.

J'ai refait une mesure complète de toute la courbe ça ne ralentit même pas le calcul d'avance et je n'ai pas eu besoin de modifier le reste.

Il y aussi une sortie "stroboscope" à LED avec durée de flash réglable 100 μs, si besoin.

Multi-étincelles :

http://dtec.net.au/Multi%20Spark%20Ignition.htm

The late model BMW ignition scope patterns below show varied numbers of firings, they altered with temperature, rpm and running mode (i.e. cranking), above approximately 1500 rpm it reverts back to a single spark.
Les derniers modèles BMW d'allumage ci-dessous montrent un nombre variable d'allumages, ils ont changé avec la température, le régime et le mode de fonctionnement (c'est-à-dire démarrage), au-dessus d'environ 1500 tr / min il revient à une seule étincelle.
Image
BMW coil current during cranking, 9 sparks!

Image
BMW coil current at idle, 6 sparks

Courbe d'avance mesurée (option multi-étincelles en service)

Image
Avatar de l’utilisateur
Jagbruno
Messages : 1660
Inscription : 06 août 2010, 12:43
Localisation : Bruxelles
Contact :

Re: Allumage électronique à 20€ !

Message non lu par Jagbruno »

Génial! Félicitations à tous ceux concernés par ce magnifique projet!

Je suis impatient de le voir finalisé!

Par contre, quelque chose me dit que les problèmes pourraient bien venir plutôt des propriétaires, pas forcément capables de poser les bons choix de courbes pour leurs bécanes spécifiques... 8)

:mrgreen:




(J'en fais partie: j'avais un allumage programmable Sachse, super bien foutu d'ailleurs, sur ma Laverda et j'ai toujours hésité entre plusieurs courbes que j'essayais à tour de rôle sans parvenir à me décider)
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Oui le problème sera de choisir la bonne courbe d'avance à l'allumage.
Par sécurité il faudra mettre la courbe d'origine, et peut-être faire une courbe légèrement modifiée pour l'essence actuelle qui n'a plus les mêmes caractéristiques que celle des années 60/70 par exemple.
Il se peut que cela nécessite moins d'avance.

Après pour affiner ça dépend pas mal de la configuration du moteur, dont pas mal ont été modifiés, plus qu'en auto.
Par exemple une carburation trop riche nécessitera plus d'avance, ceci dit il vaudra mieux revoir la carburation que de modifier l'avance pour compenser.

Une utilisation riche mais optimale pour la puissance, pour du circuit, aura besoin de moins d'avance.

Une utilisation tranquille aurait besoin de beaucoup plus d'avance à bas et moyen régime, d'où l’intérêt de l'information de l'ouverture des gaz ou de la dépression pour automatiquement s'adapter au lieu de choisir une courbe et de ne pas penser à la modifier si on change de conduite.
J'espère pouvoir donner quelques repères en testant sur la Triumph T140, et plus tard sur la Norton.
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

C'était presque parfait alors j'ai cherché comment me compliquer la vie........ et j'ai réussi ! :mrgreen:

Tout allait bien et j'ai pensé utiliser cet allumage avec des bobines "modernes" à faible résistance de type automobile.
La résistance primaire est d'environ 0,5 Ω, la durée de charge mesurée à l'oscilloscope est de 5 ms (moteur Renault), avant la saturation car sinon le courant devient très important 13 A à 14 A ce qui pourrait les détruire rapidement. (2 bobines en série).

Il faut donc parfaitement maîtriser le temps de charge, contrairement aux bobines classiques à courant faible environ 3,5 A.
Et là le programme de l'allumage a un problème sur la bonne tenue du temps de charge en particulier à bas régime pendant les phases d'accélération et de ralentissement, le temps de charge varie parfois beaucoup temporairement.
Absolument sans conséquence avec les anciennes bobines à bain d'huile qui sont prévues pour des vis platinées, mais risqué pour les bobines modernes.

J'ai donc voulu modifier le programme pour le rendre très stable sur le temps de charge bobines, j'ai réussi mais j'ai foutu le "bordel" pour la gestion de l'avance ! :oops:
Et j'ai encore du mal à le rendre utilisable pour le moment.

Accessoirement j'ai quand même réussi à faire un allumage avec un très léger retard jusqu'à 150 tr/mn, l'avance n'est plus calculée, elle est fixe par la position du capteur à 0° (PMH),
ensuite jusqu'à 500 tr/mn elle est calculée à 0°,
puis à plus haut régime c'est la courbe programmée, avec choix de 5 et correction en roulant si on veut.

Ainsi absolument aucun risque de retour même si on kicke tout doucement ou mal en s'arrêtant avant le PMH.
La contrainte du démarrage au kick est plus importante que celle au démarreur, mais je pense que la solution est bonne maintenant.

Quel avantage des bobines modernes ?

L'inductance peut-être plus faible par exemple 6 à 7 mH, mais un courant nettement plus important permet une énergie emmagasinée plus importante et donc une durée d'étincelle plus longue ce qui devrait améliorer les démarrages même dans de mauvaises conditions.

Donc électriquement l'énergie c'est :
E = 1/2 L I², on voit l’intérêt d'augmenter I au carré, plutôt que L.
De plus L grand va augmenter le temps de charge, la constante de temps est T = L/R , il en faut au moins 3 pour être assez bien chargée, à 1 T on est à 63%. Mais comme R a aussi diminué le temps de charge est peu différent des anciennes bobines.

D'après ce que j'ai pu lire ou tester :
Une bobine Lucas doit faire 13 mH, (je pensais moins environ 7 mH), R = 3.7 Ω le courant est de 3,5 A, l'énergie serait de 79 mJ.
Le temps de charge est d'environ 7 ms. La durée d'étincelle sur la T140 était faible moins de 0,5 ms.

Une bobine Beru pour moteur Renault fait 6,3 mH, R = 0,45 Ω, le courant maxi pourrait être de 14A, mais il est limité à environ 10 A.
L'énergie devrait être de plus de 300 mJ.
Le temps de charge vérifié est limité à 5 ms, la saturation est vers 10 ms.
Le temps d'étincelle est long, mesuré à 2 ms.

Pourquoi ces bobines ?

Parce que j'en ai, que je peux faire des mesures facilement et qu'elles sont de faible diamètre, on peut les mettre sous le réservoir avec un câble HT court vers la bougie de nos motos.
Bobine crayon de marque Beru car elles sont fiables (pas comme certaines bobines françaises Renault Sagem ou Valéo !), le prix est mesuré 27€ car de grande diffusion.

Temps de charge bobine crayon moderne, à 5 ms on a environ 90% de I maxi, donc probablement au moins 10 A :

Image


Si vous voulez en savoir beaucoup plus sur les bobines d'allumage, et même sur des Lucas, lire ce document très détaillé :

http://hackerschicken.eu/electric/bobines.pdf

Et le site où il est aussi question de motos anglaises anciennes :

http://www.hackerschicken.eu/www/introFR.html
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Dernière option développée par Philippe Loutrel une connexion Bluetooth avec un Smartphone Androïd, on n'arrête pas le progrès !
Il faut ajouter un module H05 (environ 5€) à l'Arduino Nano.

http://a110a.free.fr/SPIP172/IMG/jpg/Sm ... ueTerm.jpg

http://a110a.free.fr/SPIP172/article.ph ... rticle=142

http://eskimon.fr/2498-arduino-annexes- ... ooth-hc-05

Mais si les "anciens" commencent à se connecter en Bluetooth avec l'allumage de leurs motos d'un autre âge, où va le monde !
(D'ici à ce que l'on trouve le pilotage au Tourit Trophy avec sa moto favorite, avec le casque de réalité virtuelle il n'y a pas des kms...)

Pour en revenir à l'allumage :

Il y a donc une version de 1 à 6 cylindres (voire plus), qui fonctionne très bien avec des bobines d'allumage "classiques" (faible courant) comme les allumages du commerce, ou les Lucas d'origine,
avec la possibilité de multi étincelles,
multi courbes d'avance programmable comme on le veut,
correction d'avance en roulant,
Led de calage statique,
flash Led effet stroboscope pour calage dynamique,
avance à 0° anti retour de kick au démarrage.
A noter que la courbe d'avance peut avoir un nombre assez important de points : 20, 30, etc. ça doit quand même un peu ralentir le temps de calcul de l'avance qui peut se compenser.
Pour des nombres impairs de cylindres comme 3, 5, il faut que le capteur soit obligatoirement en bout de distribution (comme d'origine avec les vis platinées), pour 1, 2, 4 cylindres on peut aussi le mettre en bout de vilebrequin avec une étincelle perdue.

Et je continue une version avec bobines d'allumage type auto, moderne, haute énergie, durée d'étincelle longue, avec un contrôle parfait du temps de charge bobine, idem pour le reste.
L'anti retour de kick est encore plus sûr car l'avance à 0° n'est plus calculée ce qui demande un régime de démarrage assez régulier, elle est physiquement imposée à 0° (léger retard avec le temps de charge bobine, environ 1 à 3°).
J'ai pu aussi supprimer l'étincelle perdue à la mise du contact.

Ça me prend du temps car je ne maîtrise pas le code (C, C++ adapté Arduino) et pour mon niveau la compréhension du programme est lente :oops:
Mais au moins je vais peut-être arriver à comprendre toutes ces subtilités !
Avatar de l’utilisateur
elmo
Messages : 10684
Inscription : 02 mars 2008, 00:42
Localisation : Colomiers/Toulouse

Re: Allumage électronique à 20€ !

Message non lu par elmo »

En tout cas bravo pour ce travail.....

Une fois que tu auras tout bien "calé".... Tu comptes faire des essais routiers de la dernière version du bouzin, j'imagine.
Avatar de l’utilisateur
Jagbruno
Messages : 1660
Inscription : 06 août 2010, 12:43
Localisation : Bruxelles
Contact :

Re: Allumage électronique à 20€ !

Message non lu par Jagbruno »

Encore bravo pour ce travail formidable, j'espère pouvoir d'ici peu équiper une ou plusieurs de mes motos avec ton système!
En ce qui concerne les bobines, j'ai une question (peut-être idiote): sur toutes mes anglaises, j'ai des bobines doubles (Boyer?) noires qui présentent l'avantage d'être très compactes et relativement résistantes..mais j'en ai quand même cramé une sur ma Norton :roll: ces bobines sont-elles compatibles avec ton montage?
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Merci Elmo, le plus gros a été fait par Phil. Loutrel au départ.

Oui il faudra faire des essais en réel, sur les autos et autres motos ça fonctionne bien avec la première version (AEPL) il n'y a pas de raison que sur nos motos se soit différent.
Ce qui peut changer c'est que les motos anciennes et anglaises en particulier ont pas mal été modifiées, que chaque moto risque d'être un cas particulier, conception moteur un peu différente, cylindrée différente, compression différente, arbre à came différent, carbu nombre et réglages différents, le plus sûr sera de partir d'une courbe d'avance connue avant de vouloir l'améliorer avec une prise de risque à ne pas négliger.

Pour la réalisation il faudra voir s'il y a du monde d'intéressé, le Nano se trouve très facilement, c'est la capteur Hall en petite quantité qui peut coûter plus cher en frais divers que le composant, une commande groupée serait souhaitable.
Sinon il y a des capteurs type auto ou moto qui pourraient être utilisés, ça serait plus simple. On n'en est pas encore là.

Ça tombe bien que ma version logicielle ne soit pas encore au point car la ferraille est bien froide en ce moment, et pas que la ferraille d'ailleurs !
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Merci Jagbruno

Oui compatible avec toutes les bobines car je le fais (enfin ma version) pour des bobines à très fort courant et qui nécessitent un parfait contrôle du temps de charge comme sur les calculateurs d'injection et allumage récent, c'est le plus contraignant, et à ma connaissance ça n'existait pas avec les allumages connus pour nos motos.
Les bobines Boyer sont certainement à résistance primaire pas trop faible, de l'ordre de 3 ohms voire plus donc pas de soucis.

Concernant le claquage d'une bobine : si la partie HT (fil de bougie, antiparasite) se trouve déconnectée (oubli ou essai etc.) la haute tension plus importante, normalement encore plus grâce à l'allumage électronique, va chercher un "chemin" pour l'amorçage.
Souvent c'est interne à la bobine, si c'est une classique à huile, l'huile qui circule peut arriver à auto-réparer le claquage de l'isolant, la bobine peut encore fonctionner. Mais si on recommence ça finira par être HS.

Avec une bobine "sèche" isolant solide, pas d'huile, si ça amorce en interne c'est très probablement définitif et irréversible, la bobine est définitivement HS.

A noter que sur des Magnétos il peut y avoir un éclateur à l'air libre (donc plusieurs mm car il n'y a pas de compression comme une bougie) qui permet un amorçage externe et ainsi sauver l'enroulement HT de la Magnéto.
Lire ici :
http://www.hackerschicken.eu/www/electr ... tricFR.php
Avatar de l’utilisateur
Jagbruno
Messages : 1660
Inscription : 06 août 2010, 12:43
Localisation : Bruxelles
Contact :

Re: Allumage électronique à 20€ !

Message non lu par Jagbruno »

Merci Michelm pour ces précisions et encore bravo pour ce formidable projet!!
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Il serait temps que je m'y remette un peu, quelques nouvelles infos :

J'ai vu que Trispark a mis une option pour modifier la courbe d'avance, c'est mieux :

http://trispark.blogspot.fr/

Image
The advance curve can be set with 11 points by simply dragging the dots on the curve or by entering the values in the boxes. The rev limit is programmable along with the coil dwell time making it compatible with a wide variety of large and small ignition coils.

Phil. Loutrel progresse de son coté avec

http://a110a.free.fr/SPIP172/article.ph ... rticle=152
Strobo Logger Afficheur
mardi 24 janvier 2017.

Ce stroboscope commandé par un smartphone Android (ou tablette) permet d’enregistrer les couples (N tr/mn, Avance en degrés). C’est la fonction Logger.

Ces couples, écrits en mémoire EEPROM sont relus et affichables sous forme de courbe par la fonction Afficheur.

L’utilisation de l’écran et du clavier d’un smartphone permettent de limiter au minimum le nombre de composants autour de l’Arduino.

Le coût total de ce stroboscope à mémoire est inférieur à 20€.
Vous avez remarqué tout est à 20€, pour rester abordable.

Ce stroboscope à LED permet donc avec l'Arduino et une connexion Bluetooth à un smartphone d'enregistrer les données et de tracer la courbe d'avance sur un fichier Excel... !
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

Enfin après des semaines, et de multiples essais, alors que j'allais abandonner, j'ai peut-être trouvé une version qui me satisfait.
Boileau avait raison :
"Hâtez-vous lentement, et sans perdre courage,
Vingt fois sur le métier remettez votre ouvrage,
Polissez-le sans cesse, et le repolissez,
Ajoutez quelquefois, et souvent effacez."

La difficulté est mon amateurisme certain pour la programmation et le code en C, C++ pour Arduino, j'ai bien cherché des conseils sur le forum Arduino mais aucune réponse pour bien m'expliquer et me donner quelques conseils sur le programme d'allumage.

Donc cette fois ce programme d'allumage déclenche un allumage instantané sans calcul d'avance, uniquement à 0° Point Mort Haut moteur au démarrage sous un seuil N démarrage de 150 tr/mn (réglable), donc de 0 à 150 tr/mn, aucun risque de retour de kick ou pour un démarreur et sa roue libre.
La cible et le capteur seront donc calés à 0° grâce à une LED (calage statique).

Ensuite, le régime moteur étant calculé à chaque tour moteur, s'il est supérieur à N dém mais inférieur à N limite (zone rouge régime maxi), donc de 150 à 7000 tr/mn par exemple, l'avance est calculée suivant les points de la courbe enregistrée, par exemple 10 points.
La limite de ma version semble être le nombre de points, 10 semble raisonnable, 14 comme au début c'est trop, il y des risques de ratés d'allumage à haut régime vers 6000 tr/mn.
Pas non plus de transmission de données par USB ou Bluetooth apparemment ça perturbe l'allumage à haut régime, l'Arduino semble être à ses limites de temps de calcul.

Autre avantage le temps de charge bobine, par exemple 5 ms pour une bobine moderne "auto" faible résistance, est strictement respecté dès le démarrage jusqu'au maxi.

Ce n'était pas le cas avant avec AEPL et mes autres versions dérivées, le temps de charge pouvait monter à plus de 100 ms au démarrage ce qui interdisait l'utilisation de bobine faible résistance qui aurait "cramée" probablement.
Il ne pouvait pas non plus avoir le capteur à 360°, et calculait l'avance dès les plus bas régimes il subsistait donc un risque de retour de kick...

Maintenant il va falloir mettre tout en boîte et trouver une solution de montage sur la T140, si possible avec capteur et cible coté primaire en bout d'alternateur...

Le code dans le prochain message sinon trop de caractères !
Avatar de l’utilisateur
michelm
Messages : 2461
Inscription : 14 févr. 2007, 12:48
Localisation : 63 Puy de Dôme

Re: Allumage électronique à 20€ !

Message non lu par michelm »

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 
}
Avatar de l’utilisateur
elmo
Messages : 10684
Inscription : 02 mars 2008, 00:42
Localisation : Colomiers/Toulouse

Re: Allumage électronique à 20€ !

Message non lu par elmo »

.... à vos souhaits :roll:
Avatar de l’utilisateur
momo
Messages : 221
Inscription : 28 janv. 2009, 18:50
Localisation : Bretagne

Re: Allumage électronique à 20€ !

Message non lu par momo »

Si j'ai bien compris de 0 à 150 t/mn il y a un léger retard à l'allumage égal au temps de calcul de l'arduino ?
Répondre