Thread.tkinter

bonjour,
peut-être faut-il adapter ton code?

Voici le code:
from PIL import Image, ImageTk
import tkinter as tk
from tkinter import simpledialog
from tkinter import messagebox as mb
from vidgear.gears import CamGear
import argparse
import datetime
import cv2 as cv
import cv2
import os
import csv
import time
import sys, socket
from matplotlib.figure import Figure
#import matplotlib.animation as animation
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.animation import FuncAnimation
import matplotlib.animation as animation
from matplotlib import style
import numpy as np
from random import randint
import utils
import threading

#url = 'http://192.168.43.199:8081'
#cap = CamGear(source=url).start()

#Lib install

#sudo apt-get install python3-pil.imagetk
#sudo apt-get install libopencv-dev python-opencv

#Test Tkinter install
#python3 -m tkinter

white = "#ffffff"
lightBlue2 = "#adc5ed"
font = "Constantia"
fontButtons = (font, 12)
maxWidth = 1100
maxHeight = 700
temps =[]
vitesses_droites = np.array([])
vitesses_gauches = np.array([])
tps = np.array([])
xMax = 10
Distance_ultrason = []
vitesse_droite = []
vitesse_gauche = []
Latitude = []
Longitude = []
temps = []
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
#while True:
# if (not(msg == None)):
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()
class Application:
def __init__(self, output_path = "./"):
""" Initialize application which uses OpenCV + Tkinter. It displays
a video stream in a Tkinter window """
#replace with your video URL
#url = 'http://192.168.43.199:8081'
#cap = CamGear(source=url).start()
self.vs = cv2.VideoCapture('my_input.mp4') # capture video frames, 0 is your default video camera
self.vs2 = cv2.VideoCapture('my_input.mp4') # capture video frames, camVideo is your out video
self.output_path = output_path # store output path if want todo a snapshot
self.current_image = None # current image from the camera
self.current_image2 = None # current image from the camVideo

self.root = tk.Tk() # initialize root window

self.root.resizable(width=False, height=False) #block auto-resizable
self.root.geometry('%dx%d+%d+%d' % (maxWidth,maxHeight,0,0)) #window size
self.root.title("Project Interface") # set window title
self.root['bg'] = 'purple'

# self.destructor function gets fired when the window is closed
self.root.protocol('WM_DELETE_WINDOW', self.destructor)

self.panel = tk.Label(self.root, width=500,height=250) # initialize image panel
self.panel.pack(padx=5, pady=0, side=tk.LEFT)
self.panel.place(x=10, y=160)
self.img = cv2.imread("000.jpg")
self.resize_img =cv2.resize(self.img, (500, 250))
self.current_img = Image.fromarray(self.resize_img)
img_tk = ImageTk.PhotoImage(image=self.current_img)
self.panel.imgtk = img_tk
self.panel.config(image=img_tk)

self.panel1 = tk.Label(self.root, width=500,height=250) # initialize image panel1
self.panel1.pack(padx=5, pady=0, side=tk.RIGHT)
self.panel1.place(x=570, y=160)
self.img1 = cv2.imread("001.jpg")
self.resize_img1 =cv2.resize(self.img1, (500, 250))
self.current_img1 = Image.fromarray(self.resize_img1)
img_tk1 = ImageTk.PhotoImage(image=self.current_img1)
self.panel1.imgtk1= img_tk1
self.panel1.config(image=img_tk1)

self.panel2 = tk.Label(self.root, width=150,height=150)
self.panel2.pack(padx=5, pady=0, side=tk.LEFT)
self.panel2.place(x=10, y=10)
self.img = cv.imread("uam.jpg")
self.resize_img =cv.resize(self.img, (150, 150))
self.current_img = Image.fromarray(self.resize_img)
img_tk = ImageTk.PhotoImage(image=self.current_img)
self.panel2.imgtk = img_tk
self.panel2.config(image=img_tk)

self.panel3 = tk.Label(self.root, width=150,height=150)
self.panel3.pack(padx=5, pady=0, side=tk.LEFT)
self.panel3.place(x=930, y=10)
self.img = cv.imread("fast.jpg")
self.resize_img =cv.resize(self.img, (150, 150))
self.current_img = Image.fromarray(self.resize_img)
img_tk = ImageTk.PhotoImage(image=self.current_img)
self.panel3.imgtk = img_tk
self.panel3.config(image=img_tk)

#graphique courbe
#print parameters values using a listbox
self.liste = tk.Listbox(self.root, width=35,height=15)
self.liste.insert(1, "Distance Ultrason : "+ str(100))
self.liste.insert(2, "Vitesse roues droites : "+ str(65))
self.liste.insert(3, "Vitesse roues gauches : "+ str(65))
self.liste.insert(4, "Latitude : "+ str(10.4))
self.liste.insert(5, "Longitude : "+ str(51.5))
self.liste.pack()
self.liste.place(x=550, y=600)
'''
def clearlist():
listb2.delete(0,END)
for nom in cur.fetchall():
listb.insert(END,nom)

self.liste = tk.Listbox(self.root, width=35,height=15)
self.liste.insert(1, print('Distance_ultrason[i]=, Distance_ultrason[i]'))
self.liste.insert(2, print('vitesse_droite[i]=, vitesse_droite[i]'))
self.liste.insert(3, print('vitesse_gauche[i]=, vitesse_gauche[i]'))
self.liste.insert(4, print('Latitude[i]=, Latitude[i]'))
self.liste.insert(5, print('Latitude[i]=, Latitude[i]'))
self.liste.pack()
self.liste.place(x=550, y=600)
'''

