MaselliSimulatorApp.py

@@ -1,141 +1,74 @@
 import tkinter as tk
 from tkinter import ttk, scrolledtext, messagebox
 import serial
-import socket
 import threading
 import time
 import math
-import json
-import os
-from collections import deque
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-from matplotlib.figure import Figure
-import matplotlib.animation as animation
 
 class MaselliSimulatorApp:
     def __init__(self, root_window):
         self.root = root_window
-        self.root.title("Simulador Protocolo Maselli - Serial/Ethernet")
+        self.root.title("Simulador Protocolo Maselli")
 
-        self.connection = None  # Puede ser serial.Serial o socket
-        self.connection_type = None  # 'serial', 'tcp', o 'udp'
+        self.serial_port = None # Para simulación continua
         self.simulating = False
         self.simulation_thread = None
         self.simulation_step = 0
 
-        # Para el gráfico
-        self.max_points = 100
-        self.time_data = deque(maxlen=self.max_points)
-        self.brix_data = deque(maxlen=self.max_points)
-        self.ma_data = deque(maxlen=self.max_points)
-        self.start_time = time.time()
-        
-        # Archivo de configuración
-        self.config_file = "maselli_simulator_config.json"
-
         # --- Configuration Frame ---
         config_frame = ttk.LabelFrame(self.root, text="Configuración")
         config_frame.grid(row=0, column=0, padx=10, pady=10, sticky="ew", columnspan=2)
 
-        # Tipo de conexión
-        ttk.Label(config_frame, text="Tipo de Conexión:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
-        self.connection_type_var = tk.StringVar(value="Serial")
-        self.connection_type_combo = ttk.Combobox(config_frame, textvariable=self.connection_type_var,
-                                                   values=["Serial", "TCP", "UDP"], state="readonly", width=10)
-        self.connection_type_combo.grid(row=0, column=1, padx=5, pady=5, sticky="ew")
-        self.connection_type_combo.bind("<<ComboboxSelected>>", self.on_connection_type_change)
-
-        # Frame para configuración Serial
-        self.serial_frame = ttk.Frame(config_frame)
-        self.serial_frame.grid(row=1, column=0, columnspan=4, padx=5, pady=5, sticky="ew")
-
-        ttk.Label(self.serial_frame, text="Puerto COM:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="Puerto COM:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
         self.com_port_var = tk.StringVar(value="COM3")
-        self.com_port_entry = ttk.Entry(self.serial_frame, textvariable=self.com_port_var, width=10)
+        self.com_port_entry = ttk.Entry(config_frame, textvariable=self.com_port_var, width=10)
         self.com_port_entry.grid(row=0, column=1, padx=5, pady=5, sticky="ew")
 
-        ttk.Label(self.serial_frame, text="Baud Rate:").grid(row=0, column=2, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="Baud Rate:").grid(row=0, column=2, padx=5, pady=5, sticky="w")
         self.baud_rate_var = tk.StringVar(value="115200")
-        self.baud_rate_entry = ttk.Entry(self.serial_frame, textvariable=self.baud_rate_var, width=10)
+        self.baud_rate_entry = ttk.Entry(config_frame, textvariable=self.baud_rate_var, width=10)
         self.baud_rate_entry.grid(row=0, column=3, padx=5, pady=5, sticky="ew")
 
-        # Frame para configuración Ethernet
-        self.ethernet_frame = ttk.Frame(config_frame)
-        self.ethernet_frame.grid(row=1, column=0, columnspan=4, padx=5, pady=5, sticky="ew")
-        self.ethernet_frame.grid_remove()  # Oculto por defecto
-
-        ttk.Label(self.ethernet_frame, text="Dirección IP:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
-        self.ip_address_var = tk.StringVar(value="192.168.1.100")
-        self.ip_address_entry = ttk.Entry(self.ethernet_frame, textvariable=self.ip_address_var, width=15)
-        self.ip_address_entry.grid(row=0, column=1, padx=5, pady=5, sticky="ew")
-
-        ttk.Label(self.ethernet_frame, text="Puerto:").grid(row=0, column=2, padx=5, pady=5, sticky="w")
-        self.port_var = tk.StringVar(value="502")
-        self.port_entry = ttk.Entry(self.ethernet_frame, textvariable=self.port_var, width=10)
-        self.port_entry.grid(row=0, column=3, padx=5, pady=5, sticky="ew")
-
-        # Configuración común
-        ttk.Label(config_frame, text="ADAM Address (2c):").grid(row=2, column=0, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="ADAM Address (2c):").grid(row=1, column=0, padx=5, pady=5, sticky="w")
         self.adam_address_var = tk.StringVar(value="01")
         self.adam_address_entry = ttk.Entry(config_frame, textvariable=self.adam_address_var, width=5)
-        self.adam_address_entry.grid(row=2, column=1, padx=5, pady=5, sticky="ew")
+        self.adam_address_entry.grid(row=1, column=1, padx=5, pady=5, sticky="ew")
 
-        ttk.Label(config_frame, text="Función:").grid(row=2, column=2, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="Función:").grid(row=1, column=2, padx=5, pady=5, sticky="w")
         self.function_type_var = tk.StringVar(value="Lineal")
         self.function_type_combo = ttk.Combobox(config_frame, textvariable=self.function_type_var,
                                                 values=["Lineal", "Sinusoidal", "Manual"], state="readonly", width=10)
-        self.function_type_combo.grid(row=2, column=3, padx=5, pady=5, sticky="ew")
+        self.function_type_combo.grid(row=1, column=3, padx=5, pady=5, sticky="ew")
         self.function_type_combo.bind("<<ComboboxSelected>>", self.on_function_type_change)
 
-        # Parámetros para mapeo 4-20mA
-        ttk.Label(config_frame, text="Valor Mínimo (Brix) [p/ 4mA]:").grid(row=3, column=0, padx=5, pady=5, sticky="w")
+        # Parámetros para mapeo 4-20mA (y generación en Lineal/Sinusoidal)
+        ttk.Label(config_frame, text="Valor Mínimo (Brix) [p/ 4mA]:").grid(row=2, column=0, padx=5, pady=5, sticky="w")
         self.min_brix_map_var = tk.StringVar(value="0")
         self.min_brix_map_entry = ttk.Entry(config_frame, textvariable=self.min_brix_map_var, width=10)
-        self.min_brix_map_entry.grid(row=3, column=1, padx=5, pady=5, sticky="ew")
+        self.min_brix_map_entry.grid(row=2, column=1, padx=5, pady=5, sticky="ew")
 
-        ttk.Label(config_frame, text="Valor Máximo (Brix) [p/ 20mA]:").grid(row=3, column=2, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="Valor Máximo (Brix) [p/ 20mA]:").grid(row=2, column=2, padx=5, pady=5, sticky="w")
         self.max_brix_map_var = tk.StringVar(value="80")
         self.max_brix_map_entry = ttk.Entry(config_frame, textvariable=self.max_brix_map_var, width=10)
-        self.max_brix_map_entry.grid(row=3, column=3, padx=5, pady=5, sticky="ew")
+        self.max_brix_map_entry.grid(row=2, column=3, padx=5, pady=5, sticky="ew")
 
         # Parámetros específicos para simulación continua
-        ttk.Label(config_frame, text="Periodo Sim. (s):").grid(row=4, column=0, padx=5, pady=5, sticky="w")
+        ttk.Label(config_frame, text="Periodo Sim. (s):").grid(row=3, column=0, padx=5, pady=5, sticky="w")
         self.period_var = tk.StringVar(value="1.0")
         self.period_entry = ttk.Entry(config_frame, textvariable=self.period_var, width=5)
-        self.period_entry.grid(row=4, column=1, padx=5, pady=5, sticky="ew")
+        self.period_entry.grid(row=3, column=1, padx=5, pady=5, sticky="ew")
 
-        # Botones de persistencia
-        self.save_config_button = ttk.Button(config_frame, text="Guardar Config", command=self.save_config)
-        self.save_config_button.grid(row=4, column=2, padx=5, pady=5, sticky="ew")
-        
-        self.load_config_button = ttk.Button(config_frame, text="Cargar Config", command=self.load_config)
-        self.load_config_button.grid(row=4, column=3, padx=5, pady=5, sticky="ew")
-
-        # Frame para modo Manual con slider
-        manual_frame = ttk.LabelFrame(config_frame, text="Modo Manual")
-        manual_frame.grid(row=5, column=0, columnspan=4, padx=5, pady=5, sticky="ew")
-
-        ttk.Label(manual_frame, text="Valor Brix:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
+        # Parámetros específicos para modo Manual
+        ttk.Label(config_frame, text="Valor Brix Manual:").grid(row=4, column=0, padx=5, pady=5, sticky="w")
         self.manual_brix_var = tk.StringVar(value="10.0")
-        self.manual_brix_entry = ttk.Entry(manual_frame, textvariable=self.manual_brix_var, width=10, state=tk.DISABLED)
-        self.manual_brix_entry.grid(row=0, column=1, padx=5, pady=5, sticky="ew")
-        self.manual_brix_entry.bind('<Return>', lambda e: self.update_slider_from_entry())
-        self.manual_brix_entry.bind('<FocusOut>', lambda e: self.update_slider_from_entry())
+        self.manual_brix_entry = ttk.Entry(config_frame, textvariable=self.manual_brix_var, width=10, state=tk.DISABLED)
+        self.manual_brix_entry.grid(row=4, column=1, padx=5, pady=5, sticky="ew")
 
-        # Slider para valor manual
-        self.manual_slider_var = tk.DoubleVar(value=10.0)
-        self.manual_slider = ttk.Scale(manual_frame, from_=0, to=100, orient=tk.HORIZONTAL, 
-                                      variable=self.manual_slider_var, command=self.on_slider_change,
-                                      state=tk.DISABLED, length=200)
-        self.manual_slider.grid(row=0, column=2, padx=5, pady=5, sticky="ew")
+        self.manual_send_button = ttk.Button(config_frame, text="Enviar Manual", command=self.send_manual_value, state=tk.DISABLED)
+        self.manual_send_button.grid(row=4, column=2, columnspan=2, padx=5, pady=5, sticky="ew")
 
-        self.manual_send_button = ttk.Button(manual_frame, text="Enviar Manual", command=self.send_manual_value, state=tk.DISABLED)
-        self.manual_send_button.grid(row=0, column=3, padx=5, pady=5, sticky="ew")
 
-        manual_frame.columnconfigure(2, weight=1)
-
-        # --- Controls Frame ---
+        # --- Controls Frame (para simulación continua) ---
         controls_frame = ttk.LabelFrame(self.root, text="Control Simulación Continua")
         controls_frame.grid(row=1, column=0, padx=10, pady=5, sticky="ew")
 
@@ -145,222 +78,52 @@ class MaselliSimulatorApp:
         self.stop_button = ttk.Button(controls_frame, text="Detener Simulación", command=self.stop_simulation, state=tk.DISABLED)
         self.stop_button.pack(side=tk.LEFT, padx=5)
 
-        self.clear_graph_button = ttk.Button(controls_frame, text="Limpiar Gráfico", command=self.clear_graph)
-        self.clear_graph_button.pack(side=tk.LEFT, padx=5)
-
         # --- Display Frame ---
         display_frame = ttk.LabelFrame(self.root, text="Visualización")
         display_frame.grid(row=1, column=1, rowspan=2, padx=10, pady=10, sticky="nsew")
         
         ttk.Label(display_frame, text="Valor Brix Actual:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
         self.current_brix_display_var = tk.StringVar(value="---")
-        self.current_brix_label = ttk.Label(display_frame, textvariable=self.current_brix_display_var, font=("Courier", 14, "bold"))
+        self.current_brix_label = ttk.Label(display_frame, textvariable=self.current_brix_display_var, font=("Courier", 10))
         self.current_brix_label.grid(row=0, column=1, padx=5, pady=5, sticky="w")
 
         ttk.Label(display_frame, text="Valor mA Correspondiente:").grid(row=1, column=0, padx=5, pady=5, sticky="w")
         self.current_ma_display_var = tk.StringVar(value="--.-- mA")
-        self.current_ma_label = ttk.Label(display_frame, textvariable=self.current_ma_display_var, font=("Courier", 14, "bold"))
+        self.current_ma_label = ttk.Label(display_frame, textvariable=self.current_ma_display_var, font=("Courier", 10))
         self.current_ma_label.grid(row=1, column=1, padx=5, pady=5, sticky="w")
 
-        # --- Graph Frame ---
-        graph_frame = ttk.LabelFrame(self.root, text="Gráfico de Valores")
-        graph_frame.grid(row=2, column=0, padx=10, pady=5, sticky="nsew")
-
-        # Crear figura de matplotlib
-        self.fig = Figure(figsize=(6, 3.5), dpi=100)
-        self.ax1 = self.fig.add_subplot(111)
-        self.ax2 = self.ax1.twinx()
-        
-        # Configurar el gráfico
-        self.ax1.set_xlabel('Tiempo (s)')
-        self.ax1.set_ylabel('Brix', color='b')
-        self.ax2.set_ylabel('mA', color='r')
-        self.ax1.tick_params(axis='y', labelcolor='b')
-        self.ax2.tick_params(axis='y', labelcolor='r')
-        self.ax1.grid(True, alpha=0.3)
-        
-        # Líneas del gráfico
-        self.line_brix, = self.ax1.plot([], [], 'b-', label='Brix', linewidth=2)
-        self.line_ma, = self.ax2.plot([], [], 'r-', label='mA', linewidth=2)
-        
-        # Canvas de matplotlib en tkinter
-        self.canvas = FigureCanvasTkAgg(self.fig, master=graph_frame)
-        self.canvas.draw()
-        self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
 
         # --- Log Frame ---
         log_frame = ttk.LabelFrame(self.root, text="Log de Comunicación")
-        log_frame.grid(row=3, column=0, padx=10, pady=10, sticky="nsew", columnspan=2)
+        log_frame.grid(row=2, column=0, padx=10, pady=10, sticky="nsew", columnspan=2)
 
-        self.com_log_text = scrolledtext.ScrolledText(log_frame, height=10, width=70, wrap=tk.WORD, state=tk.DISABLED)
+        self.com_log_text = scrolledtext.ScrolledText(log_frame, height=12, width=70, wrap=tk.WORD, state=tk.DISABLED)
         self.com_log_text.pack(padx=5,pady=5,fill=tk.BOTH, expand=True)
 
-        # Configurar pesos de las filas y columnas
-        self.root.columnconfigure(0, weight=1)
-        self.root.columnconfigure(1, weight=1)
-        self.root.rowconfigure(2, weight=1)
-        self.root.rowconfigure(3, weight=1)
+
+        self.root.columnconfigure(1, weight=1) # Allow display_frame to expand
+        log_frame.columnconfigure(0, weight=1)
+        log_frame.rowconfigure(0, weight=1)
+
 
         self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
-        
-        # Cargar configuración si existe
-        self.load_config(silent=True)
-        
-        # Inicializar estado de la interfaz
-        self.on_connection_type_change()
-        self.on_function_type_change()
-        
-        # Iniciar animación del gráfico
-        self.ani = animation.FuncAnimation(self.fig, self.update_graph, interval=100, blit=False)
-
-    def save_config(self):
-        """Guarda la configuración actual en un archivo JSON"""
-        config = {
-            'connection_type': self.connection_type_var.get(),
-            'com_port': self.com_port_var.get(),
-            'baud_rate': self.baud_rate_var.get(),
-            'ip_address': self.ip_address_var.get(),
-            'port': self.port_var.get(),
-            'adam_address': self.adam_address_var.get(),
-            'function_type': self.function_type_var.get(),
-            'min_brix_map': self.min_brix_map_var.get(),
-            'max_brix_map': self.max_brix_map_var.get(),
-            'period': self.period_var.get(),
-            'manual_brix': self.manual_brix_var.get()
-        }
-        
-        try:
-            with open(self.config_file, 'w') as f:
-                json.dump(config, f, indent=4)
-            self._log_message("Configuración guardada exitosamente.")
-            messagebox.showinfo("Éxito", "Configuración guardada correctamente.")
-        except Exception as e:
-            self._log_message(f"Error al guardar configuración: {e}")
-            messagebox.showerror("Error", f"No se pudo guardar la configuración: {e}")
-
-    def load_config(self, silent=False):
-        """Carga la configuración desde un archivo JSON"""
-        if not os.path.exists(self.config_file):
-            if not silent:
-                messagebox.showinfo("Información", "No se encontró archivo de configuración.")
-            return
-        
-        try:
-            with open(self.config_file, 'r') as f:
-                config = json.load(f)
-            
-            # Aplicar configuración
-            self.connection_type_var.set(config.get('connection_type', 'Serial'))
-            self.com_port_var.set(config.get('com_port', 'COM3'))
-            self.baud_rate_var.set(config.get('baud_rate', '115200'))
-            self.ip_address_var.set(config.get('ip_address', '192.168.1.100'))
-            self.port_var.set(config.get('port', '502'))
-            self.adam_address_var.set(config.get('adam_address', '01'))
-            self.function_type_var.set(config.get('function_type', 'Lineal'))
-            self.min_brix_map_var.set(config.get('min_brix_map', '0'))
-            self.max_brix_map_var.set(config.get('max_brix_map', '80'))
-            self.period_var.set(config.get('period', '1.0'))
-            self.manual_brix_var.set(config.get('manual_brix', '10.0'))
-            
-            # Actualizar slider
-            try:
-                self.manual_slider_var.set(float(config.get('manual_brix', '10.0')))
-            except:
-                pass
-            
-            # Actualizar interfaz
-            self.on_connection_type_change()
-            
-            if not silent:
-                self._log_message("Configuración cargada exitosamente.")
-                messagebox.showinfo("Éxito", "Configuración cargada correctamente.")
-        except Exception as e:
-            if not silent:
-                self._log_message(f"Error al cargar configuración: {e}")
-                messagebox.showerror("Error", f"No se pudo cargar la configuración: {e}")
-
-    def on_slider_change(self, value):
-        """Actualiza el campo de texto cuando cambia el slider"""
-        self.manual_brix_var.set(f"{float(value):.1f}")
-
-    def update_slider_from_entry(self):
-        """Actualiza el slider cuando se modifica el campo de texto"""
-        try:
-            value = float(self.manual_brix_var.get())
-            # Limitar el valor al rango del slider
-            value = max(0, min(100, value))
-            self.manual_slider_var.set(value)
-            self.manual_brix_var.set(f"{value:.1f}")
-        except ValueError:
-            pass
-
-    def update_graph(self, frame):
-        """Actualiza el gráfico con los datos actuales"""
-        if len(self.time_data) > 0:
-            self.line_brix.set_data(list(self.time_data), list(self.brix_data))
-            self.line_ma.set_data(list(self.time_data), list(self.ma_data))
-            
-            # Ajustar límites
-            if len(self.time_data) > 1:
-                self.ax1.set_xlim(min(self.time_data), max(self.time_data))
-                
-                if len(self.brix_data) > 0:
-                    brix_min = min(self.brix_data) - 1
-                    brix_max = max(self.brix_data) + 1
-                    self.ax1.set_ylim(brix_min, brix_max)
-                
-                if len(self.ma_data) > 0:
-                    ma_min = min(self.ma_data) - 0.5
-                    ma_max = max(self.ma_data) + 0.5
-                    self.ax2.set_ylim(ma_min, ma_max)
-        
-        return self.line_brix, self.line_ma
-
-    def add_data_point(self, brix_value, ma_value):
-        """Agrega un punto de datos al gráfico"""
-        current_time = time.time() - self.start_time
-        self.time_data.append(current_time)
-        self.brix_data.append(brix_value)
-        self.ma_data.append(ma_value)
-        
-        # Redibujar el canvas
-        self.canvas.draw_idle()
-
-    def clear_graph(self):
-        """Limpia los datos del gráfico"""
-        self.time_data.clear()
-        self.brix_data.clear()
-        self.ma_data.clear()
-        self.start_time = time.time()
-        self.canvas.draw_idle()
-        self._log_message("Gráfico limpiado.")
-
-    def on_connection_type_change(self, event=None):
-        conn_type = self.connection_type_var.get()
-        if conn_type == "Serial":
-            self.ethernet_frame.grid_remove()
-            self.serial_frame.grid()
-        else:  # TCP o UDP
-            self.serial_frame.grid_remove()
-            self.ethernet_frame.grid()
+        self.on_function_type_change() # Set initial state of widgets
 
     def on_function_type_change(self, event=None):
         func_type = self.function_type_var.get()
         if func_type == "Manual":
             if self.simulating:
-                self.stop_simulation()
+                self.stop_simulation() # Detiene simulación continua y cierra puerto si estaba abierto por ella
             
             self.manual_brix_entry.config(state=tk.NORMAL)
             self.manual_send_button.config(state=tk.NORMAL)
-            self.manual_slider.config(state=tk.NORMAL)
             
             self.period_entry.config(state=tk.DISABLED)
             self.start_button.config(state=tk.DISABLED)
             self.stop_button.config(state=tk.DISABLED)
-        else:
+        else: # Lineal o Sinusoidal
             self.manual_brix_entry.config(state=tk.DISABLED)
             self.manual_send_button.config(state=tk.DISABLED)
-            self.manual_slider.config(state=tk.DISABLED)
 
             self.period_entry.config(state=tk.NORMAL)
             if not self.simulating:
@@ -396,6 +159,8 @@ class MaselliSimulatorApp:
 
     def _get_common_params(self):
         try:
+            com_port = self.com_port_var.get()
+            baud_rate = int(self.baud_rate_var.get())
             adam_address = self.adam_address_var.get()
             if len(adam_address) != 2:
                 messagebox.showerror("Error", "La dirección ADAM debe tener 2 caracteres.")
@@ -403,73 +168,19 @@ class MaselliSimulatorApp:
 
             min_brix_map = float(self.min_brix_map_var.get())
             max_brix_map = float(self.max_brix_map_var.get())
-            if min_brix_map > max_brix_map:
+            if min_brix_map > max_brix_map: # Allow min_brix_map == max_brix_map
                  messagebox.showerror("Error", "Valor Mínimo (Brix) para mapeo no puede ser mayor que Valor Máximo (Brix).")
                  return None
-            
-            conn_type = self.connection_type_var.get()
-            
-            if conn_type == "Serial":
-                com_port = self.com_port_var.get()
-                baud_rate = int(self.baud_rate_var.get())
-                return conn_type, {'port': com_port, 'baud': baud_rate}, adam_address, min_brix_map, max_brix_map
-            else:  # TCP o UDP
-                ip_address = self.ip_address_var.get()
-                port = int(self.port_var.get())
-                return conn_type, {'ip': ip_address, 'port': port}, adam_address, min_brix_map, max_brix_map
-                
+            return com_port, baud_rate, adam_address, min_brix_map, max_brix_map
         except ValueError as e:
-            messagebox.showerror("Error de Entrada", f"Valor inválido en la configuración: {e}")
+            messagebox.showerror("Error de Entrada", f"Valor inválido en la configuración común: {e}")
             return None
 
-    def _open_connection(self, conn_type, conn_params):
-        """Abre la conexión según el tipo especificado"""
-        try:
-            if conn_type == "Serial":
-                return serial.Serial(conn_params['port'], conn_params['baud'], timeout=1)
-            elif conn_type == "TCP":
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.settimeout(5.0)
-                sock.connect((conn_params['ip'], conn_params['port']))
-                return sock
-            elif conn_type == "UDP":
-                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                sock.settimeout(1.0)
-                # Para UDP guardamos la dirección destino
-                sock.dest_address = (conn_params['ip'], conn_params['port'])
-                return sock
-        except Exception as e:
-            raise Exception(f"Error al abrir conexión {conn_type}: {e}")
-
-    def _close_connection(self, connection, conn_type):
-        """Cierra la conexión según el tipo"""
-        try:
-            if conn_type == "Serial":
-                if connection and connection.is_open:
-                    connection.close()
-            elif conn_type in ["TCP", "UDP"]:
-                if connection:
-                    connection.close()
-        except Exception as e:
-            self._log_message(f"Error al cerrar conexión: {e}")
-
-    def _send_data(self, connection, conn_type, data):
-        """Envía datos según el tipo de conexión"""
-        try:
-            if conn_type == "Serial":
-                connection.write(data.encode('ascii'))
-            elif conn_type == "TCP":
-                connection.send(data.encode('ascii'))
-            elif conn_type == "UDP":
-                connection.sendto(data.encode('ascii'), connection.dest_address)
-        except Exception as e:
-            raise Exception(f"Error al enviar datos: {e}")
-
     def send_manual_value(self):
         common_params = self._get_common_params()
         if not common_params:
             return
-        conn_type, conn_params, adam_address, min_brix_map, max_brix_map = common_params
+        com_port, baud_rate, adam_address, min_brix_map, max_brix_map = common_params
 
         try:
             manual_brix = float(self.manual_brix_var.get())
@@ -483,27 +194,25 @@ class MaselliSimulatorApp:
         self.current_brix_display_var.set(f"{manual_brix:.3f} Brix")
         self.current_ma_display_var.set(f"{mA_str} mA")
 
-        # Agregar punto al gráfico
-        self.add_data_point(manual_brix, mA_val)
-
         message_part = f"#{adam_address}{mA_str}"
         checksum = self.calculate_checksum(message_part)
         full_string_to_send = f"{message_part}{checksum}\r"
         log_display_string = full_string_to_send.replace('\r', '<CR>')
         
-        temp_connection = None
+        temp_serial_port = None
         try:
-            temp_connection = self._open_connection(conn_type, conn_params)
-            self._log_message(f"Conexión {conn_type} abierta temporalmente para envío manual.")
+            temp_serial_port = serial.Serial(com_port, baud_rate, timeout=1)
+            self._log_message(f"Puerto {com_port} abierto temporalmente para envío manual.")
             self._log_message(f"Enviando Manual: {log_display_string}")
-            self._send_data(temp_connection, conn_type, full_string_to_send)
-        except Exception as e:
-            self._log_message(f"Error al enviar manualmente: {e}")
-            messagebox.showerror("Error de Conexión", str(e))
+            temp_serial_port.write(full_string_to_send.encode('ascii'))
+        except serial.SerialException as e:
+            self._log_message(f"Error al enviar manualmente por puerto COM: {e}")
+            messagebox.showerror("Error de Puerto COM", f"No se pudo abrir/escribir en {com_port}: {e}")
         finally:
-            if temp_connection:
-                self._close_connection(temp_connection, conn_type)
-                self._log_message(f"Conexión {conn_type} cerrada tras envío manual.")
+            if temp_serial_port and temp_serial_port.is_open:
+                temp_serial_port.close()
+                self._log_message(f"Puerto {com_port} cerrado tras envío manual.")
+
 
     def start_simulation(self):
         if self.simulating:
@@ -513,7 +222,7 @@ class MaselliSimulatorApp:
         common_params = self._get_common_params()
         if not common_params:
             return
-        self.connection_type, self.conn_params, self.adam_address, self.min_brix_map, self.max_brix_map = common_params
+        com_port, baud_rate, self.adam_address, self.min_brix_map, self.max_brix_map = common_params
         
         try:
             self.simulation_period = float(self.period_var.get())
@@ -521,7 +230,7 @@ class MaselliSimulatorApp:
                 messagebox.showerror("Error", "El periodo debe ser un número positivo.")
                 return
             self.function_type = self.function_type_var.get()
-            if self.function_type == "Manual":
+            if self.function_type == "Manual": # Should not happen if GUI logic is correct
                 messagebox.showinfo("Info", "Seleccione modo Lineal o Sinusoidal para simulación continua.")
                 return
 
@@ -530,11 +239,11 @@ class MaselliSimulatorApp:
             return
 
         try:
-            self.connection = self._open_connection(self.connection_type, self.conn_params)
-            self._log_message(f"Conexión {self.connection_type} abierta para simulación continua.")
-        except Exception as e:
-            messagebox.showerror("Error de Conexión", str(e))
-            self.connection = None
+            self.serial_port = serial.Serial(com_port, baud_rate, timeout=1)
+            self._log_message(f"Puerto {com_port} abierto a {baud_rate} baud para simulación continua.")
+        except serial.SerialException as e:
+            messagebox.showerror("Error de Puerto COM", f"No se pudo abrir el puerto {com_port}: {e}")
+            self.serial_port = None
             return
 
         self.simulating = True
@@ -548,39 +257,37 @@ class MaselliSimulatorApp:
         self._log_message("Simulación continua iniciada.")
 
     def _set_config_entries_state(self, state):
-        self.connection_type_combo.config(state=state)
         self.com_port_entry.config(state=state)
         self.baud_rate_entry.config(state=state)
-        self.ip_address_entry.config(state=state)
-        self.port_entry.config(state=state)
         self.adam_address_entry.config(state=state)
         self.function_type_combo.config(state=state)
         self.min_brix_map_entry.config(state=state)
         self.max_brix_map_entry.config(state=state)
-        self.save_config_button.config(state=state)
-        self.load_config_button.config(state=state)
         
+        # Specific to sim type
         current_func_type = self.function_type_var.get()
         if current_func_type != "Manual":
             self.period_entry.config(state=state)
             self.manual_brix_entry.config(state=tk.DISABLED)
             self.manual_send_button.config(state=tk.DISABLED)
-            self.manual_slider.config(state=tk.DISABLED)
-        else:
+        else: # Manual
             self.period_entry.config(state=tk.DISABLED)
+            # For manual, these are handled by on_function_type_change based on main state
+            # If state is tk.DISABLED, ensure manual ones are also disabled
             if state == tk.DISABLED:
                 self.manual_brix_entry.config(state=tk.DISABLED)
                 self.manual_send_button.config(state=tk.DISABLED)
-                self.manual_slider.config(state=tk.DISABLED)
-            else:
+            else: # tk.NORMAL
                  self.manual_brix_entry.config(state=tk.NORMAL)
                  self.manual_send_button.config(state=tk.NORMAL)
-                self.manual_slider.config(state=tk.NORMAL)
+
 
     def stop_simulation(self):
         if not self.simulating:
+            # Could be called when switching to Manual mode, even if not simulating
             if self.function_type_var.get() != "Manual":
                  self._log_message("Simulación continua ya estaba detenida.")
+            # Ensure GUI elements are in a consistent state for non-manual modes
             if self.function_type_var.get() != "Manual":
                 self.start_button.config(state=tk.NORMAL)
                 self.stop_button.config(state=tk.DISABLED)
@@ -594,20 +301,25 @@ class MaselliSimulatorApp:
             except Exception as e:
                 self._log_message(f"Error al esperar el hilo de simulación: {e}")
 
-        if self.connection:
-            self._close_connection(self.connection, self.connection_type)
-            self._log_message(f"Conexión {self.connection_type} cerrada (simulación continua).")
-            self.connection = None
+
+        if self.serial_port and self.serial_port.is_open:
+            self.serial_port.close()
+            self._log_message(f"Puerto {self.serial_port.name} cerrado (simulación continua).")
+            self.serial_port = None
         
         self.start_button.config(state=tk.NORMAL)
         self.stop_button.config(state=tk.DISABLED)
         self._set_config_entries_state(tk.NORMAL)
+        # Call on_function_type_change to ensure manual fields are correctly set
+        # if the current mode is manual after stopping.
         self.on_function_type_change()
 
+
         self._log_message("Simulación continua detenida.")
         self.current_brix_display_var.set("---")
         self.current_ma_display_var.set("--.-- mA")
 
+
     def run_simulation(self):
         steps_for_full_cycle = 100 
         
@@ -616,8 +328,7 @@ class MaselliSimulatorApp:
 
             if self.function_type == "Lineal":
                 progress = (self.simulation_step % (2 * steps_for_full_cycle)) / steps_for_full_cycle
-                if progress > 1.0: 
-                    progress = 2.0 - progress
+                if progress > 1.0: progress = 2.0 - progress
                 current_brix_val = self.min_brix_map + (self.max_brix_map - self.min_brix_map) * progress
             
             elif self.function_type == "Sinusoidal":
@@ -631,52 +342,53 @@ class MaselliSimulatorApp:
             self.current_brix_display_var.set(f"{current_brix_val:.3f} Brix")
             self.current_ma_display_var.set(f"{mA_str} mA")
 
-            # Agregar punto al gráfico
-            self.root.after(0, lambda b=current_brix_val, m=mA_val: self.add_data_point(b, m))
-
             message_part = f"#{self.adam_address}{mA_str}"
             checksum = self.calculate_checksum(message_part)
             full_string_to_send = f"{message_part}{checksum}\r"
             log_display_string = full_string_to_send.replace('\r', '<CR>')
             self._log_message(f"Enviando Sim: {log_display_string}")
 
-            if self.connection:
+            if self.serial_port and self.serial_port.is_open:
                 try:
-                    self._send_data(self.connection, self.connection_type, full_string_to_send)
-                except Exception as e:
-                    self._log_message(f"Error al escribir en conexión (sim): {e}")
-                    self.root.after(0, self.stop_simulation_from_thread_error)
+                    self.serial_port.write(full_string_to_send.encode('ascii'))
+                except serial.SerialException as e:
+                    self._log_message(f"Error al escribir en puerto COM (sim): {e}")
+                    self.root.after(0, self.stop_simulation_from_thread_error) # Schedule stop from main thread
                     break 
             
             self.simulation_step += 1
             time.sleep(self.simulation_period)
         
+        # Ensure GUI updates if loop exits due to self.simulating = False
         if not self.simulating and self.root.winfo_exists():
             self.root.after(0, self.ensure_gui_stopped_state_sim)
 
     def stop_simulation_from_thread_error(self):
-        """Called from main thread if connection error occurs in sim thread."""
-        if self.simulating:
-            messagebox.showerror("Error de Simulación", "Error de conexión durante la simulación. Simulación detenida.")
+        """Called from main thread if serial error occurs in sim thread."""
+        if self.simulating: # Check if it wasn't already stopped
+            messagebox.showerror("Error de Simulación", "Error de puerto COM durante la simulación. Simulación detenida.")
             self.stop_simulation()
 
+
     def ensure_gui_stopped_state_sim(self):
         """Asegura que la GUI refleje el estado detenido si el hilo de simulación continua termina."""
-        if not self.simulating:
+        if not self.simulating: # If stop_simulation wasn't called or completed fully
             self.start_button.config(state=tk.NORMAL)
             self.stop_button.config(state=tk.DISABLED)
             self._set_config_entries_state(tk.NORMAL)
-            if self.connection:
-                self._close_connection(self.connection, self.connection_type)
-                self._log_message(f"Conexión {self.connection_type} cerrada (auto, sim_end).")
-                self.connection = None
+            # self.on_function_type_change() # Reset based on current function type
+            if self.serial_port and self.serial_port.is_open:
+                 self.serial_port.close()
+                 self._log_message(f"Puerto {self.serial_port.name} cerrado (auto, sim_end).")
+                 self.serial_port = None
             self._log_message("Simulación continua terminada (hilo finalizado).")
 
+
     def on_closing(self):
         if self.simulating:
-            self.stop_simulation()
-        elif self.connection:
-            self._close_connection(self.connection, self.connection_type)
+            self.stop_simulation() # Esto ya maneja el thread y el puerto
+        elif self.serial_port and self.serial_port.is_open: # Si el puerto quedó abierto por otra razón (improbable con lógica actual)
+            self.serial_port.close()
         self.root.destroy()
 
 if __name__ == "__main__":