Le TTimer n'est pas précis a la seconde???

Version imprimable

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:

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

15/09/2008, 16h13
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.
15/09/2008, 16h16
Baxter67

ah d'accord, mais alors quesque je dois utiliser pour pouvoir compté des temps préci a la seconde ?
16/09/2008, 19h52
Crayon

Salut, peut-être que GetTickCount() ferait l'affaire.
16/09/2008, 20h32
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 !
17/09/2008, 10h00
Gilles Louïse

Citation:

Envoyé par henderson

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

A tester sur de longue période, voici un exemple de mini chronomètre utilisant GetTickCount()

[avec un bouton Start, un bouton Stop, un Label et un Timer] :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
//# BOUTON START
void __fastcall TForm1::BtnStartClick(TObject *Sender)
{
  timerInMilli = 0 ;
  initialValue = GetTickCount() ;
  Timer1->Enabled = true ;
}
 
//# BOUTON STOP
void __fastcall TForm1::BtnStopClick(TObject *Sender)
{
  Timer1->Enabled = false ;
}
 
//# TIMER
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
  Timer1->Enabled = false ;
  timerInMilli = GetTickCount() - initialValue ;
  Label1->Caption = IntToStr( timerInMilli  ) ;
  Timer1->Enabled = true ;
}

Avec :

Code:

1
2
   int timerInMilli ;
   int initialValue ;

18/09/2008, 23h27
Crayon

La solution apporté par sat83 est très bien et pour plus de détail il y a la FAQ: http://cpp.developpez.com/faq/bcb/?p...etrertickcount
19/09/2008, 21h19
Baxter67

je suis d'accord c'est pas mal

mais si maintenant, je veux metre en pause et reprendre le chrono plus tard ... c'est toute une gimnastique

Quand l'info est a 1 je compte quand elle a 0 je compte plus, mais si linfo revien a 1 je continue a compter sans remetre le chrono a 0.
Avec GetTickCount c'est assez compliquer a faire je pense.
C'est pour sa que j'ai abandonner l'idée et que je suis venue vous demander conseil.
A moinn que vous connaisier une bonne fason d'utiliser gettickcount tous en pouvant arrter et reprendre le chroni

Et on ma ausi dis que le GetTickCOunt est remis a 0 tous les x temps, sa peut etre tres genant egalement :(

Pour la méthode de henderson, je n'ai jamais fais de derivation de composant actuelement, et je ne sais pas trop coment procédé ... Je vais continuer a creuser de mon coté...

Cordialement Baxter

Salut !

Donc comme promis :

a) le .h

Code:

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
40
 
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
 
class MidiEvent
{
public :
DWORD dwDeltaTime;
DWORD dwStreamID;
union
    {
    DWORD dwData;
    BYTE bData[4];
    } dwEvent;
};
 
class jMetronome : public TPanel
{
private :
TMenuItem *FRC;
bool On;
bool FFullRestartCycle;
 
protected :
    void __fastcall SetFullRestartCycle(bool Value);
    void __fastcall SelectDevice(TObject *Sender);
    void __fastcall onClick(TObject *Sender);
    void __fastcall ShowMidiOutError();
    void __fastcall SelectRestartCycle(TObject *Sender);
    void __fastcall OpenMidiOutDevice();
    void __fastcall FixerTempo(int T);
 
public :
    __fastcall jMetronome(TComponent *AOwner);
    __fastcall ~jMetronome();
 
__property bool FullRestartCycle={read=FFullRestartCycle, write=SetFullRestartCycle};
 
};

b) le .cpp

Code:

1
2
3
 
//ne pas oublier d'inclure
#include <mmsystem.h>

Code:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
//Déclarations globales
UINT Code;
UINT MidiOutNumDevs;
MIDIOUTCAPS MidiOutDevCaps;
MIDIPROPTIMEDIV Midi_TimeDiv;
MIDIPROPTEMPO Midi_Tempo;
MMRESULT Error;
HMIDISTRM hStream;
int Block;
MidiEvent Events[4];
MidiEvent *Blocks[2]={ &Events[0], &Events[2] };
MIDIHDR MidiHdr[2];
 
/*
On utilise deux blocs (séquences) pour assurer la fluidité.
Pendant que l'un des deux blocs est lu, l'autre peut être préparé
et retransmis au dispositif.
Chaque séquence est composée de deux événements :
- la noire qui est sortie immédiatement sur le port MIDI (donc pas de latence)
- un événement qui ne sert qu'à signifier l'appel de la callback après un
intervalle de temps égal à la durée d'une noire.
*/
 
