Discussion :

[Mike1979]

Bonjour à tous.

Je suis en train de developer une interface de radiotélescope basé sur raspberry.

L'interface a était faite avec Qt desinger5, Python3. Le code fonctionne, mais je souhaiterai mettre dans un thread séparé de l'IHM pour éviter le freeze, l'acquisition de valeur des ADC. C'est la que je bloque un peu. Pas trouver la bonne documentation.

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Par X. HINAULT - Tous droits réservés - GPLv3
# Déc 2012 - www.mon-club-elec.fr
 
# --- importation des modules utiles ---
from PyQt5.QtGui import *
from PyQt5.QtCore import * # inclut QTimer..
from PyQt5.QtWidgets import *
from threading import Timer
from PyQt5.QtCore import pyqtSignal 
 
import os,sys
import RPi.GPIO as GPIO
import time
import threading
 
# Import the ADS1x15 module.
import Adafruit_ADS1x15
 
# Create an ADS1115 ADC (16-bit) instance.
adc1 = Adafruit_ADS1x15.ADS1115(address=0x4a, busnum=1)
adc2 = Adafruit_ADS1x15.ADS1115(address=0x48, busnum=1)
 
# ADDR-GND:0x48; ADDR-VDD:0x49; ADDR-SDA:0x4A; ADDR-SCL:0x4B Pour ADS 1115 et 1015
 
# GPIO 19: bcm n°35; GPIO 20: BCM 38; GPIO 21: BCM 40
# GPIO 19>> Signal
# GPIO 20>> 15V
# GPIO 21>> 18V
 
GAIN = 1
 
GPIO.setmode(GPIO.BOARD)
GPIO.setup(11, GPIO.OUT)
GPIO.setup(35, GPIO.OUT)
GPIO.setup(38, GPIO.OUT)
GPIO.setup(40, GPIO.OUT)
 
# --- importation du fichier de description GUI ---
from RT_RPI import*                                                                     # <=== modifier ici le nom du fichier
 
def affichageThreadId(texte):               # affichage du thread
    print(texte + ' ----> Thread Id : ' +  
str(QtCore.QThread.currentThreadId().__int__())) 
 
# Class pour la verif de tension
class VerifTension(QtCore.QObject):                                                     # thread timer verif tension
    signal = pyqtSignal() 
 
    def __init__(self, parent=None): 
        super().__init__(parent) 
 
    def LancerTimer(self): 
        affichageThreadId("Traitement secondaire : début")    
        self.Alim5vLCD.display(adc1.read_adc(0, gain=GAIN))
        self.Alim15vLCD.display(adc1.read_adc(1, gain=GAIN))
        self.Alim18vLCD.display(adc1.read_adc(2, gain=GAIN))
        self.Alim20vLCD.display(adc1.read_adc(3, gain=GAIN))
        time.sleep(0.001) 
        self.signal.emit() 
 
#class sequence acquisition
class SeqAcq(QtCore.QObject):                                                           # thread sequence timer sequence acquisition
    signal1 = pyqtSignal() 
 
    def __init__(self, parent=None): 
        super().__init__(parent) 
 
    def SequenceAcq(self):                                                              #thread pour la sequence D'acquisition
        affichageThreadId("Traitement secondaire : début") 
        #Self.Acquisition()
        time.sleep(0.001) 
        self.signal1.emit() 
 
