Utiliser la fonction Dec avec des dixièmes ou centièmes de secondes

**Akitah** · 15/08/2019, 16h06

Bonjour et merci d'avance pour vos réponses, je suis tout nouveau sur le forum.

Voilà je présente mon problème:

Je travaille actuellement dans une entreprise allemande et je dois concevoir un banc d'essai pour tester l'étanchéité de débitmètres à ultrason, jusque là tout va bien.
J'ai conçu la bête, seulement j'en suis au stade ou je dois programmer le test, or ce test comporte plusieurs étapes, et une condition pour la passage d'une étape à l'autre.

J'ai réussi à réaliser presque tout, seulement j'utilise la fonction Dec pour tracer ma pression en fonction du temps comme ceci:

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
40
41
42
43
 
procedure TForm1.Timer2Timer(Sender: TObject);
 
begin
  DruckWert:=GetDruck;
  Label13.Caption := Format('%ds',[Step1+1]); //Ici j'affiche simplement la valeur de Step1+1 dans un label (pas de rapport avec la question)
  Dec(Step1,-1); // C'est ICI qu'est mon problème
  if Step1<=(AufPD div 1000) then
     begin
 
      AufPMax.AddXY(Step1,AufPMa);
      AufPMin.AddXY(Step1,AufPMi);
      Druck.AddXY(Step1, DruckWert)
      //TEST(1);
     end;
  if Step1=(AufPD div 1000) then
     begin
      V1_aus;
      V2_an;
 
 
     end;
  if ((Step1>=(AufPD div 1000)) AND (Step1<((AufPD div 1000)+T12))) then
     begin
            if ((NSchritt(1, DruckWert))) then
 
                   Timer3.Enabled:=True;
 
     end;
end;
 
procedure TForm1.Button3Click(Sender: TObject);
 
 
 
begin
  //DruckWert:=GetDruck;
  Kontrollleuchte_Start_an;  //Les noms avec _an ou _aus sont simplement des procédures permettant d'allumer/ouvrir ou d'éteindre/fermer des voyants/vannes
 
  V1_an;
  Timer2.Enabled := True;
  Label13.caption:='';  
end;

AufPD correspond à la durée de ma première étape, DruckWert est ma valeur de pression, AufPMax et AufPMin sont des constantes. Je trace ici en réalité simplement un intervalle dans lequel doit se trouver la pression, ainsi que la pression en elle-même. Seulement voilà, ça marche très bien, mais je préfèrerais pouvoir augmenter la valeurs de Step1 de 0,1 toutes les 0,1 seconde, et donc tracer ma pression toutes les 0,1 secondes.

J'ai déja essayé de réduire l'intervale de mon Timer2 à 100ms mais ça continue de me tracer ce que je veux toutes les secondes...

Je récapitule rapidement, je voudrais savoir s'il est possible, non pas de tracer toutes les secondes, mais tous les dixièmes ou même centièmes de seconde, et ce grâce à la fonction Dec.

Merci !

PS: Si j'ai mal expliqué quelque chose, n'hésitez pas à m'en faire part

**Jipété** · 15/08/2019, 17h53

Salut,

pas sûr que j'aie bien compris ce que tu racontes, qui est drôlement embrouillé, mais là je vois un truc bizarre :

Envoyé par Akitah

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  Dec(Step1,-1); // C'est ICI qu'est mon problème

Tu décrémentes de "-1", donc en fait tu incrémentes de "1".

Moi, si j'avais voulu décrémenter Step1, j'aurais écrit Dec(Step1) tout simplement.

PS : pourquoi as-tu cliqué sur

alors que ça ne l'est pas,

**tourlourou** · 15/08/2019, 18h19

Bonjour et bienvenue !

AufPD ne représente pas véritablement une durée, mais un nombre de cycles de Timer ? Si on fait varier la durée du Timer, il faut aussi faire varier ce nombre et ne pas laisser de DIV 1000 ?

Surtout, si on traite des intervalles de temps, autant utiliser autre chose que des entiers : TDateTime, par exemple.

Pour faire quelque chose toutes les x millisecondes, je mettrais un Timer d'intervalle x div 10 (par exemple) pour améliorer la précision, et testerais s'il est temps de faire quelque chose ; style :

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
procedure TForm1.Button3Click(Sender: TObject);
begin
  //DruckWert:=GetDruck;
  Kontrollleuchte_Start_an;  //Les noms avec _an ou _aus sont simplement des procédures permettant d'allumer/ouvrir ou d'éteindre/fermer des voyants/vannes
 
  V1_an;
 
  // NextStep étant une variable TDateTime et Tempo un entier globaux ou accessibles au Timer2 
  Tempo := 100; 
  NextStep := IncMillisecond( Now(), Tempo); // prochain déclenchement dans Tempo millisecondes  
 
  Timer2.Interval := Tempo Div 10; // il se déclenchera 10 fois plus souvent (pour augmenter la précision)
  Timer2.Enabled := True;
 
  Label13.caption:='';  
end;
 