void AddBlock()
{
//préparation d'un header
MidiHdr[Block].lpData=(char *)Blocks[Block];
MidiHdr[Block].dwBufferLength = sizeof(MidiEvent) * 2;
MidiHdr[Block].dwBytesRecorded = sizeof(MidiEvent) * 2;
MidiHdr[Block].dwFlags=0;
MidiHdr[Block].dwUser=0;
MidiHdr[Block].reserved=0;
MidiHdr[Block].dwOffset=0;
//On prépare le header
midiOutPrepareHeader(hStream, &MidiHdr[Block], sizeof(MIDIHDR));
//On le passe au dispositif MIDI
midiStreamOut(hStream, &MidiHdr[Block], sizeof(MIDIHDR));
//block suivant qui, à ce stade, est en cours de lecture
Block = Block ^ 1;
}
 
/*
La callback qui va être sollicitée à chaque fois que le dispositif
en a terminé avec la lecture d'un bloc MIDI.
On peut rajouter du code mais il doit être, au niveau temps d'exécution,
le plus court possible : bien moins que le temps de lecture d'un bloc !!!
Voir l'aide (Référence Multimédia) en ce qui concerne la MidiOutProc car
Il vaut mieux ne pas y faire appel à n'importe quoi !!!
*/
 
void CALLBACK MidiOutProc(HMIDIOUT hmo, UINT wMsg, DWORD dwInstance,
                                            DWORD dwParam1, DWORD dwParam2)
{
/****************************************
A ne pas modifier :
*****************************************/
//Libération du block qui est terminé
midiOutUnprepareHeader(hStream, &MidiHdr[Block], sizeof(MIDIHDR));
//On rajoute un bloc
AddBlock();
/****************************************
Placez votre code ici; il doit être le plus court possible...
*****************************************/
//TO DO ...
 
 
 
}
//--
 
 
//--
__fastcall jMetronome::jMetronome(TComponent *AOwner)
    : TPanel(AOwner)
{
if(AOwner->InheritsFrom(__classid(TWinControl)))
    {
    Parent = (TWinControl*)AOwner;
    }
BevelWidth = 3;
Width = 80;
Height = 23;
//Après la pause, on redémarre une seconde pleine
FFullRestartCycle = true; // simple pause si false
 
Caption = "Metronome";
Color = clBlack;
Font->Color = clLime;
 
OnClick = onClick;
 
// Nombre de dispositifs MIDI disponibles
MidiOutNumDevs = midiOutGetNumDevs();
if(MidiOutNumDevs !=0 )
    {
    //Construction du popupmenu et "mise en menu" des dispositifs
    PopupMenu = new TPopupMenu(this);
    PopupMenu->AutoPopup = true;
    TMenuItem *M;
    for(Code = 0; Code < MidiOutNumDevs; Code++)
        {
        midiOutGetDevCaps(Code,(LPMIDIOUTCAPS)&MidiOutDevCaps,
                                        sizeof(MIDIOUTCAPS));
        M = new TMenuItem(this);
        M->Caption = MidiOutDevCaps.szPname;
        M->Tag = (int)Code;
        M->OnClick = SelectDevice;
        PopupMenu->Items->Add(M);
        }
    M = new TMenuItem(this);
    M->Caption = "-";
    PopupMenu->Items->Add(M);
 
    FRC = new TMenuItem(this);
    FRC->Caption = "Pause Cycle";
    FRC->OnClick = SelectRestartCycle;
    PopupMenu->Items->Add(FRC);
 
    // Initialisation des blocs MIDI
    int e;
    for(int j = 0; j < 2; j++)
        {
        e = j * 2;
        //la note, un simple side-stick du drum set
        Events[e].dwDeltaTime=0;
        Events[e].dwStreamID=0;
        Events[e].dwEvent.bData[0]=0x99; // NoteOn pour le Drum Set Channel
        Events[e].dwEvent.bData[1]=37;   // Side Stick
        Events[e].dwEvent.bData[2]=0x7F;  // Velocity :0 = min ... 127 = max
        Events[e].dwEvent.bData[3]=0;     // Midi event
 
        //L'événement de synchronisation
        Events[e + 1].dwDeltaTime=96;
        Events[e + 1].dwStreamID=0;
        Events[e + 1].dwEvent.bData[0]=0;
        Events[e + 1].dwEvent.bData[1]=0;
        Events[e + 1].dwEvent.bData[2]=0;
        Events[e + 1].dwEvent.bData[3]= (Byte)(MEVT_NOP | MEVT_F_CALLBACK);
        }
    Code = 1;
    }
}
//--
__fastcall jMetronome::~jMetronome()
{
if(hStream != 0)
    {
    midiStreamStop(&hStream);
    midiStreamClose(&hStream);
    }
}
//--
void __fastcall jMetronome::onClick(TObject *Sender)
{
On = !On;
if(On)
    {
    if(hStream == 0)
        {
        OpenMidiOutDevice();
        }
    midiStreamRestart(hStream);
    BevelOuter = bvLowered;
    }
else
    {
    if(FFullRestartCycle)
        {
        midiStreamStop(hStream);
        midiStreamClose(hStream);
        hStream=0;
        }
    else
        {
        midiStreamPause(hStream);
        }
    BevelOuter = bvRaised;
    }
}
//--
void __fastcall jMetronome::SelectDevice(TObject *Sender)
{
if(hStream != 0)
    {
    midiStreamStop(hStream);
    midiStreamClose(hStream);
    }
Code = (UINT)((TMenuItem*)Sender)->Tag;
OpenMidiOutDevice();
}
//--
void __fastcall jMetronome::SelectRestartCycle(TObject *Sender)
{
FFullRestartCycle = !FFullRestartCycle;
if(!FFullRestartCycle) FRC->Caption = "Full Restart Cycle";
else FRC->Caption = "Pause Cycle";
}
//--
void __fastcall jMetronome::OpenMidiOutDevice()
{
Error = midiStreamOpen(&hStream, &Code,1,(LONG)MidiOutProc,0,
                                    CALLBACK_FUNCTION);
if(Error == MMSYSERR_NOERROR)
    {
    Midi_TimeDiv.cbStruct = sizeof(MIDIPROPTIMEDIV);
    Midi_TimeDiv.dwTimeDiv = 96; //96 PPQN pour une noire
    midiStreamProperty(hStream,(Byte*)&Midi_TimeDiv,
                                    MIDIPROP_SET | MIDIPROP_TIMEDIV);
    FixerTempo(1000000); //1000000 = 60 bpm, 2000000 = 30 bpm
 
    Block = 0;
    //Ajoute le bloc [0]
    AddBlock();
    //Ajoute le bloc [1]
    AddBlock();
    //A ce stade, on est prêt à gérer le retour du bloc [0]
    }
if(Error != MMSYSERR_NOERROR) ShowMidiOutError();
}
//--
void __fastcall jMetronome::FixerTempo(int T)
{
if(hStream != 0)
    {
    Midi_Tempo.cbStruct=sizeof(MIDIPROPTEMPO);
    Midi_Tempo.dwTempo=T;
    Error = midiStreamProperty(hStream,(Byte*)&Midi_Tempo, MIDIPROP_SET | MIDIPROP_TEMPO);
    //if(Error != MMSYSERR_NOERROR) ShowMidiOutError();
    }
}
//--
void __fastcall jMetronome::ShowMidiOutError()
{
char *ErrorString = new char[128];
midiOutGetErrorText(Error, ErrorString, 128);
Application->MessageBox(ErrorString, "Erreur MIDI", MB_OK);
delete [] ErrorString;
}
//--
void __fastcall jMetronome::SetFullRestartCycle(bool Value)
{
FFullRestartCycle = Value;
}
//--

J'ai utilisé ça bêtement :

Code:

1
2
3
4
5
6
7
8
9
 
jMetronome *Metronome;
//--
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
Metronome = new jMetronome(this);
Metronome->SetBounds(100,100,80,23);
}

Je ne suis pas très chaud pour y apporter des modifications donc...
Par contre, si ça fonctionne (aussi bien que chez moi) faites le moi savoir !

Un conseil : ne pas utiliser de synthés logiciels comme dispositif de sortie MIDI. On a intérêt à être le plus près possible du matériel ! Donc optez pour la carte son !

A plus !

26/09/2008, 09h32
Baxter67

excuse mon ignorance, mais ma je vois pas le rapport avec mon prob de timer :S
26/09/2008, 13h26
henderson

Salut !

Citation:

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) :

Citation:

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
);

Citation:

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 !