# classe principale contenant le code actif
class myApp(QWidget, Ui_Form):                                                          # la classe reçoit le Qwidget principal ET la classe définie dans test.py obtenu avec pyuic4
        def __init__(self, parent=None):
                QWidget.__init__(self)                                                  # initialise le Qwidget principal
                self.setupUi(parent)                                                    # Obligatoire
 
                #-- variables utiles --
 
                #Réalisez les connexions supplémentaires entre signaux et slots
 
                self.TestPush.clicked.connect(self.TestPushClicked)                     # push button test
                self.TestPush_2.clicked.connect(self.TestV1)                            # push button test V1
                self.TestPush_3.clicked.connect(self.TestV2)                            # push button test V2
                self.MesPush.clicked.connect(self.MesPushClicked)                       # push button mesure
                self.TestPush_4.clicked.connect(self.Top)                               # push button Stop
                self.InterMesSlider.valueChanged.connect(self.Interval)                 # Slider intervalle de mesure
                self.TpsAcqSlider.valueChanged.connect(self.Interval)                   # Slider tps total d'acquisition
                self.Fermer.clicked.connect(self.Quitter)
 
                self.Tension=QTimer()                                                   # timer pour mise a jour des tensions de la carte. Sequence dans un thread
                self.Tension.timeout.connect(self.ADCTension) 
                self.Tension.start(5000)                                                # depart du chrono
 
                #thread pour la sequence d'acquisition 
                self.SeqAcq = SeqAcq() 
                self.threadSeqAcq = QtCore.QThread() 
                self.SeqAcq.moveToThread(self.threadSeqAcq)
                self.SeqAcq.signal1.connect(self.SeqAcqFini) 
                self.threadSeqAcq.start()
                #self.Acq=QTimer()                                                       # Timer pour la sequence d'acquisition et runtime dans unthread.
                #self.Acq.timeout.connect(self.SeqAcq.SequenceAcq()) 
 
        #--- fonctions actives
        def SeqAcqFini(self): 
                affichageThreadId('Fenêtre principale : traitement secondaire terminé')
 
        def Quitter(self):                                                              # fonction quitter la fenetre 
                a.instance().quit
 
        def Interval(self):                                                             # fonction calcul du nombre de Cycle de mesure
                if self.InterMesLCD.value() != 0 and self.TpsAcqLCD.value() != 0:
                        tmp1= self.TpsAcqLCD.value() // (self.InterMesLCD.value() + 5)  # calcul à l'arrondi Hypothese de duree d'acquisition 5s
                        if tmp1 == 0:
                                self.Cycle.display(1)
                        else:
                                self.Cycle.display(tmp1)                                #Fixe la valeur sur le LCD Cycle
                else:
                        self.Cycle.display(1)
 
                if self.InterMesLCD.value() == 0 and self.TpsAcqLCD.value() == 0:
                        self.Cycle.display(0)
 
        def TestPushClicked(self):                                                      # fonction appui bouton Test
                print ("click Test")
 
                GPIO.output(38, 1)                                                      # Activer GPIO HT Bdf
                time.sleep(500/1000)                                                    # tempo 0.5s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                Nb = self.NbPtMesLCD.value()
                i == 0
                Bdf == 0
                while i!= Nb:
                        Bdf = Bdf + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        i += 1
 
                BdfMoy = Bdf/Nb
 
                GPIO.output(38, 0)                                                      # Des Activer GPIO HT Bdf
                time.sleep(500/1000)                                                    # tempo 0.5s  
                GPIO.output(38, 0)                                                      # des Activier GPIO Mesure
 
                GPIO.output(40, 1)                                                      # Activer GPIO HT Mesure
                time.sleep(500/1000)                                                    # tempo 0.5s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                i == 0
                Mes == 0
                while i!= Nb:
                        Mes = MES + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        i += 1
 
                MesMoy = Mes/Nb
                MesNet = MesMoy - BdfMoy
 
                GPIO.output(40, 0)                                                      # Des Activer GPIO HT Mesure
                time.sleep(500/1000)                                                    # tempo 0.5s 
                GPIO.output(35, 0)                                                      # des Activier GPIO Mesure
 
        def Top(self):                                                                  # fonction lors appui bouton Stop
                print ("stop")
                self.Acq.stop()                                                         # arret Timer et sequence d'acquisition
 
        def TestV1(self):                                                               # fonction lors appui bouton TestV1
                self.TemMes.setStyleSheet('QPushButton {color: red;}')                  # changement couleur ecriture bouton mesure
                GPIO.output(38, 1)                                                      # Application +15v
                GPIO.output(35, 1)                                                      # acquisition signal
 
                tmp = 0
                i = 0
 
                while i < 10:
                        tmp = tmp + adc2.read_adc(0, gain=GAIN)
                        i = i + 1
 
                tmp = tmp / 10
                self.TestV1_LCD_Moy.display(tmp)
                self.TestV1_LCD.display(adc2.read_adc(0, gain=GAIN))                    # valeur ADC
 
                GPIO.output(35, 0)                                                      # coupure liaison signal
                GPIO.output(38, 0)                                                      # Remise a zero
 
                self.TemMes.setStyleSheet('QPushButton {color: green;}')
 
        def TestV2(self):                                                               # fonction lors appui bouton TestV2
                GPIO.output(40, 1)                                                      # Application +18V
                GPIO.output(35, 1)                                                      # acquisition signal
 
                tmp = 0
                i = 0
 
                while i < 10:
                        tmp = tmp + adc2.read_adc(0, gain=GAIN)
                        i = i + 1
 
                tmp = tmp / 10
                self.TestVLCD_2.display(tmp)
                self.TestVLCD.display(adc2.read_adc(0, gain=GAIN))
 
                GPIO.output(35, 0)                                                      # coupure liaison signal
                GPIO.output(40, 0)                                                      # Remise a zero
 
        def MesPushClicked(self):                                                       # fonction lors appui bouton Mes
                duree = self.InterMesLCD.value() + 5                                    # lancement de l'acquisition (intervale entre 2 mesure +5s d'acquisition
                 #self.Acq.start(duree)
 
        def ADCTension(self):                                                           # Fonction d'affichage tension
                self.Alim5vLCD.display(adc1.read_adc(3, gain=GAIN)*0.000125)
                self.Alim15vLCD.display(adc1.read_adc(1, gain=GAIN)*0.000125)
                self.Alim18vLCD.display(adc1.read_adc(2, gain=GAIN)*0.000125)
                self.Alim20vLCD.display(adc1.read_adc(0, gain=GAIN)*0.000125)
 
        def Acquisition(self):                                                          # fonction d'acquisition
                GPIO.output(38, 1)                                                      # Activer GPIO HT Bdf
                time.sleep(50/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                Nb = self.NbPtMesLCD.value()
                i == 0
                Bdf == 0
                while i!= Nb:
                        Bdf = Bdf + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        i += 1
 
                BdfMoy = Bdf/Nb
 
                GPIO.output(38, 0)                                                      # Des Activer GPIO HT Bdf
                time.sleep(50/1000)                                                     # tempo 0.05s  
                GPIO.output(38, 0)                                                      # des Activier GPIO Mesure
 
                GPIO.output(40, 1)                                                      # Activer GPIO HT Mesure
                time.sleep(50/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                i == 0
                Mes == 0
                while i!= Nb:
                        Mes = MES + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        i += 1
 
                MesMoy = Mes/Nb
                MesNet = MesMoy - BdfMoy
 
                GPIO.output(40, 0)                                                      # Des Activer GPIO HT Mesure
                time.sleep(500/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 0)                                                      # des Activier GPIO Mesure 
 
# fonction principale exécutant l'application Qt
def main(args):
    a=QApplication(args) # crée l'objet application
    f=QWidget() # crée le QWidget racine
    c=myApp(f) # appelle la classe contenant le code de l'application
    f.show() # affiche la fenêtre QWidget
    r=a.exec_() # lance l'exécution de l'application
    return r
# pour rendre le fichier *.py exécutable
if __name__=="__main__": # pour rendre le code exécutable
    main(sys.argv) # appelle la fonction main

Pouvez vous m'eclaircir sur la facon de faire.

J'ai tester le code ci dessous mais ca ne fonctionne pas. Les fonctions de mesure des tensions et des valeurs fonctionne sans les threads.

Merci d'avance pour votre aide.

[wiztricks]

Salut,

C'est la que je bloque un peu. Pas trouver la bonne documentation.

Dans une documentation, vous allez éventuellement trouver comment utiliser les threads.... mais pas grand chose concernant la répartition du travail entre ce qui doit se faire côté thread et côté GUI (thread principale).

Ceci dit, si vous voulez que toute la partie GPIO soit effectué par un thread... déjà mettre toutes ces opérations dans la "class" dont l'instance sera exécutée par le thread est le minimum.

Après il faut que le thread du GUI et le thread qui s'occupe du GPIO s'échangent des messages/informations avec la mécanique signal/slot que ce soit côté mise à jour de l'interface et/ou commande à faire exécuter (côté GPIO) depuis l'interface.

Et pour faire çà sereinement, il est préférable d'avoir quelques notions de POO et d'avoir passé du temps dans les tutos et codé quelques exemples pour comprendre comment çà se construit.

Impossible de se lever un bon matin et imaginer ajouter une interface "à l'arrache"...

- W

[tyrtamos]

Bonjour,

Voilà un petit exemple d'utilisation d'un thread pour qu'une opération longue (simulée ici) ne gèle pas le graphique.

Pour le thread, j'utilise ici "QThread" de PyQt5 et non "Thread" de threading, grâce à la capacité de QThread de communiquer avec le graphique par l'intermédiaire de signaux. A part ça, QThread fonctionne de la même façon que le Thread de threading. J'utilise ici le thread par héritage de QThread et surcharge de ses méthodes (POO).

Un autre avantage de QThread est qu'on peut l'arrêter "sauvagement" en cas de besoin (.terminate()), ce qui n'est pas prévu dans threading. Bien sûr, dans ce cas, aucune information valable ne peut être obtenue du thread ainsi stoppé.

Rappel: ce qui se trouve dans le thread ne doit pas toucher directement au graphique à part lui envoyer des signaux, car il n'est pas "thread-safe"! A défaut, plantage aléatoire possible.

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
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
import time
from PyQt5 import (QtWidgets, QtCore)
 
#############################################################################
class Operationlongue(QtCore.QThread):
 
    # crée deux nouveaux signaux
    info = QtCore.pyqtSignal(int) # signal pour informer d'une progression
    fini = QtCore.pyqtSignal(bool, list) # signal pour la fin du thread
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
 
        # initialise un drapeau pour signaler une demande d'arrêt
        self.stop = False 
 
    #========================================================================
    def run(self):
        """partie qui s'exécute en tâche de fond
        """
        for i in range(0, 101):
            if self.stop:
                break # arrêt anticipé demandé
            time.sleep(0.05) # tempo pour ralentir la boucle
            self.info.emit(i) # envoi du signal de progression d'exécution
 
        # # envoi du signal de fin du thread
        # self.stop dira si la fin est normale ou pas
        # et [1,2,3] n'est qu'un exemple de données envoyées par le thread
        self.fini.emit(self.stop, [1,2,3]) 
 
    #========================================================================
    def arreter(self):
        """pour arrêter avant la fin normale d'exécution du thread
        """
        self.stop = True
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
 
        # bouton de lancement du thread
        self.depart = QtWidgets.QPushButton("Départ", self)
        self.depart.clicked.connect(self.lancement)
 
        # bouton d'arrêt anticipé du thread
        self.arret = QtWidgets.QPushButton("Arrêt", self)
        self.arret.clicked.connect(self.stopthread)
 
        # barre de progression
        self.barre = QtWidgets.QProgressBar(self)
        self.barre.setRange(0, 100)
        self.barre.setValue(0)
 
        # positionne les widgets dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.depart, 0, 0)
        posit.addWidget(self.arret, 1, 0)
        posit.addWidget(self.barre, 2, 0)
        self.setLayout(posit)
 
        # initialise la variable d'instance de classe du thread
        self.operationlongue = None
 
    #========================================================================
    @QtCore.pyqtSlot(bool)
    def lancement(self, ok=False):
        """lance l'opération longue dans le thread
        """
        if self.operationlongue==None or not self.operationlongue.isRunning():
            # initialise la barre de progression
            self.barre.reset()
            self.barre.setRange(0, 100)
            self.barre.setValue(0)
            # initialise l'opération longue dans le thread
            self.operationlongue = Operationlongue()
            # prépare la réception du signal de progression
            self.operationlongue.info.connect(self.progression)
            # prépare la réception du signal de fin
            self.operationlongue.fini.connect(self.finduthread)
            # lance le thread (mais ne l'attend pas avec .join!!!)
            self.operationlongue.start()
 
    #========================================================================
    @QtCore.pyqtSlot(int)
    def progression(self, i):
        """lancé à chaque réception d'info de progression émise par le thread
        """
        self.barre.setValue(i)
 
    #========================================================================
    @QtCore.pyqtSlot(bool)
    def stopthread(self, ok=False):
        """pour arrêter avant la fin
        """
        if self.operationlongue!=None and self.operationlongue.isRunning():
            self.operationlongue.arreter()
 
    #========================================================================
    @QtCore.pyqtSlot(bool, list)
    def finduthread(self, fin_anormale=False, liste=()):
        """Lancé quand le thread se termine
        """
        if fin_anormale:
            # fin anticipée demandée
            QtWidgets.QMessageBox.information(self,
                "Opération longue",
                "Arrêt demandé avant la fin!")
        else:
            # fin normale
            self.barre.setValue(100)
            QtWidgets.QMessageBox.information(self,
                "Opération longue",
                "Fin normale!")
            # récupération des infos transmises par signal à la fin du thread
            print("Infos données par le thread:", liste)
        # désactive les liens
        self.operationlongue.info.disconnect()
        self.operationlongue.fini.connect 
        # signale quil n'y a plus de thread actif
        self.operationlongue = None
 
    #========================================================================
    def closeEvent(self, event):
        """lancé à la fermeture de la fenêtre quelqu'en soit la méthode
        """
        # si le thread est en cours d'eécution, on l'arrête (brutalement!)
        if self.operationlongue!=None and self.operationlongue.isRunning():
            # désactive les liens
            self.operationlongue.info.disconnect()
            self.operationlongue.fini.connect                        
            # et arrête brutalement le thread
            self.operationlongue.terminate()
        # accepte la fermeture de la fenêtre
        event.accept()
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    sys.exit(app.exec_())

[Mike1979]

Après recherche et test de différentes solutions, j'ai réussis a faire communique le QThread avec la fenêtre graphique.

Le QThread fait bien la recuperation des donnée, et les envoie a la l'interface graphique mais je souhaiterai faire passer un paramètre de la fenêtre graphique vers le QThread, et la je bloque.
Le parametre que je souhaite faire passer entre la fenetre graphique et le QTHREAD est :Nb

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def MesPushClicked(self):                                                       # fonction lors appui bouton Mes
                #duree = self.InterMesLCD.value() + 5                                   # lancement de l'acquisition (intervale entre 2 mesure +5s d'acquisition
                #self.Acq.start(duree)
                Nb = self.NbPtMesLCD.value()
                print(Nb)
                self.Acq = Acquisition(Nb)                                                # definition et lancement du thread d'acquisition
                self.Acq.start()
                self.Acq.update_Acqui.connect(self.update_progress)                     # Connection signal entre la fenetre et le thread
 
        def update_progress(self, val1, val2, val3, val4):                              # fonction de recuperation des valeurs du thread et mise a jour de la fenetre
                print(val1)
                print(val2)
                print(val3)
                print(val4)

La class du QTHREAD:

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
#class sequence acquisition
class Acquisition(QThread):
        update_Acqui = pyqtSignal(int,int,int,int)                                      # liaison signal entre la fenetre et le thread
 
        def __init__(self, Nb, parent=None):
                boucle(Acquisition, self).__init_(parent)
                self.Nb = Nb
 
        def run(self):
 
                affichageThreadId("ADC2") 
 
                GPIO.output(38, 1)                                                      # Activer GPIO HT Bdf
                time.sleep(50/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                a == 0
                Bdf == 0
                while a!= Nb:
                        Bdf = Bdf + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        a += 1
 
                BdfMoy = Bdf/Nb
 
                GPIO.output(38, 0)                                                      # Des Activer GPIO HT Bdf
                time.sleep(50/1000)                                                     # tempo 0.05s  
                GPIO.output(38, 0)                                                      # des Activier GPIO Mesure
 
                GPIO.output(40, 1)                                                      # Activer GPIO HT Mesure
                time.sleep(50/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 1)                                                      # Activier GPIO Mesure
 
                a == 0
                Mes == 0
                while a!= Nb:
                        Mes = MES + adc2.read_adc(0, gain=GAIN) #remplacer par le bon ADC
                        a += 1
 
                MesMoy = Mes/Nb
                MesNet = MesMoy - BdfMoy
 
                GPIO.output(40, 0)                                                      # Des Activer GPIO HT Mesure
                time.sleep(500/1000)                                                     # tempo 0.05s 
                GPIO.output(35, 0)                                                      # des Activier GPIO Mesure
                self.update_Acqui.emit(Bdf,BdfMoy,MesMoy,MesNet)

Merci d'avance pour votre aide.

[wiztricks]

Le parametre que je souhaite faire passer entre la fenetre graphique et le QTHREAD est :Nb

ll devrait être "transmis", et si vous en doutez, ajouter un "print" juste à l'entré de la fonction __init__ devrait permettre de le vérifier.

Pour le reste:

Code :

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

1
2
3
4
5
6
class Acquisition(QThread):
        update_Acqui = pyqtSignal(int,int,int,int)                                      # liaison signal entre la fenetre et le thread
 
        def __init__(self, Nb, parent=None):
                boucle(Acquisition, self).__init_(parent)
                self.Nb = Nb

Je ne sais pas ce qu'est "boucle" mais on s'attend à trouver QThread à la place ou un super().__init_(parent).

- W

[Mike1979]

Bonjour.

Je viens de tester les codes suivants:

Code :

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

1
2
3
4
5
6
class Acquisition(QThread):
        update_Acqui = pyqtSignal(int,int,int,int)                                      # liaison signal entre la fenetre et le thread
 
        def __init__(self, Nb, parent=None):
                super().__init_(parent)
                self.Nb = Nb

le code:

Code :

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

1
2
3
4
5
6
class Acquisition(QThread):
        update_Acqui = pyqtSignal(int,int,int,int)                                      # liaison signal entre la fenetre et le thread
 
        def __init__(self, Nb, parent=None):
                QThread().__init_(parent)
                self.Nb = Nb

Celui-ci:

Code :

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

1
2
3
4
5
6
class Acquisition(QThread):
        update_Acqui = pyqtSignal(int,int,int,int)                                      # liaison signal entre la fenetre et le thread
 
        def __init__(self, Nb):
                QThread().__init_(self)
                self.Nb = Nb

J'ai ce message qui apparait:

Traceback (most recent call last):
File "RT_multiprocess.py", line 226, in MesPushClicked
self.Acq = Acquisition() # definition et lancement du thread d'acquisition
TypeError: __init__() missing 1 required positional argument: 'Nb'

Voici le code qui permet de lancer le Thread:

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
def MesPushClicked(self):                                                       # fonction lors appui bouton Mes
 
                #duree = self.InterMesLCD.value() + 5                                   # lancement de l'acquisition (intervale entre 2 mesure +5s d'acquisition
 
                #self.Acq.start(duree)
 
                Nb = self.NbPtMesLCD.value()
 
                print(Nb)
 
                self.Acq = Acquisition()                                                # definition et lancement du thread d'acquisition
 
                self.Acq.start()
 
                self.Acq.update_Acqui.connect(self.update_progress)                     # Connection signal entre la fenetre et le thread

Aborted

Je suis un peu a court d'idée.
Je n'arrive pas non plus a trouver d'exemple sur la transmission de donnée entre Thread.