procedure TForm1.Timer2Timer(Sender: TObject);
begin
  if Now() >= NextStep then
  begin
    Timer2.Enabled := False;
    NextStep := IncMillisecond( NextStep, Tempo);
 
    // ici le code à exécuter toutes les Tempo millisecondes
 
    Timer2.Enabled := True;
  end;
end;

**BeanzMaster** · 15/08/2019, 18h40

Salut pourquoi décrémenter un compteur pour avoir le temps dans un Timer ????

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
StartProcess := Now;
EndProcess := Now;
 
Elapsed = EndProcess - StartProcess
 
//Ou mieux utiliser GetTickCount64
 
StartProcess := GetTickCount64;
EndProcess := GetTickCount64;
 
ElapsedProcessInSec = (EndProcess - StartProcess) / 1000;

Je rejoins Tourlourou. Et toujours, pourquoi utiliser un Timer ?, si ton process doit juste durer un certain temps une boucle serais suffisante non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
StartProcess := GetTickCount64;
While  ElapsedProcessInSec<=10 do
Begin
   // Tes mesures
  EndProcess := GetTickCount64;
  ElapsedProcessInSec = (EndProcess - StartProcess) / 1000;
End;

Si non si tu veux afficher tes mesures en même temps le mieux serait de passer par des threads