#
#create a button, that when pressed, start a car driving
#Todo : define the function
btn = tk.Button(self.root, text="Demarrer", bg='red', command=demarrer)
btn.pack()
btn.place(x=580, y=550)

#create a button, that when pressed, stop a car driving
#Todo : define the function
btn1 = tk.Button(self.root, text="arreter", bg='cyan', command=arreter)
btn1.pack()
btn1.place(x=680, y=550)

#create a button, that when pressed, change a car direction
#Todo : define the function
btn2 = tk.Button(self.root, text="devier_a_gauche", bg='green', command=devier_a_gauche)
btn2.pack()
btn2.place(x=780, y=550)

# create a button, that when pressed, will take the current frame and save it to file
btn3 = tk.Button(self.root, text="devier_a_droite", bg='orange', command=devier_a_droite)
btn3.pack()
btn3.place(x=950, y=550)

btn4 = tk.Button(self.root, text="Quitter", bg='yellow', command=self.root.quit)
btn4.pack()
btn4.place(x=500, y=550)

# start a self.video_loop and self.video2_loop that constantly pools the video sensor
# for the most recently read frame
#self.video_loop()
#self.video2_loop()

def video_loop(self):
""" Get frame from the video stream and show it in Tkinter """
ok, frame = self.vs.read() # read frame from video stream
if ok: # frame captured without any errors
cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA) # convert colors from BGR to RGBA
self.current_image = Image.fromarray(cv2image) # convert image for PIL
imgtk = ImageTk.PhotoImage(image=self.current_image) # convert image for tkinter
self.panel.imgtk = imgtk # anchor imgtk so it does not be deleted by garbage-collector
self.panel.config(image=imgtk) # show the image
self.root.after(30, self.video_loop) # call the same function after 30 milliseconds

def video2_loop(self):
""" Get frame from the video stream and show it in Tkinter """
ok, frame = self.vs2.read() # read frame from video stream
if ok: # frame captured without any errors
cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA) # convert colors from BGR to RGBA
self.current_image2 = Image.fromarray(cv2image) # convert image for PIL
imgtk = ImageTk.PhotoImage(image=self.current_image2) # convert image for tkinter
self.panel1.imgtk = imgtk # anchor imgtk so it does not be deleted by garbage-collector
self.panel1.config(image=imgtk) # show the image
self.root.after(30, self.video2_loop) # call the same function after 30 milliseconds

def destructor(self):
""" Destroy the root object and release all resources """
print("[INFO] closing...")
self.root.destroy()
self.vs.release() # release
self.vs2.release() # release
cv2.destroyAllWindows() # it is not mandatory in this application

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-o", "--output", default="./",
help="path to output directory to store snapshots (default: current folder")
args = vars(ap.parse_args())

# start the app
print("[INFO] starting...")
pba = Application(args["output"])

def get_back_values():
global vitesses_droites, vitesses_gauches, xMax, tps
# vitesse_droite, vitesse_gauche, temps = connexion()
"Dummy function"
if (len(vitesses_droites) < xMax):
vitesses_droites = np.append(vitesses_droites, vitesse_droite)
vitesses_gauches = np.append(vitesses_gauches, vitesse_gauche)
tps = np.append(tps, temps)
else:
vitesses_droites[0:10] = vitesses_droites[0:xMax]
vitesses_droites[9] = vitesse_droite
vitesses_gauches[0:10] = vitesses_gauches[0:xMax]
vitesses_gauches[9] = vitesse_gauche
tps[0:10] = tps[0:xMax]
tps[9] = temps
x = [tps[i] for i in range(10)]
print(temps[i])
y1 = [vitesses_droites[i] for i in range(10)]
print(vitesse_droite[i])
y2 = [vitesses_gauches[i] for i in range(10)]
print(vitesse_gauche[i])
return x, y1, y2
def update_graph(event=True):
global vitesses_droites
if (not(len(vitesses_droites) < 10)):
x, y1, y2 = get_back_values()
ax1.clear()
ax2.clear()
ax1.set_ylim(0, 10, auto=False)
#ax1.xaxis.set_ticks(range(6))
#ax1.xaxis.set_ticklabels(['0', '2', '4', '6', '8', '10'])
ax2.set_ylim(0, 10,auto=False)
#ax2.xaxis.set_ticks(range(6))
#ax2.xaxis.set_ticklabels(['0', '2', '4', '6', '8', '10'])
ax2.set_xlabel('Temps')
ax1.set_ylabel('vitesse_droite', color='g', fontsize = 22)
ax2.set_ylabel('vitesse_gauche', color='r', fontsize = 22)
ax1.plot(x, y1, 'g-o')
ax2.plot(x, y2, 'r-o')

