Bonjour,

J'ai développé un programme python sur mon ordinateur de bureau possédant Windows10 et un processeur Intell Core i7 sur Pycharm, mon code fonctionne correctement sur cette ordinateur.

L'objectif est de pouvoir utiliser le logiciel sur une tablette fessant office d'ordinateur (type Getac) avec Windows 10 et un processeur Intell Atom x7.

Sur mon logiciel j'effectue la lecture d'une trame transmisse via une une communication série, et j'interprète la trame ou message réceptionné.

Sur la tablette le logiciel ne fonctionne pas correctement la boucle de lecture infinie ne s'exécute pas assez rapidement, observation d'un temps de latence durant l'interprétation de la trame ou message, puis désynchronisation de la lecture du message.

Je soupçonne la performance du processeur Atom x7 pas assez performante pour exécuter mon programme, y a-t-il une solution pour palier à cela ?

Merci d'avance pour votre aide

-
Edité par N12ico 26 octobre 2022 à 10:21:33

Atom c'est lent. Il y a peut-être moyen d'optimiser un peu ton code si tu nous le montres

Merci pour la réponse umfred, voici mon code :

import sys
import time
import tkinter as tk
import serial
import numpy as np
import threading
from tkinter import ttk
from tkinter import *
from serial.tools.list_ports import comports
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg)
from datetime import datetime


