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.