Bonjour à tous.

J'ai créer une IHM avec QtDesigner et le code en python 3 sous raspberry.
A l'ouverture de mon programme, je lis un fichier configuration et récupère les données dans des variables qui seront utiliser plus tard dans le logiciel.

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
# --- 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
 
from datetime import datetime 
 
import os,sys
 
import RPi.GPIO as GPIO
 
import time
 
import threading
 
import mysql.connector as mc
 
import pymsgbox                                                                         # pip3 install PyMsgBox
 
# Import the ADS1x15 module.
 
import Adafruit_ADS1x15
 
# Create an ADS1115 ADC (16-bit) instance.
 
adc1 = Adafruit_ADS1x15.ADS1115(address=0x4a, busnum=1)                                 #A0=18V; A1=15V; A2=20V; A3=5V
 
adc2 = Adafruit_ADS1x15.ADS1115(address=0x48, busnum=1)                                 #A0= signal
 
GAIN = 1
 
# configuration des GPIO
 
GPIO.setmode(GPIO.BOARD)
 
GPIO.setup(11, GPIO.OUT)
 
GPIO.setup(35, GPIO.OUT)
 
GPIO.setup(38, GPIO.OUT)
 
GPIO.setup(40, GPIO.OUT)
 
# Lecture fichier configuration et attribution facteur multiplicatif ADC
 
config = open("Config.ini", "r")        #r, en lecture (READ);w, en écriture (WRITE), à chaque ouverture le contenu du fichier est écrasé;a, en mode ajout à la fin du fichier (APPEND). Si le fichier n'existe pas python le crée.b, en mode binaire.t, en mode texte.x, crée un nouveau fichier et l'ouvre pour écriture
 
GainAdc = config.readlines()[0:7]
 
GADC1A0 = float(GainAdc[0])
 
GADC1A1 = float(GainAdc[1])
 
GADC1A2 = float(GainAdc[2])
 
GADC1A3 = float(GainAdc[3])
 
GADC2A0 = float(GainAdc[4])
 
USER = GainAdc[5]
 
MDP = GainAdc[6]
 
config.close()
Jusque la tout vas bien.

J'ai créer un onglet qui permet de faire un étalonnage de ma carte et de modifier les gain des convertisseurs (GADC) dans une fonction.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
def etal5v(self, GADC1A3):                                                      # fonction d'etalonnage de la voie 5v
 
                GADC1A3 = (self.lcdNumber_5v.value() / 100000000000)
 
                self.Alim5vLCD_2.display(adc1.read_adc(3, gain=GAIN)*GADC1A3)             # 0.000125*1.34264232
Cette meme variable est utilisé dans une class et une def __init__ de ma fenêtre. Du coup lorsque je modifie ma variable elle ne se change pas dans tous les onglets de interfaces et surtout la fonction(def ADCTension(self)) qui est appeler par un timer tous les 5 secondes.

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
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)                               # push button fermer
 
                self.Fermer_3.clicked.connect(self.Quitter)                             # push button fermer
 
                self.lineEdit.textChanged.connect(self.ActivMesure)                     # sur changement du texte de nom table SQL
 
                self.horizontalSlider_4.valueChanged.connect(self.etal5v)               # Slider etalonnage voie 5v
 
                self.horizontalSlider_3.valueChanged.connect(self.etal15v)              # Slider etalonnage voie 15v
 
                self.horizontalSlider_2.valueChanged.connect(self.etal18v)              # Slider etalonnage voie 18v
 
                self.horizontalSlider.valueChanged.connect(self.etal20v)                # Slider etalonnage voie 20v
 
                self.horizontalSlider_4.sliderMoved.connect(self.etal5v)                # Slider etalonnage voie 5v
 
                self.horizontalSlider_3.sliderMoved.connect(self.etal15v)               # Slider etalonnage voie 15v
 
                self.horizontalSlider_2.sliderMoved.connect(self.etal18v)               # Slider etalonnage voie 18v
 
                self.horizontalSlider.sliderMoved.connect(self.etal20v)                 # Slider etalonnage voie 20v
 
 
 
                self.Voie1.clicked.connect(self.ContinueV1)                             # push button Voie1
 
                self.Voie2.clicked.connect(self.ContinueV2)                             # push button Voie2
 
                self.Enreg_2.clicked.connect(self.Enregistrement)                       # push button enregistrer partie configuration
 
 
 
                self.Tension=QTimer()                                                   # timer pour mise à jour des tensions de la carte.
 
                self.Tension.timeout.connect(self.ADCTension) 
 
                self.Tension.start(5000)                                                # depart du chrono
 
 
 
                self.Acq=QTimer()                                                       # Timer pour la sequence d'acquisition 
 
                self.Acq.timeout.connect(self.Acqui)                                    # Sequence avec boucle 
 
 
 
                self.lcdNumber_20v.display(GADC1A2 * 100000000000)
 
                self.horizontalSlider.setValue(self.lcdNumber_20v.value())
 
                self.lcdNumber_18v.display(GADC1A0 * 100000000000)
 
                self.horizontalSlider_2.setValue(self.lcdNumber_18v.value())
 
                self.lcdNumber_15v.display(GADC1A1 * 100000000000)
 
                self.horizontalSlider_3.setValue(self.lcdNumber_15v.value())
 
                self.lcdNumber_5v.display(GADC1A3 * 100000000000)
 
                self.horizontalSlider_4.setValue(self.lcdNumber_5v.value())
 
 
 
                self.lineEdit_2.setText(USER)
 
                self.lineEdit_3.setText(MDP)
 
 
 
        def etal5v(self, GADC1A3):                                                      # fonction d'etalonnage de la voie 5v
 
                GADC1A3 = (self.lcdNumber_5v.value() / 100000000000)
 
                self.Alim5vLCD_2.display(adc1.read_adc(3, gain=GAIN)*GADC1A3)             # 0.000125*1.34264232
 
        def ADCTension(self):                                                           # Fonction d'affichage tension
 
                self.Alim5vLCD.display(adc1.read_adc(3, gain=GAIN)*GADC1A3)             # 0.000125*1.34264232
 
                self.Alim15vLCD.display(adc1.read_adc(1, gain=GAIN)*GADC1A1)
 
                self.Alim18vLCD.display(adc1.read_adc(0, gain=GAIN)*GADC1A0)
 
                self.Alim20vLCD.display(adc1.read_adc(2, gain=GAIN)*GADC1A2)
 
                self.Alim5vLCD_3.display(self.Alim5vLCD.value())
 
                self.Alim15vLCD_3.display(self.Alim15vLCD.value())
 
                self.Alim18vLCD_3.display(self.Alim18vLCD.value())
 
                self.Alim20vLCD_3.display(self.Alim20vLCD.value())
Avez vous une idée de procéder?

Merci d'avance pour votre aide.