Partage
  • Partager sur Facebook
  • Partager sur Twitter

deconnexion port com

Sujet résolu
    23 janvier 2025 à 17:04:34

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



    • Partager sur Facebook
    • Partager sur Twitter
      23 janvier 2025 à 17:51:17

      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?

      • Partager sur Facebook
      • Partager sur Twitter
        23 janvier 2025 à 18:39:55

        j'ai résolu le probleme c'est le driver ch340 qui mettais le bazarre et je parlais juste de cliquer sur le bouton déconnecter puis connecter à nouveau sans rien débranché
        • Partager sur Facebook
        • Partager sur Twitter
          24 janvier 2025 à 12:23:52

          j'ai eu le même soucis sou VBA, il faut le pilote 3.5 pour le CH340 (la dernière version 3.9 bug sur ce point)
          • Partager sur Facebook
          • Partager sur Twitter

          deconnexion port com

          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
          • Editeur
          • Markdown