Bonjour à tous.
Je me prénomme Pierre, j'ai 37 ans, je débute sur arduino, j'ai fait quelque montages simple et j'ai récupéré les cours basiques arduino du collège ou je travaille pour avoir quelques bases.
J'aurai voulu avoir une explication sur le fonctionnement d'un programme : une version écrite par un ami et une version que j'ai faite moi même
Si mon post dérange ou si je n'ai pas posté dans la bonne rubrique n'hésitez pas à me le faire savoir et je supprimerai celui-ci.
Je suis passionné de véhicules ancien et youngtimer et j'ai fabriqué un boitier qui allonge le temps d'injection sur les injections DIGIFANT du groupe volkswagen, qui me permet de corriger la richesse du véhicule.
Le boitier fonctionne parfaitement sur base d'arduino nano.
le principe est simple, je lis le signal émit par le calculateur du véhicule, j'ajoute un temps supplémentaire à ce temps d'ouverture pour fermer les injecteurs un peu plus tard. Je peux régler ce temps sur la base d'un pourcentage d'enrichissement avec un potentiomètre et affiner avec une lecture afr large bande pour obtenir le mélange parfait selon l'utilisation (économie, puissance, mix)
Toutes mes variables et broches sont définies et ma version du programme fonctionne (en partie) sur mon véhicule. Celle écrite par un ami me pose problème, elle obtient pourtant de bon résultats jusqu'a une certaine limite de temps (ou régime ici).
Je m'explique :
Première version : sur mon programme, je scrute la broche de signal avec la commande while(digitalread=HIGH) ; je note le temps avec la fonction micros, j'active la broche de sortie. En même temps que je fais ça, je scrute si le signal passe à LOW toujours avec une fonction while, je note le temps quand il passe à LOW, je fais mon calcul de temps additionnel et je ferme ma broche une fois que j'ai ajouté ce temps additionnel au temps normal d'ouverture, et pour cela dans ce premier cas j'utilise la fonction delayMicroseconde.
Dans cette version, mon montage "fonctionne", c'est a dire que j'arrive à peu près à avoir des résultats escomptés, mais c'est pas parfait et même en augmentant la valeur de temps je reste dans une plage correcte mais pas optimale de richesse dans certaines conditions.
Deuxième version écrite : à la place d'utiliser delayMicroseconde, il y a une interruption avec la librairie TimerOne (que personnellement je ne maitrise pas encore), donc définition des variables et du Timer1.attacInterrupt pour la fermeture de la broche de sortie. Il y a donc à la place de "delayMicroseconde" un "Timer1.initialise" qui déclenche le compte à rebours, puis l'appel de la fonction et le Timer.stop qui va déclencher la fermeture de la broche de sortie.
Dans ce cas, j'ai des résultats parfait, jusqu'à ce que le temps total (temps allongé par le programme) déborde sur le signal suivant, c'est à dire que j'ai des coupures, exemple : arrivé à une certain régime, le temps ou la broche qui lit le signal du calculateur est sur LOW est plus court que le temps d'activation de la broche de sortie, et donc il ne prends pas en compte le signal suivant à cause du timer je pense.
Je ne sais pas si c'est clair et j'en suis désolé
Je voudrais savoir si il est possible pendant un timer de prendre en compte le signal d'entrée sans couper le signal de sortie et ainsi éviter ces coupures.
Je me tords l'esprit avec ça depuis un moment en essayant de lui dire que si le temps de coupure est plus court que le temps totale d'ouverture il doit reprendre au début, ou prendre en compte le moment de coupure plutôt que le moment de changement de signal pour faire le calcul mais je n'y arrive pas.
Si on pouvait me confirmer qu'avec le timer je ne peux pas faire ce que je veux, j'arrêterai de chercher midi à quatorze heure et me contenterai de ma version fonctionnelle imparfaite.
Sinon, si vous pouviez me mettre sur la voie, ce serait pour moi l'occasion d'en apprendre un peu plus sur l'utilisation du nano.
voici ce que ça donne sur la partie du code concernée, je n'utilise donc que deux broches du nano:
Ma version au fonctionnement pas parfait mais fiable depuis 3 mois (manque de richesse sous certaines conditions même si j'augmente le temps, surtout en pleine charge quand le temps d'injection est censé augmenté fortement)
La version avec timerone, parfaite jusqu'à mis régime en pleine charge, après il coupe car le timer déborde sur le signal suivant
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14 { while (digitalRead(Signal_injecteurs) == HIGH); //on capte le signal du calculateur pour l'ouverture des injecteurs debut_ouverture = micros(); //on note l'heure d'ouverture digitalWrite(Commande_injecteurs, HIGH); //on ouvre les injecteur digitalWrite(led_int, HIGH); while (digitalRead(Signal_injecteurs) == LOW); //le calculateur ferme les injecteurs, on les garde ouvert Fermeture_inj = micros(); T_inj = Fermeture_inj - debut_ouverture; //On calcule le temps d'injection ordonné par le calculateur T_sup = float(T_inj * Cor_inj); //On calcule le temps supplémentaire d'ouverture pour application de l'enrichissement delayMicroseconds(T_sup); digitalWrite(Commande_injecteurs, LOW); //Fermeture des injecteurs digitalWrite(led_int, LOW); Fermeture_injecteurs = micros(); }
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 { while (digitalRead(Signal_injecteurs) == HIGH); debut_ouverture = micros(); digitalWrite(Commande_injecteurs, HIGH); digitalWrite(led_int, HIGH); while (digitalRead(Signal_injecteurs) == LOW); Fermeture_inj = micros(); T_inj = Fermeture_inj - debut_ouverture; T_sup = float(T_inj * Cor_inj); if (Fermeture_injecteurs > debut_ouverture) { T_inj = (Fermeture_injecteurs - Fermeture_inj); T_sup = float(T_inj * Cor_inj); } Timer1.initialize(T_sup); } } void ISR_fermeture_injecteurs() { Timer1.stop(); Fermeture_injecteurs = micros(); digitalWrite(Commande_injecteurs, LOW); digitalWrite(led_int, LOW); }
Je vous remercie de m'avoir lu.
Pierre
Partager