backend done

backend/config_builder.py

@@ -1,28 +1,42 @@
 import gradio as gr
-from lerobot.simulations import aloha, pusht, xarm
+from lerobot.robots import LeFeetech
+import time
 
-def run_simulation(sim_type):
-    if sim_type == "aloha":
-        env = aloha.make_env()
-    elif sim_type == "pusht":
-        env = pusht.make_env()
-    elif sim_type == "xarm":
-        env = xarm.make_env()
-    else:
-        return "Simulación no reconocida"
+# Inicializa conexión con robot Feetech
+try:
+    robot = LeFeetech(port="/dev/ttyUSB0")  # Cambia este puerto si es necesario
+    motors = robot.motors
+except Exception as e:
+    raise RuntimeError(f"Error al conectar con el robot: {e}")
 
-    obs = env.reset()
-    frame = env.render()
-    return frame  # Devolver imagen inicial
+# Función para mover los motores desde los sliders
+def controlar_robot(motor1_pos, motor2_pos, motor3_pos):
+    try:
+        # Envía posición a cada motor (ajusta según IDs reales)
+        motors[0].goto(motor1_pos)
+        motors[1].goto(motor2_pos)
+        motors[2].goto(motor3_pos)
+        
+        time.sleep(0.5)  # espera para que el robot se mueva
+        # Podrías agregar aquí sensores o cámara para devolver imagen
+        return f"Motor1: {motor1_pos}, Motor2: {motor2_pos}, Motor3: {motor3_pos}"
+    except Exception as err:
+        return f"Error: {err}"
 
+# Interfaz
 with gr.Blocks() as demo:
-    gr.Markdown("# Simulador LeRobot Interface")
+    gr.Markdown("# Control en Tiempo Real del Robot LeRobot con Feetech")
+    
+    with gr.Row():
+        motor1 = gr.Slider(0, 1023, value=512, label="Motor 1")
+        motor2 = gr.Slider(0, 1023, value=512, label="Motor 2")
+        motor3 = gr.Slider(0, 1023, value=512, label="Motor 3")
 
-    sim_selector = gr.Dropdown(
-        ["aloha", "pusht", "xarm"], label="Selecciona simulación"
-    )
-    output = gr.Image(label="Vista previa del entorno")
-
-    sim_selector.change(fn=run_simulation, inputs=sim_selector, outputs=output)
+    estado = gr.Textbox(label="Estado del Robot")
+    
+    # Actualiza cada vez que se mueva algún slider
+    motor1.change(fn=controlar_robot, inputs=[motor1, motor2, motor3], outputs=estado)
+    motor2.change(fn=controlar_robot, inputs=[motor1, motor2, motor3], outputs=estado)
+    motor3.change(fn=controlar_robot, inputs=[motor1, motor2, motor3], outputs=estado)
 
 demo.launch()

backend/record_controller.py

@@ -0,0 +1,407 @@
+# backend/record_controller.py (o record_controller_gradio.py)
+import subprocess
+import os
+import gradio as gr
+import serial.tools.list_ports # Nuevo: para listar puertos seriales
+import json # Necesario para la función load_config si la copiamos aquí
+
+# IMPORTANTE: Si robot_detector.py está en el mismo directorio 'backend',
+# puedes importar su función de carga de configuración.
+# Asegúrate de que el archivo robot_detector.py exista en la misma carpeta.
+try:
+    from robot_detector import load_config as load_robot_config, CONFIG_FILE as ROBOT_CONFIG_FILE
+except ImportError:
+    print("Advertencia: No se pudo importar 'load_config' de 'robot_detector.py'.")
+    print("Asegúrate de que 'robot_detector.py' esté en el mismo directorio 'backend'.")
+    print("Se usará una implementación local de load_config.")
+    
+    # Implementación fallback de load_config si no se puede importar
+    ROBOT_CONFIG_FILE = "robot_config.json"
+    def load_robot_config():
+        if os.path.exists(ROBOT_CONFIG_FILE):
+            try:
+                with open(ROBOT_CONFIG_FILE, 'r') as f:
+                    config = json.load(f)
+                return (
+                    config.get("robot_follower", {}).get("port", ""),
+                    config.get("robot_follower", {}).get("id", ""),
+                    config.get("teleop_leader", {}).get("port", ""),
+                    config.get("teleop_leader", {}).get("id", "")
+                )
+            except Exception as e:
+                print(f"Error al cargar la configuración existente desde '{ROBOT_CONFIG_FILE}': {e}. Se usarán valores por defecto.")
+                return "", "", "", ""
+        return "", "", "", ""
+
+
+def run_command(command: str, description: str):
+    """
+    Ejecuta un comando de shell y captura su salida, manejando errores.
+    """
+    print(f"\n--- {description} ---")
+    process_output = [] # Use a list to collect output for better streaming if needed later
+    try:
+        # Use Popen to stream output in real-time, important for long running processes
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT, # Redirect stderr to stdout
+            text=True
+        )
+
+        for line in iter(process.stdout.readline, ''):
+            print(line, end='') # Print to console for server-side logging
+            process_output.append(line)
+            # You could add a gr.Progress() here for real-time update in Gradio if needed
+
+        process.wait() # Wait for the process to complete
+
+        if process.returncode == 0:
+            print(f"Éxito: {description}")
+            return True, "".join(process_output)
+        else:
+            error_message = f"Error durante '{description}': El comando devolvió el código de salida {process.returncode}"
+            print(error_message)
+            return False, "".join(process_output) # Return all collected output, including errors
+    except Exception as e:
+        error_message = f"Ocurrió un error inesperado durante '{description}': {e}"
+        print(error_message)
+        return False, error_message
+
+def list_serial_device_paths():
+    """
+    Lista los puertos seriales disponibles y devuelve solo las rutas de los dispositivos.
+    """
+    ports = serial.tools.list_ports.comports()
+    device_paths = []
+    if not ports:
+        return [] # Return empty list if no ports found
+    
+    for port in ports:
+        device_paths.append(port.device)
+    
+    return device_paths
+
+def login_to_huggingface(token: str):
+    """
+    Inicia sesión en Hugging Face CLI con el token proporcionado.
+    """
+    if not token or token == "hf_YOUR_ACTUAL_WRITE_TOKEN_HERE":
+        return False, "Error: Por favor, proporciona un token de Hugging Face válido."
+    
+    success, output = run_command(
+        f"huggingface-cli login --token {token}", # <--- ¡Argumento eliminado!
+        "Iniciando sesión en Hugging Face CLI"
+    )
+    if success:
+        return True, "¡Inicio de sesión en Hugging Face exitoso!"
+    else:
+        return False, output
+
+def get_huggingface_user():
+    """
+    Obtiene el nombre de usuario de Hugging Face.
+    """
+    success, output = run_command(
+        "huggingface-cli whoami | head -n 1",
+        "Obteniendo nombre de usuario de Hugging Face"
+    )
+    if success:
+        # The output might contain warnings before the actual username.
+        # Try to find the username, which should be the first non-empty, non-warning line.
+        lines = output.splitlines()
+        for line in lines:
+            if line.strip() and not (line.strip().startswith("warnings.") or "deprecated" in line.lower()):
+                return True, line.strip()
+        return False, "No se pudo extraer el nombre de usuario de la salida de 'whoami'."
+    else:
+        return False, output
+
+def record_dataset_core(hf_user: str,
+                        robot_port: str,
+                        teleop_port: str,
+                        num_episodes: int = 2,
+                        single_task: str = "Grab the black cube",
+                        push_to_hub: bool = True,
+                        resume: bool = False,
+                        episode_time_s: int = 60,
+                        reset_time_s: int = 60):
+    """
+    Función central para grabar un dataset usando LeRobot.
+    """
+    if not hf_user:
+        return False, "Error: Nombre de usuario de Hugging Face no disponible. ¿Falló el inicio de sesión?"
+
+    # Use the IDs from the loaded config for consistency
+    initial_follower_port, initial_follower_id, initial_leader_port, initial_leader_id = load_robot_config()
+    robot_id = initial_follower_id if initial_follower_id else "my_awesome_follower_arm"
+    teleop_id = initial_leader_id if initial_leader_id else "my_awesome_leader_arm"
+
+
+    dataset_repo_id = f"{hf_user}/record-test"
+    
+    command = [
+        "python", "-m", "lerobot.record",
+        "--robot.type=so101_follower",
+        f"--robot.port={robot_port}",
+        f"--robot.id={robot_id}", # Use ID from config/default
+        "--robot.cameras=\"{{ front: {{type: opencv, index_or_path: 0, width: 1920, height: 1080, fps: 30}}}}\"", # Escaping for shell command
+        "--teleop.type=so101_leader",
+        f"--teleop.port={teleop_port}",
+        f"--teleop.id={teleop_id}", # Use ID from config/default
+        "--display_data=true",
+        f"--dataset.repo_id={dataset_repo_id}",
+        f"--dataset.num_episodes={num_episodes}",
+        f"--dataset.single_task=\"{single_task}\"",
+        f"--dataset.episode_time_s={episode_time_s}",
+        f"--dataset.reset_time_s={reset_time_s}"
+    ]
+
+    if not push_to_hub:
+        command.append("--dataset.push_to_hub=False")
+    if resume:
+        command.append("--resume=true")
+
+    full_command = " ".join(command)
+
+    success, output = run_command(full_command, "Grabación del dataset")
+    if success:
+        final_message = f"¡Grabación del dataset completada exitosamente!\n"
+        final_message += f"El dataset se almacenó localmente en: ~/.cache/huggingface/lerobot/{dataset_repo_id}\n"
+        if push_to_hub:
+            final_message += f"El dataset ha sido subido a: https://huggingface.co/datasets/{dataset_repo_id}\n"
+            final_message += "Puedes añadir etiquetas personalizadas (ej. 'tutorial') en la página del dataset en Hugging Face."
+        else:
+            final_message += "La subida al Hugging Face Hub fue deshabilitada."
+        return True, final_message
+    else:
+        return False, output
+
+# --- Gradio Interface Logic ---
+
+# Variable global para almacenar el usuario de Hugging Face
+current_hf_user = None
+
+def gradio_login(hf_token_input: str):
+    """Interfaz Gradio para iniciar sesión en Hugging Face."""
+    global current_hf_user
+    success, message = login_to_huggingface(hf_token_input)
+    if success:
+        gr.Info(message)
+        success_user, user_name = get_huggingface_user()
+        if success_user:
+            current_hf_user = user_name
+            return gr.update(value=user_name, interactive=False), gr.update(visible=True, value=message) # Update username field and status box
+        else:
+            return gr.update(value="", interactive=True), gr.update(visible=True, value=user_name) # Show error if user not retrieved
+    else:
+        current_hf_user = None
+        return gr.update(value="", interactive=True), gr.update(visible=True, value=message) # Clear username and show error
+
+def gradio_record(robot_port_input: str,
+                  teleop_port_input: str,
+                  num_episodes_input: int,
+                  single_task_input: str,
+                  push_to_hub_input: bool,
+                  resume_input: bool,
+                  episode_time_s_input: int,
+                  reset_time_s_input: int):
+    """Interfaz Gradio para iniciar la grabación del dataset."""
+    global current_hf_user
+    if not current_hf_user:
+        return gr.update(visible=True, value="Error: No se ha iniciado sesión en Hugging Face o no se pudo obtener el usuario. Por favor, inicia sesión primero."), gr.update(interactive=False)
+
+    gr.Info("Iniciando grabación del dataset. Esto puede tardar unos segundos...")
+    success, message = record_dataset_core(
+        hf_user=current_hf_user,
+        robot_port=robot_port_input,
+        teleop_port=teleop_port_input,
+        num_episodes=num_episodes_input,
+        single_task=single_task_input,
+        push_to_hub=push_to_hub_input,
+        resume=resume_input,
+        episode_time_s=episode_time_s_input,
+        reset_time_s=reset_time_s_input
+    )
+    if success:
+        gr.Info("Grabación completada.")
+        return gr.update(visible=True, value=message), gr.update(interactive=True)
+    else:
+        gr.Info("Grabación fallida. Revisa el log para más detalles.")
+        return gr.update(visible=True, value=message), gr.update(interactive=True)
+
+# Define la interfaz de Gradio
+with gr.Blocks(title="Controlador de Grabación LeRobot") as demo:
+    gr.Markdown("# <center>Controlador de Grabación de Datasets LeRobot</center>")
+    gr.Markdown("Esta interfaz te ayuda a gestionar la grabación de datasets para LeRobot.")
+
+    with gr.Tab("1. Configuración de Hugging Face"):
+        gr.Markdown("## Configuración de Hugging Face")
+        gr.Markdown(
+            "Introduce tu **token de Hugging Face con permisos de escritura**. "
+            "Puedes generarlo en [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)."
+        )
+        hf_token_input = gr.Textbox(
+            label="Token de Hugging Face",
+            type="password",
+            placeholder="hf_YOUR_ACTUAL_WRITE_TOKEN_HERE",
+            info="El token debe tener permisos de escritura (write)."
+        )
+        login_btn = gr.Button("Iniciar Sesión / Verificar Token")
+        hf_user_output = gr.Textbox(label="Usuario de Hugging Face Actual", interactive=False, placeholder="No autenticado", show_copy_button=True)
+        login_status_output = gr.Textbox(label="Estado de Autenticación", interactive=False, visible=False)
+        
+        login_btn.click(
+            fn=gradio_login,
+            inputs=hf_token_input,
+            outputs=[hf_user_output, login_status_output]
+        )
+
+    with gr.Tab("2. Parámetros de Grabación"):
+        gr.Markdown("## Parámetros del Robot y la Grabación")
+        gr.Markdown(
+            "Asegúrate de que los **puertos seriales** de tus robots sean correctos. "
+            "Puedes detectarlos automáticamente o introducirlos manualmente."
+        )
+
+        # Load initial config from robot_config.json
+        initial_follower_port, initial_follower_id, initial_leader_port, initial_leader_id = load_robot_config()
+
+        with gr.Group(): # Group for auto-detection and manual input
+            gr.Markdown("### Puerto del Robot Follower")
+            robot_port_dropdown = gr.Dropdown(
+                label="Seleccionar Puerto",
+                choices=[], # Populated on load/refresh
+                value=initial_follower_port, # Pre-fill from config
+                interactive=True,
+                allow_custom_value=True # Allow manual input
+            )
+            robot_port_manual = gr.Textbox(
+                label="O introducir Puerto Manualmente",
+                value=initial_follower_port, # Pre-fill from config
+                placeholder="ej. /dev/tty.usbmodemXXXXX",
+                interactive=True
+            )
+            # Synchronize dropdown and manual textbox
+            robot_port_dropdown.change(lambda x: x, inputs=robot_port_dropdown, outputs=robot_port_manual)
+            robot_port_manual.change(lambda x: x, inputs=robot_port_manual, outputs=robot_port_dropdown)
+
+        with gr.Group(): # Group for auto-detection and manual input
+            gr.Markdown("### Puerto del Teleoperador Leader")
+            teleop_port_dropdown = gr.Dropdown(
+                label="Seleccionar Puerto",
+                choices=[], # Populated on load/refresh
+                value=initial_leader_port, # Pre-fill from config
+                interactive=True,
+                allow_custom_value=True # Allow manual input
+            )
+            teleop_port_manual = gr.Textbox(
+                label="O introducir Puerto Manualmente",
+                value=initial_leader_port, # Pre-fill from config
+                placeholder="ej. /dev/tty.usbmodemXXXXX",
+                interactive=True
+            )
+            # Synchronize dropdown and manual textbox
+            teleop_port_dropdown.change(lambda x: x, inputs=teleop_port_dropdown, outputs=teleop_port_manual)
+            teleop_port_manual.change(lambda x: x, inputs=teleop_port_manual, outputs=teleop_port_dropdown)
+
+        refresh_ports_btn = gr.Button("🔄 Refrescar Puertos Detectados")
+
+        num_episodes_input = gr.Slider(
+            minimum=1, maximum=100, step=1, value=2, label="Número de Episodios a Grabar",
+            info="Define cuántos episodios se grabarán."
+        )
+        single_task_input = gr.Textbox(
+            label="Descripción de la Tarea (Single Task)",
+            value="Grab the black cube",
+            placeholder="Describe la tarea que realizará el robot"
+        )
+        episode_time_s_input = gr.Slider(
+            minimum=10, maximum=300, step=10, value=60, label="Duración del Episodio (segundos)",
+            info="Tiempo máximo de grabación para cada episodio."
+        )
+        reset_time_s_input = gr.Slider(
+            minimum=5, maximum=120, step=5, value=60, label="Tiempo de Reseteo (segundos)",
+            info="Tiempo para preparar el entorno entre episodios."
+        )
+        push_to_hub_input = gr.Checkbox(
+            label="Subir Dataset a Hugging Face Hub",
+            value=True,
+            info="Marca esta casilla para subir el dataset a tu perfil de Hugging Face."
+        )
+        resume_input = gr.Checkbox(
+            label="Reanudar Grabación Existente",
+            value=False,
+            info="Si hay una grabación previa, continúa desde donde se detuvo."
+        )
+
+        # Function to update dropdown choices on button click or page load
+        def update_port_dropdowns():
+            ports = list_serial_device_paths()
+            # The dropdowns allow custom values, so setting choices updates the list for selection
+            return gr.update(choices=ports), gr.update(choices=ports)
+
+        # Attach update function to refresh button and initial load
+        refresh_ports_btn.click(
+            fn=update_port_dropdowns,
+            inputs=None,
+            outputs=[robot_port_dropdown, teleop_port_dropdown]
+        )
+        demo.load(
+            fn=update_port_dropdowns,
+            inputs=None,
+            outputs=[robot_port_dropdown, teleop_port_dropdown]
+        )
+
+    with gr.Tab("3. Iniciar Grabación"):
+        gr.Markdown("## Ejecutar Grabación del Dataset")
+        gr.Markdown(
+            "Haz clic en el botón para iniciar la grabación. "
+            "Una nueva ventana de LeRobot se abrirá para la teleoperación y visualización."
+        )
+        record_btn = gr.Button("🚀 Iniciar Grabación 🚀", variant="primary")
+        
+        # Output para el estado y mensajes de la grabación
+        record_status_output = gr.Textbox(
+            label="Estado de la Grabación",
+            interactive=False,
+            visible=False,
+            lines=10
+        )
+
+        record_btn.click(
+            fn=gradio_record,
+            inputs=[
+                # Use the current value from either dropdown or textbox (they are synchronized)
+                robot_port_manual, # We'll use the textbox value as it's the ultimate source of truth
+                teleop_port_manual, # Same for teleop port
+                num_episodes_input,
+                single_task_input,
+                push_to_hub_input,
+                resume_input,
+                episode_time_s_input,
+                reset_time_s_input
+            ],
+            outputs=[record_status_output, record_btn] # Update status output and re-enable button
+        )
+        gr.Markdown("### Controles de Teclado Durante la Grabación (en la ventana de LeRobot):")
+        gr.Markdown(
+            "- **Flecha Derecha (→):** Detener el episodio actual y pasar al siguiente.\n"
+            "- **Flecha Izquierda (←):** Cancelar el episodio actual y volver a grabar.\n"
+            "- **Escape (ESC):** Detener la sesión, codificar videos y subir el dataset (si está activado)."
+        )
+
+    gr.Markdown("---")
+    gr.Markdown("Hecho con ❤️ para RobotCleanPupusas503")
+
+# Lanza la interfaz de Gradio
+if __name__ == "__main__":
+    try:
+        import serial # Test if pyserial is installed
+    except ImportError:
+        print("Error: La librería 'pyserial' no está instalada.")
+        print("Por favor, instala 'pyserial' ejecutando: pip install pyserial")
+        exit(1)
+    
+    demo.launch(share=False)

backend/train_controller.py

@@ -0,0 +1,563 @@
+# backend/train_robot.py
+import subprocess
+import os
+import gradio as gr
+import json
+import torch
+
+# --- Helper Functions (reused from record_controller for consistency) ---
+
+def run_command(command: str, description: str):
+    """
+    Ejecuta un comando de shell y captura su salida, manejando errores.
+    """
+    print(f"\n--- {description} ---")
+    process_output = []
+    try:
+        # Use Popen to stream output in real-time
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT, # Redirect stderr to stdout
+            text=True
+        )
+
+        for line in iter(process.stdout.readline, ''):
+            print(line, end='') # Print to console
+            process_output.append(line)
+            # You might want to yield here for Gradio's gr.Progress,
+            # but for simplicity, we'll collect all output and return at the end.
+
+        process.wait() # Wait for the process to complete
+
+        if process.returncode == 0:
+            print(f"Éxito: {description}")
+            return True, "".join(process_output)
+        else:
+            error_message = f"Error durante '{description}': El comando devolvió el código de salida {process.returncode}"
+            print(error_message)
+            return False, "".join(process_output) # Return all collected output, including errors
+    except Exception as e:
+        error_message = f"Ocurrió un error inesperado durante '{description}': {e}"
+        print(error_message)
+        return False, error_message
+
+def login_to_huggingface(token: str):
+    """
+    Inicia sesión en Hugging Face CLI con el token proporcionado.
+    """
+    if not token or token == "hf_YOUR_ACTUAL_WRITE_TOKEN_HERE":
+        return False, "Error: Por favor, proporciona un token de Hugging Face válido."
+
+    success, output = run_command(
+        f"huggingface-cli login --token {token} --add-to-git-credential",
+        "Iniciando sesión en Hugging Face CLI"
+    )
+    if success:
+        return True, "¡Inicio de sesión en Hugging Face exitoso!"
+    else:
+        return False, output
+
+def get_huggingface_user():
+    """
+    Obtiene el nombre de usuario de Hugging Face.
+    """
+    success, output = run_command(
+        "huggingface-cli whoami | head -n 1",
+        "Obteniendo nombre de usuario de Hugging Face"
+    )
+    if success:
+        # The output might contain warnings before the actual username.
+        # Try to find the username, which should be the first non-empty, non-warning line.
+        lines = output.splitlines()
+        for line in lines:
+            if line.strip() and not (line.strip().startswith("warnings.") or "deprecated" in line.lower()):
+                return True, line.strip()
+        return False, "No se pudo extraer el nombre de usuario de la salida de 'whoami'."
+    else:
+        return False, output
+
+# --- Core Training and Upload Logic ---
+
+def train_policy_core(hf_user: str,
+                      dataset_repo_id: str,
+                      policy_type: str,
+                      output_dir: str,
+                      job_name: str,
+                      policy_device: str,
+                      wandb_enable: bool,
+                      resume: bool,
+                      resume_config_path: str):
+    """
+    Entrena una política de robot usando el script `lerobot/scripts/train.py`.
+    """
+    if not hf_user:
+        return False, "Error: Nombre de usuario de Hugging Face no disponible. Por favor, inicia sesión primero."
+    if not dataset_repo_id.startswith(f"{hf_user}/"):
+        dataset_repo_id = f"{hf_user}/{dataset_repo_id.split('/')[-1]}" # Ensure correct repo_id format
+
+    print(f"\nPreparando para entrenar la política '{policy_type}' con el dataset '{dataset_repo_id}'...")
+
+    command = [
+        "python", "-m", "lerobot.scripts.train" # Changed to -m lerobot.scripts.train
+    ]
+
+    if resume and resume_config_path:
+        command.extend([
+            f"--config_path={resume_config_path}",
+            "--resume=true"
+        ])
+    else:
+        command.extend([
+            f"--dataset.repo_id={dataset_repo_id}",
+            f"--policy.type={policy_type}",
+            f"--output_dir={output_dir}",
+            f"--job_name={job_name}",
+            f"--policy.device={policy_device}"
+        ])
+        if wandb_enable:
+            command.append("--wandb.enable=true")
+
+    full_command = " ".join(command)
+
+    success, output = run_command(full_command, "Entrenamiento de la Política")
+    if success:
+        final_message = f"¡Entrenamiento de la política completado exitosamente!\n"
+        final_message += f"Los checkpoints se guardaron en: {output_dir}/checkpoints\n"
+        if wandb_enable:
+            final_message += "Revisa Weights & Biases para los gráficos de entrenamiento.\n"
+        return True, final_message + "\n" + output # Add full output for visibility
+    else:
+        return False, f"Error durante el entrenamiento: {output}"
+
+def upload_policy_core(hf_user: str, policy_repo_name: str, checkpoint_path: str, is_intermediate: bool = False):
+    """
+    Sube un checkpoint de política a Hugging Face Hub.
+    """
+    if not hf_user:
+        return False, "Error: Nombre de usuario de Hugging Face no disponible. Por favor, inicia sesión primero."
+    if not policy_repo_name:
+        return False, "Error: El nombre del repositorio de la política no puede estar vacío."
+    if not checkpoint_path:
+        return False, "Error: La ruta al checkpoint no puede estar vacía."
+    if not os.path.exists(checkpoint_path):
+        return False, f"Error: La ruta del checkpoint '{checkpoint_path}' no existe."
+
+    full_repo_id = f"{hf_user}/{policy_repo_name}"
+    
+    # Hugging Face CLI upload expects the local path to be the second argument
+    command = [
+        "huggingface-cli", "upload",
+        full_repo_id,
+        checkpoint_path,
+        "--repo-type=model" # Specify repo type as model for policies
+    ]
+    
+    if is_intermediate:
+        # For intermediate, we might want to append CKPT to the repo name or use a specific folder within the repo
+        # The provided doc uses policy_nameCKPT. Let's adapt to that if the user provides just base name
+        # However, huggingface-cli upload expects a repo_id, which is HF_USER/REPO_NAME
+        # The common practice is to upload to the same repo but into a different subfolder.
+        # For simplicity, we'll stick to uploading the specified path to the given repo_id.
+        pass # The logic for is_intermediate might depend on how the user names their repos/checkpoints
+
+    full_command = " ".join(command)
+
+    success, output = run_command(full_command, f"Subiendo política a {full_repo_id}")
+    if success:
+        return True, f"¡Política subida exitosamente a https://huggingface.co/{full_repo_id}!"
+    else:
+        return False, f"Error al subir política: {output}"
+
+def evaluate_policy_core(hf_user: str,
+                         robot_type: str,
+                         robot_port: str,
+                         robot_cameras: str, # Raw string for cameras
+                         robot_id: str,
+                         display_data: bool,
+                         dataset_repo_id_eval: str,
+                         single_task: str,
+                         policy_path: str,
+                         teleop_enable: bool = False, # Optional teleop for evaluation
+                         teleop_type: str = "",
+                         teleop_port: str = "",
+                         teleop_id: str = ""):
+    """
+    Evalúa una política utilizando el script `lerobot.record` modificado.
+    """
+    if not hf_user:
+        return False, "Error: Nombre de usuario de Hugging Face no disponible. Por favor, inicia sesión primero."
+    if not policy_path:
+        return False, "Error: La ruta a la política para evaluar no puede estar vacía."
+
+    # Ensure eval dataset repo ID starts with user
+    if not dataset_repo_id_eval.startswith(f"{hf_user}/"):
+        dataset_repo_id_eval = f"{hf_user}/{dataset_repo_id_eval.split('/')[-1]}"
+
+
+    print(f"\nPreparando para evaluar la política '{policy_path}'...")
+
+    command = [
+        "python", "-m", "lerobot.record",
+        f"--robot.type={robot_type}",
+        f"--robot.port={robot_port}",
+        f"--robot.cameras=\"{robot_cameras}\"", # Use the raw string provided by user
+        f"--robot.id={robot_id}",
+        f"--display_data={str(display_data).lower()}",
+        f"--dataset.repo_id={dataset_repo_id_eval}",
+        f"--dataset.single_task=\"{single_task}\"",
+        f"--policy.path={policy_path}"
+    ]
+
+    if teleop_enable:
+        command.extend([
+            f"--teleop.type={teleop_type}",
+            f"--teleop.port={teleop_port}",
+            f"--teleop.id={teleop_id}"
+        ])
+
+    full_command = " ".join(command)
+
+    success, output = run_command(full_command, "Evaluación de la Política")
+    if success:
+        final_message = f"¡Evaluación de la política completada exitosamente!\n"
+        final_message += f"Los datos de evaluación se guardaron en: ~/.cache/huggingface/lerobot/{dataset_repo_id_eval}\n"
+        return True, final_message + "\n" + output
+    else:
+        return False, f"Error durante la evaluación: {output}"
+
+# --- Gradio Interface Logic ---
+
+# Variable global para almacenar el usuario de Hugging Face
+current_hf_user = None
+
+def gradio_login(hf_token_input: str):
+    """Interfaz Gradio para iniciar sesión en Hugging Face."""
+    global current_hf_user
+    success, message = login_to_huggingface(hf_token_input)
+    if success:
+        gr.Info(message)
+        success_user, user_name = get_huggingface_user()
+        if success_user:
+            current_hf_user = user_name
+            return gr.update(value=user_name, interactive=False), gr.update(visible=True, value=message)
+        else:
+            return gr.update(value="", interactive=True), gr.update(visible=True, value=user_name)
+    else:
+        current_hf_user = None
+        return gr.update(value="", interactive=True), gr.update(visible=True, value=message)
+
+def gradio_train(dataset_repo_id_input: str,
+                 policy_type_input: str,
+                 output_dir_input: str,
+                 job_name_input: str,
+                 policy_device_input: str,
+                 wandb_enable_input: bool,
+                 resume_input: bool,
+                 resume_config_path_input: str):
+    """Interfaz Gradio para iniciar el entrenamiento."""
+    global current_hf_user
+    if not current_hf_user:
+        return gr.update(visible=True, value="Error: No se ha iniciado sesión en Hugging Face o no se pudo obtener el usuario. Por favor, inicia sesión primero.")
+
+    gr.Info("Iniciando entrenamiento del modelo. Esto puede tardar mucho tiempo...")
+    success, message = train_policy_core(
+        hf_user=current_hf_user,
+        dataset_repo_id=dataset_repo_id_input,
+        policy_type=policy_type_input,
+        output_dir=output_dir_input,
+        job_name=job_name_input,
+        policy_device=policy_device_input,
+        wandb_enable=wandb_enable_input,
+        resume=resume_input,
+        resume_config_path=resume_config_path_input
+    )
+    if success:
+        gr.Info("Entrenamiento completado. Revisa la salida para los detalles.")
+    else:
+        gr.Info("Entrenamiento fallido. Revisa la salida para los errores.")
+    return gr.update(visible=True, value=message)
+
+def gradio_upload(policy_repo_name_input: str, checkpoint_path_input: str):
+    """Interfaz Gradio para subir un checkpoint."""
+    global current_hf_user
+    if not current_hf_user:
+        return gr.update(visible=True, value="Error: No se ha iniciado sesión en Hugging Face. Por favor, inicia sesión primero.")
+
+    gr.Info(f"Subiendo checkpoint '{checkpoint_path_input}' a '{policy_repo_name_input}'...")
+    success, message = upload_policy_core(
+        hf_user=current_hf_user,
+        policy_repo_name=policy_repo_name_input,
+        checkpoint_path=checkpoint_path_input
+    )
+    if success:
+        gr.Info("Subida completada.")
+    else:
+        gr.Info("Subida fallida. Revisa la salida.")
+    return gr.update(visible=True, value=message)
+
+def gradio_evaluate(robot_type_input: str,
+                    robot_port_input: str,
+                    robot_cameras_input: str,
+                    robot_id_input: str,
+                    display_data_input: bool,
+                    dataset_repo_id_eval_input: str,
+                    single_task_eval_input: str,
+                    policy_path_input: str,
+                    teleop_enable_input: bool,
+                    teleop_type_input: str,
+                    teleop_port_input: str,
+                    teleop_id_input: str):
+    """Interfaz Gradio para evaluar una política."""
+    global current_hf_user
+    if not current_hf_user:
+        return gr.update(visible=True, value="Error: No se ha iniciado sesión en Hugging Face. Por favor, inicia sesión primero.")
+
+    gr.Info("Iniciando evaluación de la política...")
+    success, message = evaluate_policy_core(
+        hf_user=current_hf_user,
+        robot_type=robot_type_input,
+        robot_port=robot_port_input,
+        robot_cameras=robot_cameras_input,
+        robot_id=robot_id_input,
+        display_data=display_data_input,
+        dataset_repo_id_eval=dataset_repo_id_eval_input,
+        single_task=single_task_eval_input,
+        policy_path=policy_path_input,
+        teleop_enable=teleop_enable_input,
+        teleop_type=teleop_type_input,
+        teleop_port=teleop_port_input,
+        teleop_id=teleop_id_input
+    )
+    if success:
+        gr.Info("Evaluación completada.")
+    else:
+        gr.Info("Evaluación fallida. Revisa la salida.")
+    return gr.update(visible=True, value=message)
+
+# --- Gradio Interface Definition ---
+
+with gr.Blocks(title="Controlador de Entrenamiento y Evaluación LeRobot") as demo:
+    gr.Markdown("# <center>Controlador de Entrenamiento y Evaluación de Políticas LeRobot</center>")
+    gr.Markdown("Esta interfaz te permite entrenar, subir y evaluar políticas de robot con LeRobot.")
+
+    with gr.Tab("1. Configuración de Hugging Face"):
+        gr.Markdown("## Configuración de Hugging Face")
+        gr.Markdown(
+            "Introduce tu **token de Hugging Face con permisos de escritura**. "
+            "Puedes generarlo en [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)."
+        )
+        hf_token_input = gr.Textbox(
+            label="Token de Hugging Face",
+            type="password",
+            placeholder="hf_YOUR_ACTUAL_WRITE_TOKEN_HERE",
+            info="El token debe tener permisos de escritura (write)."
+        )
+        login_btn = gr.Button("Iniciar Sesión / Verificar Token")
+        hf_user_output = gr.Textbox(label="Usuario de Hugging Face Actual", interactive=False, placeholder="No autenticado", show_copy_button=True)
+        login_status_output = gr.Textbox(label="Estado de Autenticación", interactive=False, visible=False, lines=3)
+        
+        login_btn.click(
+            fn=gradio_login,
+            inputs=hf_token_input,
+            outputs=[hf_user_output, login_status_output]
+        )
+
+    with gr.Tab("2. Entrenamiento de la Política"):
+        gr.Markdown("## Entrenar una Política")
+        gr.Markdown(
+            "Configura los parámetros para entrenar tu política. Asegúrate de tener el dataset listo en Hugging Face Hub."
+        )
+        with gr.Row():
+            dataset_repo_id_input = gr.Textbox(
+                label="ID del Repositorio del Dataset (ej. YOUR_USER/so101_test)",
+                value="YOUR_USER/so101_test", # Placeholder, will be updated by HF user
+                placeholder="Dataset para entrenar",
+                info="Asegúrate de que este dataset ya haya sido subido con el script de grabación."
+            )
+            policy_type_input = gr.Dropdown(
+                label="Tipo de Política",
+                choices=["act", "diffusion", "rlds"], # Add more types as needed from LeRobot
+                value="act",
+                info="Tipo de arquitectura de política a entrenar (e.g., ACT)."
+            )
+        with gr.Row():
+            output_dir_input = gr.Textbox(
+                label="Directorio de Salida para Checkpoints",
+                value="outputs/train/act_so101_test",
+                placeholder="Directorio donde se guardarán los resultados del entrenamiento."
+            )
+            job_name_input = gr.Textbox(
+                label="Nombre del Trabajo (Job Name)",
+                value="act_so101_test",
+                placeholder="Nombre para identificar tu sesión de entrenamiento."
+            )
+        with gr.Row():
+            policy_device_input = gr.Dropdown(
+                label="Dispositivo de Entrenamiento",
+                choices=["cuda", "mps", "cpu"],
+                value="cuda" if torch.cuda.is_available() else ("mps" if torch.backends.mps.is_available() else "cpu"), # Auto-detect simple device
+                info="Dispositivo a usar para el entrenamiento (GPU Nvidia: cuda, Apple Silicon: mps, CPU: cpu)."
+            )
+            wandb_enable_input = gr.Checkbox(
+                label="Habilitar Weights & Biases",
+                value=True,
+                info="Habilita el seguimiento de métricas con Weights & Biases (asegúrate de haber ejecutado 'wandb login')."
+            )
+        
+        gr.Markdown("### Opciones de Reanudación")
+        resume_input = gr.Checkbox(
+            label="Reanudar Entrenamiento Existente",
+            value=False,
+            info="Marca esta casilla para continuar un entrenamiento desde un checkpoint."
+        )
+        resume_config_path_input = gr.Textbox(
+            label="Ruta al train_config.json para Reanudar (ej. outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json)",
+            placeholder="Ruta al archivo train_config.json del checkpoint a reanudar.",
+            visible=False # Hidden by default, shown when resume is checked
+        )
+        
+        resume_input.change(
+            lambda x: gr.update(visible=x),
+            inputs=resume_input,
+            outputs=resume_config_path_input
+        )
+
+        train_btn = gr.Button("🚀 Iniciar Entrenamiento 🚀", variant="primary")
+        train_status_output = gr.Textbox(
+            label="Log de Entrenamiento",
+            interactive=False,
+            visible=False,
+            lines=20,
+            autoscroll=True
+        )
+
+        train_btn.click(
+            fn=gradio_train,
+            inputs=[
+                dataset_repo_id_input,
+                policy_type_input,
+                output_dir_input,
+                job_name_input,
+                policy_device_input,
+                wandb_enable_input,
+                resume_input,
+                resume_config_path_input
+            ],
+            outputs=train_status_output
+        )
+
+    with gr.Tab("3. Subir Checkpoint de Política"):
+        gr.Markdown("## Subir Checkpoint de Política al Hub")
+        gr.Markdown(
+            "Sube tus modelos entrenados a Hugging Face Hub para compartirlos o usarlos en evaluación."
+        )
+        policy_repo_name_input = gr.Textbox(
+            label="Nombre del Repositorio de la Política (ej. act_so101_test)",
+            value="act_so101_test",
+            placeholder="Nombre del repositorio en Hugging Face Hub para tu política."
+        )
+        checkpoint_path_input = gr.Textbox(
+            label="Ruta Local al Directorio del Checkpoint (ej. outputs/train/act_so101_test/checkpoints/last/pretrained_model)",
+            placeholder="Ruta completa al directorio 'pretrained_model' del checkpoint."
+        )
+        upload_btn = gr.Button("⬆️ Subir Política ⬆️", variant="secondary")
+        upload_status_output = gr.Textbox(
+            label="Log de Subida",
+            interactive=False,
+            visible=False,
+            lines=5
+        )
+
+        upload_btn.click(
+            fn=gradio_upload,
+            inputs=[policy_repo_name_input, checkpoint_path_input],
+            outputs=upload_status_output
+        )
+
+    with gr.Tab("4. Evaluar Política"):
+        gr.Markdown("## Evaluar una Política Entrenada")
+        gr.Markdown(
+            "Usa esta sección para probar tu política entrenada con el robot real. "
+            "La teleoperación es opcional durante la evaluación."
+        )
+        with gr.Row():
+            robot_type_eval_input = gr.Textbox(label="Tipo de Robot (e.g., so100_follower)", value="so100_follower")
+            robot_port_eval_input = gr.Textbox(label="Puerto del Robot (e.g., /dev/ttyACM1)", value="/dev/ttyACM1")
+        
+        robot_cameras_eval_input = gr.Textbox(
+            label="Configuración de Cámaras (JSON string)",
+            value='{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}',
+            info="Define tus cámaras como un string JSON. Asegúrate de escapar las comillas internas si es necesario."
+        )
+        robot_id_eval_input = gr.Textbox(label="ID del Robot", value="my_awesome_follower_arm")
+        display_data_eval_input = gr.Checkbox(label="Mostrar Datos (Display Data)", value=False)
+        dataset_repo_id_eval_input = gr.Textbox(
+            label="ID del Repositorio del Dataset de Evaluación (ej. YOUR_USER/eval_so100)",
+            value="YOUR_USER/eval_so100",
+            info="El nombre del dataset para guardar los resultados de la evaluación (suele empezar con 'eval_')."
+        )
+        single_task_eval_input = gr.Textbox(
+            label="Descripción de la Tarea (Single Task)",
+            value="Put lego brick into the transparent box"
+        )
+        policy_path_input = gr.Textbox(
+            label="Ruta de la Política a Evaluar (local o Hugging Face Hub ID)",
+            placeholder="ej. outputs/train/eval_act_so101_test/checkpoints/last/pretrained_model O YOUR_USER/my_policy",
+            info="Puede ser una ruta local al checkpoint o el ID de un repositorio de modelo en Hugging Face Hub."
+        )
+
+        gr.Markdown("### Teleoperación (Opcional durante la Evaluación)")
+        teleop_enable_eval_input = gr.Checkbox(label="Habilitar Teleoperación Durante Evaluación", value=False)
+        with gr.Row(visible=False) as teleop_options_row: # Hidden by default
+            teleop_type_eval_input = gr.Textbox(label="Tipo de Teleop (e.g., so100_leader)", value="so100_leader")
+            teleop_port_eval_input = gr.Textbox(label="Puerto de Teleop (e.g., /dev/ttyACM0)", value="/dev/ttyACM0")
+            teleop_id_eval_input = gr.Textbox(label="ID de Teleop", value="my_awesome_leader_arm")
+        
+        teleop_enable_eval_input.change(
+            lambda x: gr.update(visible=x),
+            inputs=teleop_enable_eval_input,
+            outputs=teleop_options_row
+        )
+
+        evaluate_btn = gr.Button("📊 Iniciar Evaluación 📊", variant="primary")
+        evaluate_status_output = gr.Textbox(
+            label="Log de Evaluación",
+            interactive=False,
+            visible=False,
+            lines=15,
+            autoscroll=True
+        )
+
+        evaluate_btn.click(
+            fn=gradio_evaluate,
+            inputs=[
+                robot_type_eval_input,
+                robot_port_eval_input,
+                robot_cameras_eval_input,
+                robot_id_eval_input,
+                display_data_eval_input,
+                dataset_repo_id_eval_input,
+                single_task_eval_input,
+                policy_path_input,
+                teleop_enable_eval_input,
+                teleop_type_eval_input,
+                teleop_port_eval_input,
+                teleop_id_eval_input
+            ],
+            outputs=evaluate_status_output
+        )
+
+    gr.Markdown("---")
+    gr.Markdown("Hecho con ❤️ para RobotCleanPupusas503")
+
+# Auto-detect CUDA/MPS availability for default device selection (requires torch)
+try:
+    import torch
+except ImportError:
+    print("Advertencia: PyTorch no está instalado. No se podrá auto-detectar 'cuda' o 'mps'.")
+    torch = None
+
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt → requeriments.txt

@@ -1,50 +1,114 @@
+absl-py==2.3.0
 aiofiles==24.1.0
 annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
 anyio==4.9.0
-audioop-lts==0.2.1
+appdirs==1.4.4
+asciitree==0.3.3
+attrs==25.3.0
+av==14.4.0
+beautifulsoup4==4.13.4
 certifi==2025.6.15
+cffi==1.17.1
 charset-normalizer==3.4.2
 click==8.2.1
+cloudpickle==3.1.1
+Cython==3.1.2
+decorator==4.4.2
+diffusers==0.26.3
+dm-env==1.6
+dm-tree==0.1.9
+docker-pycreds==0.4.0
+einops==0.7.0
+etils==1.12.2
+exceptiongroup==1.3.0
 fastapi==0.115.12
+fasteners==0.19
 ffmpy==0.6.0
 filelock==3.18.0
 fsspec==2025.5.1
+gdown==5.2.0
+gitdb==4.0.12
+GitPython==3.1.44
+glfw==2.9.0
 gradio==5.34.0
 gradio_client==1.10.3
 groovy==0.1.2
+gym==0.26.2
+gym-notices==0.0.8
 h11==0.16.0
+h5py==3.14.0
 hf-xet==1.1.3
 httpcore==1.0.9
 httpx==0.28.1
 huggingface-hub==0.33.0
+hydra-core==1.3.2
 idna==3.10
+imageio==2.37.0
+imageio-ffmpeg==0.6.0
+importlib_metadata==8.7.0
+importlib_resources==6.5.2
 Jinja2==3.1.6
+lazy_loader==0.4
+lerobot==0.1.0
+llvmlite==0.42.0
 markdown-it-py==3.0.0
 MarkupSafe==3.0.2
 mdurl==0.1.2
-numpy==2.3.0
+moviepy==1.0.3
+mpmath==1.3.0
+mujoco==3.3.3
+mujoco-py==2.1.2.14
+networkx==3.4.2
+numba==0.59.1
+numcodecs==0.13.1
+numpy==1.26.4
+omegaconf==2.3.0
+opencv-python==4.11.0.86
 orjson==3.10.18
 packaging==25.0
 pandas==2.3.0
 pillow==11.2.1
+proglog==0.1.12
+protobuf==4.25.8
+psutil==7.0.0
+pycparser==2.22
 pydantic==2.11.7
 pydantic_core==2.33.2
 pydub==0.25.1
+pygame==2.6.1
 Pygments==2.19.1
+pymunk==6.11.1
+PyOpenGL==3.1.9
+PySocks==1.7.1
 python-dateutil==2.9.0.post0
 python-multipart==0.0.20
 pytz==2025.2
 PyYAML==6.0.2
+regex==2024.11.6
 requests==2.32.4
 rich==14.0.0
 ruff==0.11.13
 safehttpx==0.1.6
+safetensors==0.5.3
+scikit-image==0.22.0
+scipy==1.15.3
 semantic-version==2.10.0
+sentry-sdk==2.30.0
+setproctitle==1.3.6
+shapely==2.1.1
 shellingham==1.5.4
 six==1.17.0
+smmap==5.0.2
 sniffio==1.3.1
+soupsieve==2.7
 starlette==0.46.2
+sympy==1.14.0
+termcolor==2.5.0
+tifffile==2025.5.10
 tomlkit==0.13.3
+torch==2.2.2
+torchvision==0.17.2
 tqdm==4.67.1
 typer==0.16.0
 typing-inspection==0.4.1
@@ -52,4 +116,8 @@ typing_extensions==4.14.0
 tzdata==2025.2
 urllib3==2.4.0
 uvicorn==0.34.3
+wandb==0.16.6
 websockets==15.0.1
+wrapt==1.17.2
+zarr==2.18.3
+zipp==3.23.0

robot_detector.py

@@ -0,0 +1,183 @@
+# backend/robot_detector.py
+import serial.tools.list_ports
+import gradio as gr
+import json
+import os
+
+# Define the path to save/load configurations
+CONFIG_FILE = "config/default_config.json"
+
+def list_serial_ports():
+    """
+    Lista todos los puertos seriales disponibles en el sistema.
+    """
+    ports = serial.tools.list_ports.comports()
+    port_list = []
+    if not ports:
+        return ["No se encontraron puertos seriales disponibles."]
+    
+    for port in ports:
+        port_info = f"{port.device} - {port.description}"
+        if port.hwid and "VID:PID" in port.hwid:
+            port_info += f" ({port.hwid})"
+        port_list.append(port_info)
+    
+    return port_list
+
+def save_config(follower_port: str, follower_id: str, leader_port: str, leader_id: str):
+    """
+    Guarda la configuración del robot y teleoperador en un archivo JSON.
+    """
+    config = {
+        "robot_follower": {
+            "port": follower_port.split(' ')[0] if follower_port else "", # Extract only device path
+            "id": follower_id
+        },
+        "teleop_leader": {
+            "port": leader_port.split(' ')[0] if leader_port else "", # Extract only device path
+            "id": leader_id
+        }
+    }
+    try:
+        with open(CONFIG_FILE, 'w') as f:
+            json.dump(config, f, indent=4)
+        return f"Configuración guardada en {CONFIG_FILE} correctamente."
+    except Exception as e:
+        return f"Error al guardar la configuración: {e}"
+
+def load_config():
+    """
+    Carga la configuración del robot y teleoperador desde un archivo JSON.
+    """
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, 'r') as f:
+                config = json.load(f)
+            return (
+                config.get("robot_follower", {}).get("port", ""),
+                config.get("robot_follower", {}).get("id", ""),
+                config.get("teleop_leader", {}).get("port", ""),
+                config.get("teleop_leader", {}).get("id", "")
+            )
+        except Exception as e:
+            gr.Warning(f"Error al cargar la configuración existente: {e}. Se usarán valores por defecto.")
+            return "", "", "", ""
+    return "", "", "", ""
+
+# --- Gradio Interface ---
+
+# Load initial config values for Gradio components
+initial_follower_port, initial_follower_id, initial_leader_port, initial_leader_id = load_config()
+
+with gr.Blocks(title="Detector y Configuración de Robots LeRobot") as demo:
+    gr.Markdown("# <center>Detector y Configuración de Robots LeRobot</center>")
+    gr.Markdown(
+        "Esta herramienta te ayuda a identificar los puertos seriales de tus robots "
+        "SO101 (follower y leader) y asignarles un ID consistente."
+    )
+
+    with gr.Tab("1. Detectar Puertos Seriales"):
+        gr.Markdown("## Puertos Seriales Detectados")
+        gr.Markdown(
+            "Conecta tus robots SO101 (follower y leader) a tu computadora y haz clic en 'Refrescar Puertos'. "
+            "Observa la lista y compara con los nombres de tus dispositivos si es posible para identificarlos."
+        )
+        refresh_btn = gr.Button("🔄 Refrescar Puertos")
+        port_list_output = gr.Textbox(
+            label="Puertos Seriales Disponibles",
+            interactive=False,
+            lines=10,
+            value="\n".join(list_serial_ports()), # Initial list on startup
+            show_copy_button=True
+        )
+        refresh_btn.click(
+            fn=lambda: "\n".join(list_serial_ports()),
+            inputs=None,
+            outputs=port_list_output
+        )
+
+    with gr.Tab("2. Asignar Puertos e IDs"):
+        gr.Markdown("## Asignación de Robots y Teleoperadores")
+        gr.Markdown(
+            "Selecciona el puerto correcto para cada dispositivo y asigna un ID único. "
+            "**¡Es crucial usar el mismo ID en todos los scripts (grabación, entrenamiento, evaluación)!**"
+        )
+        gr.Markdown("### Robot Follower (Brazo del Robot SO101)")
+        follower_port_dropdown = gr.Dropdown(
+            label="Puerto Serial del Robot Follower",
+            choices=[], # Will be populated dynamically
+            value=initial_follower_port,
+            info="Selecciona el puerto donde está conectado el brazo del robot (SO101)."
+        )
+        follower_id_input = gr.Textbox(
+            label="ID del Robot Follower",
+            value=initial_follower_id if initial_follower_id else "my_robot_follower_arm",
+            placeholder="ej. my_robot_follower_arm",
+            info="Un identificador único para este robot. Usado para archivos de calibración."
+        )
+
+        gr.Markdown("### Teleoperador Leader (Brazo de Control SO101)")
+        leader_port_dropdown = gr.Dropdown(
+            label="Puerto Serial del Teleoperador Leader",
+            choices=[], # Will be populated dynamically
+            value=initial_leader_port,
+            info="Selecciona el puerto donde está conectado el dispositivo de control (SO101)."
+        )
+        leader_id_input = gr.Textbox(
+            label="ID del Teleoperador Leader",
+            value=initial_leader_id if initial_leader_id else "my_teleop_leader_arm",
+            placeholder="ej. my_teleop_leader_arm",
+            info="Un identificador único para el dispositivo de teleoperación."
+        )
+
+        save_btn = gr.Button("💾 Guardar Configuración", variant="primary")
+        save_status_output = gr.Textbox(
+            label="Estado de Guardado",
+            interactive=False,
+            visible=False
+        )
+
+        save_btn.click(
+            fn=save_config,
+            inputs=[follower_port_dropdown, follower_id_input, leader_port_dropdown, leader_id_input],
+            outputs=save_status_output
+        )
+
+        # Function to update dropdown choices based on current ports
+        def update_port_choices():
+            ports = list_serial_ports()
+            # Extract just the device path for dropdown value (e.g., /dev/tty.usbmodemXXX)
+            device_paths = [p.split(' ')[0] for p in ports if "No se encontraron" not in p]
+            return gr.update(choices=device_paths), gr.update(choices=device_paths)
+
+        # Update dropdowns on initial load and when refresh button is clicked
+        demo.load(
+            fn=update_port_choices,
+            inputs=None,
+            outputs=[follower_port_dropdown, leader_port_dropdown]
+        )
+        refresh_btn.click( # Re-bind refresh button to update dropdowns too
+            fn=update_port_choices,
+            inputs=None,
+            outputs=[follower_port_dropdown, leader_port_dropdown]
+        )
+
+
+    gr.Markdown("---")
+    gr.Markdown(f"**La configuración guardada se almacenará en:** `{os.path.abspath(CONFIG_FILE)}`")
+    gr.Markdown(
+        "**Instrucciones para otros scripts:**\n"
+        "1. Abre `robot_config.json`.\n"
+        "2. Copia los valores de `port` y `id` a tus scripts de `record_controller.py` y `train_robot.py` (para evaluación)."
+    )
+    gr.Markdown("Hecho con ❤️ para RobotCleanPupusas503")
+
+if __name__ == "__main__":
+    try:
+        import serial # Test if pyserial is installed
+    except ImportError:
+        print("Error: La librería 'pyserial' no está instalada.")
+        print("Por favor, instala 'pyserial' ejecutando: pip install pyserial")
+        exit(1)
+        
+    demo.launch(share=False)