Tiens je te met une petite unité qui te sera peut-être utile (et à d'autres)

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
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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
(*================================================================================@br
  @created(24/02/2019)
  @author(J.Delauney (BeanzMaster))
  Historique : @br
  @unorderedList(
    @item(Creation : 24/02/2019)
    @item(Mise à jour : )
  )
 --------------------------------------------------------------------------------@br
 
  @bold(Description :)@br
    L'unité BZStopWatch contient un composant "TBZStopWatch" servant à effectuer un chronometrage
  de vos procedures ou fonctions en micro, nano, milli secondes et secondes.@br
  Mais également pour calculer le FPS dans des applications graphique.@br@br
 
  ------------------------------------------------------------------------------@br
 
  @bold(Notes :)@br
    Une variable globale "GlobalPerformanceTimer" est créée automatiquement. V
 
    Si vous démarrer le chronometre avec le parametre "AUseTickCount" de la procedure
  "Start" à "TRUE" (par defaut à FALSE) alors TBZStopWatch utilisera  l'horloge
  temps réel (RTC) (Déconseiller sous FPC en mode 32bit).@br
  Elle est précise sur de longues périodes, mais n'est pas exacte à la milliseconde.@br
  Sinon TBZStopWatch utilisera le compteur de performance "Windows". Pour Linux un "hack" est utilisé.@br
  Le compteur de performance a une meilleure précision, mais il peut quand même
  dériver sur de longues périodes. C'est l'option par défaut car elle permet une
  plus grande précision sur les systèmes rapides. Mais si la procedure est trop rapide il vaut mieux utilser la RTC
  pour obtenir un résultat.
 
  ------------------------------------------------------------------------------@br
  * Dependances : BZSystem @br
  ------------------------------------------------------------------------------@br
 
  @bold(Credits :)@br
    @unorderedList(
      @item(J.Delauney (BeanzMaster))
    )
 
  ------------------------------------------------------------------------------@br
  LICENCE : MPL / LGPL @br
  @br
 *==============================================================================*)
unit BZStopWatch;
 
//==============================================================================
{$mode objfpc}{$H+}
{.$i ..\bzscene_options.inc}
//==============================================================================
 
interface
 
uses
  Classes, SysUtils;
  //BZSystem;
 
type
  TBZTimeUnit = (
    tuNanosecond,       // 1/1000000000 s
    tuMicrosecond,      // 1/1000000 s
    tuMillisecond,      // 1/1000 s
    tuSecond           // 1 s
//    tuMinute,           // 60 s
//    tuHour              // 3600 s
  );
 
type
 
  { TBZStopWatch : Composant non-visuel permettant de chronométrer une action }
  TBZStopWatch = class(TComponent)
  private
    FFrequency, FPerformanceCountStart, FPerformanceCountStop: Int64;
    FFrameCounter : Int64;
    FFPSCurrentTime : Double;
  protected
 
    FNanoSecPerTick: Double;
    FMicroSecPerTick: Double;
    FMilliSecPerTick: Double;
    FSecPerTick: Double;
    FInvPerformanceCounterFrequencyReady: Boolean;
    FFPS: Single;
    FPrecision : Byte;
    FUseRTC, FStarted : Boolean;
    FCPUClock :Double;
 
  public
    { Creation de TBZStopWatch }
    constructor Create(AOwner: TComponent); override;
 
    { Démarre le chronomètre }
    procedure Start(Const AUseRTC:boolean = false);
    { Arrête le chronomètre }
    procedure Stop;
    { Retourne le temps écoulé en ticks}
    function getTimerLap : Double;
    { Convertis les "Ticks" dans l'unité de temps choisi }
    function TickToTimeUnit(const ATick: Int64; AUnit: TBZTimeUnit): Extended;
 
    function GetValueAsTime: String;
 
    { Retourne le temps écoulé en microsecondes sous forme de chaine de caratères }
    function getValueAsMicroSeconds: string;
    { Retourne le temps écoulé en nanosecondes sous forme de chaine de caratères }
    function getValueAsNanoSeconds: string;
    { Retourne le temps écoulé en millisecondes sous forme de chaine de caratères }
    function getValueAsMilliSeconds: string;
    { Retourne le temps écoulé en secondes sous forme de chaine de caratères }
    function getValueAsSeconds: string;
    //function GetValueAsText(TimeUnit:TBZTime): String;
    { Retourne une valeur entiere du temps écoulé microsecondes }
    function getValue: Int64;
    { Retourne une valeur double du temps écoulé secondes }
    function getAsSecond : Double;
    { Retourne une valeur double du temps écoulé secondes }
    function getAsMilliSeconds : Double;
    { Retourne une valeur Extended du temps écoulé ticks }
    function getTicks: Extended;
    { Retourne le nombre de FPS en fonction du nombre de "Frame" }
    function getFPS(FrameCounter:Integer):Single; overload;
    { Retourne le nombre de FPS en fonction du nombre de "Frame" }
    function getFPS:Single; overload;
    { Retourne le nombre de FPS en fonction du nombre de "Frame" sous forme de caractères }
    function getFPSAsString(FrameCounter:Integer):String;
    { Convertis un nombre de ticks en microsecondes sous forme de chaine de caractères }
    function TickToMicroSecond(const ATick: Int64): String;
 
    { Utiliser l'horloge RTC }
    property UseRTC : Boolean read FUseRTC write FUseRTC;
    { Retourne la valeur entiere du temps au démarrage du chronomètre }
    property PerformanceCountStart:Int64 read FPerformanceCountStart;
    { Retourne la valeur entiere du temps a l'arrêt du chronomètre }
    property PerformanceCountStop:Int64 read FPerformanceCountStop;
    { Frequence de l'horloge interne }
    property Frequency : Int64 read FFrequency;
    { Nombre de chiffre après la virgule pour les resultats }
    property Precision : Byte read FPrecision write FPrecision default 12;
  end;
 
//==============================================================================
 
var
  GlobalPerformanceTimer: TBZStopWatch;
 
//==============================================================================
 
implementation
 
//==============================================================================
const
  SecsPerMin = 60;
  SecsPerHour = SecsPerMin * 60;
  SecsPerDay = SecsPerHour * 24;
 
  DefaultDisplayFormat = '#,##0.0';
  TimeUnitName: array[TBZTimeUnit] of String =
    (' ns', ' µs', ' ms', ' s');//, 'm', 'h');
  TimeUnitCoefficient: array[TBZTimeUnit] of Extended =
    (1000000000, 1000000, 1000, 1);//, 1/60, 1/3600);
 
//===[ TBZStopWatch ]===========================================================
 
Type
  TTimeItemNames = Array[0..5] of string;
 
var
  vBZStartTime : TDateTime;
{$IFDEF WINDOWS}
  vLastTime: TDateTime;
  vDeltaMilliSecond: TDateTime;
{$ENDIF}   
 
{$IFDEF UNIX}
const _SC_NPROCESSORS_ONLN = 83;
function sysconf(i: cint): clong; cdecl; external name 'sysconf';
{$ENDIF}  
 
{$IFDEF USE_ASM_OPTIMIZATIONS}
function GetClockCycleTickCount: Int64; assembler; register;
{$IFDEF CPU32}
asm
  DB $0F,$31
end;
{$ENDIF}
{$IFDEF CPU64}
asm
   RDTSC //dw 310Fh // rdtsc
   shl rdx, 32
   or rax, rdx
end;
{$ENDIF}
{$ELSE}
function GetClockCycleTickCount: Int64;
begin
  result:=getTickCount64;
end;
{$ENDIF}  
 
{ Returns time in milisecond from application start.}
function BZStartTime: Double;
{$IFDEF WINDOWS}
var
  SystemTime: TSystemTime;
begin
  GetLocalTime({%H-}SystemTime);
  with SystemTime do
    Result :=(wHour * (MinsPerHour * SecsPerMin * MSecsPerSec) +
             wMinute * (SecsPerMin * MSecsPerSec) +
             wSecond * MSecsPerSec +
             wMilliSeconds) - vBZStartTime;
  // Hack to fix time precession
  if Result - vLastTime = 0 then
  begin
    Result := Result + vDeltaMilliSecond;
    vDeltaMilliSecond := vDeltaMilliSecond + 0.1;
  end
  else begin
    vLastTime := Result;
    vDeltaMilliSecond := 0.1;
  end;
end;
{$ENDIF}
 
{$IFDEF UNIX}
var
  tz: timeval;
begin
  fpgettimeofday(@tz, nil);
  Result := tz.tv_sec - vBZStartTime;
  Result := Result * 1000000;
  Result := Result + tz.tv_usec;
// Delphi for UNIX variant (for future ;)
//var
//  T: TTime_T;
//  TV: TTimeVal;
//  UT: TUnixTime;
//begin
//  gettimeofday(TV, nil);
//  T := TV.tv_sec;
//  localtime_r(@T, UT);
//  with UT do
//    Result := (tm_hour * (MinsPerHour * SecsPerMin * MSecsPerSec) +
//             tm_min * (SecsPerMin * MSecsPerSec) +
//             tm_sec * MSecsPerSec +
//             tv_usec div 1000) - vGLSStartTime;
end;
{$ENDIF}
 
{$IFDEF UNIX}
var
  vProgStartSecond: int64;
 
procedure Init_vProgStartSecond;
//var
//  tz: timeval;
//begin
//  fpgettimeofday(@tz, nil);
//  val := tz.tv_sec - vProgStartSecond;
//  val := val * 1000000;
//  val := val + tz.tv_usec;
//end;
 
var
  tp: timespec; // timespec record tv_sec seconds tv_nsec nanoseconds
begin
  //clock_gettime(CLOCK_MONOTONIC, @tp); // orig
  clock_gettime(CLOCK_MONOTONIC_RAW, @tp);
  // multiplier les secondes par 1000 pour pouvoir y ajouter les millisec,
  // multiplier les secondes par 1000000 pour pouvoir y ajouter les microsec,
  // multiplier les secondes par 1000000000 pour pouvoir y ajouter les nanosec
  // du coup le "result" sera le nombre de milli-secondes depuis le démarrage de la machine
  vProgStartSecond  := (Int64(tp.tv_sec) *  1000000) + int64(tp.tv_nsec); //
end;
{$ENDIF}
 
procedure QueryPerformanceCounter(var val: Int64);
{$IFDEF WINDOWS}
begin
  Windows.QueryPerformanceCounter(val);
end;
{$ENDIF}
{$IFDEF UNIX}
var
  tp: timespec; // timespec record tv_sec seconds tv_nsec nanoseconds
begin
  //clock_gettime(CLOCK_MONOTONIC, @tp); // orig
  clock_gettime(CLOCK_MONOTONIC_RAW, @tp);
  val := ((tp.tv_sec - vProgStartSecond) * 1000000) + tp.tv_nsec; // valeur en milli secondes
end;
 
{$ENDIF}
 
function QueryPerformanceFrequency(var val: Int64): Boolean;
{$IFDEF WINDOWS}
begin
  Result := Boolean(Windows.QueryPerformanceFrequency(val));
end;
{$ENDIF}
{$IFDEF UNIX}
begin
  val := 1000000;
  Result := True;
end;
{$ENDIF}                        
 
 
 
 
function SecondsToTimeString(Seconds: Int64; const itemNames: TTimeItemNames): string;overload;
const
  divisors: array [0..5] of Int64 = (SecsPerDay * 365, SecsPerDay * 31, SecsPerDay, SecsPerHour, SecsPerMin, 1);
 
var
  resCount: integer;
  I: Integer;
  C, V: Int64;
begin
  result := '';
  resCount := 0;
  C := Seconds;
  for I := 0 to 5 do
  begin
    V := C div divisors[I];
    if V > 0 then
    begin
      if resCount > 0 then  result := result + ' ';
      result := result + IntToStr(V) + itemNames[I];
      Inc(resCount);
      //if resCount > 4 then break;
      C := C mod divisors[I];
    end;
  end;
end;
 
function SecondsToTimeString(Seconds: Int64): string; overload;
const
  itemNames: TTimeItemNames = ('year', 'month', 'day', 'h', 'm', 's');
begin
  result := SecondsToTimeString(Seconds, itemNames);
end;
 
function TBZStopWatch.GetValueAsTime : String;
begin
  if FUseRTC then
  begin
    Result := SecondsToTimeString(round((getTimerLap/ FCPUClock)*FSecPerTick));
  end
  else
  begin
    Result := SecondsToTimeString(round(getTimerLap*FSecPerTick));
  end;
end;
 
function TBZStopWatch.TickToTimeUnit(const ATick : Int64; AUnit : TBZTimeUnit) : Extended;
begin
  if FUseRTC then
  begin
    Result := (ATick /FCPUClock) * TimeUnitCoefficient[AUnit];
  end
  else
  begin
    Result := ATick * FSecPerTick * TimeUnitCoefficient[AUnit];
  end;
end;
 
function TBZStopWatch.TickToMicroSecond(const ATick : Int64) : String;
begin
  if FUseRTC then
  begin
     Result := FloatToStrF((ATick/FCPUClock) / (TimeUnitCoefficient[tuMilliSecond]), ffGeneral, 15, 3)+TimeUnitName[tuMilliSecond];
  end
  else
  begin
   // Result := ATick * FSecPerTick * TimeUnitCoefficient[AUnit];
    result:=FloatToStrF(ATick*( TimeUnitCoefficient[tuMilliSecond]/FFrequency), ffGeneral, 15, 3)+TimeUnitName[tuMilliSecond];
  end;
end;
 
constructor TBZStopWatch.Create(AOwner : TComponent);
begin
  inherited;
  FPerformanceCountStart:=0;
  FPerformanceCountStop:=0;
  FPrecision:=12;
  QueryPerformanceFrequency(FFrequency);
  Assert(FFrequency > 0);
 
  FNanoSecPerTick:=1000000000.0/FFrequency; // Resolution du timer en nanosecondes;
  FMicroSecPerTick:=1000000.0/FFrequency;   // Resolution du timer en microsecondes
  FMilliSecPerTick:=1000.0/FFrequency;      // Resolution du timer en millisecondes
  FSecPerTick:=1.0/FFrequency;              // Resolution du timer en secondes
                                            // minute = (1/60)/FFrequency,  heure = (1/3600)/FFrequency
 
  FFPS:=0.0;
  FUseRTC:=False;
  FStarted:=false;
  FCPUClock := CPU_Speed;
end;
 
function TBZStopWatch.getTimerLap : Double;
var
  StopTime:Int64;
begin
  StopTime :=0;
  if FPerformanceCountStop > 0 then StopTime := FPerformanceCountStop
  else
  begin
    if FUseRTC then
    begin
      StopTime:=GetClockCycleTickCount;
    end
    else
    begin
      QueryPerformanceCounter(StopTime);
    end;
  end;
 
  if FUseRTC then
  begin
    Result := (StopTime - FPerformanceCountStart);
  end
  else
  begin
    Result := (StopTime - FPerformanceCountStart);
  end;
end;
 
function TBZStopWatch.getValueAsMicroSeconds : string;
begin
  if FUseRTC then
  begin
    Result := FloatToStrF((getTimerLap/ FCPUClock)*FMicroSecPerTick, ffGeneral, 15, FPrecision)+' µs';
  end
  else
  begin
    Result:= FloatToStrF(getTimerLap*FMicroSecPerTick, ffGeneral, 15, FPrecision)+' µs';
  end;
end;
 
function TBZStopWatch.getValueAsNanoSeconds : string;
begin
  if FUseRTC then
  begin
    Result := FloatToStrF((getTimerLap/ FCPUClock)*FNanoSecPerTick, ffFixed, 15, FPrecision)+' ns';
  end
  else
  begin
    Result:= FloatToStrF(getTimerLap*FNanoSecPerTick, ffFixed, 15, FPrecision)+' ns';
  end;
end;
 
function TBZStopWatch.getValueAsMilliSeconds : string;
begin
  if FUseRTC then
  begin
    Result := FloatToStrF((getTimerLap/ FCPUClock)*FMilliSecPerTick, ffFixed, 15, FPrecision)+' ms';
  end
  else
  begin
    Result := FloatToStrF(getTimerLap*FMilliSecPerTick, ffFixed, 15, FPrecision)+' ms';
  end;
end;
 
function TBZStopWatch.getValueAsSeconds : string;
begin
  if FUseRTC then
  begin
    Result := FloatToStrF((getTimerLap/ FCPUClock)*FSecPerTick, ffFixed, 15, FPrecision)+' sec';
  end
  else
  begin
    Result := FloatToStrF((getTimerLap)*FSecPerTick  , ffFixed, 15, FPrecision)+' sec';
  end;
end;
 
function TBZStopWatch.getValue : Int64;
begin
  if FUseRTC then
  begin
    Result := Round((getTimerLap/ FCPUClock));
  end
  else
  begin
    Result := Round(getTimerLap);
  end;
end;
 
function TBZStopWatch.getAsSecond : Double;
Begin
  if FUseRTC then
  begin
    Result := (getTimerLap/ FCPUClock)*FSecPerTick;
  end
  else
  begin
    Result := getTimerLap*FSecPerTick;
  end;
End;
 
function TBZStopWatch.getAsMilliSeconds : Double;
begin
  if FUseRTC then
  begin
    Result := (getTimerLap/ FCPUClock)*0.0001;
  end
  else
  begin
    Result := (getTimerLap*FMilliSecPerTick);
  end;
end;
 
function TBZStopWatch.getTicks : Extended;
begin
  if FUseRTC then
  begin
    Result := (getTimerLap/ FCPUClock);
  end
  else
  begin
    Result := getTimerLap;
  end;
end;
 
procedure TBZStopWatch.Start(const AUseRTC : boolean);
begin
  FPerformanceCountStop := 0;
  FPerformanceCountStart:=0;
  FFPS:=0.0;
  FFrameCounter := 0;
  FUseRTC := AUseRTC;
  if FUseRTC then
  begin
   // FUseRTC:=True;
    FPerformanceCountStart:=GetClockCycleTickCount;
  end
  else
  begin
    QueryPerformanceCounter(FPerformanceCountStart);
  end;
  FStarted:=true;
end;
 
procedure TBZStopWatch.Stop;
begin
  if FUseRTC then
  begin
    FPerformanceCountStop:=GetClockCycleTickCount;
  end
  else
  begin
    QueryPerformanceCounter(FPerformanceCountStop);
  end;
  FStarted:=False;
 
end;
 
function TBZStopWatch.getFPS(FrameCounter : Integer) : Single;
begin
 
  if FrameCounter > 0 then
  begin
    if FUseRTC then
    begin
      FFPS := FrameCounter / ((getTimerLap/ FCPUClock)*0.000001);  //1000.0
    end
    else
    begin
      FFPS := FrameCounter / (getTimerLap*FSecPerTick);
    end;
  end;
  result:=FFPS;
end;
 
function TBZStopWatch.getFPS : Single;
begin
 
  FFPSCurrentTime := getAsMilliSeconds;
  if (FFPSCurrentTime >= 1000) then
  begin
    if FFrameCounter > 0 then
    begin
      FFPS := FFrameCounter * (FFPSCurrentTime*0.001);
      FFPSCurrentTime := 0;
      FPerformanceCountStop := 0;
      FPerformanceCountStart:=0;
      FFrameCounter := 0;
      if FUseRTC then
      begin
        FPerformanceCountStart:=GetClockCycleTickCount;
      end
      else
      begin
        QueryPerformanceCounter(FPerformanceCountStart);
      end;
    end;
  end;
  inc(FFrameCounter);
  result:=FFPS;
 
  //    FPS := 1000/FPSCurrentTime*FFrameCounter;
end;
 
function TBZStopWatch.getFPSAsString(FrameCounter : Integer) : String;
begin
  result:=Format('%.*f FPS', [3, getFPS(FrameCounter)]);
end;
 
//==============================================================================
 
initialization
 
   vBZStartTime := BZStartTime;
  {$IFDEF UNIX}
    Init_vProgStartSecond;
  {$ENDIF}    
 
  GlobalPerformanceTimer := TBZStopWatch.Create(nil);
 
finalization
 
  FreeAndNil(GlobalPerformanceTimer);
 
//==============================================================================
end.

Bon je pense ne rien oublié car à la base j'utilise une unité supplémentaire (BZSystem)

A+

**Akitah** · 16/08/2019, 13h11

Bonjour et merci pour vos réponses.

J'ai choisi de faire Dec(Step1,-1) car je veux bel et bien augmenter la valeur de 1 à chaque intervalle de relance du timer.
Seulement je suis allé fouiller dans la doc pour voir qu'il y avait impossibilité d'utiliser du float dans un Dec, donc impossibilité de tracer ma pression tous les dixième de seconde ainsi.

Mais j'ai finalement fait plus simple en changeant la valeur de Step1 par la une simple implémentation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
Step1:=Step1+0.5;

La raison pour laquelle je n'avais pas fait cela auparavant était que je n'arrivais plus à utiliser Format pour afficher Step dans le label, mais j'ai alors simplement utiliser FloatToStr pour changer le caption de mon Label

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
 
 
procedure TForm1.Timer2Timer(Sender: TObject); 
 
    Label13.Caption := FloatToStr(Step1)+' s';
    Step1:=Step1+0.5;
 
  if Step1<=(AufPD div 1000) then
     begin
 
      AufPMax.AddXY(Step1,AufPMa);
      AufPMin.AddXY(Step1,AufPMi);
      Druck.AddXY(Step1, DruckWert)
      //TEST(1);
     end;

Et cela marche parfaitement bien ! Le seul soucis que j'ai c'est que mon acquisition est peut-être un peu lourde car mon automate n'arrive pas à me récupérer, tester et tracer ce que je veux tous les dixièmes de seconde. Je me contente pour le moment de toutes les demi-secondes.

M'enfin désolé si mon intro en a embrouillé certains, et aussi désolé si je fais des choses qui vous paraissent louche, j'ai commencé à écrire sur Lazarus la semaine dernière et ce que j'ai du mal à optimiser mon code sans me perdre ou tout faire planter.. :p

Mais merci pour vos réponse et vos lignes je vais essayer ça dès lundi, car maintenant.. WEEKEND

Encore MERCI

**Akitah** · 16/08/2019, 13h14

Envoyé par Jipété

PS : pourquoi as-tu cliqué sur

alors que ça ne l'est pas,

Désolé, étant donné que j'avais trouvé une alternative ne répondant pas à la question je voulais supprimer la discussion mais je n'ai pas trouvé.
Au final je suis bien content d'avoir des réponses donc je regrette pas de ne pas avoir trouvé comment faire !

Désolé !

**BeanzMaster** · 16/08/2019, 15h17

Envoyé par Akitah

M'enfin désolé si mon intro en a embrouillé certains, et aussi désolé si je fais des choses qui vous paraissent louche, j'ai commencé à écrire sur Lazarus la semaine dernière et ce que j'ai du mal à optimiser mon code sans me perdre ou tout faire planter.. :p

Salut, pas de problèmes

n'hésites pas si besoins. Comme je te l'ai dis je chercherais plus du coté des Threads que du TTimer, c'est plus précis et tu peux synchroniser avec ton affichage ou autre ?

Petite question quelle interface utilises tu pour l'acquisition de tes données avec ton automate ? Si tu passes par les Com port tu as l'excellent composant TLazSerial de notre ami JurassikPork

Si jamais j'ai un compo "TBZCadencer" que je me sert pour mes animations en temps réel.Il existe une version dans GLScene. il dispose, de quelques options supplémentaires et d'un gestionnaire d'événement comme ceci :

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
40
41
42
43
44
45
46
47
 { TBZProgressEvent : Événement de progression pour des animations / simulations basées sur le temps.
    DeltaTime est le delta du temps écoulé depuis le dernier état et newTime est la nouvelle heure après la fin de l'événement.}
  TBZCadencerProgressEvent = Procedure(Sender: TObject; Const deltaTime, newTime: Double) Of Object; 
 
 
  { TBZCadencerMode: Détermine comment fonctionne le TBZCadencer.@Br
***- cmManual: vous devez déclencher la progression manuellement (dans votre code). @br
***- cmASAP: la progression est déclenchée aussi tôt que possible après une précédente*progression (utilise les messages de Windows).@br
***- cmApplicationIdle: va accrocher Application.OnIdle, cela va écraser toute manipulation d'événement précédente, et un seul cadencer peut être utilisé dans ce mode.
  }
  TBZCadencerMode = (cmManual, cmASAP, cmApplicationIdle);
 
  { TBZCadencerTimeReference : Determines à quelle moment le TBZCadencer doit "progesser".@br
***- cmRTC: l'horloge en temps réel est utilisée (précise sur de longues périodes, mais*pas précis à la milliseconde.@br
            Peut limiter la vitesse ( efficace*à moins de 50 FPS sur certains systèmes)
***- cmPerformanceCounter: le compteur de performances a une bonne précision. Il peut dériver sur de longues périodes.@br
                           C'est l'option par défaut*car il permet l'animation la plus douce sur les systèmes rapides.@br
***- cmExternal: La propriété CurrentTime est utilisée
  }
  TBZCadencerTimeReference = (cmRTC, cmPerformanceCounter, cmExternal); 
 
 
    { TimeReference : Définit comment CurrentTime est mis à jour.*Voir TBZCadencerTimeReference.@br
 *****Le changement dynamique de TimeReference peut provoquer un 'saut'.
    }
    Property TimeReference: TBZCadencerTimeReference read FTimeReference write SetTimeReference Default cmPerformanceCounter;
 
    { TimeMultiplier: multiplicateur appliqué à la référence de temps.@br
******Zéro n'est pas une valeur autorisée, et sachez que si des valeurs négatives
******sont acceptés, elles peuvent ne pas être pris en charge par d'autres objets.@br
***** La modification du TimeMultiplier modifiera OriginTime.
    }
    Property TimeMultiplier: Double read FTimeMultiplier write SetTimeMultiplier Stored StoreTimeMultiplier;
 
    { MaxDeltaTime : Valeur maximale pour deltaTime dans les événements de progression.@br
******Si null ou négatif, aucun deltaTime max est défini. Sinon, chaque fois qu'un événement
      dont le deltaTime réel est supérieur à MaxDeltaTime, le deltaTime sera à son maximum, et le temps supplémentaire est mise en cache
******par le cadencer (il n'est pas encore pris en compte dans CurrentTime).@br
******Cette option permet de limiter le taux de progression dans les simulations où*Des valeurs élevées entraîneraient des erreurs / comportement aléatoire.
    }
    Property MaxDeltaTime: Double read FMaxDeltaTime write FMaxDeltaTime;
 
    { MinDeltaTime :  Valeur minimale pour deltaTime dans les événements de progression.@br
******Si supérieur à zéro, cette valeur spécifie le "pas" du temps minimum entre deux événements de progression.@br
******Cette option permet de limiter le taux de progression dans les simulations où*les valeurs faibles entraîneraient des erreurs / comportement aléatoire.
    }
    Property MinDeltaTime: Double read FMinDeltaTime write FMinDeltaTime;

SI cela t'intéresse je te mettrai le code à disposition

A+Bon week-end

**Akitah** · 19/08/2019, 09h42

Envoyé par BeanzMaster

Petite question quelle interface utilises tu pour l'acquisition de tes données avec ton automate ? Si tu passes par les Com port tu as l'excellent composant TLazSerial de notre ami JurassikPork

Salut ! Le weekend est fini

Je ne suis pas sûr de comprendre ce que tu veux dire par interface, mais j'utilise bel et bien les com port (étant donné que j'ai un variable COM_PORT=3

)
À vrai dire je travaille en entreprise allemande et donc avec du matériel allemand, je m'y perds un peu

Mais toujours est-il que pour gérer mon automate j'ai repris le code écrit par l'électricien/informaticien (je ne sais pas trop ce qu'il est au final

), je te l'aurais bien montré, mais j'imagine qu'il est la propriété de la boîte et je préfère ne pas prendre de risques !

J'irai tout de même jeter un oeil au lien que tu m'as envoyé ne serait-ce que pour ma culture personnelle

TBZCadencer peut me servir pour tracer un graphe en fonction du temps ? En réalité je n'ai pas de réelle animation à faire, je trace simplement l'évolution de la pression, et si possible j'aimerai effectuer une mesure et la tracer dans un intervalle de temps le plus court possible, enfin plutôt si possible entre le dixième et la demi-seconde :p

J'ai réussi à la tracer toutes les demi-secondes, mais j'imagine que le TTimer n'a pas une précision extraordinaire, n'est ce pas ?

Merci de prendre le temps de me répondre, j'apprécie

**Akitah** · 19/08/2019, 09h53

Encore un précision !

J'ai décidé d'utiliser les Timer pour la raison suivante, voilà ce qu'il se passe dans les étapes de mon test:

- j'ouvre une vanne qui délivre la pression,

- Pendant T1 secondes je teste si ma pression reste dans un certain intervalle,

- Si ces T1 secondes sont passées et que la pression est restée dans l'intervalle voulu, je ferme la vanne et en ouvre une autre pour relâcher une partie de la pression,

- La pression doit atteindre un nouvel intervalle en moins de T12 secondes,

- Si l'intervalle est atteint, je dois voir si la pression y reste pendant T2 secondes,

- etc.

Cela continue ainsi jusqu'à un test où la pression doit rester dans un intervalle pendant T3 secondes.

J'ai donc pensé que les Timer étaient une bonne idée car il faut que je test si une certaine valeur reste dans un certain intervalle, il faut que je puisse faire pause à mon programme, il faut également que je puisse savoir si la pression atteint un certain intervalle en moins d'un certains temps, il faut également à la fin que je puisse avoir accés à ces temps. J'ai alors pensé que les TTimer seraient adapter à cette application ^^

**BeanzMaster** · 19/08/2019, 11h36

Salut, le timer peux te servir mais pour passer d'un test à autre et encore.

Les threads me semblerai plus adapter dans ton cas.

Pour des tests simples, une boucle semble suffisante (mais c'est un peu bloquant, surtout si tu veux faire des pauses)
Un exemple ultra basqiue "From Sratch" avec mon composant TBZStopWath

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
40
   StopWatch : TBZStockWatch;
   EnPause : Boolean;
 
procedure Init;
begin
   StopWatch := TBZStopWatch.Create;
   EnPause := False;
end;
 
function TestMachine1: Boolean;
Var 
  ElapsedTime : Double;
  FinTest : Boolean;
 
  MachineValues : TMachine
begin
   StopWath.Start;
   FinTest := False;
   Result := False;
 
   While not(FinTest) do
   begin
      if (EnPause) then
      begin
        ....
      end
      else
      begin
         ElapsedTime := StopWatch.GetAsSecond;
         if (ElpasedTime >=15) or (MachineValues.value1>=10.235)  then FinTest:=True
         MachineValues := GetMachinesValues;        
         MachinesValue.ElapsedTime := ElapsedTime;
         AfficheValues;          
      end;      
      Application.ProcessMessages; // Le problème ici rend la main à l'UI. Cela fausse la mesure de temps
   end;
 
 
   if (Machines.ElpasedTime >=14.5) and (Machines.ElpasedTime <=15.2) and (MachineValues.value1>=9.235) (MachineValues.value1<=10.235) then Result := True;
end;

Avec une liste de threads (1 par machine) tu pourrais attendre qu'une condition soit vrai ou fausse pour que le prochain thread (ou plusieurs) démarre automatiquement. De plus cela ne figera pas l'UI et tu peux synchroniser l'affichage toutes les x secondes, faire des pause etc....

Dans Lazarus menu --> Outils --> Exemples de projets. Dans filtre met "Thread" tu as 4 petits exemples de l'utilisation de "multithreading" l'exemple "waitforExample1" me semble le plus indiquer pour ton projet

A+

**BeanzMaster** · 19/08/2019, 13h05

En fouinant sur mon disque dur je suis tombé sur un pdf. J'ai retrouvé la page de l'auteur. Je pense que l'exemple 3, moyennant un peu de modifs bien sur, serait tout a fait adapté à ton cas :
https://codes-sources.commentcamarch...les-de-threads et d'autres exemples

Bonne lecture

**Akitah** · 19/08/2019, 16h19

Super, je vais me faire un plaisir de lire tout ça, j'ai 2 semaines pour terminer ce projet, on y croit !!

Merci Maître des haricots

Je vais essayer de te tenir au jus

**Akitah** · 19/08/2019, 16h24

Envoyé par BeanzMaster

En fouinant sur mon disque dur je suis tombé sur un pdf. J'ai retrouvé la page de l'auteur. Je pense que l'exemple 3, moyennant un peu de modifs bien sur, serait tout a fait adapté à ton cas :
https://codes-sources.commentcamarch...les-de-threads et d'autres exemples

Bonne lecture

Le pdf ne contient que des pages blanches quand je l'ouvre :/

**BeanzMaster** · 21/08/2019, 10h51

Salut voila le pdf : Utilisation des Threads.pdf

A+

Utiliser la fonction Dec avec des dixièmes ou centièmes de secondes

Lazarus Pascal

Discussions similaires

Partager

Partager