class Testeur(tk.Tk):
    """
    classe principale
    """

    def __init__(self):
        """
        constructeur de la classe
        """
        super().__init__()
        self.title('Outil de Contrôle T340')
        self.geometry("1200x750")
        icon = tk.PhotoImage(file="icon.png")
        self.iconphoto(False, icon)
        self.label_titre = ttk.Label(self, text="Contrôle T340", font=("Helvetica", 27, "bold"))
        self.label_titre.place(x=780, y=2)
        self.logo_atoms = tk.PhotoImage(file='ATOMS_new.png')
        self.image_logo = ttk.Label(self, image=self.logo_atoms, compound='top')
        self.image_logo.place(x=1060, y=2)
        # //////////////////////////////////////////////////////////////////////////////////////////////////////////////
        # Déclaration et Placement des lignes
        # //////////////////////////////////////////////////////////////////////////////////////////////////////////////
        self.line1 = tk.Frame(self, bg='black', height=2.5, width=1190)
        self.line1.place(x=2, y=45)
        self.line2 = tk.Frame(self, bg='black', height=700, width=2.5)
        self.line2.place(x=565, y=50)
        # ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        # Déclaration des différents élements de la fenêtre
        # //////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ttk.Style().configure('my.TButton', font=("Helvetica", 10, "bold"))
        self.start_button = ttk.Button(self, text='Démarrer', style='my.TButton', command=self.start)
        self.start_button.place(x=2, y=2)
        self.stop_button = ttk.Button(self, text='Stop', style='my.TButton', command=self.stop)
        self.stop_button.place(x=180, y=2)
        self.reset_button = ttk.Button(self, text='Reset', style='my.TButton', command=self.reset)
        self.reset_button.place(x=90, y=2)
        self.select_com = ttk.Label(self, text="Sélectionner Port :", font=("Helvetica", 10, "bold"))
        self.select_com.place(x=280, y=2)

        self.label_baud = ttk.Label(self, text="Baud Programmé :", font=("Helvetica", 10, "bold"))
        self.label_baud.place(x=430, y=2)
        self.label_baud_value = ttk.Label(self, text=115200, font=("Helvetica", 10, "bold"))
        self.label_baud_value.place(x=430, y=20)
        self.select_mode = ttk.Label(self, text="Sélectionner Mode :", font=("Helvetica", 10, "bold"))
        self.select_mode.place(x=580, y=2)
        self.manual = tk.IntVar()
        self.monitoring = tk.IntVar()
        self.check_manual = ttk.Checkbutton(self, text="Manuel", command=self.modemanual, variable=self.manual,
                                            onvalue=1, offvalue=0)
        self.check_manual.place(x=580, y=20)
        self.check_monitoring = ttk.Checkbutton(self, text="Monitoring", command=self.modemonitoring,
                                                variable=self.monitoring,  onvalue=1, offvalue=0)
        self.check_monitoring.place(x=660, y=20)

        self.help = ttk.Label(self, text="INSTRUCTION D'UTILISATION :\n"
                                    "1) Alimenter le DHCU T344\n"
                                    "2) Sélectionner le Port COM et le Mode\n"
                                    "3) Utiliser l'outil avec les boutons (Démarrer/Reset)\n"
                                    "4) Si la lecture n'est pas correctement établie effectuer un RESSET et DEMARRER ou bien redémarrer l'outil\n"
                                    "5) Ne pas éteindre le DHCU durant l'utilisation de l'outil",
                              font=("Helvetica", 10, "bold"))
        self.help.place(x=580, y=340)
        self.plan_T344 = tk.PhotoImage(file='plan_T340.png')
        tk.Label(self, image=self.plan_T344).place(x=575, y=58)
        self.my_frame_textbox = Frame(self)
        self.tex_scroll = Scrollbar(self.my_frame_textbox, orient=VERTICAL)
        self.tex_scroll.pack(side=RIGHT, fill=Y)
        self.my_textbox = tk.Text(self.my_frame_textbox, width=120, height=25, font=("Helvetica", 7),
                                  yscrollcommand=self.tex_scroll.set, wrap="none")
        self.my_textbox.pack(side=RIGHT)
        self.tex_scroll.config(command=self.my_textbox.yview, )
        self.my_frame_textbox.place(x=580, y=445)

        self.TitleDataHeader1 = ttk.Label(self, text="HEADER", font=("Helvetica", 10, "bold"))
        self.TitleDataHeader1.place(x=2, y=50)
        self.TitleDataHeader2 = ttk.Label(self, text="HEADER", font=("Helvetica", 10, "bold"))
        self.TitleDataHeader2.place(x=2, y=80)
        self.TitleDataHeader3 = ttk.Label(self, text="HEADER", font=("Helvetica", 10, "bold"))
        self.TitleDataHeader3.place(x=2, y=110)
        self.TitleDataHeader4 = ttk.Label(self, text="HEADER", font=("Helvetica", 10, "bold"))
        self.TitleDataHeader4.place(x=2, y=140)
        self.TitleData0 = ttk.Label(self, text="DATA 0", font=("Helvetica", 10, "bold"))
        self.TitleData0.place(x=2, y=170)
        self.TitleData1 = ttk.Label(self, text="DATA 1", font=("Helvetica", 10, "bold"))
        self.TitleData1.place(x=2, y=200)
        self.TitleData2 = ttk.Label(self, text="DATA 2", font=("Helvetica", 10, "bold"))
        self.TitleData2.place(x=2, y=230)
        self.TitleData3 = ttk.Label(self, text="DATA 3", font=("Helvetica", 10, "bold"))
        self.TitleData3.place(x=2, y=260)
        self.TitleData4 = ttk.Label(self, text="DATA 4", font=("Helvetica", 10, "bold"))
        self.TitleData4.place(x=2, y=290)
        self.TitleData5 = ttk.Label(self, text="DATA 5", font=("Helvetica", 10, "bold"))
        self.TitleData5.place(x=2, y=320)
        self.TitleData6 = ttk.Label(self, text="DATA 6", font=("Helvetica", 10, "bold"))
        self.TitleData6.place(x=2, y=350)
        self.TitleData7 = ttk.Label(self, text="DATA 7", font=("Helvetica", 10, "bold"))
        self.TitleData7.place(x=2, y=380)
        self.TitleData8 = ttk.Label(self, text="DATA 8", font=("Helvetica", 10, "bold"))
        self.TitleData8.place(x=2, y=410)
        self.TitleData9 = ttk.Label(self, text="DATA 9", font=("Helvetica", 10, "bold"))
        self.TitleData9.place(x=200, y=50)
        self.TitleData10 = ttk.Label(self, text="DATA 10", font=("Helvetica", 10, "bold"))
        self.TitleData10.place(x=200, y=80)
        self.TitleData11 = ttk.Label(self, text="DATA 11", font=("Helvetica", 10, "bold"))
        self.TitleData11.place(x=200, y=110)
        self.TitleData12 = ttk.Label(self, text="DATA 12", font=("Helvetica", 10, "bold"))
        self.TitleData12.place(x=200, y=140)
        self.TitleData13 = ttk.Label(self, text="DATA 13", font=("Helvetica", 10, "bold"))
        self.TitleData13.place(x=200, y=170)
        self.TitleData14 = ttk.Label(self, text="DATA 14", font=("Helvetica", 10, "bold"))
        self.TitleData14.place(x=200, y=200)
        self.TitleData15 = ttk.Label(self, text="DATA 15", font=("Helvetica", 10, "bold"))
        self.TitleData15.place(x=200, y=230)
        self.TitleData16 = ttk.Label(self, text="DATA 16", font=("Helvetica", 10, "bold"))
        self.TitleData16.place(x=200, y=260)
        self.TitleData17 = ttk.Label(self, text="DATA 17", font=("Helvetica", 10, "bold"))
        self.TitleData17.place(x=200, y=290)
        self.TitleData18 = ttk.Label(self, text="DATA 18", font=("Helvetica", 10, "bold"))
        self.TitleData18.place(x=200, y=320)
        self.TitleData19 = ttk.Label(self, text="DATA 19", font=("Helvetica", 10, "bold"))
        self.TitleData19.place(x=200, y=350)
        self.TitleDataChecksum1 = ttk.Label(self, text="CHECKSUM", font=("Helvetica", 10, "bold"))
        self.TitleDataChecksum1.place(x=200, y=380)
        self.TitleDataChecksum2 = ttk.Label(self, text="CHECKSUM", font=("Helvetica", 10, "bold"))
        self.TitleDataChecksum2.place(x=200, y=410)

        self.DataHeader1 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader1.place(x=80, y=50)
        self.DataHeader2 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader2.place(x=80, y=80)
        self.DataHeader3 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader3.place(x=80, y=110)
        self.DataHeader4 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader4.place(x=80, y=140)
        self.Data0 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data0.place(x=80, y=170)
        self.Data1 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data1.place(x=80, y=200)
        self.Data2 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data2.place(x=80, y=230)
        self.Data3 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data3.place(x=80, y=260)
        self.Data4 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data4.place(x=80, y=290)
        self.Data5 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data5.place(x=80, y=320)
        self.Data6 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data6.place(x=80, y=350)
        self.Data7 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data7.place(x=80, y=380)
        self.Data8 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data8.place(x=80, y=410)
        self.Data9 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data9.place(x=280, y=50)
        self.Data10 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data10.place(x=280, y=80)
        self.Data11 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data11.place(x=280, y=110)
        self.Data12 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data12.place(x=280, y=140)
        self.Data13 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data13.place(x=280, y=170)
        self.Data14 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data14.place(x=280, y=200)
        self.Data15 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data15.place(x=280, y=230)
        self.Data16 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data16.place(x=280, y=260)
        self.Data17 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data17.place(x=280, y=290)
        self.Data18 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data18.place(x=280, y=320)
        self.Data19 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.Data19.place(x=280, y=350)
        self.DataChecksum1 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataChecksum1.place(x=280, y=380)
        self.DataChecksum2 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataChecksum2.place(x=280, y=410)

        self.titleFOV = ttk.Label(self, text="POS1", font=("Helvetica", 15, "bold"))
        self.titleFOV.place(x=390, y=60)
        self.titleCHAN = ttk.Label(self, text="POS3", font=("Helvetica", 15, "bold"))
        self.titleCHAN.place(x=390, y=110)
        self.titleGTRIG = ttk.Label(self, text="POS4", font=("Helvetica", 15, "bold"))
        self.titleGTRIG.place(x=390, y=160)
        self.titleDMS = ttk.Label(self, text="POS5", font=("Helvetica", 15, "bold"))
        self.titleDMS.place(x=390, y=210)
        self.titleATRIG = ttk.Label(self, text="POS6", font=("Helvetica", 15, "bold"))
        self.titleATRIG.place(x=390, y=260)
        self.TitleCompteur = ttk.Label(self, text="Compteur\nTrame", font=("Helvetica", 10, "bold"))
        self.TitleCompteur.place(x=380, y=310)
        self.TitleTaux = ttk.Label(self, text="Taux\nRéception", font=("Helvetica", 10, "bold"))
        self.TitleTaux.place(x=380, y=360)
        self.titleErreur = ttk.Label(self, text="PBIT / CBIT", font=("Helvetica", 10, "bold"))
        self.titleErreur.place(x=290, y=640)
        self.titleJOY_X = ttk.Label(self, text="JOY X", font=("Helvetica", 15, "bold"))
        self.titleJOY_X.place(x=290, y=460)
        self.X_percent_label = ttk.Label(self, text="%", font=("Helvetica", 15, "bold"))
        self.X_percent_label.place(x=510, y=460)
        self.JOY_X_label = ttk.Label(self, text="0", font=("Helvetica", 15, "bold"))
        self.JOY_X_label.place(x=460, y=460)
        self.titleJOY_Y = ttk.Label(self, text="JOY Y", font=("Helvetica", 15, "bold"))
        self.titleJOY_Y.place(x=290, y=510)
        self.Y_percent_label = ttk.Label(self, text="%", font=("Helvetica", 15, "bold"))
        self.Y_percent_label.place(x=510, y=510)
        self.JOY_Y_label = ttk.Label(self, text="0", font=("Helvetica", 15, "bold"))
        self.JOY_Y_label.place(x=460, y=510)

        self.FOV_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                   font=("Helvetica", 10, "bold"))
        self.FOV_button.place(x=450, y=60)
        self.CHAN_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                   font=("Helvetica", 10, "bold"))
        self.CHAN_button.place(x=450, y=110)
        self.GTRIG_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                   font=("Helvetica", 10, "bold"))
        self.GTRIG_button.place(x=450, y=160)
        self.DMS_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                   font=("Helvetica", 10, "bold"))
        self.DMS_button.place(x=450, y=210)
        self.ATRIG_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                   font=("Helvetica", 10, "bold"))
        self.ATRIG_button.place(x=450, y=260)
        self.CPT_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                    font=("Helvetica", 10, "bold"))
        self.CPT_button.place(x=450, y=310)
        self.TAUX_button = tk.Button(self, bg='white', width=12, height=2, borderwidth=2, relief="solid",
                                    font=("Helvetica", 10, "bold"))
        self.TAUX_button.place(x=450, y=360)
        self.Erreur_button = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid",
                                       font=("Helvetica", 10, "bold"))
        self.Erreur_button.place(x=370, y=640)
        self.JOY_X_button = tk.Button(self, bg='white', width=10, borderwidth=2, relief="solid",
                                      font=("Helvetica", 10, "bold"))
        self.JOY_X_button.place(x=360, y=460)
        self.JOY_Y_button = tk.Button(self, bg='white', width=10, borderwidth=2, relief="solid",
                                      font=("Helvetica", 10, "bold"))
        self.JOY_Y_button.place(x=360, y=510)

        self.WIDTH = self.HEIGHT = 280
        self.x1 = self.y1 = self.WIDTH / 2
        self.canvas = tk.Canvas(self, width=self.WIDTH, height=self.HEIGHT, bg="white")
        self.canvas.place(x=2, y=460)
        self.c3 = self.canvas.create_oval(10, 10, self.WIDTH - 10, self.WIDTH - 10, width=2.5, outline="blue")
        self.c4 = self.canvas.create_rectangle(2, 2, self.WIDTH - 2, self.WIDTH - 2, width=2.5)
        self.c5 = self.canvas.create_line(self.x1, self.WIDTH - 2, self.x1, 2, width=2.5, dash=(5, 2), fill="green")
        self.c6 = self.canvas.create_line(self.WIDTH - 2, self.y1, 2, self.y1, width=2.5, dash=(5, 2), fill="green")
        self.c2 = self.canvas.create_oval(self.x1 - 5, self.y1 - 5, self.x1 + 5, self.y1 + 5, fill="red")
        self.trace = tk.IntVar()
        self.check_trace = ttk.Checkbutton(self, text="Trace Point", variable=self.trace, command=self.modetrace,
                                           onvalue=1, offvalue=0)
        self.check_trace.place(x=290, y=710)

        self.PORT = None
        self.BAUD_RATE = 115200
        self.Device = serial.Serial(
            port=self.PORT,
            baudrate=self.BAUD_RATE,
            parity=serial.PARITY_NONE,
            stopbits=serial.STOPBITS_ONE,
            bytesize=serial.EIGHTBITS,
            timeout=1
        )
        self.sel_com = tk.StringVar()
        self.options_com = ttk.OptionMenu(self, self.sel_com)
        self.options_com.place(x=280, y=20)

        self.message_txt = ""
        self.defaut = self.DMS = self.GTRIG = self.UP = self.DOWN = self.CHAN = self.ATRIG = False
        self.acquisition_compteur = self.data_compteur = self.taux = 0
        self.X_val = self.Y_val = False
        self.input_rst = 0
        self.FORMAT = '%d-%m-%Y_%Hh%M_' + str(self.input_rst)
        self.path = 'Testeur T344.txt'
        self.txt_file = '%s_%s' % (datetime.now().strftime(self.FORMAT), self.path)
        self.file = None
        self.stop_ = True  # démarrer la lecture
        self.init_loop = False
        self.data_X = 0  # valeur de la position X
        self.data_Y = 0  # valeur de la position Y
        self.data_Xmonitoring = 0  # valeur de la position X max en monitoring
        self.data_Ymonitoring = 0  # valeur de la position X max en monitoring
        self.X_val = self.Y_val = False
        self.defaut = self.DMS = self.DMS = self.GTRIG = self.UP = self.DOWN = self.CHAN = self.ATRIG = False
        self.data18 = self.data19 = self.data4 = self.data5 = self.data6 = self.data7 = self.data_compteur = 0
        self.acquisition_compteur = 0

    def initDevice(self, com):
        # '''This function opens the connection between Device and the PC
        #         Input: <string> COM port (optional. uses the globally defined port if not given)
        #         Output: <boolean> the success of the operation'''
        print("Connection to:", com)
        self.Device.port = com
        try:
            self.Device.open()
            print("Connection with Device successfully opened")
            return True
        except (FileNotFoundError, OSError):
            # print("ERROR: Can't connect to this port!")
            return False

    def listPorts(self):
        # ''' Refreshes the available COM ports and updates the Options Menu
        # '''
        ports = [port.device for port in comports()]  # get the available ports
        print("Ports found:", ports)
        menu = self.options_com['menu']
        menu.delete(0, 'end')  # Clear the previous items
        if len(ports) == 0:
            self.sel_com.set('No ports found')
        else:
            for port in ports:
                menu.add_command(label=port, command=lambda p=port: self.sel_com.set(p))
            self.sel_com.set('COM')

    def start(self):
        print("start")
        self.acquisition_compteur = 0
        if self.monitoring.get():
            self.input_rst = self.input_rst + 1
            self.FORMAT = '%d-%m-%Y_%Hh%M_' + str(self.input_rst)
            self.path = 'Testeur T344.txt'
            self.txt_file = '%s_%s' % (datetime.now().strftime(self.FORMAT), self.path)
            self.file = open(self.txt_file, 'w')
            self.file.close()

        time.sleep(1)
        self.initDevice(self.sel_com.get())
        time.sleep(1)
        self.stop_ = False

    def stop(self):
        print("stop")
        self.stop_ = True

    def reset(self):
        print("reset")
        self.stop_ = True
        self.my_textbox.delete("1.0", "end")
        self.data_X = 0
        self.data_Y = 0
        self.data_Xmonitoring = 0
        self.data_Ymonitoring = 0
        self.DataHeader1.configure(text=" ")
        self.DataHeader2.configure(text=" ")
        self.DataHeader3.configure(text=" ")
        self.DataHeader4.configure(text=" ")
        self.Data0.configure(text=" ")
        self.Data1.configure(text=" ")
        self.Data2.configure(text=" ")
        self.Data3.configure(text=" ")
        self.Data4.configure(text=" ")
        self.Data5.configure(text=" ")
        self.Data6.configure(text=" ")
        self.Data7.configure(text=" ")
        self.Data8.configure(text=" ")
        self.Data9.configure(text=" ")
        self.Data10.configure(text=" ")
        self.Data11.configure(text=" ")
        self.Data12.configure(text=" ")
        self.Data13.configure(text=" ")
        self.Data14.configure(text=" ")
        self.Data15.configure(text=" ")
        self.Data16.configure(text=" ")
        self.Data17.configure(text=" ")
        self.Data18.configure(text=" ")
        self.Data19.configure(text=" ")
        self.DataChecksum1.configure(text=" ")
        self.DataChecksum2.configure(text=" ")
        self.change_button(self.JOY_Y_button, "white", "")
        self.JOY_Y_label["text"] = ""
        self.change_button(self.JOY_X_button, "white", "")
        self.JOY_X_label["text"] = ""
        self.change_button(self.DMS_button, "white", "")
        self.change_button(self.GTRIG_button, "white", "")
        self.change_button(self.FOV_button, "white", "")
        self.change_button(self.CHAN_button, "white", "")
        self.change_button(self.ATRIG_button, "white", "")
        self.change_button(self.Erreur_button, "white", "")
        self.change_button(self.CPT_button, "white", "")
        self.change_button(self.TAUX_button, "white", "")

    def modemanual(self):
        if self.monitoring.get() == 1:
            self.monitoring.set(0)
            print("manual")
        self.reset()

    def modemonitoring(self):
        if self.manual.get() == 1:
            self.manual.set(0)
            print("monitoring")
        self.reset()

    def modetrace(self):
        self.canvas.delete('all')
        self.c3 = self.canvas.create_oval(10, 10, self.WIDTH - 10, self.WIDTH - 10, width=2.5, outline="blue")
        self.c4 = self.canvas.create_rectangle(2, 2, self.WIDTH - 2, self.WIDTH - 2, width=2.5)
        self.c5 = self.canvas.create_line(self.x1, self.WIDTH - 2, self.x1, 2, width=2.5, dash=(5, 2), fill="green")
        self.c6 = self.canvas.create_line(self.WIDTH - 2, self.y1, 2, self.y1, width=2.5, dash=(5, 2), fill="green")

    def generatePoint(self):
        if self.trace.get() == 0:
            self.canvas.delete(self.c2)

        data_Xp = self.data_X + self.x1
        data_Yp = -self.data_Y + self.y1
        self.c2 = self.canvas.create_oval(data_Xp+5, data_Yp+5,
                                          data_Xp-5, data_Yp-5, fill="red")

    def write_data(self, mess_txt):
        str_current_datetime = str(datetime.now().strftime("%Y-%m-%d    %H:%M:%S    "))
        with open(self.txt_file, 'a') as f:
            f.write('\n')
            f.write(str_current_datetime)
            f.write('\t')
            f.write(''.join(mess_txt))
            f.close()

        text_file = open(self.txt_file, 'r')
        stuff = text_file.readlines()[-1]
        self.my_textbox.insert(INSERT, stuff + '\n')
        self.my_textbox.see("end")
        text_file.close()

    def change_button(self, button=tk.Button, color="", text=""):
        button["bg"] = color
        button["text"] = text

    def read_data(self, data_message="", head_pos=0):
        self.data_X = int(data_message[head_pos + 40] + data_message[head_pos + 41], 16)
        self.data_Y = int(data_message[head_pos + 42] + data_message[head_pos + 43], 16)
        self.data18 = int(data_message[head_pos + 44] + data_message[head_pos + 45], 16)
        self.data19 = int(data_message[head_pos + 46] + data_message[head_pos + 47], 16)
        self.data4 = int(data_message[head_pos + 16] + data_message[head_pos + 17], 16)
        self.data5 = int(data_message[head_pos + 18] + data_message[head_pos + 19], 16)
        self.data6 = int(data_message[head_pos + 20] + data_message[head_pos + 21], 16)
        self.data7 = int(data_message[head_pos + 22] + data_message[head_pos + 23], 16)
        data4int = self.data4 * (255 * 255 * 255)
        data5int = self.data5 * (255 * 255)
        data6int = self.data6 * 255
        data7int = self.data7
        self.data_compteur = data4int + data5int + data6int + data7int

    def calcul_taux(self, acquisition, cpt_val):
        if acquisition == 0:
            acquisition = cpt_val
        else:
            acquisition = acquisition + 1

        if cpt_val != 0:
            taux = int((acquisition * 100) / cpt_val)
            write_taux = str(taux)
            self.change_button(self.TAUX_button, "white", write_taux + "%")
        else:
            self.acquisition_compteur = 0

    def loop(self):
        """
        boucle de lecture infinie événementielles
        """
        if not self.init_loop:
            self.listPorts()
            self.init_loop = True
        if not self.stop_:
            message = self.Device.read(52).hex()
            # print(message)
            header = '5555aaaa'  # valeur du header
            pos = message.find(header)  # on cherche la position du header dans le message
            messagesize = sys.getsizeof(message)  # lecture de la taille du message
            # print(messagesize)
            if messagesize == 153:  # si le massage à la bonne taille
                self.DataHeader1.configure(text=message[pos + 0] + message[pos + 1])
                self.DataHeader2.configure(text=message[pos + 2] + message[pos + 3])
                self.DataHeader3.configure(text=message[pos + 4] + message[pos + 5])
                self.DataHeader4.configure(text=message[pos + 6] + message[pos + 7])
                self.Data0.configure(text=message[pos + 8] + message[pos + 9])
                self.Data1.configure(text=message[pos + 10] + message[pos + 11])
                self.Data2.configure(text=message[pos + 12] + message[pos + 13])
                self.Data3.configure(text=message[pos + 14] + message[pos + 15])
                self.Data4.configure(text=message[pos + 16] + message[pos + 17])
                self.Data5.configure(text=message[pos + 18] + message[pos + 19])
                self.Data6.configure(text=message[pos + 20] + message[pos + 21])
                self.Data7.configure(text=message[pos + 22] + message[pos + 23])
                self.Data8.configure(text=message[pos + 24] + message[pos + 25])
                self.Data9.configure(text=message[pos + 26] + message[pos + 27])
                self.Data10.configure(text=message[pos + 28] + message[pos + 29])
                self.Data11.configure(text=message[pos + 30] + message[pos + 31])
                self.Data12.configure(text=message[pos + 32] + message[pos + 33])
                self.Data13.configure(text=message[pos + 34] + message[pos + 35])
                self.Data14.configure(text=message[pos + 36] + message[pos + 37])
                self.Data15.configure(text=message[pos + 38] + message[pos + 39])
                self.Data16.configure(text=message[pos + 40] + message[pos + 41])
                self.Data17.configure(text=message[pos + 42] + message[pos + 43])
                self.Data18.configure(text=message[pos + 44] + message[pos + 45])
                self.Data19.configure(text=message[pos + 46] + message[pos + 47])
                self.DataChecksum1.configure(text=message[pos + 48] + message[pos + 49])
                self.DataChecksum2.configure(text=message[pos + 50] + message[pos + 51])

                self.read_data(message, pos)

                self.change_button(self.CPT_button, "white", self.data_compteur)

                self.calcul_taux(self.acquisition_compteur, self.data_compteur)

            if self.manual.get():

                if self.data_X >= 0x80:
                    self.data_X = int(self.data_X - 2 * 128)
                    x_percent = int(100 * self.data_X / 127)
                else:
                    x_percent = int(100 * self.data_X / 127)
                self.change_button(self.JOY_X_button, "white", self.data_X)
                self.JOY_X_label["text"] = x_percent

                if self.data_Y >= 0x80:
                    self.data_Y = int(self.data_Y - 2 * 128)
                    y_percent = int(100 * self.data_Y / 127)
                else:
                    y_percent = int(100 * self.data_Y / 127)
                self.change_button(self.JOY_Y_button, "white", self.data_Y)
                self.JOY_Y_label["text"] = y_percent

                self.generatePoint()

                if self.data18 != 0:
                    self.change_button(self.Erreur_button, "#F35757", "Error")
                else:
                    self.change_button(self.Erreur_button, "white", "")

                if (self.data19 & 1) > 0:  # 0x01
                    self.change_button(self.DMS_button, "#CCEDAA", "ON")
                else:
                    self.change_button(self.DMS_button, "white", "")

                if (self.data19 & 2) > 0:  # 0x02
                    self.change_button(self.GTRIG_button, "#CCEDAA", "ON")
                else:
                    self.change_button(self.GTRIG_button, "white", "")

                if (self.data19 & 16) > 0:  # 0x10
                    self.change_button(self.FOV_button, "#CCEDAA", "UP")
                elif (self.data19 & 32) > 0:  # 0x20
                    self.change_button(self.FOV_button, "#CCEDAA", "DOWN")
                else:
                    self.change_button(self.FOV_button, "white", "")

                if (self.data19 & 64) > 0:  # 0x40
                    self.change_button(self.CHAN_button, "#CCEDAA", "ON")
                else:
                    self.change_button(self.CHAN_button, "white", "")

                if (self.data19 & 128) > 0:  # 0x80
                    self.change_button(self.ATRIG_button, "#CCEDAA", "ON")
                else:
                    self.change_button(self.ATRIG_button, "white", "")

            if self.monitoring.get():

                message_txt = [
                    message[pos + 0] + message[pos + 1] + message[pos + 2] + message[pos + 3] +
                    message[pos + 4] + message[pos + 5] + message[pos + 6] + message[pos + 7] + '    ' + '    ' +
                    message[pos + 8] + message[pos + 9] + message[pos + 10] + message[pos + 11] +
                    message[pos + 12] + message[pos + 13] + message[pos + 14] + message[pos + 15] + '    ' +
                    message[pos + 16] + message[pos + 17] + message[pos + 18] + message[pos + 19] +
                    message[pos + 20] + message[pos + 21] + message[pos + 22] + message[pos + 23] + '    ' + '    ' + '    ' +
                    message[pos + 24] + message[pos + 25] + message[pos + 26] + message[pos + 27] +
                    message[pos + 28] + message[pos + 29] + message[pos + 30] + message[pos + 31] +
                    message[pos + 32] + message[pos + 33] + message[pos + 34] + message[pos + 35] +
                    message[pos + 36] + message[pos + 37] + message[pos + 38] + message[pos + 39] + '    ' + '    ' +
                    message[pos + 40] + message[pos + 41] + '    ' + '    ' + message[pos + 42] + message[pos + 43] + '    ' + '    ' +
                    message[pos + 44] + message[pos + 45] + '    ' + '    ' + message[pos + 46] + message[pos + 47] + '    ' + '    ' +
                    message[pos + 48] + message[pos + 49] + message[pos + 50] + message[pos + 51]]

                if self.data_X >= 0x80:
                    self.data_X = int(self.data_X - 2 * 128)
                    x_percent = int(100 * self.data_X / 127)
                else:
                    x_percent = int(100 * self.data_X / 127)
                if (not self.X_val) & (abs(self.data_X) > abs(self.data_Xmonitoring)):
                    self.X_val = True
                    self.data_Xmonitoring = self.data_X
                    self.change_button(self.JOY_X_button, "white", self.data_X)
                    self.JOY_X_label["text"] = x_percent
                else:
                    self.X_val = False

                if self.data_Y >= 0x80:
                    self.data_Y = int(self.data_Y - 2 * 128)
                    y_percent = int(100 * self.data_Y / 127)
                else:
                    y_percent = int(100 * self.data_Y / 127)
                if (not self.Y_val) & (abs(self.data_Y) > abs(self.data_Ymonitoring)):
                    self.Y_val = True
                    self.data_Ymonitoring = self.data_Y
                    self.change_button(self.JOY_Y_button, "white", self.data_Y)
                    self.JOY_Y_label["text"] = y_percent
                else:
                    self.Y_val = False

                self.generatePoint()

                if (self.data_X != 0) | (self.data_Y != 0):
                    self.write_data(message_txt)

                if (not self.defaut) & (self.data18 != 0):
                    self.defaut = True
                    self.change_button(self.Erreur_button, "#F35757", "Error")
                    self.write_data(message_txt)
                elif self.data18 == 0:
                    self.defaut = False

                if (not self.DMS) & ((self.data19 & 1) > 0):  # 0x01
                    self.DMS = True
                    self.change_button(self.DMS_button, "#CCEDAA", "ON")
                    self.write_data(message_txt)
                elif (self.data19 & 1) == 0:
                    self.DMS = False

                if (not self.GTRIG) & ((self.data19 & 2) > 0):  # 0x02
                    self.GTRIG = True
                    self.change_button(self.GTRIG_button, "#CCEDAA", "ON")
                    self.write_data(message_txt)
                elif (self.data19 & 2) == 0:
                    self.GTRIG = False

                if (not self.UP) & ((self.data19 & 16) > 0):  # 0x10
                    self.UP = True
                    self.change_button(self.FOV_button, "#CCEDAA", "UP")
                    self.write_data(message_txt)
                elif (self.data19 & 16) == 0:
                    self.UP = False

                if (not self.DOWN) & ((self.data19 & 32) > 0):  # 0x20
                    self.DOWN = True
                    self.change_button(self.FOV_button, "#CCEDAA", "DOWN")
                    self.write_data(message_txt)
                elif (self.data19 & 32) == 0:
                    self.DOWN = False

                if (not self.CHAN) & ((self.data19 & 64) > 0):  # 0x40
                    self.CHAN = True
                    self.change_button(self.CHAN_button, "#CCEDAA", "ON")
                    self.write_data(message_txt)
                elif (self.data19 & 64) == 0:
                    self.CHAN = False

                if (not self.ATRIG) & ((self.data19 & 128) > 0):  # 0x80
                    self.ATRIG = True
                    self.change_button(self.ATRIG_button, "#CCEDAA", "ON")
                    self.write_data(message_txt)
                elif (self.data19 & 128) == 0:
                    self.ATRIG = False

        appl.after(5, self.loop)

    def destroy(self):
        """
        destructeur de la classe
        """
        print('Bye!')
        self.quit()  # ferme la fenêtre principale
        exit()  # termine tous les process en cours


