Aide Lecture GPIO RPI4 depuis une interface Qtdesinger

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:

---

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.

Salut,

Citation:

---

Envoyé par Mike1979

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

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:

---

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_())

---

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:

---

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:

---

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.

Citation:

---

Envoyé par Mike1979

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:

---

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

Bonjour.

Je viens de tester les codes suivants:

Code:

---

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:

---

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:

---

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:

---

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.

Salut,

Citation:

---

Envoyé par Mike1979

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.

---

Si vous ne comprenez pas qu'après avoir déclaré une fonction avec un argument

Code:

---

def __init__(self, Nb):

---

çà râle "il manque des arguments", lorsque vous l'appelez sans...

Je comprends que vous pataugiez mais si vous vous lancez dans des constructions un peu trop compliquées à votre niveau... c'est normal. Et malheureusement, difficile de vous suggérer autre chose que de passer du temps à apprendre les bases.

- W

Bonjour.

J'essaie de comprendre, je passe du temps a patauger, a essayer. Mais je trouve peu d'exemple qui fonctionne et qui pourrais me faire progresser.

Je dois avoir des erreurs de syntaxe car meme en mettant "Nb dans les parentheses "self.Acq =Acquisition(Nb)", ca ne fonctionne pas.

On trouve beaucoup de morceau de code avec erreur mais une fois le problème résolu, on ne vois pas la solution.
Je ne cherche pas que l'on me fasse le code tout près mais juste donner un marceaux de code qui fonctionne.

Citation:

---

Envoyé par Mike1979

Je ne cherche pas que l'on me fasse le code tout près mais juste donner un marceaux de code qui fonctionne.

---

Programmer, c'est apprendre à les écrire...

Et durant l'apprentissage, vous allez vous familiariser avec un tas de messages d'erreurs, apprendre à relire votre code pour les corriger, et progresser.

Ca sert à rien de récupérer des exemples qui marchent sur Internet: s'ils ne fonctionnent plus (parce que les versions ont changé), vous ne pourrez pas les corriger sans avoir un niveau (en programmation) presque semblable à celui qui les a écrits.

S'ils marchent, vous ne pourrez pas les adapter sans les casser...

- W