Version imprimable
Mais encore faut-il que tu puisse aller demander un sampling au moins une fois par période, tu ne crois pas ?Citation:
Envoyé par calitom
C'est cette ligne qui est "fautive" à priori :
car elle vérifie le temps "réel", et peut donc "sauter" des échantillons si elle a passé trop de temps dans le corps du "if". Il faudrait utiliser un timer et/ou un thread d'acquisition "pure".Code:if( Perio.force<=(tempsboucle-tps_force) )
C'est à dire? Qu'est ce qu'un thread d'acquisition "pure"? Je ne vois pas vraiment ce que tu veux que j'essaye de faire...Citation:
Envoyé par Mac LAK
C'est pourtant simple : ta boucle fait un polling sur le temps écoulé (contrôlé par l'OS, et indépendant de ton programme) par rapport à une limite prédéfinie (deadline).Citation:
Envoyé par calitom
Par exemple, si tu dois faire une acquisition toutes les 20 ms, et que l'exécution de ta boucle prends 21 ms :
- 1ère étape : acquisition.
- 2ème étape : delta = 21, donc on n'effectue pas l'itération => acquisition perdue.
- 3ème étape : delta < 1 ms, donc acquisition.
- 4ème étape : delta = 22 ms => acquisition perdue.
etc, etc, etc.
C'est encore plus vicieux si ton temps d'exécution d'une itération est (par exemple) de 10 ms, mais que tu te fais "piquer" la main par un autre processus... :twisted: En ce cas, tu devras attendre la fin du quantum de temps de l'autre processus, soit 100 ms de manière générale...
La solution passe en général par un thread de très haute priorité (TIME_CRITICAL), qui ne fait qu'un traitement simple :
- Récupération de l'adresse du buffer d'échantillons (passé en paramètre du thread).
- Passage en priorité maximale.
- Attente d'un évènement => le thread est suspendu.
- L'application finit de préparer les données, puis déclenche l'évènement.
- Le thread se réveille immédiatement, car il est de priorité supérieure.
- Il va acquérir les données, mais l'attente entre deux samplings se fait via un appel à Sleep plutôt qu'une deadline (vérifier le temps d'exécution du sampling, s'il est long, afin de ne pas introduire de dérive temporelle).
- Pendant le Sleep du thread d'acquisition, l'application peut s'exécuter. Tu peux utiliser un compteur de samples auquel tu accèdes via les fonctions "Interlocked*" si tu as besoin de récupérer les informations en continu.
- Lorsque le Sleep est terminé, le thread d'acquisition reprend (presque) immédiatement la main, car de priorité supérieure. On peut aider ce passage de main en effectuant des Sleep(1) dans l'application, par exemple.
- Lorsque l'acquisition est terminée, le thread déclenche l'évènement indiquant à l'application que les 1024 échantillons sont obtenus, puis se se termine.
- L'application n'a plus qu'à finir la destruction du thread.
Une autre solution peut être faite à l'aide d'un timer, mais suivant l'implémentation, ce n'est pas toujours très précis...
Je repose ma question : quelle est la fréquence d'échantillonnage ? Ou, pour être plus précis, la période d'échantillonnage ? Un sample toutes les milli, toutes les 10, 20, 200 ms ? Suivant la précision requise, l'une ou l'autre des solutions sera préférable...
Tu comprends un peu mieux ?
A vrai dire, je ne sais pas vraiment quelle est la fréquence d'échantillonage... Ce que j'ai réussi à comprendre, c'est que l'acquisition sur un capteur se fait à chaque appel d'une des fonctions du type:Citation:
Envoyé par Mac LAK
Ces fonctions font l'acquisition. Ci-dessous, la fonction Lecture Deplacement():Code:
2
DEPLACE; correspond à ce code:Code:
2
3
4
5
6
7
8
9
10
La fonction AISampleChannel, fournie par LabWindows, fait l'acquisition sur la carte numéro "2", sur la voie "1", avec 10V max et 0V min, et range la valeur acquise dans Capt.deplace[1].Code:#define DEPLACE AISampleChannel (2, "1", 10, 0, &Capt.deplace[1]);
Ainsi, je pense que la fréquence d'acquisition dépend de la vitesse d'éxécution du programme. Mais c'est ce que je pense avoir compris...
Oui, c'est ça.Citation:
Envoyé par calitom
Exemple caractéristique : l'appel à la fonction "Timer()" (elle fait quoi, d'ailleurs, cette babasse ???), qui manipule des flottants en plus (monumentale erreur).
Admettons que la ligne suivante :, qui est une mesure de temps par deadline, soit exprimée en secondes : ça fait donc 20 ms. Il est beaucoup plus rapide et précis d'utiliser l'API Win32 et la fonction GetTickCount() à la place !! Que des entiers, précision à la milliseconde, gain de temps d'exécution important (les flottants renvoyés par Timer() sont forcément, d'une manière ou d'une autre, calculés à partir d'entiers), etc...Code:if((Timer()-tempsdeb)>0.02)
Même topo pour cette ligne :.Code:if( Perio.force<=(tempsboucle-tps_force) )
Bref, arrange ça, tu vas déjà gagner pas mal de performances.
J'avais deja penser aux timer, mais je n'étais pas sur que ca venait de la...
Je vais essayer avec GetTickCount alors...
En tout cas, merci beaucoup de ton aide...
Je te tiens au courant du résultat...