if __name__ == '__main__':
    appl = Testeur()
    try:
        appl.loop()
        appl.mainloop()
    except KeyboardInterrupt:  # interruption clavier CTRL-C: appel à la méthode destroy() de appl.
        appl.destroy()

Hello, je vois que la boucle qui gère l’interface est la même que celle qui consomme les données.

Idéalement il faudrait faire ça dans deux threads différents et échanger les données via un "pipe" pour éviter que le Global Interpreter Lock de python ne ralentisse au final le programme.

C’est sans doute l’interface qui est lente. TK c’est pas gégé

@Soupalonion Bonjour, j'ai sorti votre message des spams, si cela arrive encore vous pouvez poster dans ce sujet Si votre message est considéré comme spam

Slt !
 
Pfiou ça c'est du code !

Une idée : chronométrer le temps de certains bouts de code et voir si c'est optimisable : du genre ça : message.find(header) est-ce qu'on peut pas le remplacer par un string.index(header) plus rapide ? (Aucune idée, je propose sûrement de la m****)

PS : Soupalonion ça change qqchose de faire 2 threads ?

-
Edité par Anonyme 27 octobre 2022 à 17:13:09

beaucoup trop de code répété à mon goût. Il y a moyen de passer par des tableaux/listes pour créer/stocker/manipuler les textbox et autres choses qui se répètent 

        self.DataHeader1 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader1.place(x=80, y=50)
        self.DataHeader2 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader2.place(x=80, y=80)
        self.DataHeader3 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader3.place(x=80, y=110)
        self.DataHeader4 = tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid")
        self.DataHeader4.place(x=80, y=140)

