Sur un 4 cylindre (90° =360/4) F sera l'angle pendant lequel le contact est fermé et O l'angle pendant lequel il sera ouvert. Chaque moteur aura son optimal
zoilgust:
Oui mais je stocke comment ?
Une boucle ? Tant que je n'ai pas 8 CHANGE je stocke dans des variables ?
Ces 8 CHANGE = Temps total ?
Il te faut juste stocker les durées d'etats entre les "changes" (et ensuite faire de la discrimination) et comme AMHA (par ... intuition/expérience ) il y aura plus de 8 "changes" par rotation de 360° sur ton rupteur , il faut aussi déjà penser à intégrer les notions d’anti rebonds/hysteresis 8)
Pour le filtrage, je vous conseille le montage que je vous ai donné à la réponse #12.
Pour le stockage des données :
Sur l'arbre menant: il y a une information par tour elle sert à :
mesurer la vitesse de l'arbre menant,
donner un instant de référence pour les autres mesures.
Sur l'arbre mené, il y a 4 informations par tour (dédoublées par les ouvertures/fermetures). Par le jeu des interruptions Arduino, on relève les temps auxquels ces informations apparaissent par rapport à la référence.
Il faut donc deux interruptions :
la première pour enregistrer le temps de référence de l'axe menant (sur front montant ou descendant)
la deuxième pour enregistrer les commutations de la came (sur front changeant)
et on recommence à chaque tour.
Bien évidemment, vous n'aurez pas les mêmes résultats à chaque tour à cause des incertitudes de mesures. Il faut introduire un système de filtrage. Du type de celui-ci dépend le nombre d'informations à stocker.
Pour un filtre passe-bas, il faut que chaque information soit conservée une fois. C'est-à-dire qu'à chaque tour, on aura à disposition :
les mesures sur le tour précédent,
les mesures sur le tour courant.
Si, au lieu d'un filtrage, vous faites un lissage, alors, il vous faudra autant de paquets de mesure que l'opérateur de lissage en demandera (un dizaine en général).
par contre est-ce que je peux faire plusieurs interruptions avec la même pin du type :
const pinILS1 = 2
byte comptageILS1 = 0; //pour recuperer le temps du FALLING
byte comptageILS2 = 0;
byte comptageILS3 = 0;
byte comptageILS4 = 0;
etc...
attachInterrupt(pinILS1, interruptILS1, FALLING);
attachInterrupt(pinILS1, interruptILS2, FALLING);
attachInterrupt(pinILS1, interruptILS3, FALLING);
etc ...
void interruptILS1 {
comptageILS1 = 0; // recupere le temps de l'interruption 1
}
void interruptILS2{
comptageILS2 = 0; // recupere le temps de l'interruption 2
}
void interruptILS3{
comptageILS3 = 0; // recupere le temps de l'interruption 3
}
etc...
etc...
ou alors passer par le CHANGE et le digitalread, mais je bloque sur un bouclage pour stocker 4 temps d'interruption.
punaise je pars de loin ...
const pinILS1 = 2
byte comptageILS1 = 0; //pour récupérer le temps du FALLING
byte comptageILS2 = 0;
byte comptageILS3 = 0;
byte comptageILS4 = 0;
etc...
attachInterrupt(pinILS1, interruptILS1, CHANGE);
void interruptILS1 {
if(digitalread = LOW){
for (un bouclage ?)
comptageILS1 = 0; // recupere le temps de l'interruption 1
comptageILS2 = 0; // recupere le temps de l'interruption 2
comptageILS3 = 0; // recupere le temps de l'interruption 3
comptageILS4 = 0; // recupere le temps de l'interruption 4
et un calcul qui prend le temps total
}
}
ChPr:
Faites le montage décrit sur le schéma ci-joint. Une capacité de 4.7 ou 10 nF convient bien. Pour cette application, n'importe quel type de condensateur convient. Ce qu'il faut, c'est qu'il soit bien au plus près des bornes de l'Arduino.
mouaif ... j'ai l'impression de tourner en rond ...
ça ressemble à quelque chose ?
//declaration de variables
//variable etat = low
//variable temps = 0
void setup() {
//pin 2 en OUTPUT
//serialbegin(9600)
//un attachinterrupt qui prend en compte les CHANGE => tick
}
void loop() {
//recuperation de la variable dans tick
// si variable etat = low => il compte le temps => stockage var 1
// si variable etat = high => il compte le temps => stockage var 2
// si variable etat = low => il compte le temps => stockage var 3
// si variable etat = high => il compte le temps => stockage var 4
etc ...
etc...
//totalise toutes les variables pour avoir le temps total (var 1 + .... + var 8)
//converti en angle chaque temps de fermeture (high)
//affichage de la var 2 qui sera une fermeture (high)
//affichage de la var 4 qui sera une fermeture (high)
//affichage de la var 6 qui sera une fermeture (high)
//affichage de la var 8 qui sera une fermeture (high)
//delay 500
}
void tick() {
//un digitalread qui lit le signal
//stockage de cet etat dans la variable etat
}
Ce que vous avez écrit en langage symbolique puis traduit en C montre que vous n'avez pas vraiment assimilé la philosophie du fonctionnement des interruptions.
Je ne peux que vous inviter à revoir cela en tapant par exemple dans votre moteur de recherche :"Arduino les interruptions matérielles" et de lire et chercher à comprendre la philosophie de la chose sans pour l'instant chercher à détailler plus précisément.
Une fois que vous aurez assimilé ce principe, vous verrez que son application vous paraitra plus claire.
Pour résumer :
une interruption c'est une entrée matérielle de l'Arduino
quand il y a un changement dans cette entrée, l'Arduino effectue une tache courte (ISR) consistant principalement à noter le moment où cela s'est produit
Après, dans le fonction loop(), l'Arduino va scruter cycliquement les données que l'ISR a modifiées et faire les traitements appropriés.
Dans les liens que vous trouverez sur internet, cela vous sera expliqué de différentes manières. Il y en aura certainement une qui fera "tilt" chez vous.
