Bonjour

j'utilise le code ci dessous pour récupérer les données série depuis un Arduino seulement si je déconnecte le port et veux le reconnecter j'ai systématique un code d'erreur me disant que je n'ai pas la permission de me connecté il faut alors que je débranche et rebranche l’Arduino pour résoudre le probleme pouvez vous m'aider ?

import serial
import serial.tools.list_ports
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
import time

class SerialManager:
    def __init__(self, root):
        self.root = root
        self.baud_rate = 9600
        self.data_points_visible = 100
        self.max_data_points = 1000
        self.ser = None
        self.x_data = []
        self.y_data = []
        self.start_index = 0
        self.real_time_mode = True

        self.setup_ui()

    def setup_ui(self):
        self.root.title("Gestionnaire de Port Série")

        frame = tk.Frame(self.root)
        frame.pack(side=tk.TOP, fill=tk.X, pady=10)

        tk.Label(frame, text="Sélectionnez le port série:").pack(side=tk.LEFT, padx=5)

        self.port_var = tk.StringVar()
        self.port_dropdown = ttk.Combobox(frame, textvariable=self.port_var)
        self.port_dropdown.pack(side=tk.LEFT, padx=5)

        self.refresh_ports()

        tk.Button(frame, text="Connecter", command=self.connect).pack(side=tk.LEFT, padx=5)
        tk.Button(frame, text="Déconnecter", command=self.disconnect).pack(side=tk.LEFT, padx=5)
        tk.Button(frame, text="Rafraîchir les ports", command=self.refresh_ports).pack(side=tk.LEFT, padx=5)

        self.status_label = tk.Label(self.root, text="", fg="green")
        self.status_label.pack(pady=10)

        # Set up the plot
        self.fig, self.ax = plt.subplots()
        self.line, = self.ax.plot([], [], label="Tension (V)")
        self.ax.set_ylim(0, 5)
        self.ax.set_xlabel("Échantillons")
        self.ax.set_ylabel("Tension (V)")
        plt.legend()

        # Integrate the plot with Tkinter
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.root)
        self.canvas.draw()
        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

        self.toolbar = NavigationToolbar2Tk(self.canvas, self.root)
        self.toolbar.update()
        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

        self.root.bind('<Key>', self.on_key)

    def refresh_ports(self):
        ports = list(serial.tools.list_ports.comports())
        port_list = [port.device for port in ports]
        self.port_dropdown['values'] = port_list
        if port_list:
            self.port_dropdown.current(0)

    def connect(self):
        port = self.port_var.get()
        self.disconnect()  # Ensure any previous connection is closed
        if port:
            try:
                self.ser = serial.Serial(port, self.baud_rate, timeout=1)
                self.status_label.config(text=f"Connecté au port {port}", fg="green")
                print(f"Connecté au port {port}")
            except serial.SerialException as e:
                self.status_label.config(text=f"Erreur: {e}", fg="red")
                print(f"Erreur lors de l'ouverture du port série : {e}")
                self.ser = None
        else:
            messagebox.showwarning("Avertissement", "Veuillez sélectionner un port série.")

    def disconnect(self):
        if self.ser:
            try:
                if self.ser.is_open:
                    # Reset Arduino by toggling DTR
                    self.ser.dtr = False
                    time.sleep(0.5)  # Wait for reset
                    self.ser.dtr = True
                    self.ser.close()
                self.status_label.config(text="Déconnecté", fg="green")
                print(f"Déconnecté du port")
            except serial.SerialException as e:
                self.status_label.config(text=f"Erreur: {e}", fg="red")
                print(f"Erreur lors de la fermeture du port série : {e}")
            finally:
                self.ser = None

    def read_serial_data(self):
        if self.ser and self.ser.is_open and self.ser.in_waiting > 0:
            try:
                line_data = self.ser.readline().decode("utf-8", errors="ignore").strip()
                print(f"Données brutes reçues : {line_data}")  # Debugging line
                if line_data:
                    try:
                        voltage = float(line_data)
                        self.x_data.append(len(self.x_data))
                        self.y_data.append(voltage)

                        if len(self.x_data) > self.max_data_points:
                            self.x_data = self.x_data[-self.max_data_points:]
                            self.y_data = self.y_data[-self.max_data_points:]

                        print(f"Données reçues : {voltage}")
                    except ValueError as e:
                        print(f"Erreur de conversion : {line_data} ({e})")
            except serial.SerialException as e:
                print(f"Erreur lors de la lecture des données série : {e}")

    def update_plot(self):
        end_index = min(self.start_index + self.data_points_visible, len(self.x_data))
        self.start_index = max(0, min(self.start_index, len(self.x_data) - self.data_points_visible))
        x_visible = self.x_data[self.start_index:end_index]
        y_visible = self.y_data[self.start_index:end_index]

        if x_visible:
            self.line.set_data(x_visible, y_visible)
            # Avoid identical limits which cause a singular transformation
            if x_visible[0] == x_visible[-1]:
                self.ax.set_xlim(x_visible[0] - 1, x_visible[0] + 1)
            else:
                self.ax.set_xlim(x_visible[0], x_visible[-1])
            self.ax.relim()
            self.ax.autoscale_view()
        self.canvas.draw()

    def on_key(self, event):
        if event.key == 'Right':
            self.start_index += 10
            self.real_time_mode = False
            print("Mode non temps réel : défilement vers la droite")
        elif event.key == 'Left':
            self.start_index -= 10
            self.real_time_mode = False
            print("Mode non temps réel : défilement vers la gauche")
        elif event.key == ' ':  # Utilisation de ' ' pour l'espace
            self.real_time_mode = True
            print("Mode temps réel réactivé")
        self.update_plot()

    def start_reading(self):
        try:
            while True:
                self.read_serial_data()
                if self.real_time_mode:
                    self.start_index = max(0, len(self.x_data) - self.data_points_visible)
                self.update_plot()
                self.root.update_idletasks()
                self.root.update()
        except tk.TclError:
            self.disconnect()

if __name__ == "__main__":
    def on_closing():
        manager.disconnect()
        root.destroy()

    root = tk.Tk()
    manager = SerialManager(root)
    root.protocol("WM_DELETE_WINDOW", on_closing)
    root.after(100, manager.start_reading)
    root.mainloop()

Qu'entendez vous par déconnecter/reconnecter le port? Déconnecter / reconnecter le câble ou cliquer sur le button qui appelle disconnect puis sur celui qui appelle connect?