devient

    self.DataHeader=[]
    for i in range(4):
        self.DataHeader.append(tk.Button(self, bg='white', width=12, borderwidth=2, relief="solid"))
        self.DataHeader[i].place(x=80, y=50+i*30)

Après il faut faire quelques calculs pour le positionnement ou tout intégrer dans la même boucle et selon la valeur de i, dire que c'est du header, de la data ou du checksum

Tes opérations sur data_message sont toutes simplifiables par du slicing

data_message[head_position+40]+data_message[head_position + 41] ==> data_message[head_position:][40:42]

 ton loop se relance toutes les 5ms, est-ce suffisamment trop rapide ? 

Je pense qu'il y a des calculs qui peuvent être fait par des opérations binaires (les *255 revient à un décalage vers la gauche de 8) voir même s'en passer et passer directement par les données .
par exemple ces lignes 449 et suivantes:

        self.data4 = int(data_message[head_pos + 16] + data_message[head_pos + 17], 16)
        self.data5 = int(data_message[head_pos + 18] + data_message[head_pos + 19], 16)
        self.data6 = int(data_message[head_pos + 20] + data_message[head_pos + 21], 16)
        self.data7 = int(data_message[head_pos + 22] + data_message[head_pos + 23], 16)
        data4int = self.data4 * (255 * 255 * 255)
        data5int = self.data5 * (255 * 255)
        data6int = self.data6 * 255
        data7int = self.data7
        self.data_compteur = data4int + data5int + data6int + data7int

