[TThread][TTimer] comment utiliser un timer dans un thread ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour

J'ai un thread qui a dans son .h
Code:

1 2 3 4 //... TTimer *Timer1; void __fastcall EventTimer1(TObject *Sender); //...
dans le cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 //... void __fastcall MyThread::Execute() { Timer1 = new TTimer(NULL); Timer1->Enabled=false; Timer1->OnTimer=EventTimer1; Timer1->Interval=100; //... Timer1->Enabled=true; } void __fastcall MyThread::EventTimer1(TObject *Sender) { stringlist1->Add(asValue); }
et mon timer ne s'éxécute jamais. malgré que le thread existe pendant pret de 7 secondes.

Afin de tester mon code j'avais ajouté :

Code:

EventTimer1(NULL);

a la fin de la methode Execute, et j'avais bien 1 valeur dans mon StringList a la fin.

donc comment faire pour que mon Timer fasse son job ?

Merci a vous par avance :merci:

07/12/2006, 00h16
pottiez

Je ne sais pas trop se que tu veut faire mais a priori on ne mais jamais de composant VCL dans un Thread, les composant son mis sur une fiche (même si ce ne sont pas des composants graphiques) ou a la limite dans une simple classe mais pas dans un Thread, par contre, grace à la fonction Synchronize du Thread, tu peut accéder au evenement du Timer que tu aura placé sur ta fiche.

J'espère avoir été clair et ne pas trop mettre emélé ;)
07/12/2006, 09h31
netah25
Bon, suite a ta remarque j'ai repensé mon thread :)

a la fin de Execute j'ai ajouté:
Code:

1 2 3 4 5 6 fin=true; while(fin) { //code de mon Event Application->ProcessMessage(); }
et j'ai ajouté une methode public FinishThread
Code:

1 2 3 { fin=false }
il me reste quelques test a faire, mais ca fonctionne a priori :)

netah

merci pottiez
07/12/2006, 09h58
pottiez

De rien, si tu as d'autre problemes tu sais ou venir :mouarf:
07/12/2006, 11h09
netah25

je m'en sors pas je vais donc poser une question générale sur les thread :)

je vais pas rentrer dans les details, mais en gros j'ai une grosse class qui gere mon système.

et dans une des méthodes j'ai besoin de faire une acquisition regulière de data.

comment je dois faire ?

disons que ma tache d'acquisition est la methode AcquData()

il se trouve que cette méthode ralentit enormement mon execution.

je fais un threads qui appel AcquData avec Synchronize ? je déplace AcquData dans mon thread ? autre ?

:merci:
07/12/2006, 11h28
pottiez

Les deux solution sont possible, tout dépend ou tu as besoin de ces infos, a prioris dans ta fiche, donc je la laisserai dans la fiche et je l'appelerai avec un Synchronize.
07/12/2006, 11h32
netah25

Citation:

Envoyé par pottiez

Les deux solution sont possible, tout dépend ou tu as besoin de ces infos, a prioris dans ta fiche, donc je la laisserai dans la fiche et je l'appelerai avec un Synchronize.

si je fais comme ca , je viens de tester, ca me ralentit toujours beaucoup mon applis, execution 3 x plus lente ...

quekls info je peux donner pour que vous m'aidier a faire le bon choix ?
07/12/2006, 11h35
pottiez

La configuration de ton programme, combient de fiche, combien de thread, combien de classe, quel classe connait quel classe, etc...
07/12/2006, 11h40
netah25

alors j'ai :

une Unit d'authentification
| --> une unit de configuration
| | --> ma unit principale de fonctionnement

c'est unit principal gère toute la partie interface et tous le pilotage du système (un robot) est géré par une class (PilotageLib)

PilotageLib dispose de 2 classes , un class lui permettant de gérer le port USB, une autre le port Série

lors de sa construction elle construit 1 usb et 4 port serie

et donc maintenant un thread.

le code qui me ralentit utilise les communications séries pour remplir de TStringList

netah
07/12/2006, 11h58
pottiez

Dans ce cas, tu peut facilement mettre ta fonction dans le Thread, et remplir le TStringList avec un Synchronize(), en fonction de la ou est placé le TStringList.
07/12/2006, 12h01
netah25

Citation:

Envoyé par pottiez

