Discussion :

[Mike1979]

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.

[wiztricks]

Salut,

Avez vous une idée de procéder?

La valeur affichée ne va pas se mettre à jour toute seule.... Et si vous ne voulez pas le faire "à la main", Qt implémente des Delegate pour ce genre de mise à jour (et c'est plus compliqué que les Variables TK).

- W

[cobalt11]

Bonjour à tous les abonnés, avec ce code, j'ai réussi avec beaucoup de difficultés d'afficher les différentes valeurs du input()
mais ce que voudrais c'est récupérer ces différentes valeurs pour les insérer dans une liste. Merci

Code :

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

1
2
3
4
5
6
7
def f():
    return float(input("Cote: "))
 
s = ""
for i in range(1,4):
    s += str(i) + " " + str(f()) + "\n"
print(s)

[wiztricks]

mais ce que voudrais c'est de recuperer ces differentes valeurs pour les inserer dans une liste.

C'est ce que vous allez trouver dans tous les tutos (supposé avoir été potassés avant de poster)... et vous pourriez avoir la politesse de continuer la discussion que vous avez déjà commencé sur ce sujet plutôt que de cannibaliser une discussion qui n'a rien à voir.

- W

[cobalt11]

Je voudrais te remerçier de m'avoir aider a trouver cette fonction qui m'a faciliter la taches. Si vous pouvez me dire dans quel tutoriel se trouve la réponse à mes question ça serait sympa.
Merçi wiztricks

[wiztricks]

Si vous pouvez me dire dans quel tutoriel se trouve la réponse à mes question ça serait sympa.

Les listes sont un des types de bases du langage et marchent bien avec les boucles: n'importe quel tuto vous montrerait comment les utiliser.

Vous pouvez choisir un de ceux qui sont proposés ici dans la rubrique Tutoriels Python.

- W