pourraient s'écrire

        self.data4 = int(data_message[head_pos:][16:18], 16)
        self.data5 = int(data_message[head_pos:][18:20], 16)
        self.data6 = int(data_message[head_pos:][20:22], 16)
        self.data7 = int(data_message[head_pos:][22:24], 16)
        self.data_compteur = int(data_message[head_pos:][16:24],16)

(pourquoi 255 et pas 256 d'ailleurs?)

-
Edité par umfred 27 octobre 2022 à 18:43:08

umfred a écrit:

ton loop se relance toutes les 5s, est-ce suffisamment rapide ?

root.after(msec, function) 😉

oups encore  , du coup trop rapide ?

Waouh ce code ... il faudrait songer à la passer en MVC car là c'est un sac de noeud incompréhensible et non maintenable.

ErispoeLeNarvalo a écrit:

PS : Soupalonion ça change qqchose de faire 2 threads ?

Comme je le disais, avoir un thread pour les calculs et mise à jour de l’interface, et un autre pour la réception des données, à mon sens permettra 1. de séparer le code qui gère la communication de celui qui fait les calculs et sort les résultats à l’utilisateur 2. un contrôle très précis des entrées sorties de manière totalement indépendance de l’interface.

Ça ne devrait même pas tellement complexifier le code puisqu’il suffira d’utiliser le module `queue` https://docs.python.org/3/library/queue.html de python pour envoyer les données reçues par paquets cohérents.

On assure un découplage de l’UI et du traitement et ça semble ici essentiel.

Quand aux opérations de calculs avec des opérations "bitwise" vs calculs "normaux" et le slicing, ça peut avoir une incidence m’enfin la taille des données n’est pas non plus énorme, donc je doute que le gros du problème soit à ce moment là.

Cependant, un très bon commentaire indique qu’il faut MESURER.

Et pour ça il faudrait effectivement mesurer le temps consommé à rafraichir l’UI, à récupérer les info des I/O, à faire les calculs.

Ça se fait facilement avec le module timeit https://docs.python.org/3/library/timeit.html

J'ai un doute sur le faite que le multithreading rende le truc plus rapide.
Je n'y connais pas grand chose mais le processeur va pas traiter 2 threads plus rapidement qu'un seul, si ?
J'y connais quasi rien mais peut-être que le multiprocessing est plus adapté si l'on veut optimiser l'usage du processeur, non ?

ErispoeLeNarvalo a écrit:

J'ai un doute sur le faite que le multithreading rende le truc plus rapide.
Je n'y connais pas grand chose mais le processeur va pas traiter 2 threads plus rapidement qu'un seul, si ?
J'y connais quasi rien mais peut-être que le multiprocessing est plus adapté si l'on veut optimiser l'usage du processeur, non ?

Je suis presque sûr que son Atom dispose d’au moins 2 cores, surtout quand le plus basique des raspberry pi a déjà 4 cores

Donc 1 thread qui s’occupe de la communication avec le bus et qui balance les info dans une "file d’attente", et 1 autre qui consomme cette file et qui fait les mise à jour de l’interface au besoin.

TKinter c’est pas une lib connue pour ses performances. Mais de toute façon il faut mesurer avant d’agir :

 * temps passé à rafraichir les éléments d’UI

 * temps passé à faire les calculs

 * temps passé à récupérer les informations

genre de la ligne 480 à 485 c’est la récupération des infos, le reste c’est du calcul et de l’affichage. bon ben faut mesurer les deux indépendament.

et il faut le faire sur le i7 et sur le Atom pour comparer.

Les threads de Python sont soumis au GIL, donc ils ne sont pas parallèles. Pour utiliser plusieurs cœurs CPU il faut utiliser la bibliothèque standard multiprocessing.

AMHA factoriser le code et séparer l'interface et le cœur de l'application, en respectant quelques règles de codage* ; éviter les fonction trop longue, 20 lignes et 80 colonnes max, utiliser des types adaptés, ne pas numéroter les variables, etc, devrait déjà beaucoup aider pour la suite.

Et la suite c'est du test et du profilage, avec les bibliothèques standards unittest et profile par exemple.

* Au-delà même de la lisibilité, ces règles servent réellement à penser et à concevoir efficacement.