Dans ce cas, tu peut facilement mettre ta fonction dans le Thread, et remplir le TStringList avec un Synchronize(), en fonction de la ou est placé le TStringList.

ca ressmble a quoi un code comme ca ?

car le Synchronize j'ai pas encore trop compris ce que je devais lui passer en parametre ...

netah
07/12/2006, 12h09
pottiez

En fait tu fait

Code:

Synchronize(instruction normale de C++) ;

En fait cette fonction sert à ce que on n'appelle pas la meme fonction en meme temps, comme c'est dans un thread, on ne sais pas quand est appelé la fonction, donc on synchronise pour eviter des conflits.
07/12/2006, 13h56
netah25

dernière chose, dans mon thread a l'intérieur de Synchroniyze, si je veux utiliser des propriété de ma class appelant le thread, je peux le faire directement ? ou je dois les déclarer en extern ?

merci
07/12/2006, 14h15
pottiez

Deux condition pour pouvoir appeller une propriété, il faut que le thread connaisse la classe, a priorie c'est bon vu que tu accede au TStringList, il faut que le thread est les droit sur la propriété, pour qu'il est les droits, soit mettre la propriété en public, soit mettre deux fonction (une lire et une ecrire) en public, qui agit sur la propriété qui elle est en private ou protected

Bon j'ai essayé de faire un exemple clair de mon probleme ...

en gros, j'ai une appli appelante :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//$$---- Form CPP ----
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include "unit2.h"
 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
TExemple *Exemple;
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
	Label1->Caption=1;
	Exemple = new TExemple();
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	Exemple->Start();	
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	Exemple->Stop();	
}
//---------------------------------------------------------------------------

qui utilise donc une class :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
#pragma hdrstop
 
#include "Unit2.h"
#include "Unit3.h"
 
//---------------------------------------------------------------------------
 
#pragma package(smart_init)
 
TMyThread *thread;
 
TExemple::TExemple()
{
	Timer1 = new TTimer(NULL);
	Timer1->Enabled  = false;
	Timer1->OnTimer  = EventTimer1;
	Timer1->Interval = 50;
}
 
TExemple::~TExemple()
{
	delete Timer1;
}
 
void __fastcall TExemple::EventTimer1(TObject *Sender)
{
	Form1->Label1->Caption=(StrToInt(Form1->Label1->Caption)+1);
}
 
void TExemple::Start()
{
	Timer1->Enabled=true;
	thread = new TMyThread(false);
}
 
void TExemple::Stop()
{
	Timer1->Enabled=false;
	thread->StopThread();
	delete thread;
}
 
void TExemple::AcquData()
{
	Sleep(500);
}

qui elle meme utilise un thread :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//$$---- Thread CPP ----
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit3.h"
#include "Unit2.h"
#pragma package(smart_init)
 
extern TExemple *Exemple;
 
bool fin;
 
__fastcall TMyThread::TMyThread(bool CreateSuspended)
	: TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall TMyThread::Execute()
{
	fin=true;
 
	while(fin)
	{
		Synchronize(&Acqu);
		Application->ProcessMessages();
    }
}
//---------------------------------------------------------------------------
 
void TMyThread::StopThread()
{
	fin = false;
}
 
void __fastcall TMyThread::Acqu()
{
	Exemple->AcquData();
}

Mon but (et peut etre que je sur estime le pouvoir des threads) etait de pouvoir faire tourner AcquData (de la class) sans ralentir l'execution du timer, dont dépendent des element de sécurité de mon système.

Seulement mes incrément (dans cette exemple) se font a la vitesse de mon Sleep (represantant ma fonction blocante car lente)

Un thread peut il bien repondre a ma problematique ?

Comment gérer la priorité du thread si cela peut avoir une influence positive,

est ce que j'ai rien compris ? :aie:

:merci:

08/12/2006, 10h46
pottiez

Pour la priorité du Thread, il vaut mieux la laisser en normale, car si on le regle mal, tu peut etre amené a bloqué le PC complet et à devoir rebooter.

Pour ta fonction AcquData() qui contien le Sleep(), mais son contenu dans la fonction Acqu() de ton Thread, plutot que de simplement l'appeler, ensuite, il me semble que dans cette fonction tu devait remplir un TStringList(dis moi si je me trompe), il faudrais que je sache dans quel classe il est instentié et avec quel securité (public, private,protected).
08/12/2006, 10h54
netah25
bon en fait je ne peux pas déplacer le code de AcquData, car il contient des appel a des hinstance d'une class de communication par le port série.

