On y apprend comment tester un rotor et une tête d'allumeur, entre autres.
Ce module d’allumage
programmable a pour
caractéristiques :
fonctionnement
à partir de 4.5V jusqu’à
plus de 15V (négatif à la masse)
facilité
de saisie de la courbe d’avance
programmation
(via le câble USB fourni
avec le Nano) par tout PC
3
composants seulement ( +1 régulateur
en option) pour un coût total inférieur à 20€
Le
faisceau d’allumage doit être
classique (antiparasites, c’est à dire résistif) sinon l’Arduino est
perturbé !!!
On gère ici la courbe
d’avance en fonction du régime
moteur uniquement ce qui correspond à un allumeur à masselottes
d’avance centrifuge, SANS capsule à depression.
L’utilisateur entre les
chiffres en italique, puis la
compilation et programmation (téléversement en jargon Arduino)
s’effectue d’un clic avec l’environnement Arduino, en accès libre.
On notera que le dernier N
(7000t/mn ci dessus) fixe la
ligne rouge, c’est à dire la coupure de l’allumage
Pour les détails de
programmation de l’Arduino, voir
Nota : si la librairie
"TimerOne.h"est réclamée ,
son installation est expliquée dans la reference ci dessus.
Parametrage
Conçu pour un moteur 4 temps, il faut multiplier le nombre de cylindres
par 2 pour un moteur deux temps (variable Ncyl dans le sketch).
La première fois, on
entre :
— Ncyl = nombre de
cylindres
— AngleCapteur =
souvent 45° avant le point mort
haut allumage du premier cylindre, mais on voit que cet angle est
modifiable si nécessaire, par exemple suite à une légère erreur de
montage du capteur.
— CaptOn = 0 ou 1
selon le capteur (voir l’ Annexe
1 ci dessous)
— Dwell = 1 ou 2 ou 3,
ou 4, mais 2 est obligatoire pour
bobine à faible résistance, voir l’Annexe 5 pour les détails.
Le
Materiel
Ce boitier est la dernière version
en date
(module Bluetooth optionnel)
On notera les pistes protégées pour ces circuits de qualité pro.
Une autre version avec la liaison Bluetooth (optionnelle),
sans circuit imprimé.
Aepl-Duino_31_03_22
Schéma
electronique
****************************
L'IGBT
Irgs 14C40L étant obsolète, le remplacer par FGP3040 ou ISL9V5036 ou
équivalent***********************************
Du point de vue matériel,
il semble difficile de faire
plus simple car Arduino, capteur Hall et Igbt sont 3 composants
indispensables.Pour les batteries de 6V le régulateur ne doit pas être
monté.
Par contre si comme c’est
souvent le cas on utilise une
copie asiatique de l’Arduino Nano original ( Construit par Gravitech,
vendu 35 €, par exemple chez St Quentin radio http://www.stquentin-radio.com/prod... ) il est
prudent d’alimenter le Nano via un classique régulateur 7805 à 5V (
coût 0.25€)
Le "vrai " Arduino supporte
13V à 15V, pour les autres
c’est aléatoire...
Non indispensable en general mais recommandé en cas de parasites :
ajouter un condensateur de 1000µF /16V ou plus sur l'arrivée du 12V
Les
Options
Ralenti
régulé par ajustement dynamique de l'avance
On entre une valeur de ralenti, par exemple 800 t/mn,
et le logiciel maintient cette valeur, à + ou – 50 t/mn, en adaptant en
permanence l’avance à l’allumage.
Le ralenti tient sans avoir à pomper
à l'accélérateur comme habituellement.
En effet, à froid le mélange
air/essence se condense trop rapidement et il faut
ajouter de
l'essence, via les pompes de reprise, pour obtenir l'inflammation.
Essais de démarrage à froid (12°C)
avec lecture des t/mn et degrés d'avance au smartphone via Bluetooth.
Essais sans accélérer
À froid 750t/mn, avance
20° l'augmentation de l'avance permet d'enflammer ce
mélange pauvre Après 1mn 800t/mn
15° Après 2mn
850t/mn 12° Après qq mn
820t/mn 5°
Un avantage annexe du maintien du
ralenti à froid, sans utilisation des pompes de reprise, est que
l'on minimise le risque de noyage des bougies.
Multi-étincelles
Surtout utile
pour lutter contre le noyage des bougies, jusqu'à environ 2000t/mn, un
train de 3 puis 2 étincelles est généré.
Multi-courbes-Compte-tours
sensible
On peut ajouter
une ou deux courbes d'avance supplémentaires.Une solution simplifiée en
Annexe 6 utilise un simple potentiomètre.
Une meilleure
solution utilise un module Bluetooth et un smartphone.
Affichage du
régime sur le smartphone en unités de 10 t/mn, utile pour le règlage de
la carburation.
Jouer avec
l'avance
Toujours en
Bluetooth avec un smartphone, on peut faire +1degrès...+6
ou -1degrès ...-6 sur la courbe active.
Variantes et autres utilisations
Exemple de pilotage
d'un boitier à décharge capacitive (CDI)
Une adaptation performante
a été réalisée justement
pour prendre en compte la depression dans la tubulure d’admission par
un sympathique ( et compétent ) groupe de "Panhardistes"
Pour une vue d’ensemble de
cet allumage pour le
bi-cylindre Panhard ( lire "Article AECP" en premier).
Cette évolution la plus récente de l’AEPL/ AEPL-S ne
possède que des avantages par rapport à ses ancêtres en terme de
simplicité de réalisation, programmation, entrée de la courbe d’avance
et coût.
Avec un boitier plus compact et en fait si léger que l’ensemble est
fixé dans l’aile avec du Velcro.
Le bornier permet de connecter un potard à distance pour faire varier
l’avance "au vol".Voir Annexe 6.
Autre exemple de réalisation
Capteur sur vilo ou capteur dans l’allumeur ?
Pour un moteur à nombre de cylindre pair :Ncyl =
2, 4, 6, 8, 10, 12, 16... on a le choix, le nombre de cibles étant égal
à Ncyl / 2 sur le vilo et Ncyl dans l’allumeur.
Pour un mono cylindre, avec 1 cible on a une étincelle
perdue, ce qui est tout à fait acceptable.
Par contre si Ncyl = 3,5, 7 et 9 ( ?) il FAUT
necessairement un capteur dans l’allumeur et Ncyl cibles.
Comment ça marche
Uniquement pour les esprits curieux, ces commentaires
ne sont aucunement indispensables pour la réalisation du module.
Contrairement aux versions précédentes à base de Pic,
grâce à la puissance de l’Arduino, l’avance est calculée en temps réel
à partir des deux lignes de données de l’utilisateur ( N et Ang
) : on supprime la phase de saisie de la courbe avec un logiciel
spécifique (sous DOS) ainsi que la phase d’assemblage. Le programmateur
de Pic disparaît lui aussi.
La courbe d’avance est une suite de segments de droite
fixant l’angle d’avance en degrés en fonction du régime en tours/minute.
Dans setup(), la fonction Init() convertit ces couples
en deux tableaux de coefficients C1 et C2 . A chaque couple (N,Angle)
correspond un couple (C1,C2).
La période T est mesurée en microsecondes entre deux
passages de la cible devant le capteur au moyen de la fonction standard
micros().
La fonction principale loop() attend le front du
capteur pour calculer T, puis situer T sur le segment d’avance
approprié. Ceci permet d’extraire le couple (C1,C2) associé pour le
calcul de D
D = T*C1 + C2 ( ici encore l’équation d’une droite mais
dans le domaine temporel cette fois)
Le calcul du délai D à observer avant l’étincelle est
réduit à une simple multiplication suivie d’une addition.
Le temps de calcul à compenser se trouve dans tcor=
120/140 µs. Cette valeur a été retranchée de C2 lors de son évaluation
avant stockage. La valeur tcor a été mesurée avec un oscilloscope
numérique de precision.
La précision est correcte puisque à 7000 t/m, et 28°
d’avance, le délai théorique est 408 µs et le délai mesuré au scope est
410 à 415 µs.
A ce régime, 1° correspond à 28µs, l’erreur est donc
bien inférieure à 1°.
Si Dwell = 1,le temps de coupure de la bobine (donc
d’étincelle ) est fixé à 1 ms, ce qui maximise le temps de charge.
Pour Dwell = 2 ou 3, voir le détail dans l’Annexe 5.
Une interruption est générée par overflow de Timer1
toutes les secondes pour s’assurer qu’une étincelle a bien été émise,
sinon le moteur est considéré arrêté et le courant dans la bobine est
coupé. Si le moteur tourne, l’interruption de Timer1 commande le
rétablissement du courant dans la bobine après le délai Davant_rech,
calculé selon le type de dwell .
Concernant le schéma, la résistance de charge du
capteur est la résistance de PullUp interne de l’Arduino.
Et finalement ces 150 lignes de code C ( C-Arduino,
hors variables et commentaire) font nettement plus et plutôt mieux que
300 lignes de code assembleur (Pic) + 250 lignes de Basic pour la
saisie de la courbe d’avance...
Pour creuser les details voici le scan de ma doc, pas
très lisible mais on connait le dicton "Documentation is like
SEX : when it’s good it’s very good. And when it’s bad, it’s
better than nothing"...
Incorporé la fonction compte-tours sensible (et
affichage de l’avance) sur smartphone dans la version standard.Il
suffit de connecter un module Bluetooth avec 3 fils (+5V,masse et RX
sur la patte 11 de l’Arduino) et d’installer une simple appli sur le
smartphone, voir les explications dans le logiciel.
Ce compte-tours sensible est surtout utile pour les réglages de
carburation au ralenti.
Mai 2017
Une évolution avec 4 bobines crayon, pour 4 cylindres
uniquement. Voir AEPL-4bobines dans la même rubrique
Le 28/11/16 En option une version couplée en BlueTooth
à un smartphone pour afficher l’avance en degrés en temps réel.
Pas vraiment indispensable mais ce fut intéressant à
développer et aussi démontre la simplicité de mise en oeuvre d’une
telle liaison radio à moins de 5€
Le 11/11/16 En option un module de flash, LED 3W, pour
visualiser l’avance sur la poulie
Le 27/6/16 : suppression du délai de 2 secondes
entre mise du contact et démarrage.
Certain diront que c’est du luxe mais ce délai dû au
bootloader résidant tant tout Arduino peut être éliminé en supprimant
le bootloader : l’exécution du sketch démarre immédiatement à la
mise sous tension de l’Arduino. .
C’est expliqué dans l'article Arduino, debugging, et autres trucs
ainsi que la régénération du bootloader si une reprogrammation
est
nécessaire.
Le 31/5/16 :ajouté la fonction multi-étincelles,
en option, pour aider au dénoyage des bougies en ville.
Le 3/5/16 : ajouté la possibilité de programmer 2
courbes en plus, sélectionnées en connectant soit D8 soit D9 à la
masse.La Led L présente sur tout Arduino suit le courant dans la bobine.
Le 9/4/16 :c’est la version du 5/4/16 avec la
possibilité de connecter un potentiomètre de 100 kohms entre la patte
A0 et la masse. Relié par un fil au Nano, placé près du volant, il
permet de faire varier l’avance ’au vol’
Voir l’Annexe 6.
Le 5/4/16 :Nouvelle version permettant de choisir
entre 3 types de "Dwell"
Voir l’Annexe 5.
***Le 4/4/16 :Mise à jour des schémas
d’alimentation en 6V et 12V.
****References
Une excellente étude bien détaillée sur les
bobines :
Le capteur à fourche SR17-C est dit saturé : sa
sortie est à 0V en permanence et monte à 5 V lorsque une cible en acier
passe entre les fourches. Ceci est indiqué au logiciel par la valeur
CaptOn = 1, déclenchement sur front montant.
Inversement le capteur 1GT101DC est dit non
saturé : sa sortie est à +5 V en permanence et descend à 0 V
lorsque une cible en acier passe à moins de 2 mm de sa face avant. Ceci
est indiqué au logiciel par la valeur CaptOn = 0, déclenchement sur
front descendant.
Ces deux capteurs peuvent être alimentés soit en 5V
soit directement sur le +12V de la batterie.
Ce montage quand la poulie de vilo est accessible est à
préférer pour sa simplicité et sa precision comparés à l’implantation
dans l’allumeur.Ici le capteur 1GT101DC est non saturé et les deux
cibles en acier dans la poulie en alu déclenchent le front descendant.
Montage dit "en hachoir" ( très efficace pour happer un chiffon par
exemple et s’auto-arracher...) avec un capteur à fourche SR17 saturé.
Les deux dents en acier diluent le flux magnétique et le niveau monte à
5V, c’est un front montant.
Noter que la largeur des pales n’a
pas d’importance ici car le temps de charge de la bobine ( dwell ) est
géré par le Nano Arduino.
Rappelons que le capteur est calé à 45° avant le PMH sur le vilo et que ceci correspond à 22°5 allumeur.
Sur http://cb125k.lebonforum.com/t125-a... une moto
Honda 125, avec un kit d’allumage. Montage puis modification d’un
capteur SR17c chauffant à plus de 85°C.Notons que le capteur 1GT101DC
est donné lui pour 150°C.
Encore une moto Honda mais avec un AEPL-duino cette fois
Honda 125 CB S3 ( ou CBJ ) de 1976 équipée a l
’origine d ’un allumage a rupteur et batterie bobine en 6 volts.
" J ’ai totalement résolu les problèmes de coupure d
’allumage dû a des variations trop basses de tension électrique de la
moto en montant un élévateur- abaisseur de tension de marque POLULU
référence S7V7F5 qui fonctionne a merveille. J’ai également monté sur l
’alimentation de l ’élévateur-abaisseur de tension un condensateur de
470 micro farads, et maintenant quelque soit le voltage disponible sur
le faisceau électrique de la moto l ’Arduino est alimenté en permanence
en 5,15 volts sur sa broche 5V.
Annexe 2 : pourquoi un allumage programmable sur
un moteur préparé ?
Voici des résultats concrets obtenus après essais de
plusieurs courbes, par Cedric Lebocq, créateur de l’excellent logiciel
PowerDyn, sur une Mini de 90cv (celle des années 70 bien sur, donc déjà
bien améliorée et les chevaux supplémentaires sont difficile à aller
chercher !)
Annexe 3 : details de réalisation
Pour le version 6V, ou le "vrai Arduino marqué
Gravitech", supprimer le 7805 et connecter le +12V à la patte Vin.
Le capteur Hall peut rester sur la patte +5V ou sur
Vin, c’est comme on le sent.
Schéma de câblage pour la version 12V ( avec Arduino à
3€ ).
Exemples de prix :
Igbt 1.97€(Conrad...), 7805 0.25€ (Conrad...), capteur
Hall SR17 12.99€ (Conrad, Farnell...), Arduino Nano et son câble USB
environ 3€ (livré) sur le Net.
Annexe 4 : Doc Atmel 328P
Pour les courageux mais tout y est, les 600pages+ de la
datasheet de l’Atmel Mega 328P
D’abord quelques définitions : le Dwell est une
mesure du temps de recharge de la bobine entre deux étincelles .
Le Dwell s’exprime en % ou en degrès allumeur. Par
exemple, pour un allumeur Ducellier de R8G ou Alpine il est environ de
57° ce qui veut dire que sur les 90° de rotation d’une came à la
suivante, les vis restent fermées (donc la bobine se recharge) pendant
57°.
Une variante est de l’exprimer en %, soit 57/90, donc
environ 63%. Pour un allumage classique on règle indirectement le dwell
en jouant sur écartement des vis platinées : trop écartement, le
dwell est trop faible (le courant n’est établi que trop peu de temps)
et vice versa.
Ceci étant posé, on va utiliser "Dwell" ici avec un
abus de langage...
Quel dwell choisir pour
une bobine classique ( 3 à 4 ohms) ?
Pour aider dans le choix du dwell voici le resultat de
mesures effectuées au labo avec une bobine classique (
Delco Remy 3.7 ohms). On mesure le courant primaire I . La bobine
alimentée sous 12.2 V. Un generateur de créneaux de fréquence variable
permet de balayer de 1000 à 7000 t/m n.
Dwell 1 (1 ms de coupure),pour mémoire,
remplacé par 3 ou 4
Dwell 3 ( 1/3 Off, 2/3 On), type vis
platinées, suggéré comme option par défaut dans la pluspart des cas.
Dwell 4 (idem Dwell 3 jusqu’à 3100 t/
mn puis temps d’étincelle réduit à 0.5 ms au delà)
Pourquoi une telle chute de courant donc de puissance
dans l’étincelle quand le régime croit ?
La coupable est l’inductance de la
bobine (self de plusieurs milliHenry ) qui impose un temps de
montée au courant de plusieurs millisecondes.Comparable au débit d’un
robinet, limité, qui n’a pas le temps de remplir un reservoir avant la
prochaine vidange (étincelle).
Une solution simple mais qui fonctionne bien est de
limiter le temps d’étincelle à 0.5 ms, autrement dit démarrer plus tôt
la recharge de la bobine.
Vérifier que la bobine, plus sollicitée ne chauffe pas
exagérément (surtout pour les bobine sèches de type transformateur).
Quel dwell choisir pour
une bobine "electronique" c'est à dire inférieure à 3 ohms
Dwell = 2 obligatoirement!
Le courant n’est rétabli
dans la bobine que 3 ms avant
sa coupure pour l’étincelle : le temps de charge est fixe donc.Ce
mode est indispensable pour les bobines de faible résistance (0.5
à 3 ohm par exemple) dites aussi "électroniques".
Les autres modes de Dwell
feraient partir une telle bobine en fumée...
— Dwell = 1 c’est la coupure du courant 1 ms par cycle, qui est
acceptable si la bobine ne chauffe pas excessivement (cas des Ducellier
noir, par exemple).
— Dwell = 2 le courant n’est rétabli dans la bobine que 3 ms avant
sa coupure pour l’étincelle : le temps de charge est fixe donc.Ce
mode est indispensable pour les bobines de faible résistance (0.5 à 2.5
ohm par exemple) dites aussi "électroniques"
— Dwell = 3 ce mode est équivalent à l’allumeur classique à
rupteur (vis platinées), le courant est établi 2/3 du cycle et coupé
donc 1/3 du cycle.A utiliser avec une bobine classique qui chaufferait
trop pour le mode 1
— Dwell = 4 compense la chute de puissance dans
l’étincelle avec le régime.L’étincelle est limitée à 0.5 ms au delà de
3100 t/ mn.
Annexe 6 :Avance variable ’au vol’
Si l’on veut jouer à translater la courbe d’avance en connectant un
potard de 100 kohms entre A0 et la masse,
la tension mesurée entre A0 et la masse permet de se repérer :
— de 0 à 1V environ, courbe originale.
— de 1 a 2V environ, avance augmentée de delAv.
— plus de 2V environ, avance augmentée de 2*delAv.
L’unité d’augmentation de l’avance est la valeur delAV,
par exemple 1 ou 2 ou 3°.
Attention.....Pas de pleine charge avec trop d’avance,
danger pour les pistons...
Connecté et en test sur l’auto cela donne :
Boitier fixé dans l’intérieur de l’aile, au Velcro.
Pour dégrossir, sans trop tirer sur la bête delAv = 3°,
donc on translate la courbe d’origine de 3° et 6°.
Noter la limitation à 0° de 0 à 500 t/mn, car il faut
penser aux chevilles de nos camarades motards qui démarrent au kick...
Ce montage que l’on peut qualifier "d’à la Dubout"
fonctionne bien sur une Golf GTI...preuve qu’un Nano Arduino se
contente de peu !!! :)
Annexe 7 : Aepl-duino sur une Mini
Ludomini a concocté ce boitier de qualité de réalisation quasi
pro !!!
Noter la ’dent vide’ comme cible du capteur.C’est un moteur de Mini,
une de ses spécialités...
Annexe 8 : Banc d’essai
Réalisé par Jean Louis A ( MotoDniepr).
- Banc d’essai allumage AEPL-duino 6 volts, pour une moto Dniepr K750
(pouvant s’adapter facilement à d’autres motos Russes). Avec bobine 2cv
à étincelle perdue, platine réglable maintenant le capteur 1GT101DC et
rotor en alu contenant les 2 cibles (axe métallique rentré par frettage
). Le rotor étant fixé en bout d’arbre à cames sur la moto.
- disque gradué fabriqué avec un CD fixé sur un
épaulement tourné à l’arrière du rotor, permettant de vérifier l’avance
aux différentes vitesses, avec un stroboscope classique.
Annexe 9 : Module flash
Suivant l’idée de Christophe-Grouch4
Annexe 10 : Liaison BlueTooth
Le petit module HC05 BlueTooth est connecté au boitier d’allumage.
Le smartphone fonctionne sous l’application BluTerm qui émule un
terminal simple.
L’avance en degrés s’affiche en permanence
Annexe 11 : Un mariage impressionnant avec une
injection programmable
"Suite à la lecture de cet article , une envie de
moderniser un allumage programmable par "minitel 2 " qui est tombé en
panne ( puis réparé) ainsi que la bobine qui a cramé , le tout à cause
de l’oubli du contact .
Le montage d’une injection programmable récente sur un V8 ( 1500€
boitier + bobines) m’a permis de supprimer les 2 distributeur afin de
diminuer les pièces en mouvement et de gagner du poids (2Kg au total
environ).
Suite à ces 2 réflexions j’ai décidé de faire de même sur un bloc
Renault Cléon-alu de 1860cc qui est équipé d’une injection Haltech F9
depuis la fin des années 90 : supprimer l’allumeur/distributeur et
la bobine pour monter une bobine par cylindre et un Arduino Nano
programmé en conséquence en ayant comme point de départ l’AEPL-duino ,
le tout pour un coût de 310€.
Il est à noter que l’on peut presque diminuer le coût par 2 si on
change le type des bobines et que l’on ajoute quelques composants.
Le moteur a été démarré avec ce montage mais tout n’est pas finalisé ni
fiabilisé."
Avec 2 capteurs Hall, s’il vous plait, Alain Bertout
n’a peur de rien, comme de décaler de 90° la clavette du volant
magnétique pour inverser la polarité de la bobine par exemple...
L’allumage n’est pas ( encore ? ) programmable
mais on y trouve déjà une position 0° d’avance pour le démarrage.
Annexe 15 Un allumage programmable pour Fiat 500, une moto KAWASAKI 750 H2 (3 cylindres, 2 temps), une moto Kawasaki 500 H1
Richard ( pbarbusse@sfr.fr ) a "imprimé le boitier et
utilise une bobine deux sorties d’Harley Davidson " qui fait 4 et 5
Ohms suivant l’arrivage..."
Et un tableau de bord sur mesures
Richard récidive avec cette fois une moto légendaire,
la Kawasaki H2- 750 (2 temps , 3 cylindres).
"Ce petit mot pour te dire que j’ai
« adapté » l’APPEL-duino au moteur d’une KAWASAKI 750cc H2 2
temps (de ma jeunesse)
régime maxi 12500 trm DWELL 2 et 400µs (bobines 1.5
Ohm) après quelque tâtonnements sur les avances par rapport aux
différents régime la moto et devenue impressionnante de par son couple
et ses montées en régime.
Deux photos du boîtier d’allumage."
Notons le choix d’un Arduino par cylindre ce qui est
sage vu le regime de 12500t/mn.....
*************Une autre expérience par Bertrand Martin (martin.bertrand@free.fr) sur une Kawa H1 , qui a souffert de différences de qualité entre les Arduino.
"La reprise du câblage sous les Arduino + ajout de la capa 1000uf 50v + remplacement des Arduino (par des
elegoo amazon) ont résolu mon problème de parasite.
Il y a bien des différences entre les Arduinos.
J’ai acheté une autre marque sur Amazon avec connecteur en usb C après
avoir refait tout mon câblage . Ca ne fonctionnait pas correctement.
Un des 3 Arduino se mettait en défaut aléatoirement.
J’ai décidé de reprendre des arduino Elegoo en mini USB (un peu plus cher).
Et là, impecc.
Avant ces dernières modif, j’avais fait une autre platine. Un peu fouillis
je le reconnais, pour essais. Avec des Arduino Alliexpress.
Le moteur tournait bien mais au bout de 5min un des 3 se mettait en défaut.
J’ai d’abord soupçonné les capteurs hall qui sont positionné juste derrière
l’alternateur.
Je les ai remplacé par des capteur opto.
Même problème.
J’ai remplacé tous mes câbles d’origine qui allait des capteurs à mon
boitier par du câble LIYCY 0.75 blindé ( j’en ai plein au boulot).
Tresses de masse connecté que d’un coté relié aux GND des Arduino.
Il ne restait plus qu’à
reprendre mon câblage coté boitier, en passant tout les fil sous les Arduinos et le tour était
joué"
Annexe 16 Vespa 400
Un montage très soigné à double capteur sur Vespa 400.
Plus de détails dans l'article sur ce site:
AEPL
pour Vespa 400
Annexe 17 205 XS
Un montage de Young Timer sympathique...
"L'ensemble
fonctionne parfaitement après plusieurs kilomètres d'essais, j'ai pu
récupérer les chevaux perdu à cause de mon acien allumeur défectueux et
à moindre coût.
Ma 205 étant une XS pour 1360cm3 et 85ch
A
venir je compte faire évoluer mon moteur vers celui d'une rallye avec
une préparation.
Le
montage arduino me permettra de me passer d'acquérir un allumeur de 205
rallye."
Lors de la réfection et
préparation
de mon moteur, la question s'est posée naturellement:
Comment adapter l'allumage
à mon
nouvel arbre à cames?
En cherchant parmi les
systèmes
programmables souvent hors de prix, je suis tombé sur l'AEPL.
Je ne savais même pas ce
qu'était un
Arduino, mais j'adore le DIY ainsi que creuser des sujets alors je m'y
suis
collé, avec un cahier des charges assez précis:
-Gestion de la dépression :
fort
heureusement, les camarades Panhardistes ( voir ci dessus
en début d'article) avaient mâché le travail!
-Un montage le plus propre
et fiable
possible (pour ne pas transpirer à chaque sortie).
-Et le petit plus, la
possibilité de
récupérer un signal pour exploiter le logiciel Powerdyn (et
oui,
comment faire
des bonnes modifs sans voir leurs impact?).
Par souçi de fiabilité et
de
facilité d'adaptation, j'ai pioché dans l'énorme banque de pièces
détachées
automobiles.
Il faut avoir de
l'imagination:
-Pour passer le
distributeur en
effet Hall, un distributeur de Golf GTI 16V (qui m'en aura fait voir de
toutes
les couleurs: voir
les pannes diaboliques) et une tête de delco de
Peugeot 505.
-Pour le capteur à
dépression, un
capteur de colmatage de filtre à particules d'origine 1.6 HDI.
-Petite subtilité,
l'incontournable
IGBT a été remplacé par un module Bosch TSZ-H de Golf GTI, intégrant
une
limitation de courant et prévu pour fonctionner avec ma bobine
d'origine.
Et le fameux Arduino Nano!
Avec son
faisceau et son boitier (qui prends place dans l'habitacle sous la
boite à
fusibles).
Le code à été retiré de
tout ce que
je n'avais pas besoin (il n'en reste plus grand chose...).
Et voici le schéma de
principe:
Ca fonctionne à merveille !
L'auto se comporte bien
mieux, même
en courbe d'origine. Preuve de l'efficacité et de la précision de ce
système
DIY par rapport à un allumeur classique souvent fatigué.
Reste le plus sympa: jouer
avec les
courbes pour aller chercher les derniers chevaux !
belle mise en oeuvre et cela fait toujours plaisir
de voir un utilisateur satisfait...Je te cite :
"Petit bonus. Ayant la flemme de faire un disque
gradué pour caler précisément l’avance statique (45° entre top capteur
et PMH), j’ai calé au pif et démarré. N’ayant pas de lampe strobo
fiable, j’ai ajouté une LED de 3W allumée par l’Arduino au moment de la
coupure du courant bobine, elle sert de lampe strobo pour affiner le
calage."
Cette idée est excellent et te la pique
immédiatement....Elle doit permettre d’éviter le traçage du repère à
45° avant le PMH sur la poulie de vilo, suivi du calage en statique du
capteur pratiqué habituellement avec un voltmètre ou une Led.
Je pense l’utiliser comme suit : on programme
une courbe avec 0° à 1000 et 2000 t/mn par exemple.On met le capteur
non bloqué vers 45° avant PMH, au pif.On démarre ( en ajustant à la
main le capteur si nécessaire ) et quand le moteur tourne, on amène le
repère de PMH sur l’index du carter, soit une avance de 0°, toujours en
ajustant à la main le capteur.On bloque le capteur en position car il
est alors parfaitement à 45° avant le PMH.
Oui, c’est tout à fait ça. En fait je n’ai pas
eu à faire une courbe spéciale à 0° car sur une Fiat 126, il y a un repère sur la
poulie vilo et 2 repères lui faisant face sur le carter. Un à 0°
l’autre à 10° d’avance. la courbe de la Fiat est à 10° de 500tr à
12000tr je n’avais donc qu’a viser le repère 10° au ralenti.
Pour l’utiliser sur n’importe quel véhicule, le
mieux est effectivement de programmer une courbe à 0°. On peut se
servir d’une des courbes B et C sélectionnées par D8/D9.
Pour ce qui est du soft, voici ce que j’ai
fait :
D = D - tflash ;
[....]
digitalWrite (Flash, 1) ; // Flash de
calage
delayMicroseconds(tflash) ;
digitalWrite (Flash, 0) ;
digitalWrite(Bob, 0) ; //Couper le
courant, donc étincelle
digitalWrite(Led13, 0) ; //Temoin
Mais, à la réflexion, il aurait été tout aussi
simple de faire comme suit :
digitalWrite(Bob, 0) ; //Couper
le courant, donc étincelle
Bravo et merci pour le développement de cet
AEPLduino ! J’avais, il y a quelques années, commencé à monter un
prototype d’AEPL à base de PIC, mais je n’étais pas arrivé au bout (il
est assez frustrant de faire un montage sans maitriser le langage de
programmation utilisé !).
Je viens donc de démarrer ma Fiat 126 avec un
AEPLduino et ça marche super !!!
Pour le moment, j’ai programmé la courbe d’origine selon la RTA, il me
reste à l’optimiser et à trouver un boîtier un peu plus étanche.
Je lis avec un très grand intérêt vos differentes
rubriques et me suis laissé séduire par la fabrication d’un aeplduino
pour une moto flat Russe. L’appareil est sur son banc d’essai et j’ai
quelques questions à vous poser :
- La moto étant en 6 volts, j’ai une bobine de 6
volts de 1,5 ohms. Vous indiquez l’obligation d’avoir une bobine 6volts
d’au moins 3 ohms, je suppose pour ne pas griller le nano ou le IGBT.
Puis je rajouter une resistance balast de 1,5 ohms en serie à la
bobine ?.
- Malgrés tous mes essais dans la programmation du
Nano, je n’arrive pas à dépasser 15° d’avance à l’allumage à plein
régime, mon 1GT101DC étant, dans la programmation, à 45° du PMH et le
moteur etant un bicylindre flat à étincelle perdue type 2cv, les 2
cibles etant en fait un axe de 8mm noyé dans un rotor en alu
cylindrique, le tout fixé sur l’arbre à cames. Cette impossibilité à
dépasser les 15° d’avance arbre à came ( 30° vilo) est elle due à la
trop faible resistance de la bobine (1,5 ohms) ?, ou à autre chose.
- Une dernière question : est il possible de
supprimer, lorsque le moteur cale, la dernière étincelle qui survient
systématiquement 1 seconde apres l’arrêt du rotor cible ? et qui
dans une certaine phase du cycle du moteur est susceptible de
déclencher une derniere explosion un peu aléatoire. Ou bien cette
dernière étincelle est elle inhérente à la conception de
l’aeplduino ?.
eh bien ton enthousiasme fait chaud au cœur du
rédacteur de ces notes techniques, merci... !
Effectivement ce logiciel accepte tout nombre de
cylindres, avec possibilité de cibles sur le vilos si le nombre de
cylindres est pair mais l’allumeur est obligatoire pour les nombres
impairs ( sauf le monocylindre, pour lequel on génère une étincelle
perdue).
La prise en compte de la dépression par
l’Aepl-duino a été réalisée par une équipe de talent sur des moteurs
Panhard.
Ajouter une entrée venant d’un détecteur de
cliquetis ne poserait pas problème : on peut alors facilement
retrancher quelques degrés pendant quelques secondes.
Il y a quelques années nous nous sommes croisé sur
ce forum (ou par mail) je ne me souviens plus, à propos de L’AEPL pour
les 5 Cylindres Audi .... Je viens de repasser sur ton excellent site
web et je viens de découvrir l’AEPL Duino !!!! un mot résume ma
joie, mais ne peux l’écrire !
J’ai téléchargé le code, car j’ai lu nb de
cylindres sans forcement voir de limitations.
Dans le code j’ai vue que tu avais prévu le coup pour des moteurs
bancales (3, 5, cylindres) ..... :-) MERCI !
Je vais essayer sur mon 5 audi (2 litres atmo) dés
que j’aurais la voiture sous la main. En plus mon allumeur intégre déjà
un Hall, puisque c’est lui qui commande le module (TZ) d’allumage. donc
il faut juste que je vire le module et que je le remplace par
AEPL-Duino. (et l’avance à dépression bien sur).
En lisant ta doc j’aime beaucoup le potard qui
permet de décaler la courbe d’avance, comme j’ai aussi un 5 cylindres
Turbo (UR quattro) et que son module d’allumage (complexe) est rare et
pas modifiable je me posais la question de remplacer la consigne du
potard par un module MAP (qui me permettrait de décaler la courbe en
fonction de la pression ...) et donc éviter le cliquetis. ou de
switcher sur des courbes différentes (B, C) adapté au fonctionnement en
mode suralimentation ...
Vue ton code et vue cette fonction décalage ...
pourquoi pas également récupérer une info cliquetis pour éviter de
fumer les gamelles avec trop d’avance. en utilisant un module GM (20€)
qui traite le signal et qui fourni une info nettoyée parfaite pour
trigger une entrée du Duino. (déja vue ailleur, et je dois avoir la
doc).
Bref je me prend à rêver en ayant lu ton code (je
dois y revenir pour comprendre certaine chose) mais je vois pas
pourquoi ce ne serait pas possible.
Bonjour,
Ce site est une référence pour moi depuis déjà longtemps.
Mais là c’est le bonheur total !!! L’année dernière je me suis
interessé à l’arduino et au code (C++) dans l’espoir de réaliser un
allumage programmable sur la base d’un UNO. Mais ...... j’ai pas
réussis. Manque d’expérience et de connaissance.
Bref, j’ai passé plusieurs heures à lire votre code
avec beaucoup d’attention, et avec un grand sourire !
La bonne nouvelle (pour moi), c’est que la philosophie de ma tentative
de code était sur la bonne voie.
La mauvaise c’est que je comprends toujours pas bien le fonctionnement
des timers.
J’ai donc une question : la loop est cadencé à
quelle fréquence ? J’étais convaincus qu’il fallait appeler une
interruption hardware (pour la détection de la cible) pour être précis.
PS : un topics sur lequel j’avais partagé mon
projet http://forum.arduino.cc/index.php ?topic=307249.0
le rouge de la confusion s’étant effacé, je te
remercie de ces commentaires flatteurs mais venons en au fait :
dans la fonction principale (loop()),
effectivement je n’utilise pas les interruptions pour mesurer la
période du signal du capteur.Chaque fois que cela est possible, il est
plus sur et plus facile d’utiliser le polling (scrutation en bon
Anglais).Donc la première ligne de loop() attend tout simplement
l’arrivée d’un front.Quand il arrive, on calcul le délai avec le front
précédent, c’est à dire la période T.
L’interruption de Timer1 est utilisée, par
contre, pour définir le délai avant reconnexion de la bobine, variable
suivant le dwell désiré par l’utilisateur.
As tu jeté un coup d’oeil sur les 2 macros ps
et pv qui sont des points d’arrêt, vraiment utiles pendant la mise au
point ?
Elles sont expliquées dans
http://a110a.free.fr/SPIP172/article.php3 ?id_article=144
Bravo pour votre site et votre inventivité, c’est
un vrai régal de vous lire, je vous avez posé des questions sur aepl-si
et voici que vous sortez un nouvel allumage avec arduino nano.
Juste 2 questions sur le montage AEPL- duino avant
de me lancer :
Le montage fonctionne-t-il réellement en 6
volts ?
Ma bobine 6 volts a 1,9 ohms au primaire et 7,95
kohms au secondaire ( type 2cv ), cela peut il fonctionner en sachant
que la masse est négative ?. Le tout pour faire fonctionner un
allumage de bicylindre à plat latéral Russe de type Dniepr k750 qui n’a
même pas d’avance mécanique à l’allumage.
Voir 2 sites dont je n’arrive pas à inserer
l’URL :
Cb 125 k
le bon forum.com : adieu vis platinées bonjour effet hall
Pour tes site avec un copier/collé dans Google
je n’ai pas eu de problème d’accès, sous Chrome en tous cas.
http://cb125k.lebonforum.com/
http://www.est-motorcycles.fr/forum/viewtopic.php ?t=3126
pour l’oeil de Moscou
Ta bobine de 2 ohms environ sous 6V donnera 3A
ce qui est parfait.
Mes essais sous alimentation variable du Nano,
entrée directe sur la patte Vin (surtout pas de régulateur ) , et
mesure de la tension sur la patte 6 du processeur 328 P (Vcc) ont
donné :
— Vin =4.5V Vcc= 3.5V un peu juste pour la
précision de l’horloge à 16MHz du Nano, mais rien de vital (Noter que
le 328P fonctionne dès Vcc = 1.8V mais à 4MHZ seulement)
— Par contre dès que Vin = 4.9V, Vcc= 3.9V
et là c’est suffisant, donc tout doit aller bien même à 5V sur la
batterie.
Bonjour et un grand merci pour ce montage avec
Arduino !
J’y pensais depuis un bon moment, je regardais d’autres montages
Arduino d’allumages mais là ça paraît être l’idéal.
J’ai hâte d’essayer sur des motos : Triumph, Norton (anciennes),
voir sur le MAC.
C’est vrai que l’avantage du Nano (et autres) c’est qu’on le trouve
facilement et à petit prix.
Pour les composants il faut guetter les -20% chez Conrad ça revient
périodiquement, par contre le capteur à effet Hall SR17C-J6 est avec 7
semaines de délai en ce moment. Il doit y avoir moyen de trouver du
capteur automobile à prix raisonnable.
Ma préférence sur la moto serait de monter le capteur, comme en auto,
en bout de vilebrequin, et de conserver l’ancien allumage (coté
distribution) en dépannage éventuel...
Encore merci pour cette réalisation et de partager
le code !
Un allumage à chaque bout du vilo ? Bonne
idée, et le coté électronique dépannera le standard...
C’est à peine une boutade car sur la Berlinette
(1600S de 1971, 1796cc) je roule avec un Aepl standard depuis plus de
10 ans et c’est un des rares composant qui n’ait pas offert "une
opportunité d’amélioration", comme on dit pour les pannes dans le petit
monde Alpine....
Bonjour,
Le MAC pardon c’est http://www.motos-anglaises.com/.
Un allumage électronique en bout de vilo mais en conservant celui
d’origine en bout d’arbre à cames.
En attendant l’arrivée du Nano, j’ai fait
un essai statique avec l’Arduino Uno, ça fonctionne très bien, mais
c’est vrai que la (les) bobine(s) risque de chauffer à bas régime. Déjà
j’ai mis un temps plus long d’étincelle 3ms mais ce n’est pas suffisant
à bas régime et une mauvaise solution (à haut régime). J’avoue que je
ne sais pas si c’est compliqué d’ajouter un temps de dwell comme dans
certains programmes d’allumage, pour pouvoir utiliser des bobines
modernes à faible résistance ou simplement éviter sur des véhicules
anciens à faible puissance de charge de gaspiller de l’énergie
électrique.
Comme je l’ai mis sur le MAC il est
intéressant pour la courbe d’avance d’avoir une auto-régulation du
régime de ralenti, c’est juste quelques points en plus à ajouter aux
avances et régimes donc très facile dans ce programme.
Un exemple un peu grossier du principe :
//Au régime moteur de :
const int N[] = 0, 500, 600, 800, 900, 1000,
....................., 7000, 0 ;
//degrés d’avance vilebrequin correspondant :
const int Ang[] = 0, 0, 8, 12, 8, 12,
........................., 28, 0 ;
Le régime de ralenti va être régulé vers
900tr/mn, si le moteur veut descendre à 800 l’avance augmente ce qui
tend à l’accélérer...
ça fait plaisir d’avoir des
commentaires chiffré de surcroît sur ce montage !
Tu as bien raison pour la gestion du dwell, c’est à dire limiter à 3 ou
4 ms le passage du courant dans la bobine par cycle.Je l’ai réalisée
sur la version Aepl Jumo, je me cite :
"Contrairement aux bobines classiques
dont le primaire mesure environ 3 ohms, ces bobines jumo ont une très
faible resistance, de l’ordre de 0,6 ohm. Sous 12 volts, le courant
dans une bobine classique est de 4 A, mais 20A dans une bobine
jumo ! A cette intensité, la puissance dissipée dans une telle
bobine serait 20*12= 360W, traduisez qu’elle part en fumée en quelques
secondes ! La version standard de l’Aepl gère le courant en
l’interrompant 1ms seulement entre deux étincelles. Ici ce n’est pas
envisageable, donc il a été développé une gestion de courant plus
complexe : le courant n’est rétabli dans la bobine que 3ms avant
la prochaine étincelle, soit avec un délai de T-3ms après étincelle. La
constante de temps de ces bobines est faible, le courant monte
rapidement, quasi linéairement, à raison de 1.3A/ms environ. En 3ms on
atteint le courant maxi de 4A environ. La consommation globale des deux
bobines est proportionnelle au régime moteur, moins de 1A à bas régime,
et environ 2A à 6000t/mn. Après les premiers essais, l’algorithme de la
gestion du courant a dû être affiné pour tenir compte des
accélérations ! En effet, durant une forte accélération, la
période diminuant rapidement, il faut en tenir compte pour conserver
3ms de temps de charge. Si T est la période actuelle et Tprec celle
précédente, le délai est T-(Tprec-T)-3ms = 2T-Tprec-3ms
Inversement, à la deceleration,la
période augmente d’une période à l’autre, le courant est rétabli plus
tard, régulant le courant moyen dans la bobine."
Le problème est que je galère pour
programmer ça sur l’Arduino, les Timers se mélangeant un peu les
pinceaux. Donc patience, il va bien falloir que j’y arrive et si une
bonne âme veut m’aider (le code ne fait que 70 lignes, commentées) je
suis preneur...
Ta courbe auto régulée à bas régime me
donne l’idée de l’essayer sur l’Alpine pour régler les Weber un peu
plus pauvres au ralenti, et diminuer ainsi l’encrassement des
bougies... ??? Facile à essayer je te tiens au courant.
fonctionnement
à partir de 4.5V jusqu’à
plus de 15V (négatif à la masse)
Aepl-Duino_31_03_22
sur une Fiat 126, il y a un repère sur la
poulie vilo et 2 repères lui faisant face sur le carter. Un à 0°
l’autre à 10° d’avance. 