style.use("ggplot")

fig = Figure(figsize=(8, 5), dpi=50)
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212, sharex=ax1)
ax2.set_xlabel('Temps')
ax1.set_ylim(0, 10, auto=False)
#ax1.xaxis.set_ticks(range(6))
#ax1.xaxis.set_ticklabels(['0', '2', '4', '6', '8', '10'])
ax1.set_ylabel('vitesse_droite', color='g', fontsize = 22)
ax2.set_ylabel('vitesse_gauche', color='r', fontsize = 22)
ax2.set_ylim(0, 10, auto=False)
#ax2.xaxis.set_ticks(range(6))
#ax2.xaxis.set_ticklabels(['0', '2', '4', '6', '8', '10'])
fig.tight_layout()

graph = FigureCanvasTkAgg(fig, master=pba.root)
#graph = FigureCanvasTkAgg(fig, height= 100, width=100; background='red', itmaster=app)
canvas = graph.get_tk_widget()
canvas.grid(row=0, column=0)

FuncAnimation(fig, update_graph, interval=2000)
ani = animation.FuncAnimation(fig, update_graph, interval=500)
canvas.pack()
canvas.place(x=45, y=440)
pba.root.mainloop()

#if __name__ == "__main__":
#fen = Application()
#fen.start()

Bonjour, j'ai testé plusieurs fois ces balises pour préserver l'indentation mais ça ne marche pas toujours. Le problème du code est que le thread envoie la variable globale msg au serveur en tenant compte de ses variations lorsqu'on clique sur les boutons de tkinter. Merci.

Bonjour,

C'est pourtant simple et ça marche toujours:

on fait un copier/coller du code ici, on le sélectionne à la souris, on clique sur la petite icone

"flèche vers le bas" dans la barre d'icones au dessus, on choisit Python dans la liste déroulante

et cela met le code entre balises

Ensuite, lorsque le message est validé, le code apparait comme ceci:

def test():
    print('test')

test()

tu écris "Le clic sur un bouton d'une interface graphique tkinter change la valeur de la variable globale ''msg''.".
En es-tu certain? Comment l'as-tu vérifié?

Ton code contient plein de choses qui n'ont rien à voir avec ton soucis. Simplifie-le pour n'en garder que le minimum qui montre le soucis.

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

Merci, 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 plait. Merci d'avance.

Je l'ai vérifié parce que lorsque je clique sur un bouton et que ça n'a pas marché, je relance le code et là ça marche mais lorsque je clique sur un autre bouton ça ne marche pas, le thread n'envoie pas.

Salut,

Que doit faire ton script en fait ?
Quel travail doit faire le thread ?

Parce d'après tes dernières réponses, je crois qu'utiliser un thread n'a pas d'intérêt sachant que tkinter peut faire la même chose naturellement.

Par exemple, quelques retouches de ton code en utilisant une simple variable tkinter à laquelle on définit une fonction de callback laquelle sera exécutée chaque fois que celle-ci est modifiée.

import tkinter as tk

class Commandes():
    def __init__(self, communication):
        self._com = communication

    def demarrer(self):
        self._com.send("1")

    def arreter(self):
        self._com.send("4")

    def devier_a_gauche(self):
        self._com.send("2")

    def devier_a_droite(self):
        self._com.send("3")

Resultat = None
class Fenetre():
    def __init__(self):
        self.root = tk.Tk()
        self.root.geometry("450x500")
        self.communication = Communication(self.root)
        self.communication.run()
        self.commandes = Commandes(self.communication)
        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.commandes.demarrer)
        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.commandes.devier_a_gauche)
        btn3.pack()
        btn3.place(x=320, y=200)
        btn4 = tk.Button(self.root, text="commande3", bg='yellow', command=self.commandes.devier_a_droite)
        btn4.pack()
        btn4.place(x=20, y=300)
        btn5 = tk.Button(self.root, text="commande4", bg='orange', command=self.commandes.arreter)
        btn5.pack()
        btn5.place(x=320, y=300)

class Communication():
    def __init__(self, window):
        self._win = window
        self._msg = tk.Variable(self._win, '', 'msg')
        self._msg.trace('w', self._manage)
        self._stopped = False

    def _manage(self, *args):
        if self._stopped:
            print("Can't send message, communication is not running")
            return
        print(self._msg.get())
        if self._msg.get() == "4":
            self._stopped = True

    def run(self):
        self._stopped = False
        print('Ready !')

    def send(self, msg):
        self._msg.set(msg)

fenetre = Fenetre()
fenetre.root.mainloop()

Ce n'est qu'un simple exemple, maintenant si ce n'est pas possible de gérer ça de cette façon, regarde alors du côté de la méthode after de tkinter, dans 99,99% des cas il n'y a pas besoin d'utiliser un thread avec tkinter.

En résumé le script permet de commander un robot-car à distance. Le thread est nécessaire pour la communication client-serveur et l'interface pour la commande. Les deux doivent être indépendants.