Discussion :

[Invité]

Bonjour,

Je développe actuellement un logiciel de prise de mesure et j'ai un soucis pour l'exécution continue du thread.

Mon logiciel est construit selon une architecture multi-threadée. Principalement, il dispose d'un thread principal (contenant l'IHM) et d'un thread de mesure.

Constructeur du thread principal :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Manager::Manager(int argv, char* argc[])
{
     QApplication app(arv, argc);
     m_mesureInterface = new MeasureInterface();
     m_mainGUI = new ClasseHeritantMainWindow();
 
     QObject::connect(m_mainGUI, SIGNAL(startSignal()), m_mesureInterface, SLOT(start()));
     QObject::connect(m_mainGUI, SIGNAL(stopSignal()), m_mesureInterface, SLOT(stop()));
 
     m_mainGUI->show();
     app.exec();

Et voici une partie du code de la classe de mesure :

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
MeasureInterface::MeasureInterface()
{
     moveToThread(&m_tread);
     m_thread.start();
     QObject::connect(this, SIGNAL(initiateSignal()), this, SLOT(initiate()));
     QObject::connect(this, SIGNAL(nextStep()), this, SLOT(execute()));
     emit initiateSignal();
}
 
void MeasureInterface::start()
{
     m_continue = true;
     execute();
}
 
void MeasureInterface::stop()
{
     m_continue = false;
}
 
void MeasureInterface::execute()
{
     //   Pilotage de l'appareil pour prise de mesure
 
     emit transmitResult(Result res);
 
     if(m_continue)
          emit nextStep();
}

Le but de tout ceci est que le thread de mesure doit tourner en continu de façon indépendante, sans jamais être dérangé par l'exécution des autres threads du logiciel. Ma toute première idée avait été une boucle while dans la fonction execute(), mais bien entendu, ce n'est pas possible puisque cela bloque la boucle évènementielle.

Une autre version, celle actuellement utilisée, envoie au thread principal un signal de résultat, et dès que ce signal est reçu, le thread principal envoie un signal pour rappeler la fonction execute(). Cela fonctionnait bien, mais me pose un problème : si le thread principal est déjà occupé sur une opération longue, le signal est mis en attente et cela bloque le fonctionnement du thread de mesure.

J'ai donc tenté la solution du code écrit plus haut. A priori, cela fonctionne, mais lorsque j'essaie de stopper l'exécution (par l'envoi du signal stop), tout plante. Ce fonctionnement partiel me laisse penser que l'idée mais est bonne mais que je m'y prend mal.

Si vous savez ce qui ne colle pas, ou même si vous avez une autre façon de faire à proposer, cela m'aiderait bien.

Cordialement.