Bonjour,

dans le cadre de mon projet j'ai du séparer les boucles de fonctionnement entre 2 threads principaux (récepteur et de calcul) et le second peut lui aussi créer des threads secondaires.
Mon problème est d'arriver à envoyer des signaux du thread secondaire au 1er thread principal. Je viens de découvrir que le connect ne suffit pas car il ne semble pas y avoir de lien entre les 2 threads.
Je pourrai envoyer des signaux au 2nd thread principal qui enverrait alors un signal au 1er thread principal mais je me demande si on ne peut pas faire plus simple.
J'oubliais de préciser que j'utilise un classe statique pour envoyer mes signaux pour qu'ils soient disponible à tous les niveaux de mes threads (et classes) de mon thread de calcul.

Je n'ai pas de probleme de connexion car j'ai testé hors du 2 niveaux de thread et tout fonctionne bien.

Voici un essaie de présentation de mon problème avec du code simple (et certainement des erreurs car c'est vraiment simplifié par rapport à mon programme) mais c'est pour aider peut être à la compréhension :

Reciever.h - recepteur 1 thread principal
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <QThread>
#include <QObject>
 
class Reciever : public QThread
{
    Q_OBJECT
public:
    Reciever();
    void inititateProcess();
public slots:
    void do_result(std::string, double);
}
computeSignals.h - pour envoyer les signaux
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
class ComputeSignals : public QObject {
	  Q_OBJECT
  public :
	  static ComputeSignals *getComputeSignal();
 
	  void emitNewResult(std::string name, double value){ emit newResult(name,value);}
 
  signals :
	  void newResult(std::string name, double value);
  private :
	  static ComputeSignals *computeSignals;
  };

ComputeThread.h - thread principal 2 de calcul
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <QThread>
 
class ComputeThread : public QThread
{
    Q_OBJECT
public:
    ComputeThread();
    void initiateProcess();
 
private: 
virtual void run(void);
}
ComputeThread.cpp - thread principal 2 de calcul
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
 
...
void ComputeThread::run(void){
  ComputeSignals::getComputeSignal()->emitNewResult("test", 1337);
  if(...){
      thread = new computeThread2();
      thread->Start();
  }
...
}
computeThread2 - thread de calcul secondaire appeler par le thread de calcul principal il doit pouvoir envoyer des signaux au récepteur
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <QThread>
 
class ComputeThread2 : public QThread
{
    Q_OBJECT
public:
    ComputeThread2();
    void initiateProcess();
 
private: 
virtual void run(void);
}
ComputeThread2.cpp
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
ComputeThread2::run(void){
...
ComputeSignals::getComputeSignal()->emitNewResult("test2", 111);
...
}
Et enfin le main
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
int main (int argc, char **argv) {
Reviever *recieve = new Reciever();
QObject::connect(ComputeSignals::getComputeSignal(), SIGNAL(newResult(std::string, double)),recieve, SLOT(do_result(std::string, double)));
 
ComputeThread *t = new ComputeThread();
t->start();
reciever->start();
}