hbachetti:
Aucun contact n'est parfait. Il y a des rebonds.
Des rebonds, ok, je les filtre avec une resistance et un condo.
La variable EtatCaptPiste n'etant pas remise a zéro, le compteur ne devrait s'incrémenter que de 1, non ?
Il y a un délai entre l'interruption (qui positionne la variable à 1) et le routine qui détermine si il y a eu interruption pour incrémenter le compteur. Tu peux rater des interruptions.
Pourquoi ne pas faire directement, sous interruption :
EtatCaptPiste est bien déclarée volatile?
On suppose que tu la remets à 0 après avoir incrémenté le compteur. Si ta boucle de traitement est rapide tu peux parfaitement attraper 2 interruptions consécutives. Il faudrait avoir plus d'information sur le matériel et la constante de temps de ton filtrage des rebonds.
fdufnews:
EtatCaptPiste est bien déclarée volatile?
En effet, EtatCaptPiste est bien déclaré volatile :
//Initialisation des variables de lecture d etat des entrees
volatile int EtatCaptPiste = 0;
fdufnews:
On suppose que tu la remets à 0 après avoir incrémenté le compteur. Si ta boucle de traitement est rapide tu peux parfaitement attraper 2 interruptions consécutives. Il faudrait avoir plus d'information sur le matériel et la constante de temps de ton filtrage des rebonds.
fdufnews:
La variable est remise a zero 5 secondes apres son activation :
if(EtatCaptPiste ==1)
{
CurrentCaptPiste = millis();
if ((CurrentCaptPiste - RaZEtatCaptPiste) >= 5000)
{
RaZEtatCaptPiste = CurrentCaptPiste;
EtatCaptPiste = 0;
OldCaptPiste = 0;
}
}
Point de vue matériel, le capteur est branché en pull-up sur l'entree de l'arduino. C'est un capteur ILS qui est embarque sur un mobile. Il detecte le franchissement d'une boucle magnetique dans le sol.
Le filtrage est assuré par :
10nF et 10KΩ cela donne une constante de temps de 100µs.
C'est probablement insuffisant comme anti-rebond. En général on filtre à 10ms ou même 50ms en fonction de la qualité du contact.
hbachetti:
10nF et 10KΩ cela donne une constante de temps de 100µs.
C'est probablement insuffisant comme anti-rebond. En général on filtre à 10ms ou même 50ms en fonction de la qualité du contact.
Ok, je vais augmenter la constante de temps.
Pour autant comme le dit fdufnews, dans un délais de 5 secondes, le compteur ne devrait pas s'incrémenter de plus de 1.
C'est ce que je ne m'explique pas ....
Tu ferais bien de mettre l'ensemble du code parce que là on ne voit que des portions qui semblent indépendantes les unes des autres. En particulier le comptage et la désactivation.
De ce que je vois actuellement, une IT arrive tu incrémentes le compteur mais tu vas attendre 5s avant de mettre à jour EtatCaptPiste et OldCaptPiste donc pendant tout se temps ils sont différents et tu peux compter.
fdufnews:
Tu ferais bien de mettre l'ensemble du code parce que là on ne voit que des portions qui semblent indépendantes les unes des autres. En particulier le comptage et la désactivation.
De ce que je vois actuellement, une IT arrive tu incrémentes le compteur mais tu vas attendre 5s avant de mettre à jour EtatCaptPiste et OldCaptPiste donc pendant tout se temps ils sont différents et tu peux compter.
Le programme étant assez long, je mets en fichier joint la sauvegarde du programme
moi pas tout compris : où, dans ton code, "EtatCaptPiste" est-il mis à jour ? tu ne fais que le mettre à '1' ou '0' "à la main", mais jamais il n'est lu sur une quelconque entrée ?
après, j'ai pas chiadé la lecture jusqu'à vérifier s'il est possible d'avoir un double comptage, je n'ai fait pour l'instant que choufer les modifs sur cette variable
La logique de verrouillage est erronée. Tu comptes le temps d'inhibition par rapport à la dernière remise à zéro alors qu'il faudrait la compter par rapport à la date du dernier comptage.
Tu dois mémoriser millis() lorsque tu incrémentes le compteur et c'est ce temps que tu dois utiliser dans la condition pour remettre EtatCaptPiste à zéro.
Tout ça me parait bien compliqué.
Il suffit d’incrémenter dans l’interruption comme le propose biggil et de n’incrémenter que si le temps depuis la dernière incrémentation est supérieur à 5s (pourquoi 5s? ça parait énorme)
void FaireIncrement()
{
//**********************************************
// Acquisition capteur boucle de chronometrage *
//**********************************************
static unsigned long lastMillis=0;
if (millis()-lastMillis<5000)
return; // filtrage à 5s
Compteur += 1;
lastMillis=millis();
}
Pour recadrer un peu tout ça ...
Le Mobile que je surveille, se déplace à une vitesse relativement élevée, ce qui a pour conséquence que l'ILS qui détecte son passage sur la bande magnétique est furtive (de l'ordre d'une dizaine de millisecondes, et les rebonds qui vont avec).
D'où l'utilisation d'une interruption et de sa fonction associée pour voir les changements d'état.
La fonction appelée :
void FaireIncrement()
{
//************************************
// Acquisition capteur boucle de chronometrage *
//************************************
EtatCaptPiste = 1;
}
Ensuite, pour éviter de comptabiliser les rebonds, je pensai utiliser un front montant pour ne voir que la première transition de la variable EtatCaptPiste
//Detection du front montant capteur piste
if((EtatCaptPiste != OldCaptPiste) && (EtatCaptPiste == 1))
{
CptBoucle++;
}
OldCaptPiste = EtatCaptPiste;
Et pour terminer le traitement, la variable EtatCapt Piste est remise à zéro 5 secondes après son activation
if(EtatCaptPiste ==1)
{
CurrentCaptPiste = millis();
if ((CurrentCaptPiste - RaZEtatCaptPiste) >= 5000)
{
RaZEtatCaptPiste = CurrentCaptPiste;
EtatCaptPiste = 0;
OldCaptPiste = 0;
}
}
Ce que je n'arrive pas à comprendre, c'est comment le compteur (CptBoucle) peut s'incrémenter de 2 alors que son traitement est verrouillé d'un tour de cycle sur l'autre.
@Restani - depuis le temps vous auriez pu lire comment poster correctement.
Merci de corriger votre post ci dessus et rajouter les code tags autour du code: [code]`` [color=blue]// votre code ici[/color] ``[/code].
ça doit ressembler à cela:// votre code ici
(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)
Le traitement de l'IT n'est pas verrouillé. Lorsque tu quittes faire incrément les interruptions sont activent, si un rebond se produit une nouvelle IT est mémorisée.
Comme le dit kamill c'est compliqué.