c'est le return de ces methode qui est misdanns des TStringList.

en gros :
Code:

1 2 3 4 PuissanceFC -> Add ( u1500FC->ReadMotor(28) ); PuissanceRA -> Add ( u1500RA->ReadMotor(28) ); PuissanceFB -> Add ( u1500FB->ReadMotor(28) ); PuissanceAB -> Add ( u1500AB->ReadMotor(28) );
u1500xx sont des hinstances d'une class de communication avec le port série que j'ai écrit

PuissanceXX sont des TStringList
08/12/2006, 10h57
pottiez

C'est embétant, car c'est en partie (a mon avis) a cause des acces serie que ca devient long, et ce serai donc le principale a mettre dans le thread.

il faudrait que ton Thread connaisse les classe port serie, par exemple, lorsque tu le créé tu lui donne l'adresse des 4 classe port serie.
08/12/2006, 11h06
netah25

Citation:

Envoyé par pottiez

C'est embétant, car c'est en partie (a mon avis) a cause des acces serie que ca devient long, et ce serai donc le principale a mettre dans le thread.

il faudrait que ton Thread connaisse les classe port serie, par exemple, lorsque tu le créé tu lui donne l'adresse des 4 classe port serie.

je vais essayer ca, mais j'ai essayé de mettre le Sleep(500) dans le Acqu() de MyThread et j'ai les meme raentissement ...

je te dis si mes tests seront concluant

merci pourle temps que tume consacre:D

bonjour,
l'utilisation de <Application->ProcessMessages()> dans la méthode Execute est a proscrire, en effet cela provoque des conflits avec le Thread VCL Principal a savoir celui de ta Form de base --> ralentissements

dans le corps de la méthode Execute de ton thread il est conseillé d'utilisé la boucle suivante

Code:

1
2
3
4
5
 
while(!Terminated)
{
  //ton code
}

ceci garanti de pouvoir utiliser les appels à Terminate() de ton thread

personellement je n'utilise jamais Un TTimer dans un Thread, J'ai cré une classe TTimer Thread qui utilise les appels au API Win32 a savoir SetEvent,WaitForSingleObject

un petit exemple de code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
le .H
 
//---------------------------------------------------------------------------
#ifndef MytimerH
#define MytimerH
//---------------------------------------------------------------------------
#include <Classes.hpp>
//---------------------------------------------------------------------------
class TMyTimerThread : public TThread
{
private:
      HANDLE MyHandle;
      HANDLE MyEvent;
      bool FEnabled;
      unsigned long FInterval;
      TNotifyEvent FOnTimer;
      TThreadPriority FThreadPriority;
      void __fastcall SetEnabled(const bool Value);
      void __fastcall SetInterval(const unsigned long Value);
      void __fastcall SetOnTimer(const TNotifyEvent Value);
      void __fastcall Timer();
      void __fastcall SetThreadPriority(const TThreadPriority Value);
protected:
    void __fastcall Execute();
public:
    __fastcall TMyTimerThread(bool CreateSuspended);
    virtual __fastcall  ~TMyTimerThread();
    __property bool Enabled = {read=FEnabled, write=SetEnabled, default=true};
    __property unsigned long Interval = {read=FInterval, write=SetInterval, default=1000};
    __property TNotifyEvent OnTimer = {read=FOnTimer, write=SetOnTimer, default=NULL};
    __property TThreadPriority ThreadPriority = {read=FThreadPriority, write=SetThreadPriority, default=3};
};
//---------------------------------------------------------------------------
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
le .cpp
//---------------------------------------------------------------------------
//#include "libpch.h"
//#include <checks.h>
#pragma hdrstop
 
#include "Mytimer.h"
#pragma package(smart_init)
/*
*************************************************
FileName        :    MyTimer
 
FileUsage       :    Classe de Timer pour le Project TimeDispatcher
 
FileVersion     :    1
 
FileDate        :    31.07.1998
 
*************************************************/
 
 
 
 
 
