Discussion :

[Baxter67]

Bon je vais vous faire part de ma stupéfaction ...

dans mon appli je compte le temps qu'une info est a 1 ou a 0 (lecture d'entrée digital sur une carte PCI). Bon sa sa va.

Donc toute les seconde j'incrémente une variable si l'info est a 1, et j'incrémente une autre si elle a zéro.

Donc jai deux variable une qui indique le temps en seconde ou linfo a été a 1 et l'autre quand elle été a zéro.

En metant ces incrémentation dans un thread avec un sleep, jété pas très précis.

Donc jai esseyer avec un TTimer, Interval 1000.

Jai laiser l'appli compter, et jai afficher l'horloge windows a coté ... et surprise quand l'horloge windows a vue passé 15 min mon appli n'en a compter que 14min45s

Je pensais que le Timer avais une bonne précision a la seconde ... comment pourais palier a ce probléme, sans utiliser GetTickCount ?

voila le code du Timer pour info :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
void __fastcall TFormPrincipale::Timer1Timer(TObject *Sender)
{
        if(FormPrincipale->Machine1.bEnreData == true)
        {
                if(FormPrincipale->Machine1.bEntree1 == true)
                        FormPrincipale->Machine1.dTempsMarche++;
                else
                        FormPrincipale->Machine1.dTempsDarret++;
        }
        if(FormPrincipale->Machine2.bEnreData == true)
        {
                if(FormPrincipale->Machine2.bEntree1 == true)
                        FormPrincipale->Machine2.dTempsMarche++;
                else
                        FormPrincipale->Machine2.dTempsDarret++;
        }
        if(FormPrincipale->Machine3.bEnreData == true)
        {
                if(FormPrincipale->Machine3.bEntree1 == true)
                        FormPrincipale->Machine3.dTempsMarche++;
                else
                        FormPrincipale->Machine3.dTempsDarret++;
        }
        if(FormPrincipale->Machine4.bEnreData == true)
        {
                if(FormPrincipale->Machine4.bEntree1 == true)
                        FormPrincipale->Machine4.dTempsMarche++;
                else
                        FormPrincipale->Machine4.dTempsDarret++;
        }
        if(FormPrincipale->Machine5.bEnreData == true)
        {
                if(FormPrincipale->Machine5.bEntree1 == true)
                        FormPrincipale->Machine5.dTempsMarche++;
                else
                        FormPrincipale->Machine5.dTempsDarret++;
        }
}

Cordialement Baxter

[sat83]

L'utilisation de TTimer n'est pas fait pour des calculs de précision, vu qu'il n'est que très peu précis.

Tu peux utiliser TTimer pour effectuer des boucles à intervalle régulier (mais sans précision), mais tu ne peut pas l'utiliser pour compter des temps.

[Baxter67]

ah d'accord, mais alors quesque je dois utiliser pour pouvoir compté des temps préci a la seconde ?

[Crayon]

Salut, peut-être que GetTickCount() ferait l'affaire.

[henderson]

Salut !

TTimer pose un problème puisque sa réponse est événementielle : WM_TIMER pour signaler le time-out de l'intervalle !

Il existe une solution qui consiste à se servir du MIDI.
Il suffit de fixer le métronome à 60 bpm et d'envoyer des noires en continu, (l'une après l'autre) tant que ce timer (celui basé sur ce principe) est actif.
C'est donc dans la callback (liée à interruption hardware et non plus à la gestion des événements) que l'on pourra implémenter l'émission d'une noire et effectuer le test.
Donc ici, la première chose à penser, c'est de dériver de TComponent et lui donner tout ce dont il a besoin pour en faire un métronome !

A plus !

[Gilles Louïse]

Il existe une solution qui consiste à se servir du MIDI.
Il suffit de fixer le métronome à 60 bpm et d'envoyer des noires

Très astucieux, bravo à vous !

À bientôt
Gilles

[Baxter67]

excuse mon ignorance, mais ma je vois pas le rapport avec mon prob de timer :S

[henderson]

Salut !

Bon je vais vous faire part de ma stupéfaction ...

dans mon appli je compte le temps qu'une info est a 1 ou a 0 (lecture d'entrée digital sur une carte PCI). Bon sa sa va.

Donc toute les seconde j'incrémente une variable si l'info est a 1, et j'incrémente une autre si elle a zéro.

Donc jai deux variable une qui indique le temps en seconde ou linfo a été a 1 et l'autre quand elle été a zéro.

Je pensais bêtement que l'important se situait au niveau du snapshot des états à intervalle d'une seconde !

Le bilan est le suivant :
- chez toi avec TTimer ( imprécis et perturbable )
- chez moi avec le métronome ( relativement "très précis" et pratiquement imperturbable )

Autant régler les imprécisions à la source plutôt que de chercher à les compenser (compensation qui pourrait même ne pas pouvoir être effectuée) !

Autre solution plus simple que la mienne via les API Windows (avec un vision temporelle du snapshot différente) :

The SetTimer function creates a timer with the specified time-out value.

UINT SetTimer(

HWND hWnd, // handle of window for timer messages
UINT nIDEvent, // timer identifier
UINT uElapse, // time-out value
TIMERPROC lpTimerFunc // address of timer procedure
);

The TimerProc function is an application-defined callback function that processes WM_TIMER
messages.

VOID CALLBACK TimerProc(

HWND hwnd, // handle of window for timer messages
UINT uMsg, // WM_TIMER message
UINT idEvent, // timer identifier
DWORD dwTime // current system time
);

Mais à tester !!!

A plus !