Bonjour,
Dans le cadre d'un projet en informatique, je souhaiterais programmer l'épreuve du code de la route à l'aide de Python, c'est à dire : Raspberry + Tkinter.
Les 2 fonctions (c'est à dire : def Rasp() et def FenQu() ) Raspberry et Tkinter fonctionnent très bien indépendamment, mais je dois les faire fonctionner en même temps : la fonction qui utilise Tkinter crée une fenêtre avec les questions, et une autre fonction qui gère la raspberry avec des boutons pour pouvoir répondre à la question qui lui correspond. Cependant les deux fonctions se lancent l'une après l'autre, je ne sais pas comment faire :/
J'ai vu sur internet l'utilisation des "Threat" mais je n'ai pas compris grand chose :/
Merci d'avance pour votre aide,
Posez moi les questions nécessaires à la compréhension de mon problème,
Bonne journée.

Il faut etre plus clair : peut on voir ton code ?
Qu'est-ce que tu ne comprend pas dans les threat ? Les verrous ? Comment en demarrer un ?

cherche plutot "thread" a la place de "threat" c'est pas exactement la meme chose

ca par exemple ca couvre les base de comment transformer une fonction en thread en python.
http://softwareramblings.com/2008/06/running-functions-as-threads-in-python.html

A noter juste pour etre exacte et pedant, que python ne gere pas vraiment les threads sur plusieurs processeurs en parallele. Il fait semblant, mais a ton niveau ca n'a vraiment pas d'importance

En vue de vos réponses les Thread doivent être la bonne solution, et oui je me suis trompé ce n'est pas threat ^^, je vais donc m'y attarder plus longtemps et sérieusement.
Je vais regarder le lien que tu m'as envoyé et regarder plus en profondeur, et en attendant voici mon programme en espserance que cela vous sera utile^^

Voici le code :

from tkinter import *
#!/usr/bin/pyhton
#-*-coding:Utf-8-*-

import RPi.GPIO as GPIO
import time

#Paramétrage des noms pour GPIO
BUTTON1 = 18 
BUTTON2 = 23
BUTTON3 = 24
BUTTON4 = 25
BUTTONreset = 16
BUTTONvalider = 20
LED1 = 4 
LED2 = 17 
LED3 = 27 
LED4 = 22
LEDrouge = 5
LEDverte = 6
entree_avant = 0

#Paramétrage des pins
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(BUTTON1,GPIO.IN)
GPIO.setup(BUTTON2,GPIO.IN)
GPIO.setup(BUTTON3,GPIO.IN)
GPIO.setup(BUTTON4,GPIO.IN)
GPIO.setup(BUTTONreset,GPIO.IN)
GPIO.setup(BUTTONvalider,GPIO.IN)
GPIO.setup(LED1,GPIO.OUT)
GPIO.setup(LED2,GPIO.OUT)
GPIO.setup(LED3,GPIO.OUT)
GPIO.setup(LED4,GPIO.OUT)
GPIO.setup(LEDrouge,GPIO.OUT)
GPIO.setup(LEDverte,GPIO.OUT)

#On met à l’état 0 toutes les leds et les valeurs au préalable
GPIO.output(LED1, GPIO.LOW)
GPIO.output(LED2, GPIO.LOW)
GPIO.output(LED3, GPIO.LOW)
GPIO.output(LED4, GPIO.LOW)
GPIO.output(LEDrouge, GPIO.LOW)
GPIO.output(LEDverte, GPIO.LOW)
i=1
resultat = 0

#import question/rep fichier txt
F = open('questionsréponses.txt','r')
Entete = F.readline().rstrip('\n\r').split(',')

#les index
Questionidx = Entete.index("Question")
SQuestionidx = Entete.index("sous-question")
Prop1idx = Entete.index("Prop1")
Prop2idx = Entete.index("Prop2")
Prop3idx = Entete.index("Prop3")
Prop4idx = Entete.index("Prop4")
widx = Entete.index("w")
xidx = Entete.index("x")
yidx = Entete.index("y")
zidx = Entete.index("z")

#mise en place des listes
Questionliste = []
SQuestionliste = []
Prop1liste = []
Prop2liste = []
Prop3liste = []
Prop4liste = []
wliste = []
xliste = []
yliste = []
zliste = []

for ligne in F :
    donneesF = ligne.rstrip('\n\r').split(',')
    Questionliste.append(donneesF[Questionidx])
    SQuestionliste.append(donneesF[SQuestionidx])
    Prop1liste.append(donneesF[Prop1idx])
    Prop2liste.append(donneesF[Prop2idx])
    Prop3liste.append(donneesF[Prop3idx])
    Prop4liste.append(donneesF[Prop4idx])
    wliste.append(donneesF[widx])
    xliste.append(donneesF[xidx])
    yliste.append(donneesF[yidx])
    zliste.append(donneesF[zidx])

#Fonction interface questions
def Creation_fen():
    global i
    #lafenetre
    Question= Tk()
    Question.title("Question")
    Question.geometry("800x650")

    #Création Frame Image
    Image = Frame(Question, bg="red", padx=20, pady=20, width = 800, height = 400)
    Image.pack_propagate(False)
    Image.pack()

    #Création Frame QetR
    QetR = Frame(Question, bg="black", padx=20, pady=20)
    QetR.pack(fill="both", expand="yes", side = TOP)

    #Image du Login Screen
    Photo=PhotoImage(file="bank/Q"+str(i)+".gif")
    ImageCanvas=Canvas(Image,width=800,height=400,bg="white")
    ImageCanvas.create_image(0,0,image=Photo, anchor=NW)
    ImageCanvas.pack(side=TOP)

    #numéro de question
    nQ = Label(QetR, text ="Question n°"+str(i), fg = 'white', bg = 'black',font="arial 17 bold")
    nQ.pack(side = TOP, padx = 5, pady = 5)

    #la question
    Q11 = Label(QetR, text = Questionliste[i-1], fg = 'white', bg = 'black',font="arial 15 bold")
    Q11.pack(side = TOP, padx = 0, pady = 0)

    #proposition 1
    A = Label(QetR, text = Prop1liste[i-1] ,fg = 'white', bg = 'black',font="arial 15")
    A.pack(side = TOP, padx = 0, pady = 0)

    #proposition 2
    B = Label(QetR, text = Prop2liste[i-1], fg = 'white', bg = 'black', font='arial 15')
    B.pack(side = TOP, padx = 0, pady = 0)

    #Sous-question
    if SQuestionliste[i-1] != '' :
        Q12 = Label(QetR, text = SQuestionliste[i-1], fg='white' ,bg='black',font="arial 15 bold")
        Q12.pack( padx = 0, pady = 0)

    #proposition 3
    C = Label(QetR, text = Prop3liste[i-1], fg = 'white', bg = 'black',font="arial 15")
    C.pack(padx = 0, pady = 0)

    #proposition 4
    D = Label(QetR, text = Prop4liste[i-1], fg = 'white', bg = 'black', font='arial 15')
    D.pack( padx = 0, pady = 0)
    a=GPIO.input(BUTTON1)
    
    Question.mainloop()

#le code GPIO
def codeGPIO():
    global resultat
    global i
    w=0
    x=0
    y=0
    z=0
    r=0
    reponse=0
    
    while i<=20 and GPIO.input(BUTTON1)>=0 and GPIO.input(BUTTON2)>=0 and GPIO.input(BUTTON3)>=0 and GPIO.input(BUTTON4)>=0 :
        GPIO.output(LEDrouge, GPIO.LOW)
        GPIO.output(LEDverte, GPIO.LOW)
        if GPIO.input(BUTTON1)==1 :
            GPIO.output(LED1, GPIO.HIGH)
            w=1
        if GPIO.input(BUTTON2)==1 :
            GPIO.output(LED2, GPIO.HIGH)
            x=1
        if GPIO.input(BUTTON3)==1 :
            GPIO.output(LED3, GPIO.HIGH)
            y=1
        if GPIO.input(BUTTON4)==1 :
            GPIO.output(LED4, GPIO.HIGH)
            z=1
        if GPIO.input(BUTTONreset)==1 :
            GPIO.output(LED1, GPIO.LOW)
            GPIO.output(LED2, GPIO.LOW)
            GPIO.output(LED3, GPIO.LOW)
            GPIO.output(LED4, GPIO.LOW)
            w=0
            x=0
            y=0
            z=0
        if GPIO.input(BUTTONvalider)==1 :
            i=i+1
            while GPIO.input(BUTTONvalider)==1 :
                time.sleep(1)
                if w==1 and x==1 and y==1 and z==0:
                    GPIO.output(LEDverte, GPIO.HIGH)
                    print ("Gagné !")
                    resultat=resultat+1
                else :
                    GPIO.output(LEDrouge, GPIO.HIGH)
                    print ("Perdu !")
            print (resultat)
            w=0
            x=0
            y=0
            z=0
            time.sleep(3)
            GPIO.input(BUTTON1)==0
            GPIO.input(BUTTON2)==0
            GPIO.input(BUTTON3)==0
            GPIO.input(BUTTON4)==0
            GPIO.output(LED1, GPIO.LOW)
            GPIO.output(LED2, GPIO.LOW)
            GPIO.output(LED3, GPIO.LOW)
            GPIO.output(LED4, GPIO.LOW)
            GPIO.output(LEDrouge, GPIO.LOW)
            GPIO.output(LEDverte, GPIO.LOW)
                
                
    return(codeGPIO)

while i<=20:
    Creation_fen()
    codeGPIO()
    i=i+1
    print (str(resultat)+'/20') 

Bon je ne sais pas si le problème est résolu ou non, mais si tu (ou quelqu'un) a besoin d'aide sur les threads, j'ai improvisé un petit tuto pour débutant

import threading
class MonPremierThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        #code...

monThread = MonPremierThread()
monThread.start()

OUAH ! Super sympas de ta part pour ce petit tuto personnalisé :P
Je check ça tout de suite je te tiens au courant :D

Juste une petite question si je fais une boucle (while) avec les deux Thread et que je mets start dans la boucle, qu'est ce qui va se passer lorsque la boucle va refaire start ? Est ce que les thread vont se fermer puis se rouvrir ou ils vont se cumuler ?

ThreadTK = thread1()
ThreadRasp = thread2()

while i<=20:
    ThreadTK.start()
    ThreadRasp.start()
    i=i+1

Le 12 avril 2017 à 16:38:45 AxlRoses19 a écrit :
Juste une petite question si je fais une boucle (while) avec les deux Thread et que je mets start dans la boucle, qu'est ce qui va se passer lorsque la boucle va refaire start ? Est ce que les thread vont se fermer puis se rouvrir ou ils vont se cumuler ?

ThreadTK = thread1()
ThreadRasp = thread2()

while i<=20:
    ThreadTK.start()
    ThreadRasp.start()
    i=i+1

Je pense qu'il ne va rien se passer ou au mieux tu vas te prendre une erreur dans la tronche.

Ce qu'il faut voir ici c'est que tu as créé deux voitures (thread)

ThreadTK = thread1()
ThreadRasp = thread2()

T'auras beau essayer de les démarrer 20 fois tu vas pas te retrouver avec 2x20 voitures en marche. Ce qu'il va se passer c'est qu'elles vont toutes les deux démarrer à la première tentative et rien ne se passera les 19 autres fois. Cependant je parierais sur une erreur vu que ce que tu essaies de faire dans ce bout de code n'a pas de sens.

Le 12 avril 2017 à 15:08:26 Elmohe a écrit :
Bon je ne sais pas si le problème est résolu ou non, mais si tu (ou quelqu'un) a besoin d'aide sur les threads, j'ai improvisé un petit tuto pour débutant

SpoilAfficherMasquer

Un thread, ça sert à quoi ?
En gros, un thread est une méthode qui va se lancer à côté du programme, permettant de faire plusieurs actions en même temps (en temps normal ça transfère un processus sur un autre cœur, mais apparemment pas en Python).
Dans ton example, tu pourras alors utiliser un thread pour gérer à la fois ton Raspberry et à la fois ton questionnaire du code de la route Tkinter.

Comment mettre en place un (ou plusieurs) thread(s) ?
C'est assez simple : au lieu d'utiliser une fonction (def fonction(): ...) tu vas utiliser une classe qui hérite de threading.Thread (si tu ne comprends pas les héritages c'est pas trop grave, dis toi que tu vas récupérer les attributs de la classe threading.Thread).

Voici un exemple :

import threading
class MonPremierThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        #code...

monThread = MonPremierThread()
monThread.start()

En premier, on va donc importer le module threading. Il va nous permettre de créer des threads pour lancer plusieurs processus en même temps.
La ligne 2 déclare une classe, héritée de threading.Thread. (Cela montre au programme que cette classe sera destinée à accueillir un thread).
La ligne 3 (def __init__(self):) est ce qu'on appelle le constructeur de ta classe : c'est ici que tu pourras initialiser des variables (ex : self.nombreEntier = 2).
Dans ce constructeur, on va initialiser le thread en appelant son constructeur (méthode __init__()). C'est pas trop important de comprendre cette ligne, il faut juste la mettre
Ensuite, tu déclares (surcharge pour les puristes) la méthode run() : c'est celle qui va se lancer lorsque tu démarrera ton thread. Dedans, tu peux y mettre tout le code que tu veux lancer en parallèle. Dans ton exemple, c'est le code pour tkinter, ou celui du Raspberry.

Maintenant que tu as déclaré ton thread proprement, ton programme n'attend plus qu'à le lancer.
Ainsi, tu instancies (crée un objet à partir de la classe) monThread (c'est une variable de type MonPremierThread, tu aurais aussi pu l'appeler jAimeLesFrites si tu veux).
Une fois ton instance créée, tu n'as plus qu'à la lancer avec monThread.start() (ou bien jAimeLesFrites.start()) ce qui va dire à Python de lancer la méthode run() en parallèle du reste du programme.

Maintenant que tu sais comment mettre en place un thread, il ne te suffit plus qu'à en créer un pour tkinter, un pour ton raspberry, mettre le bon code dans les méthodes run(), et les lancer !
(Bon par contre tu peux avoir deux trois problèmes de portées de variables auquel cas tu devras utiliser global, je te laisse googler pour ça)

Dans le cas de figure ou le besoin est simplement de paralléliser l'exécution, on peut se limiter à uniquement redéfinir la méthode run, pas besoin de redéfinir__init__. Cela peut avoir de l'intérêt si chaque thread a des caractéristiques bien spécifiques que tu pourrais alors déclarer en variable de classe mais je ne pense pas que ce soit le cas ici (au passage tout le monde fait la confusion mais __init__ n'est pas le constructeur mais l' initialisateur ) .

En faite avec cette boucle je souhaite faire les 20 questions, donc que la fenêtre tkinter et les gpio de la raspberry s'ouvrent 20 fois. J'aimerais qu'il y ait un bouton sur la rasp qui fasse passer à la prochaine question, donc détruire l'ancienne fenêtre, fermer le thread et la relancer. Donc faire cette action 20 fois :D

Voilà où j'en suis avec mon programme :

from tkinter import *
import RPi.GPIO as GPIO
import time
import threading

#Paramétrage des noms pour GPIO
#Paramétrage des pins
#On met à l’état 0 toutes les leds et les valeurs au préalable
#import question/rep fichier txt on créer des index puis des listes
#lecture des fichiers 

#Fonction interface questions
class TkinterThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        #les  variables

    def run(self):
         #le code Tkinter
        Question.mainloop()

#Class et Thread Tkinter
class GPIOThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.running = False
        #les variables

    def run(self):
        self.running = True
        while i<=20 and GPIO.input(BUTTON1)>=0 and GPIO.input(BUTTON2)>=0 and GPIO.input(BUTTON3)>=0 and GPIO.input(BUTTON4)>=0 :
            GPIO.output(LEDrouge, GPIO.LOW)
            GPIO.output(LEDverte, GPIO.LOW)
            if GPIO.input(BUTTON1)==1 :
                GPIO.output(LED1, GPIO.HIGH)
                w=1
            if GPIO.input(BUTTON2)==1 :
                GPIO.output(LED2, GPIO.HIGH)
                x=1
            if GPIO.input(BUTTON3)==1 :
                GPIO.output(LED3, GPIO.HIGH)
                y=1
            if GPIO.input(BUTTON4)==1 :
                GPIO.output(LED4, GPIO.HIGH)
                z=1
            if GPIO.input(BUTTONreset)==1 :
                #On remet tout à 0
            if GPIO.input(BUTTONvalider)==1 :
                while GPIO.input(BUTTONvalider)==1 :
                    time.sleep(1)
                    if w==wliste[i] and x==xliste[i] and y==yliste[i] and z==zliste[i]:
                        GPIO.output(LEDverte, GPIO.HIGH)
                        print ("Gagné !")
                        resultat=resultat+1
                    else :
                        GPIO.output(LEDrouge, GPIO.HIGH)
                        print ("Perdu !")
                #On remet les variables à 0
                time.sleep(3)
                #on remet les GPIO à 0
                Question.destroy()
                
    def stop(self):
        self.running = False

ThreadRasp = GPIOThread()
ThreadTK = TkinterThread()

while i<=20:
    global i
    ThreadTK.start()
    ThreadRasp.start()
    time.sleep(30)
    ThreadTK.stop()
    ThreadRasp.stop()
    i=i+1

Le 12 avril 2017 à 21:39:18 MrGreez94 a écrit :

Le 12 avril 2017 à 15:08:26 Elmohe a écrit :
Bon je ne sais pas si le problème est résolu ou non, mais si tu (ou quelqu'un) a besoin d'aide sur les threads, j'ai improvisé un petit tuto pour débutant

SpoilAfficherMasquer

Un thread, ça sert à quoi ?
En gros, un thread est une méthode qui va se lancer à côté du programme, permettant de faire plusieurs actions en même temps (en temps normal ça transfère un processus sur un autre cœur, mais apparemment pas en Python).
Dans ton example, tu pourras alors utiliser un thread pour gérer à la fois ton Raspberry et à la fois ton questionnaire du code de la route Tkinter.

Comment mettre en place un (ou plusieurs) thread(s) ?
C'est assez simple : au lieu d'utiliser une fonction (def fonction(): ...) tu vas utiliser une classe qui hérite de threading.Thread (si tu ne comprends pas les héritages c'est pas trop grave, dis toi que tu vas récupérer les attributs de la classe threading.Thread).

Voici un exemple :

import threading
class MonPremierThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        #code...

monThread = MonPremierThread()
monThread.start()

En premier, on va donc importer le module threading. Il va nous permettre de créer des threads pour lancer plusieurs processus en même temps.
La ligne 2 déclare une classe, héritée de threading.Thread. (Cela montre au programme que cette classe sera destinée à accueillir un thread).
La ligne 3 (def __init__(self):) est ce qu'on appelle le constructeur de ta classe : c'est ici que tu pourras initialiser des variables (ex : self.nombreEntier = 2).
Dans ce constructeur, on va initialiser le thread en appelant son constructeur (méthode __init__()). C'est pas trop important de comprendre cette ligne, il faut juste la mettre
Ensuite, tu déclares (surcharge pour les puristes) la méthode run() : c'est celle qui va se lancer lorsque tu démarrera ton thread. Dedans, tu peux y mettre tout le code que tu veux lancer en parallèle. Dans ton exemple, c'est le code pour tkinter, ou celui du Raspberry.

Maintenant que tu as déclaré ton thread proprement, ton programme n'attend plus qu'à le lancer.
Ainsi, tu instancies (crée un objet à partir de la classe) monThread (c'est une variable de type MonPremierThread, tu aurais aussi pu l'appeler jAimeLesFrites si tu veux).
Une fois ton instance créée, tu n'as plus qu'à la lancer avec monThread.start() (ou bien jAimeLesFrites.start()) ce qui va dire à Python de lancer la méthode run() en parallèle du reste du programme.

Maintenant que tu sais comment mettre en place un thread, il ne te suffit plus qu'à en créer un pour tkinter, un pour ton raspberry, mettre le bon code dans les méthodes run(), et les lancer !
(Bon par contre tu peux avoir deux trois problèmes de portées de variables auquel cas tu devras utiliser global, je te laisse googler pour ça)

Dans le cas de figure ou le besoin est simplement de paralléliser l'exécution, on peut se limiter à uniquement redéfinir la méthode run, pas besoin de redéfinir__init__. Cela peut avoir de l'intérêt si chaque thread a des caractéristiques bien spécifiques que tu pourrais alors déclarer en variable de classe mais je ne pense pas que ce soit le cas ici (au passage tout le monde fait la confusion mais __init__ n'est pas le constructeur mais l' initialisateur ) .

Pardon pour cette erreur, je ne suis pas tellement Python même si je code beaucoup avec :P
Et oui j'allais le dire mais j'ai oublié de le dire qu'il était optionnel de surcharger __init__

Le 13 avril 2017 à 13:08:11 AxlRoses19 a écrit :
En faite avec cette boucle je souhaite faire les 20 questions, donc que la fenêtre tkinter et les gpio de la raspberry s'ouvrent 20 fois. J'aimerais qu'il y ait un bouton sur la rasp qui fasse passer à la prochaine question, donc détruire l'ancienne fenêtre, fermer le thread et la relancer. Donc faire cette action 20 fois :D

Voilà où j'en suis avec mon programme :

SpoilAfficherMasquer

from tkinter import *
import RPi.GPIO as GPIO
import time
import threading

#Paramétrage des noms pour GPIO
#Paramétrage des pins
#On met à l’état 0 toutes les leds et les valeurs au préalable
#import question/rep fichier txt on créer des index puis des listes
#lecture des fichiers 

#Fonction interface questions
class TkinterThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        #les  variables

    def run(self):
         #le code Tkinter
        Question.mainloop()

#Class et Thread Tkinter
class GPIOThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.running = False
        #les variables

    def run(self):
        self.running = True
        while i<=20 and GPIO.input(BUTTON1)>=0 and GPIO.input(BUTTON2)>=0 and GPIO.input(BUTTON3)>=0 and GPIO.input(BUTTON4)>=0 :
            GPIO.output(LEDrouge, GPIO.LOW)
            GPIO.output(LEDverte, GPIO.LOW)
            if GPIO.input(BUTTON1)==1 :
                GPIO.output(LED1, GPIO.HIGH)
                w=1
            if GPIO.input(BUTTON2)==1 :
                GPIO.output(LED2, GPIO.HIGH)
                x=1
            if GPIO.input(BUTTON3)==1 :
                GPIO.output(LED3, GPIO.HIGH)
                y=1
            if GPIO.input(BUTTON4)==1 :
                GPIO.output(LED4, GPIO.HIGH)
                z=1
            if GPIO.input(BUTTONreset)==1 :
                #On remet tout à 0
            if GPIO.input(BUTTONvalider)==1 :
                while GPIO.input(BUTTONvalider)==1 :
                    time.sleep(1)
                    if w==wliste[i] and x==xliste[i] and y==yliste[i] and z==zliste[i]:
                        GPIO.output(LEDverte, GPIO.HIGH)
                        print ("Gagné !")
                        resultat=resultat+1
                    else :
                        GPIO.output(LEDrouge, GPIO.HIGH)
                        print ("Perdu !")
                #On remet les variables à 0
                time.sleep(3)
                #on remet les GPIO à 0
                Question.destroy()
                
    def stop(self):
        self.running = False

ThreadRasp = GPIOThread()
ThreadTK = TkinterThread()

while i<=20:
    global i
    ThreadTK.start()
    ThreadRasp.start()
    time.sleep(30)
    ThreadTK.stop()
    ThreadRasp.stop()
    i=i+1

Tu reçois une erreur ?
Si oui, laquelle ?

D'ailleurs, à la ligne time.sleep(30), tu bloques le programme pendant 30s ; tu n'attends pas 30s : ainsi, ton code risque de ne pas s'exécuter. Je dis peut-être (sûrement) des bêtises (je ne sais pas si cela influe ou non sur le thread).
Aussi, tu risques de recevoir une erreur à cause du i non défini lors du premier passage dans le while si j'ai bien lu.

DONC, tu veux qu'à chaque fin de question, ta fenêtre se ferme, puis se rouvre pour la question suivante ?
Ne serait-il pas plus simple de juste rafraîchir l'affichage d'une seule fenêtre selon ton i (numéro de la question) ? C'est juste une suggestion, tu organises ton code comme tu veux

J'ai essayé de faire un code pour 1 seule question, avec ce code tout fonctionne pour 1 seule question, c'est à dire : création d'une fenêtre avec les questions, utilisation de boutons avec une raspberry pour répondre à cette question, et un bouton valider pour vérifier la réponse, afficher "Gagné ou Perdu" et détruire la fenêtre.

Malheureusement, le "IF" pour vérifier la réponse ne fonctionne pas je ne sais vraiment pas pourquoi :o
Donc voici la partie de code en question :

if GPIO.input(BUTTONvalider)==1 :
                while GPIO.input(BUTTONvalider)==1 :
                    time.sleep(1)
                    print (w,x,y,z)
                    print (wliste[i-1],xliste[i-1],yliste[i-1],zliste[i-1])
                    if w==wliste[i-1] and x==xliste[i-1] and y==yliste[i-1] and z==zliste[i-1] :
                        GPIO.output(LEDverte, GPIO.HIGH)
                        print ("Gagné !")
                        resultat=resultat+1
                    else :
                        GPIO.output(LEDrouge, GPIO.HIGH)
                        print ("Perdu !")

J'ai inséré 2 print pour vérifier les variables et on obtient les mêmes résultats par exemple : wxyz=0101 et wliste,xliste,yliste,zliste=0101, cependant le IF met Faux ... alors qu'il devrait mettre Vrai.

Et après pour faire la boucle je n'y arrive pas non plus :/ Il y a une erreur comme quoi on peut pas lancer plusieurs fois un Thread.
C'est pour cela que je vais me pencher sur la solution d'actualiser/rafraîchir la fenêtre, mais encore une fois j'y connais rien x)

A l'aide svp ^^

C'est bon j'ai réussi à résoudre le problème des variables et du IF qui ne fonctionnait pas ^^
Maintenant le programme fonctionne parfaitement pour une seule question, il faudrait que je puisse répéter ceci 20 fois mais je ne sais comment :/
Merci d'avance

up