//---------------------------------------------------------------------------
//   Important : les méthodes et les propriétés des objets dans la VCL ne peuvent
//   être utilisées que dans une méthode appelée en utilisant Synchronize, par exemple :
//
//      Synchronize(UpdateCaption);
//
//   où UpdateCaption pourrait être du type :
//
//      void __fastcall TMyTimerThread::UpdateCaption()
//      {
//        Form1->Caption = "Mise à jour dans un thread";
//      }
//---------------------------------------------------------------------------
__fastcall TMyTimerThread::TMyTimerThread(bool CreateSuspended)
    : TThread(CreateSuspended)
{
    // TRACE("Methode Name " << "TMyTimerThread::TMyTimerThread " << "Id "  << this->ThreadID << " Entry at  " <<__TIME__);
   MyHandle=CreateEvent(NULL,false,false,NULL);
   MyEvent= CreateEvent(NULL,false,false,NULL);
   FOnTimer=NULL;
   FInterval=5000;
   FEnabled=false;
   Priority=tpNormal;
 
    // TRACE("Methode Name " << "TMyTimerThread::TMyTimerThread " << "Id "  << this->ThreadID << " Exit at  " <<__TIME__);
   Resume();
}
//---------------------------------------------------------------------------
void __fastcall TMyTimerThread::Execute()
{
     // TRACE("Methode Name " << "TMyTimerThread::Execute() " << "Id "  << this->ThreadID << " Entry at  " <<__TIME__);
    Priority = FThreadPriority;
   while(!Terminated)
    {
       if  (FEnabled)
       {
       	 WaitForSingleObject(MyHandle,FInterval);
         if (!Terminated)  Synchronize(Timer);
         }
        else
        {
         ResetEvent(MyEvent);
         WaitForSingleObject(MyEvent,INFINITE);
        }
 
    }
 
 
    //---- Placez le code du thread ici ----
    // TRACE("Methode Name " << "TMyTimerThread::Execute() " << "Id "  << this->ThreadID << " Exit at  " <<__TIME__);
}
//---------------------------------------------------------------------------
void __fastcall  TMyTimerThread::SetEnabled(const bool Value)
{
      if(!FEnabled)ResetEvent(MyEvent);
       FEnabled= Value;
      if (Value)SetEvent(MyEvent);
 
 
}
//---------------------------------------------------------------------------
void __fastcall  TMyTimerThread::SetInterval(const unsigned long Value)
{
   if (FEnabled)
     {
      FEnabled=false;
      FInterval = Value;
      FEnabled=true;
      }
    else
       FInterval = Value;
 
 
}
//---------------------------------------------------------------------------
void __fastcall  TMyTimerThread::SetOnTimer(const TNotifyEvent Value)
{
 
    if (FEnabled)
     {
      FEnabled=false;
      FOnTimer = Value;
      FEnabled=true;
     }
     else   FOnTimer = Value;
}
//---------------------------------------------------------------------------
void __fastcall  TMyTimerThread::Timer()
{
  if (FEnabled)
     {
       if (FOnTimer)FOnTimer(this);
     }
}
//---------------------------------------------------------------------------
void __fastcall  TMyTimerThread::SetThreadPriority(const TThreadPriority Value)
{
  FThreadPriority=Value;
}
//---------------------------------------------------------------------------
 
__fastcall  TMyTimerThread::~TMyTimerThread()
{
   // TRACE("Methode Name " << "TMyTimerThread::~TMyTimerThread() " << "Id "  << this->ThreadID << " Entry at  " <<__TIME__);
 
   SetEnabled(true);
   SetEvent(MyHandle);
   Terminate();
   WaitFor();
   CloseHandle(MyHandle);
 
   CloseHandle(MyEvent);
   // TRACE("Methode Name " << "TMyTimerThread::~TMyTimerThread() " << "Id "  << this->ThreadID << " Exit at  " <<__TIME__);
}

cette classe s'utilise comme un Timer Normal mais à l'aventage de ne pas avoir besoin de Handle de Fenêtre

Pour solutionner ton application j'utiliserais plusieurs Threads

un WorkerThread qui a pour tache de créer,surveiller et synchroniser l'ensemble des threads que tu crées.
un ou plusieurs TimerThreads
un thread d'acquisition

cordialement

Voir 40 message(s) de cette discussion en une page