Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut Utiliser la fonction Dec avec des dixièmes ou centièmes de secondes
    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

  2. #2
    Expert éminent sénior
    Avatar de Jipété
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    8 443
    Détails du profil
    Informations personnelles :
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations forums :
    Inscription : juillet 2006
    Messages : 8 443
    Points : 11 994
    Points
    11 994
    Par défaut
    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 :
    Citation Envoyé par Akitah Voir le message
    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,
    Il a à vivre sa vie comme ça et il est mûr sur ce mur se creusant la tête : peutêtre qu'il peut être sûr, etc.
    Oui, je milite pour l'orthographe et le respect du trait d'union à l'impératif.
    Après avoir posté, relisez-vous ! Et en cas d'erreur ou d'oubli, il existe un bouton « Modifier », à utiliser sans modération
    On a des lois pour protéger les remboursements aux faiseurs d’argent. On n’en a pas pour empêcher un être humain de mourir de misère.
    Mes 2 cts,
    --
    jp

  3. #3
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 328
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 56
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 328
    Points : 9 705
    Points
    9 705
    Billets dans le blog
    6
    Par défaut
    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;
    Delphi 5 Pro - Delphi 10.2 Tokyo Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  4. #4
    Membre émérite
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 122
    Points : 2 949
    Points
    2 949
    Billets dans le blog
    2
    Par défaut
    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+
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

  5. #5
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    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

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    Citation Envoyé par Jipété Voir le message

    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é !

  7. #7
    Membre émérite
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 122
    Points : 2 949
    Points
    2 949
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par Akitah Voir le message
    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
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

  8. #8
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    Citation Envoyé par BeanzMaster Voir le message

    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

  9. #9
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    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 ^^

  10. #10
    Membre émérite
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 122
    Points : 2 949
    Points
    2 949
    Billets dans le blog
    2
    Par défaut
    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+
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

  11. #11
    Membre émérite
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 122
    Points : 2 949
    Points
    2 949
    Billets dans le blog
    2
    Par défaut
    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
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

  12. #12
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    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

  13. #13
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    juillet 2019
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 22
    Localisation : France, Haut Rhin (Alsace)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Industrie

    Informations forums :
    Inscription : juillet 2019
    Messages : 7
    Points : 4
    Points
    4
    Par défaut
    Citation Envoyé par BeanzMaster Voir le message
    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 :/

  14. #14
    Membre émérite
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 122
    Points : 2 949
    Points
    2 949
    Billets dans le blog
    2
    Par défaut
    Salut voila le pdf : Utilisation des Threads.pdf

    A+
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

Discussions similaires

  1. Réponses: 2
    Dernier message: 06/02/2016, 16h22
  2. Réponses: 1
    Dernier message: 16/09/2015, 15h53
  3. Utilisation de la Fonction Rand () avec des conditions
    Par Karamus dans le forum Macros et VBA Excel
    Réponses: 6
    Dernier message: 25/10/2014, 17h11
  4. utilisation de la fonction "deconv" avec des inconnues
    Par tcheck_vi dans le forum MATLAB
    Réponses: 11
    Dernier message: 27/07/2009, 19h49
  5. Réponses: 4
    Dernier message: 16/08/2008, 23h05

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo