Discussion :

[yazchapi]

Bonjour, j'ai un thread qui gère une communication client-serveur et une interface graphique tkinter qui permet de modifier la valeur affectée à la variable globale à envoyer au serveur ( par clic sur l'un des boutons de l'interface). Mais lorsque je clique sur l'un des boutons le thread n'envoie pas le message au serveur. Quelqu'un pour m'aider s'il vous plaît. Merci.

[yazchapi]

Bonjour, voilà le bout de code géré par le thread. Mais ça ne marche pas à cause de la variable globale msg. J'attend votre aide s'il vous plaît. Merci d'avance.

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
msg = None   
 
def demarrer():
    global msg
    msg = str(1)
 
def arreter():
    global msg
    msg = str(4)
 
def devier_a_gauche():
    global msg
    msg = str(2)
 
def devier_a_droite():
    global msg
    msg = str(3)
 
HOST = sys.argv[-1] if len(sys.argv) > 1 else '192.168.43.199'
PORT = utils.PORT
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
print('\nConnected to {}:{}'.format(HOST, PORT))
print("Type message, enter to send. 'q' to quit")
 
class ThreadCommunication(threading.Thread):
    """objet thread gérant la communication"""
    def __init__(self, sock):
        threading.Thread.__init__(self)
        self.connexion = sock           # réf. du socket de connexion
    def run(self):
        global msg
        if(msg):
            utils.send_msg(sock, msg)
            print(msg)
        #print(msg)
        msg = None
        msgFromArduino = utils.recv_msg(sock)
        msgFromArduino = msgFromArduino.split(':')[1].split(';')
        print(msgFromArduino)
        if (not(len(msgFromArduino) < 6)):
            data1 = msgFromArduino[0]
            data2 = msgFromArduino[1]
            data3 = msgFromArduino[2]
            data4 = msgFromArduino[3]
            data5 = msgFromArduino[4]
            start_time = time.time()
            secondes = time.time() - start_time
            Distance_ultrason.append(data1)
            vitesse_droite.append(data2)
            vitesse_gauche.append(data3)
            Latitude.append(data4)
            Longitude.append(data5)
            temps.append(round(secondes, 2))
            now = datetime.datetime.now()
            c = open('fichierrobot_car_' +  '_' + str(now.strftime("%Y-%m-%d-%H-%M")) + '.csv', "w")
            c = csv.writer(c, delimiter="\t")
            c.writerow (("Distance_ultrason","vitesse_droite","vitesse_gauche","Latitude","Longitude","temps"))
            fin1, fin2 = len(Distance_ultrason), len(vitesse_droite)
            if fin1 == fin2: 
                for i in range (fin1):
                    c.writerow((Distance_ultrason[i],vitesse_droite[i],vitesse_gauche[i],Latitude[i],Longitude[i],temps[i]))
                    return vitesse_droite, vitesse_gauche, temps
thrd = ThreadCommunication(sock)
thrd.start()

[wiztricks]

Bonjour, voilà le bout de code géré par le thread. Mais ça ne marche pas à cause de la variable globale msg. J'attend votre aide s'il vous plaît. Merci d'avance.

Le bout de code est un programme qui lance un thread qui ne fait qu'une seule opération sans même attendre que la variable globale ait été modifiée.
A la base vous ne savez pas trop programmer çà.

Commencer par un code plus simple: un Bouton tkinter qui lorsqu'on clique dessus affiche un message.

Puis vous ouvrez la documentation des threads pour apprendre à vous en servir. Vous devriez trouver qu'écrire dans une Queue serait peut être un moyen pour communiquer des données à un thread. Donc à la place d'afficher un message avec "print", vous allez le pousser dans une Queue et de l'autre côté le thread qui attendait qu'il y ait quelque chose à faire se réveille pour lire le message dans la Queue et dans un premier temps seulement l'afficher sera un bon début.

- W

[yazchapi]

J'ai commencé par un simple code: un thread qui remplit un label avec le résultat d'un calcul à chaque clic d'un bouton d'une interface tkinter et ça marche correctement. Merci.

[yazchapi]

Bonjour
Voilà un code de test que j'ai écrit en suivant ce que vous avez:

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
 from threading import Thread
from queue import Queue
from time import sleep
 
class Producer:
	def __init__(self):
		self.q = Queue()
 
	def produce(self):
		i = input()
		self.q.put(i)
		if (not(self.q.put(i) == None)):
			print('Item produced', self.q.put(i))
		else:
			self.q.put_nowait(i)
		sleep(1)
 
class Consumer:
	def __init__(self, prod):
		self.prod = prod
 
	def consume(self):
		msg = self.prod.q.get()
		if (not(msg == None)):
			print('Item receved', msg)
		else:
			self.prod.q.get_nowait()
p = Producer()
c = Consumer(p)
t1 = Thread(target=p.produce)
t2 = Thread(target=c.consume)
t1.start()
t2.start()
t1.join()
t2.join()

Et le bout de code mis à jour (J'ai pas testé comme je ne suis pas au laboratoire (Le but du projet est de commander un robot-car à distance)).

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
 msg = None	
 
def demarrer():
	global msg
	msg = str(1)
 
def arreter():
	global msg
	msg = str(4)
 
def devier_a_gauche():
	global msg
	msg = str(2)
 
def devier_a_droite():
	global msg
	msg = str(3)
 
HOST = sys.argv[-1] if len(sys.argv) > 1 else '192.168.43.199'
PORT = utils.PORT
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
print('\nConnected to {}:{}'.format(HOST, PORT))
print("Type message, enter to send. 'q' to quit")
 
class Attente:
	def __init__(self):
		self.q = Queue()
	def produce(self):
		global msg
		self.q.put(msg)
		if (not(self.q.put(msg) == None)):
			print('msg in queue', self.q.put(msg))
		else:
			self.q.put_nowait(msg)
		sleep(1)
 
class ThreadCommunication(threading.Thread):
	"""objet thread gérant la communication"""
	def __init__(self, sock, prod):
		threading.Thread.__init__(self)
		self.connexion = sock           # réf. du socket de connexion
		self.prod = prod
	def communication(self):
		msg = self.prod.q.get()
		if (not(msg == None)):
			print('msg receved', msg)
		else:
			self.prod.q.get_nowait()
		utils.send_msg(sock, msg)
		msgFromArduino = utils.recv_msg(sock)
		msgFromArduino = msgFromArduino.split(':')[1].split(';')
		print(msgFromArduino)
		if (not(len(msgFromArduino) < 6)):
			data1 = msgFromArduino[0]
			data2 = msgFromArduino[1]
			data3 = msgFromArduino[2]
			data4 = msgFromArduino[3]
			data5 = msgFromArduino[4]
			start_time = time.time()
			secondes = time.time() - start_time
			Distance_ultrason.append(data1)
			vitesse_droite.append(data2)
			vitesse_gauche.append(data3)
			Latitude.append(data4)
			Longitude.append(data5)
			temps.append(round(secondes, 2))
			now = datetime.datetime.now()
			c = open('fichierrobot_car_' +  '_' + str(now.strftime("%Y-%m-%d-%H-%M")) + '.csv', "w")
			c = csv.writer(c, delimiter="\t")
			c.writerow (("Distance_ultrason","vitesse_droite","vitesse_gauche","Latitude","Longitude","temps"))
			fin1, fin2 = len(Distance_ultrason), len(vitesse_droite)
			if fin1 == fin2:  
				for i in range (fin1):
					c.writerow((Distance_ultrason[i],vitesse_droite[i],vitesse_gauche[i],Latitude[i],Longitude[i],temps[i]))
					return vitesse_droite, vitesse_gauche, temps 
p = Attente()
thrd = ThreadCommunication(sock, p)
t1 = Thread(target=p.produce)
t2 = Thread(target=thrd.communication)
t1.start()
t2.start()
t1.join()
t2.join()

J'attends vos commentaires pour améliorer et aller faire le test. Merci de vous patienter pour des constats choquants. Merci.

[wiztricks]

Salut,

J'attends vos commentaires pour améliorer et aller faire le test. Merci de vous patienter pour des constats choquants.

Si vous pensez que le code que vous avez écrit a des chances de fonctionner, il faut le tester et (vous) poser des questions en fonction de comment il réagit (ce qu'on ne peut pas faire pour vous puisqu'on n'a pas le robot qui est commandé par le code).

Pour le reste, si vous aviez suivi les conseils que je vous ai donné (écrire un petit code pour voir comment articuler tkinter et thread via une Queue), vous auriez constaté par vous même que le thread qui produit des informations est le côté tkinter: pas besoin d'un thread Producer.

De plus, ce code là n'a pas besoin de robot pour être testé (et constater qu'il fonctionne ou pas).

- W

[wiztricks]

Vous avez bien dit qu'on peut le tester sans avoir le robot

Je parlais justedu code qui affiche un Button qui lorsqu'on clique dessus pousse une information dans une Queue avec de l'autre côté un thread qui récupère ce qu'il y a dans la Queue pour l'afficher (avec print).

- W

[yazchapi]

Ah d'accord. Merci.

[yazchapi]

Bonjour
Voilà le code avec un seul bouton, l’affichage se fait dans le terminal et non dans le label affichant None lorsqu'on quitte l'interface (c'est pas ça l'essentiel). (Je n'arrige pas à mieules lignes 40, 41, 42)

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
import sys, threading
import numpy as np
import tkinter as tk
import time
from queue import Queue
 
Resultat = None
class Fenetre():
    def __init__(self):
        threading.Thread.__init__(self)
        self.q = Queue()
        self.root = tk.Tk()
        self.root.geometry("450x500")
        label = tk.Label(self.root, text="Resultat: {}".format(Resultat))
        label.pack(side="top", fill="both", expand=True)
        btn1 = tk.Button(self.root, text="commande", bg='cyan', command=self.calcul)
        btn1.pack()
        btn1.place(x=20, y=200)
        btn2 = tk.Button(self.root, text="Quitter", bg='yellow', command=self.root.quit)
        btn2.pack()
        btn2.place(x=350, y=200)
 
    def calcul(self):
        global Resultat
        x = np.arange(4)
        y = np.arange(10,16)
        A = np.arange(2, 3, 0.1)
        B = np.append(x, y)
        Resultat = A+B
        self.q.put(Resultat)
        time.sleep(1)
class Consumer:
    def __init__(self, prod):
        self.prod = prod
 
    def consume(self):
        msg = self.prod.q.get()
        print('Item receved', msg)
 
Fenetre().root.mainloop()
p = Fenetre()
c = Consumer(p)
t1 = threading.Thread(target=p.calcul)
t2 = threading.Thread(target=c.consume)
t1.start()
t2.start()
t1.join()
t2.join()

Mais lorsque j'augmente des boutons (comme j'en ai 4 dans mon vrai code) je ne sais vraiment pas comment créer un seul thread qui vas récupérer le msg, ligne 51, 52, 53 , 54 du code ci dessous comme ce n'est pas une seule fonction (calcul1, calcul2) qui génère le msg. Merci.

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
import sys, threading
import numpy as np
import tkinter as tk
import time
from queue import Queue
 
Resultat = None
class Fenetre(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.q = Queue()
        self.root = tk.Tk()
        self.root.geometry("450x500")
        label = tk.Label(self.root, text="Resultat: {}".format(Resultat))
        label.pack(side="top", fill="both", expand=True)
        btn1 = tk.Button(self.root, text="commande1", bg='cyan', command=self.calcul1)
        btn1.pack()
        btn1.place(x=20, y=200)
        btn2 = tk.Button(self.root, text="Quitter", bg='yellow', command=self.root.quit)
        btn2.pack()
        btn2.place(x=150, y=200)
        btn3 = tk.Button(self.root, text="commande2", bg='orange', command=self.calcul2)
        btn3.pack()
        btn3.place(x=320, y=200)
 
    def calcul1(self):
        global Resultat
        x = np.arange(4)
        y = np.arange(10,16)
        A = np.arange(2, 3, 0.1)
        B = np.append(x, y)
        Resultat = A+B
        self.q.put(Resultat)
        time.sleep(1)
 
    def calcul2(self):
        global Resultat
        Resultat = np.arange(10,16)
        self.q.put(Resultat)
        time.sleep(1)
 
class Consumer:
    def __init__(self, prod):
        self.prod = prod
 
    def consume(self):
        msg = self.prod.q.get()
        print('Item receved', msg)
 
Fenetre().root.mainloop()
t1 = Fenetre()
c = Consumer(t1)
#t1 = threading.Thread(target=p.calcul)
t2 = threading.Thread(target=c.consume)
t1.start()
t2.start()
t1.join()
t2.join()

[wiztricks]

Salut,

Un code minimaliste qui affiche quelque chose lorsque je clique sur un Button serait:

Code :

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

1
2
3
4
5
6
7
8
9
10
from tkinter import Button, mainloop
 
counter = 0
def add_one():
    global counter
    counter += 1
    print (counter)
 
Button(text='add one', command=add_one).pack()
mainloop()

Si j'ajoute un thread derrière, çà donnerait:

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
from tkinter import Button, mainloop
from threading import Thread
from queue import Queue
 
queue = Queue()
def get_queue(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print (item)
 
counter = 0
def add_one():
    global counter
    counter += 1
    queue.put(('from button', counter))
 
thread = Thread(target=get_queue, args=(queue,))
thread.start()
 
Button(text='add one', command=add_one).pack()
mainloop()
queue.put(None)
thread.join()

Ça ne fait absolument rien d'intelligent hormis illustrer la "mécanique" ou j'ai des clicks qui produisent des objets consommés par un thread via une Queue.

notes:

• vous remarquez que j'expédie dans la queue un tuple (en fait un objet quelconque) et si de l'autre côté je dois savoir de quel Button çà sort...
• pas besoin de "class" pour ranger aussi peu de ligne de code.

- W

[yazchapi]

Merci. D'accord. Et si c'est plusieurs fonctions qui génèrent le message dans la queue comment va-t-on les passer à un seul thread ? J'utilise les classes parce que c'est ce que j'ai utilisé dans mon code client. Merci de vous patienter pour des impertinences d'un débutant.

[wiztricks]

Et si c'est plusieurs fonctions qui génèrent le message dans la queue comment va-t-on les passer à un seul thread ?

Imaginez faire la queue pour aller acheter un billet de cinéma ou à la caisse d'un supermarché... le client arrivera devant le caissier après un certain temps (surtout s'il n'y a qu'une seule caisse ouverte).

Ici c'est pareil: plein de fonctions poussent des messages dans la queue qui seront consommés par un seul thread (et donc traités au bout d'un certain temps).


- W

[yazchapi]

Dans mon code2 ci-dessous les fonctions calcul1() et calcul2() poussent le Resultat dans la queue. Le problème : comment le thread peut le récupérer pour le passer dans le thread 2 (t2=...) dans le même code. Je vous en prie de revenir sur ce code ? Merci.

[wiztricks]

Le problème : comment le thread peut le récupérer pour le passer dans le thread 2 (t2=...) dans le même code.

Si vous ne comprenez pas le code que j'ai écrit, vous ne comprendrez pas les bourdes qu'il y a dans votre code.

Quand je lis à partir de la ligne 50:

Code :

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

1
2
3
4
5
Fenetre().root.mainloop()
p = Fenetre()
c = Consumer(p)
t1 = threading.Thread(target=p.calcul)
t2 = threading.Thread(target=c.consume)

déjà vous n'avez pas compris ce que fait l'appel à "mainloop"...

Vous n'avez même pas le réflexe d'ajouter un "print" pour vérifier si le programme arrive bien aux instructions que vous espérez voir s'exécuter...

Cela ajouté au reste, çà ne peut pas marcher et si vous ne comprenez pas qu'avant de vouloir programmer, il y a des tas de choses à savoir et que pour savoir, il faut avoir pris le temps d'apprendre...

- W

[yazchapi]

D'accord merci.

[yazchapi]

Salut Wiztricks
Voici ce que j'ai fait à partir de votre code ci-haut. Mais je n'arrive pas à afficher en cliquant les boutons comme dans votre code. Le problème est au niveau du thread2 qui stocke le msg dans la queue et sa fonction. Je m'excuse vraiment et je suis un débutant. Comme je vous ai dit mon délai est expiré et on m'a donné d'autres taches. Du coup j'ai pas assez du temps. s'il vous plaît corrigez-moi ce code pour qu'il puisse afficher par clic sur chacun des boutons. Je m'excuse du dérangement et merci de vous patienter pour mes impertinences.

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
#from tkinter import Button, mainloop
from threading import Thread
from queue import Queue
import tkinter as tk
import time
 
msg = None
queue = Queue()
def get_queue(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print (item)
 
def demarrer():
    global msg
    msg = "1"
def arreter():
    global msg
    msg = "4"
def devier_a_gauche():
    global msg
    msg = "2"
 
def devier_a_droite():
    global msg
    msg = "3"
 
def put_queue():
    global msg
    queue.put(('from button', msg)) 
 
root = tk.Tk()
root.geometry("450x500")
btn1 = tk.Button(root, text="commande1", bg='cyan', command=demarrer)
btn1.pack()
btn1.place(x=20, y=200)
btn2 = tk.Button(root, text="Quitter", bg='yellow', command=root.quit)
btn2.pack()
btn2.place(x=150, y=200)
btn3 = tk.Button(root, text="commande2", bg='orange', command=devier_a_gauche)
btn3.pack()
btn3.place(x=320, y=200)
btn4 = tk.Button(root, text="commande3", bg='yellow', command=devier_a_droite)
btn4.pack()
btn4.place(x=20, y=300)
btn5 = tk.Button(root, text="commande4", bg='orange', command=arreter)
btn5.pack()
btn5.place(x=320, y=300)
 
root.mainloop()
 
thread1 = Thread(target=get_queue, args=(queue,))
thread2 = Thread(target=put_queue)
thread1.start()
thread2.start()
thread1.join()
thread2.join()

[wiztricks]

Du coup j'ai pas assez du temps. s'il vous plaît corrigez-moi ce code pour qu'il puisse afficher par clic sur chacun des boutons. Je m'excuse du dérangement et merci de vous patienter pour mes impertinences.

Il y a le même problème côté mainloop.
A part celle que j'ai écrite, aucune fonction/callback ne fait de queue.put.
Et je ne comprend pas d'où sort le second thread.

Quelque part vous avez collé votre code dans le mien sans chercher à comprendre: c'est juste n'importe quoi.

Je veux bien essayer de vous expliquer ce que vous avez mal compris (mais ça suppose montrer que vous avez essayé de comprendre quelque chose...) pour le reste, je ne suis pas petite main pour finir votre boulot.

- W

[yazchapi]

Pouvez-vous m'expliquer ce problème de mainloop s'il vous plaît ? J'ai vraiment pas compris ? Merci beaucoup.

[wiztricks]

Pouvez-vous m'expliquer ce problème de mainloop s'il vous plaît ? J'ai vraiment pas compris ? Merci beaucoup.

mainloop entre dans la boucle évènementielle de tkinter.
L'appel à cette fonction ne retourne que lorsque l'application appelle quit.
Accessoirement, les instructions qui suivent ne sont pas exécutées avant...
note: ce que vous pouvez constater avec un simple "print".

Ce genre d'explications ne peuvent être comprises que si vous avez passé du temps à apprendre à programmer avec tkinter... sinon c'est juste du charabia qui n'aide pas beaucoup.

C'est pas pour rien qu'on vous demande d'avoir ouvert un tuto. avant de poster: un forum de discussion suppose qu'on sache un peu de quoi on parle...
Et vous n'êtes pas en train de faire un exercice mais à écrire une (petite) application (i.e. supposé avoir appris avant) ou vous constatez que çà ne fait pas ce que vous voulez (normal ça fait ce pourquoi ça été construit... reste à savoir comment utiliser l'outil et l'apprentissage qui va avec).


- W

[yazchapi]

Je vous remercie très sincèrement.