lerobotberto 0.1.0__py3-none-any.whl

lerobotberto/__main__.py

@@ -0,0 +1,7 @@
+def main():
+    from lerobotberto.gui import App
+    App().mainloop()
+
+
+if __name__ == "__main__":
+    main()

lerobotberto/gui.py

@@ -0,0 +1,1167 @@
+#!/usr/bin/env python3
+"""
+Interfaz gráfica para lanzar dos políticas entrenadas con LeRobot
+(mediante `lerobot-rollout`):
+  1) Insertar cable rojo en el portafusibles
+  2) Extraer fusible del portafusibles
+
+Incluye una vista con la imagen de TU portafusibles (ruta configurable) y una
+animación superpuesta del cable y del fusible mientras se ejecuta cada tarea.
+
+Dependencias: solo tkinter. Para JPG y para escalar bien la imagen se
+recomienda Pillow:  pip install pillow   (sin Pillow solo se admite PNG/GIF).
+
+Control por voz (opcional):
+    pip install SpeechRecognition pyaudio
+    sudo apt install portaudio19-dev flac espeak-ng     (Ubuntu/Debian)
+  El reconocimiento usa el servicio de Google, por lo que necesita internet.
+
+Uso:  python lerobot_gui.py
+"""
+import json
+import math
+import os
+import re
+import shlex
+import shutil
+import signal
+import subprocess
+import threading
+import time
+import unicodedata
+import tkinter as tk
+from tkinter import ttk, scrolledtext, messagebox, filedialog
+
+try:
+    from PIL import Image, ImageTk
+    HAS_PIL = True
+    RESAMPLE = getattr(Image, "Resampling", Image).LANCZOS
+except ImportError:
+    HAS_PIL = False
+
+try:
+    import speech_recognition as sr
+    HAS_SR = True
+except ImportError:
+    HAS_SR = False
+
+CONFIG_PATH = os.path.expanduser("~/.lerobot_gui.json")
+LOG_PATH = os.path.expanduser("~/lerobot_gui.log")
+PERIOD = 4.0          # segundos que dura un ciclo de animación
+FRAME_MS = 33         # ~30 fps
+
+DEFAULT_CONFIG = {
+    "cfg_version": 4,
+    "robot_args": (
+        '--robot.type=so101_follower '
+        '--robot.port=/dev/ttyACM1 '
+        '--robot.id=follower_arm '
+        '--robot.cameras="{ robot: {type: opencv, index_or_path: /dev/video4, '
+        'width: 320, height: 240, fps: 30}, top: {type: opencv, '
+        'index_or_path: /dev/video0, width: 320, height: 240, fps: 30}}"'
+    ),
+    "episode_time_s": 120,        # --duration
+    "device": "cpu",              # --device
+    "conda_env": "lerobot",       # solo se usa si lerobot-rollout no está en el PATH
+    # --- Vista del portafusibles
+    "image_path": "",
+    # Puntos en coordenadas relativas a la imagen (0..1). Se calibran con clic.
+    "points": {
+        "hole": [0.50, 0.32],          # agujero de conexión (arriba)
+        "fuse": [0.50, 0.62],          # fusible (abajo)
+        "cable_start": [0.14, 0.12],   # de dónde sale el cable
+    },
+    "voice": {"lang": "es-ES", "mic": "", "confirm": True, "speak": True},
+    "anim_scale": 1.0,
+    "show_points": True,
+    "overlay_idle": True,
+    "tasks": {
+        "insertar": {
+            "label": "Insertar cable rojo",
+            "policy_path": "BertoTrujillo/act_superinscabmerged",
+            "task_text": "Insert the cable into its connector.",
+        },
+        "extraer": {
+            "label": "Extraer fusible",
+            "policy_path": "$HOME/lerobot_models/act_superextractfuse",
+            "task_text": "Extract the fuse from its holder.",
+        },
+    },
+}
+
+
+def load_config():
+    cfg = json.loads(json.dumps(DEFAULT_CONFIG))
+    if os.path.exists(CONFIG_PATH):
+        try:
+            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if data.get("cfg_version") != DEFAULT_CONFIG["cfg_version"]:
+                # Config de una versión anterior: se conservan solo imagen y opciones
+                for k in ("robot_args", "episode_time_s", "tasks", "points"):
+                    data.pop(k, None)
+            for k, v in data.items():
+                if k == "tasks":
+                    for key, val in v.items():
+                        cfg["tasks"].setdefault(key, {}).update(val)
+                elif k == "points":
+                    cfg["points"].update(v)
+                else:
+                    cfg[k] = v
+        except Exception:
+            pass
+    return cfg
+
+
+def save_config(cfg):
+    with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(cfg, f, indent=2, ensure_ascii=False)
+
+
+# ------------------------------------------------------- comandos de voz
+STOP_STRONG = {"detente", "detener", "alto", "basta", "emergencia", "stop", "halt",
+               "pare", "paro"}
+STOP_SHORT = {"para", "parar"}            # solo si es una frase muy corta
+YES_WORDS = {"si", "confirmo", "confirmado", "vale", "adelante", "ok", "okay", "dale",
+             "afirmativo", "yes", "confirm", "go"}
+NO_WORDS = {"no", "cancela", "cancelar", "cancelado", "negativo", "nada", "cancel"}
+INS_VERBS = {"inserta", "insertar", "inserte", "insertas", "mete", "meter", "conecta",
+             "conectar", "enchufa", "enchufar", "insert", "plug", "connect"}
+EXT_VERBS = {"extrae", "extraer", "extraiga", "saca", "sacar", "quita", "quitar",
+             "retira", "retirar", "extract", "remove", "pull"}
+RESET_VERBS = {"reinicia", "reiniciar", "reset", "resetea", "restablece"}
+
+
+def _audio_level(audio):
+    """Nivel RMS (16 bits) de un AudioData; comparable con r.energy_threshold."""
+    try:
+        import array
+        raw = audio.get_raw_data(convert_rate=16000, convert_width=2)
+        a = array.array("h", raw)
+        if not a:
+            return 0
+        return int((sum(x * x for x in a) / len(a)) ** 0.5)
+    except Exception:
+        return -1
+
+
+def _words(text):
+    t = unicodedata.normalize("NFD", text.lower())
+    t = "".join(ch for ch in t if unicodedata.category(ch) != "Mn")
+    return re.findall(r"[a-z0-9]+", t)
+
+
+def parse_voice(text):
+    """Devuelve: 'stop', 'yes', 'no', 'insertar', 'extraer', 'reset' o None."""
+    w = _words(text)
+    ws = set(w)
+    if not w:
+        return None
+    if ws & STOP_STRONG or (len(w) <= 2 and ws & STOP_SHORT):
+        return "stop"
+    if len(w) <= 3 and ws & NO_WORDS:
+        return "no"
+    if len(w) <= 3 and ws & YES_WORDS:
+        return "yes"
+    ins = bool(ws & INS_VERBS) and bool(ws & {"cable", "cables"})
+    ext = bool(ws & EXT_VERBS) and bool(ws & {"fusible", "fusibles", "fuse", "fuses"})
+    if ins and not ext:
+        return "insertar"
+    if ext and not ins:
+        return "extraer"
+    if ws & RESET_VERBS and ws & {"vista", "view"}:
+        return "reset"
+    return None
+
+
+# ------------------------------------------------------------- utilidades
+def ease(t):
+    t = max(0.0, min(1.0, t))
+    return t * t * (3 - 2 * t)
+
+
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+
+def lerp_pt(p, q, t):
+    return (lerp(p[0], q[0], t), lerp(p[1], q[1], t))
+
+
+def window(t, a, b):
+    """0 antes de a, 1 después de b, suave entre medias."""
+    if t <= a:
+        return 0.0
+    if t >= b:
+        return 1.0
+    return ease((t - a) / (b - a))
+
+
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("LeRobot · Panel de control portafusibles")
+        self.geometry("1260x880")
+        self.minsize(1000, 720)
+
+        self.cfg = load_config()
+        self.proc = None
+        self.current_task = None
+        self.t_start = 0.0
+        self.t_anim0 = 0.0
+        self.task_vars = {}
+
+        # Estado visual de la escena
+        self.cable_in = False
+        self.fuse_out = False
+        self.calib_mode = None
+        self.raw = None
+        self.photo = None
+        self.img_rect = None
+        self._resize_job = None
+
+        # Estado del control por voz
+        self.voice_on = False
+        self.pending = None            # (tarea, caducidad) a la espera de «sí»
+        self.speaking = False
+        self.last_speech_end = 0.0
+        self._speak_n = 0
+        self._speak_lock = threading.Lock()
+        self._voice_lang = "es-ES"
+        self._voice_mic_name = ""
+
+        self._build_style()
+        self._build_ui()
+        self.load_image()
+        self._tick()
+        self._anim_loop()
+        self.protocol("WM_DELETE_WINDOW", self.on_close)
+
+    # ------------------------------------------------------------------ UI
+    def _build_style(self):
+        style = ttk.Style(self)
+        try:
+            style.theme_use("clam")
+        except tk.TclError:
+            pass
+        style.configure("Big.TButton", font=("Helvetica", 14, "bold"), padding=14)
+        style.configure("Stop.TButton", font=("Helvetica", 14, "bold"), padding=14,
+                        foreground="#b00020")
+        style.configure("Status.TLabel", font=("Helvetica", 13, "bold"))
+
+    def _build_ui(self):
+        root = ttk.Frame(self, padding=10)
+        root.pack(fill="both", expand=True)
+
+        # --- Estado (arriba)
+        top = ttk.Frame(root)
+        top.pack(fill="x", side="top")
+        self.status_dot = tk.Canvas(top, width=22, height=22, highlightthickness=0)
+        self.status_dot.pack(side="left")
+        self.dot = self.status_dot.create_oval(3, 3, 19, 19, fill="#9e9e9e", outline="")
+        self.status_lbl = ttk.Label(top, text="Parado", style="Status.TLabel")
+        self.status_lbl.pack(side="left", padx=8)
+        self.timer_lbl = ttk.Label(top, text="00:00", font=("Helvetica", 13))
+        self.timer_lbl.pack(side="right")
+
+        # --- Log (abajo)
+        log_frame = ttk.LabelFrame(root, text="Salida de LeRobot", padding=6)
+        log_frame.pack(fill="x", side="bottom", pady=(8, 0))
+        bar = ttk.Frame(log_frame)
+        bar.pack(fill="x", pady=(0, 4))
+        ttk.Button(bar, text="Copiar todo el log", command=self.copy_log).pack(side="left")
+        ttk.Button(bar, text="Limpiar", command=self.clear_log).pack(side="left", padx=6)
+        ttk.Label(bar, text=f"(también se guarda en {LOG_PATH})").pack(side="left", padx=6)
+        self.log = scrolledtext.ScrolledText(log_frame, height=9,
+                                             font=("Courier", 10),
+                                             bg="#111", fg="#d6d6d6",
+                                             insertbackground="#d6d6d6")
+        self.log.pack(fill="both", expand=True)
+        # Solo lectura, pero se puede seleccionar y copiar (Ctrl+C / Ctrl+A / clic derecho)
+        self.log.bind("<Key>", self._log_key)
+        for ev in ("<<Paste>>", "<<Cut>>"):
+            self.log.bind(ev, lambda e: "break")
+        self.log.bind("<Button-1>", lambda e: self.log.focus_set())
+        self.log_menu = tk.Menu(self, tearoff=0)
+        self.log_menu.add_command(label="Copiar selección", command=lambda: self.copy_log(False))
+        self.log_menu.add_command(label="Copiar todo", command=self.copy_log)
+        self.log.bind("<Button-3>", lambda e: self.log_menu.tk_popup(e.x_root, e.y_root))
+
+        # --- Zona central: vista + controles
+        mid = ttk.Frame(root)
+        mid.pack(fill="both", expand=True, pady=(8, 0))
+        mid.columnconfigure(0, weight=3)
+        mid.columnconfigure(1, weight=2)
+        mid.rowconfigure(0, weight=1)
+
+        self._build_visual(mid)
+        self._build_controls(mid)
+
+    def _build_visual(self, parent):
+        vis = ttk.LabelFrame(parent, text="Vista del portafusibles", padding=6)
+        vis.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
+
+        self.canvas = tk.Canvas(vis, width=640, height=440, bg="#1e1e1e",
+                                highlightthickness=0)
+        self.canvas.pack(fill="both", expand=True)
+        self.canvas.bind("<Configure>", self._on_canvas_resize)
+        self.canvas.bind("<Button-1>", self._on_canvas_click)
+
+        # Ruta de imagen
+        row = ttk.Frame(vis)
+        row.pack(fill="x", pady=(6, 0))
+        ttk.Label(row, text="Imagen:").pack(side="left")
+        self.img_path_var = tk.StringVar(value=self.cfg.get("image_path", ""))
+        ent = ttk.Entry(row, textvariable=self.img_path_var)
+        ent.pack(side="left", fill="x", expand=True, padx=6)
+        ent.bind("<Return>", lambda e: self.load_image())
+        ttk.Button(row, text="Examinar…", command=self.browse_image).pack(side="left")
+        ttk.Button(row, text="Cargar", command=self.load_image).pack(side="left", padx=(4, 0))
+
+        # Calibración
+        cal = ttk.Frame(vis)
+        cal.pack(fill="x", pady=(6, 0))
+        ttk.Label(cal, text="Calibrar (clic en la imagen):").pack(side="left")
+        for mode, txt in (("hole", "Agujero"), ("fuse", "Fusible"),
+                          ("cable_start", "Origen cable")):
+            ttk.Button(cal, text=txt, command=lambda m=mode: self.start_calib(m))\
+                .pack(side="left", padx=3)
+
+        opts = ttk.Frame(vis)
+        opts.pack(fill="x", pady=(6, 0))
+        self.show_points = tk.BooleanVar(value=bool(self.cfg.get("show_points", True)))
+        self.overlay_idle = tk.BooleanVar(value=bool(self.cfg.get("overlay_idle", True)))
+        ttk.Checkbutton(opts, text="Mostrar puntos", variable=self.show_points)\
+            .pack(side="left")
+        ttk.Checkbutton(opts, text="Dibujar cable/fusible en reposo",
+                        variable=self.overlay_idle).pack(side="left", padx=10)
+        ttk.Label(opts, text="Tamaño:").pack(side="left")
+        self.scale_var = tk.DoubleVar(value=float(self.cfg.get("anim_scale", 1.0)))
+        ttk.Spinbox(opts, from_=0.3, to=4.0, increment=0.1, width=5,
+                    textvariable=self.scale_var,
+                    command=self._render_static).pack(side="left", padx=4)
+        ttk.Button(opts, text="Reiniciar vista", command=self.reset_view)\
+            .pack(side="right")
+
+    def _build_controls(self, parent):
+        ctrl = ttk.Frame(parent)
+        ctrl.grid(row=0, column=1, sticky="nsew")
+
+        actions = ttk.LabelFrame(ctrl, text="Acciones", padding=8)
+        actions.pack(fill="x")
+        actions.columnconfigure(0, weight=1)
+        self.buttons = {}
+        for r, (key, t) in enumerate(self.cfg["tasks"].items()):
+            b = ttk.Button(actions, text=f"▶  {t['label']}", style="Big.TButton",
+                           command=lambda k=key: self.start_task(k))
+            b.grid(row=r, column=0, sticky="ew", pady=4)
+            self.buttons[key] = b
+        self.stop_btn = ttk.Button(actions, text="■  PARAR", style="Stop.TButton",
+                                   command=self.stop_task, state="disabled")
+        self.stop_btn.grid(row=len(self.buttons), column=0, sticky="ew", pady=4)
+
+        self._build_voice(ctrl)
+
+        nb = ttk.Notebook(ctrl)
+        nb.pack(fill="x", pady=8)
+
+        tab_general = ttk.Frame(nb, padding=8)
+        nb.add(tab_general, text="Robot")
+        ttk.Label(tab_general, text="Argumentos del robot (cámaras, puerto, id…):")\
+            .pack(anchor="w")
+        self.robot_txt = tk.Text(tab_general, height=6, wrap="word")
+        self.robot_txt.pack(fill="x", pady=4)
+        self.robot_txt.insert("1.0", self.cfg["robot_args"])
+        row = ttk.Frame(tab_general)
+        row.pack(fill="x")
+        ttk.Label(row, text="Duración (s):").pack(side="left")
+        self.ep_time = tk.IntVar(value=self.cfg["episode_time_s"])
+        ttk.Spinbox(row, from_=5, to=600, textvariable=self.ep_time, width=6)\
+            .pack(side="left", padx=6)
+        ttk.Label(row, text="Dispositivo:").pack(side="left", padx=(8, 0))
+        self.device_var = tk.StringVar(value=self.cfg.get("device", "cpu"))
+        ttk.Combobox(row, textvariable=self.device_var, width=7,
+                     values=("cpu", "cuda", "mps")).pack(side="left", padx=6)
+        row2 = ttk.Frame(tab_general)
+        row2.pack(fill="x", pady=(6, 0))
+        ttk.Label(row2, text="Entorno conda (si no está activado):").pack(side="left")
+        self.conda_var = tk.StringVar(value=self.cfg.get("conda_env", "lerobot"))
+        ttk.Entry(row2, textvariable=self.conda_var, width=14).pack(side="left", padx=6)
+
+        for key, t in self.cfg["tasks"].items():
+            tab = ttk.Frame(nb, padding=8)
+            nb.add(tab, text=t["label"])
+            tab.columnconfigure(0, weight=1)
+            vars_ = {}
+            for r, (field, lbl) in enumerate([
+                ("policy_path", "Carpeta de la política (--policy.path):"),
+                ("task_text", "Descripción de la tarea (--task):"),
+            ]):
+                ttk.Label(tab, text=lbl).grid(row=2 * r, column=0, sticky="w", pady=(4, 0))
+                v = tk.StringVar(value=t[field])
+                ttk.Entry(tab, textvariable=v).grid(row=2 * r + 1, column=0, sticky="ew")
+                vars_[field] = v
+            self.task_vars[key] = vars_
+
+        save_row = ttk.Frame(ctrl)
+        save_row.pack(fill="x")
+        ttk.Button(save_row, text="Guardar ajustes", command=self.save_settings)\
+            .pack(side="left")
+        ttk.Button(save_row, text="Limpiar log", command=self.clear_log)\
+            .pack(side="left", padx=6)
+
+    # ------------------------------------------------------------- helpers
+    def write_log(self, text):
+        self.log.insert("end", text)
+        self.log.see("end")
+        try:
+            with open(LOG_PATH, "a", encoding="utf-8") as f:
+                f.write(text)
+        except OSError:
+            pass
+
+    def clear_log(self):
+        self.log.delete("1.0", "end")
+
+    def _log_key(self, event):
+        # Permite Ctrl+C, Ctrl+A y desplazamiento; bloquea cualquier edición
+        if event.state & 0x4 and event.keysym.lower() in ("c", "a", "insert"):
+            if event.keysym.lower() == "a":
+                self.log.tag_add("sel", "1.0", "end-1c")
+                return "break"
+            return None
+        if event.keysym in ("Up", "Down", "Left", "Right", "Prior", "Next",
+                            "Home", "End"):
+            return None
+        return "break"
+
+    def copy_log(self, everything=True):
+        try:
+            text = self.log.get("sel.first", "sel.last") if not everything \
+                else self.log.get("1.0", "end-1c")
+        except tk.TclError:
+            text = self.log.get("1.0", "end-1c")
+        self.clipboard_clear()
+        self.clipboard_append(text)
+        self.update()
+
+    def set_status(self, text, color):
+        self.status_lbl.config(text=text)
+        self.status_dot.itemconfig(self.dot, fill=color)
+
+    def save_settings(self, quiet=False):
+        self.cfg["robot_args"] = self.robot_txt.get("1.0", "end").strip()
+        self.cfg["episode_time_s"] = int(self.ep_time.get())
+        self.cfg["device"] = self.device_var.get().strip() or "cpu"
+        self.cfg["conda_env"] = self.conda_var.get().strip()
+        self.cfg["image_path"] = self.img_path_var.get().strip()
+        self.cfg["show_points"] = bool(self.show_points.get())
+        self.cfg["overlay_idle"] = bool(self.overlay_idle.get())
+        try:
+            self.cfg["anim_scale"] = float(self.scale_var.get())
+        except (tk.TclError, ValueError):
+            pass
+        for key, vars_ in self.task_vars.items():
+            for field, v in vars_.items():
+                self.cfg["tasks"][key][field] = v.get().strip()
+        mic = self.voice_mic.get().strip()
+        self.cfg["voice"] = {
+            "lang": self.voice_lang.get().strip() or "es-ES",
+            "mic": "" if mic in ("", "Predeterminado") else mic,
+            "confirm": bool(self.voice_confirm.get()),
+            "speak": bool(self.voice_speak.get()),
+        }
+        save_config(self.cfg)
+        if not quiet:
+            self.write_log(f"[GUI] Ajustes guardados en {CONFIG_PATH}\n")
+
+    def build_command(self, key):
+        t = self.task_vars[key]
+        policy = os.path.expandvars(os.path.expanduser(t["policy_path"].get().strip()))
+        cmd = ["lerobot-rollout"]
+        cmd += shlex.split(self.robot_txt.get("1.0", "end").strip())
+        cmd += [
+            f"--policy.path={policy}",
+            f"--task={t['task_text'].get().strip()}",
+            f"--duration={int(self.ep_time.get())}",
+            f"--device={self.device_var.get().strip() or 'cpu'}",
+        ]
+        # Si la GUI no se lanzó desde el entorno activado, usar conda run
+        env = self.conda_var.get().strip()
+        if shutil.which("lerobot-rollout") is None and env and shutil.which("conda"):
+            cmd = ["conda", "run", "--no-capture-output", "-n", env] + cmd
+        return cmd
+
+    # ------------------------------------------------------ imagen / vista
+    def browse_image(self):
+        types = [("Imágenes", "*.png *.gif *.jpg *.jpeg *.bmp *.webp"),
+                 ("Todos", "*.*")] if HAS_PIL else [("PNG / GIF", "*.png *.gif"),
+                                                    ("Todos", "*.*")]
+        p = filedialog.askopenfilename(title="Imagen del portafusibles", filetypes=types)
+        if p:
+            self.img_path_var.set(p)
+            self.load_image()
+
+    def load_image(self):
+        path = self.img_path_var.get().strip()
+        self.raw = None
+        self.photo = None
+        if path:
+            if not os.path.isfile(path):
+                self.write_log(f"[GUI] Imagen no encontrada: {path}\n")
+            else:
+                try:
+                    self.raw = Image.open(path).convert("RGB") if HAS_PIL \
+                        else tk.PhotoImage(file=path)
+                except Exception as e:
+                    self.raw = None
+                    hint = "" if HAS_PIL else \
+                        " (sin Pillow solo se admiten PNG/GIF: pip install pillow)"
+                    self.write_log(f"[GUI] No se pudo abrir la imagen: {e}{hint}\n")
+        self.cfg["image_path"] = path
+        self._render_static()
+
+    def _on_canvas_resize(self, _event):
+        if self._resize_job is not None:
+            self.after_cancel(self._resize_job)
+        self._resize_job = self.after(120, self._render_static)
+
+    def _render_static(self):
+        self._resize_job = None
+        c = self.canvas
+        c.delete("bg")
+        cw = max(100, c.winfo_width())
+        ch = max(100, c.winfo_height())
+
+        if self.raw is not None:
+            if HAS_PIL:
+                w, h = self.raw.size
+                k = min(cw / w, ch / h)
+                nw, nh = max(1, int(w * k)), max(1, int(h * k))
+                self.photo = ImageTk.PhotoImage(self.raw.resize((nw, nh), RESAMPLE))
+            else:
+                w, h = self.raw.width(), self.raw.height()
+                f = max(1, math.ceil(max(w / cw, h / ch)))
+                self.photo = self.raw.subsample(f)
+                nw, nh = self.photo.width(), self.photo.height()
+            x0, y0 = (cw - nw) // 2, (ch - nh) // 2
+            self.img_rect = (x0, y0, nw, nh)
+            c.create_image(x0, y0, image=self.photo, anchor="nw", tags="bg")
+        else:
+            # Esquema (sin imagen): base portafusibles cuadrada,
+            # agujero de conexión arriba y fusible abajo
+            w = min(cw, ch * 4 / 3)
+            h = w * 3 / 4
+            x0, y0 = (cw - w) / 2, (ch - h) / 2
+            self.img_rect = (x0, y0, w, h)
+            c.create_rectangle(x0, y0, x0 + w, y0 + h, fill="#eceff1", outline="",
+                               tags="bg")
+            s = self._units()
+            H, F = self._P("hole"), self._P("fuse")
+            cx, cy = (H[0] + F[0]) / 2, (H[1] + F[1]) / 2
+            half = 0.31 * h
+            # cuadrado = base portafusibles
+            c.create_rectangle(cx - half, cy - half, cx + half, cy + half,
+                               fill="#455a64", outline="#263238", width=4, tags="bg")
+            c.create_rectangle(cx - half + 10, cy - half + 10, cx + half - 10,
+                               cy + half - 10, fill="#37474f", outline="#546e7a",
+                               width=2, tags="bg")
+            c.create_text(cx, cy - half - 12, text="PORTAFUSIBLES", fill="#546e7a",
+                          font=("Helvetica", 10, "bold"), tags="bg")
+            # agujero de conexión (arriba)
+            r = 14 * s
+            c.create_oval(H[0] - r * 1.5, H[1] - r * 1.5, H[0] + r * 1.5, H[1] + r * 1.5,
+                          fill="#90a4ae", outline="#cfd8dc", width=2, tags="bg")
+            c.create_oval(H[0] - r, H[1] - r, H[0] + r, H[1] + r,
+                          fill="#050505", outline="", tags="bg")
+            # hueco donde va el fusible
+            c.create_rectangle(F[0] - 14 * s, F[1] - 19 * s, F[0] + 14 * s, F[1] + 19 * s,
+                               fill="#1b262c", outline="#78909c", width=2, tags="bg")
+            c.create_text(x0 + w / 2, y0 + h - 12, fill="#78909c", tags="bg",
+                          font=("Helvetica", 9),
+                          text="Sin imagen · indica una ruta abajo y pulsa Cargar")
+        c.tag_lower("bg")
+
+    # ---------------------------------------------------------- calibración
+    def start_calib(self, mode):
+        self.calib_mode = mode
+        self.canvas.config(cursor="crosshair")
+        self.show_points.set(True)
+
+    def _on_canvas_click(self, ev):
+        if not self.calib_mode or not self.img_rect:
+            return
+        x0, y0, w, h = self.img_rect
+        fx = min(1.0, max(0.0, (ev.x - x0) / w))
+        fy = min(1.0, max(0.0, (ev.y - y0) / h))
+        self.cfg["points"][self.calib_mode] = [round(fx, 4), round(fy, 4)]
+        names = {"hole": "agujero", "fuse": "fusible", "cable_start": "origen del cable"}
+        self.write_log(f"[GUI] Punto «{names[self.calib_mode]}» fijado en "
+                       f"({fx:.2f}, {fy:.2f})\n")
+        self.calib_mode = None
+        self.canvas.config(cursor="")
+        self.save_settings(quiet=True)
+        self._render_static()
+
+    def reset_view(self):
+        self.cable_in = False
+        self.fuse_out = False
+
+    # ---------------------------------------------------------- animación
+    def _units(self):
+        w = self.img_rect[2] if self.img_rect else 600
+        try:
+            k = float(self.scale_var.get())
+        except (tk.TclError, ValueError, AttributeError):
+            k = 1.0
+        base = (w / 600.0) * (1.7 if self.raw is None else 1.0)
+        return max(0.3, base * k)
+
+    def _P(self, key):
+        x0, y0, w, h = self.img_rect
+        px, py = self.cfg["points"][key]
+        return (x0 + px * w, y0 + py * h)
+
+    def _anim_loop(self):
+        try:
+            self._anim_frame()
+        finally:
+            self.after(FRAME_MS, self._anim_loop)
+
+    def _anim_frame(self):
+        c = self.canvas
+        c.delete("anim")
+        if self.img_rect is None:
+            return
+        s = self._units()
+        H = self._P("hole")
+        F = self._P("fuse")
+        S = self._P("cable_start")
+        run = self.current_task
+        t = ((time.time() - self.t_anim0) % PERIOD) / PERIOD if run else 0.0
+        has_img = self.raw is not None
+        draw_idle = self.overlay_idle.get()
+
+        D = 0.27 * self.img_rect[3]              # recorrido de extracción (hacia abajo)
+        hole_in = (H[0], H[1] + 3 * s)           # cable metido
+        cable_tip = hole_in if self.cable_in else S
+        fuse_dy = D if self.fuse_out else 0.0
+        gripper = None                           # (x, y, gap)
+        label = ""
+
+        if run == "insertar":
+            A = (H[0], H[1] - 60 * s)
+            gap_closed, gap_open = 5 * s, 13 * s
+            gap = gap_closed
+            gdy = 0.0
+            if t < 0.10:
+                cable_tip = S
+                label = "Agarrando el cable…"
+            elif t < 0.55:
+                u = ease((t - 0.10) / 0.45)
+                cable_tip = lerp_pt(S, A, u)
+                cable_tip = (cable_tip[0], cable_tip[1] - math.sin(math.pi * u) * 30 * s)
+                label = "Transportando el cable…"
+            elif t < 0.75:
+                cable_tip = lerp_pt(A, hole_in, ease((t - 0.55) / 0.20))
+                label = "Insertando en el agujero…"
+            elif t < 0.95:
+                cable_tip = hole_in
+                gap = lerp(gap_closed, gap_open, window(t, 0.75, 0.82))
+                gdy = -55 * s * window(t, 0.85, 0.95)
+                label = "Soltando el cable"
+            else:
+                cable_tip = lerp_pt(hole_in, S, ease((t - 0.95) / 0.05))
+                gap = gap_open
+                gdy = -55 * s
+            gripper = (cable_tip[0], cable_tip[1] - 18 * s + gdy, gap, False)
+
+        elif run == "extraer":
+            U = (F[0], F[1] + 140 * s)             # la pinza llega desde abajo
+            G0 = (F[0], F[1] + 14 * s)             # punto de agarre del fusible
+            gap_closed, gap_open = 23 * s, 34 * s
+            if t < 0.30:
+                g = lerp_pt(U, G0, ease(t / 0.30))
+                gap = gap_open
+                lift = 0.0
+                label = "Acercando la pinza al fusible…"
+            elif t < 0.40:
+                g = G0
+                gap = lerp(gap_open, gap_closed, window(t, 0.30, 0.40))
+                lift = 0.0
+                label = "Agarrando el fusible…"
+            elif t < 0.75:
+                lift = ease((t - 0.40) / 0.35)
+                g = (G0[0] + math.sin(lift * math.pi * 3) * 1.5 * s, G0[1] + D * lift)
+                gap = gap_closed
+                label = "Extrayendo el fusible…"
+            elif t < 0.88:
+                lift = 1.0
+                g = (G0[0], G0[1] + D)
+                gap = gap_closed
+                label = "Fusible quemado extraído"
+            else:
+                lift = 1.0 - ease((t - 0.88) / 0.12)
+                g = (G0[0], G0[1] + D * lift)
+                gap = gap_closed
+                label = "Fusible quemado extraído"
+            fuse_dy = D * lift
+            gripper = (g[0], g[1], gap, True)
+
+        # --- Marco del fusible (siempre visible)
+        self._draw_slot(c, F, s)
+
+        # --- Cable
+        show_cable = run == "insertar" or (draw_idle and (self.cable_in or not has_img)) \
+            or (run == "extraer" and self.cable_in) \
+            or (draw_idle and has_img)
+        if show_cable:
+            self._draw_cable(c, S, cable_tip, s)
+
+        # --- Fusible
+        moving = run == "extraer" or self.fuse_out
+        if moving or (draw_idle and not has_img):
+            self._draw_fuse(c, F[0], F[1] + fuse_dy, s)
+
+        # --- Pinza
+        if gripper:
+            self._draw_gripper(c, gripper[0], gripper[1], s, gripper[2], gripper[3])
+
+        # --- Texto de estado
+        if self.calib_mode:
+            names = {"hole": "agujero de conexión", "fuse": "fusible",
+                     "cable_start": "origen del cable"}
+            label = f"Haz clic en la imagen: {names[self.calib_mode]}"
+        elif not run:
+            if self.cable_in and self.fuse_out:
+                label = "Cable insertado · fusible extraído"
+            elif self.cable_in:
+                label = "Cable insertado"
+            elif self.fuse_out:
+                label = "Fusible quemado extraído"
+        if label:
+            x0, y0 = self.img_rect[0], self.img_rect[1]
+            c.create_rectangle(x0 + 8, y0 + 8, x0 + 12 + 8.2 * len(label), y0 + 32,
+                               fill="#000000", outline="", tags="anim")
+            c.create_text(x0 + 14, y0 + 20, text=label, anchor="w", fill="#ffffff",
+                          font=("Helvetica", 11, "bold"), tags="anim")
+
+        # --- Puntos de calibración
+        if self.show_points.get() or self.calib_mode:
+            for key, col, txt in (("hole", "#ff5252", "Agujero"),
+                                  ("fuse", "#ffd740", "Fusible"),
+                                  ("cable_start", "#ff8a80", "Origen cable")):
+                px, py = self._P(key)
+                c.create_oval(px - 5, py - 5, px + 5, py + 5, outline=col, width=2,
+                              tags="anim")
+                c.create_line(px - 10, py, px + 10, py, fill=col, tags="anim")
+                c.create_line(px, py - 10, px, py + 10, fill=col, tags="anim")
+                c.create_text(px + 10, py - 12, text=txt, fill=col, anchor="w",
+                              font=("Helvetica", 9, "bold"), tags="anim")
+
+    # ----- dibujo de elementos
+    def _draw_slot(self, c, F, s):
+        c.create_rectangle(F[0] - 12 * s, F[1] - 16 * s, F[0] + 12 * s, F[1] + 16 * s,
+                           outline="#fff59d", dash=(4, 3), width=2, tags="anim")
+
+    def _draw_cable(self, c, S, T, s):
+        mid = ((S[0] + T[0]) / 2, max(S[1], T[1]) + 30 * s)
+        pts = [S[0], S[1], mid[0], mid[1], T[0], T[1] - 12 * s]
+        c.create_line(*pts, smooth=True, width=9 * s, fill="#7f0000",
+                      capstyle="round", tags="anim")
+        c.create_line(*pts, smooth=True, width=6 * s, fill="#e53935",
+                      capstyle="round", tags="anim")
+        # terminal metálico
+        c.create_rectangle(T[0] - 4 * s, T[1] - 14 * s, T[0] + 4 * s, T[1],
+                           fill="#c98a4b", outline="#5d4037", tags="anim")
+
+    def _draw_fuse(self, c, cx, cy, s):
+        w, h = 11 * s, 15 * s
+        # patillas
+        for dx in (-5 * s, 5 * s):
+            c.create_rectangle(cx + dx - 2 * s, cy + h, cx + dx + 2 * s, cy + h + 8 * s,
+                               fill="#b0bec5", outline="#37474f", tags="anim")
+        # cuerpo
+        c.create_rectangle(cx - w, cy - h, cx + w, cy + h, fill="#fbc02d",
+                           outline="#6d4c00", width=2, tags="anim")
+        # ventana ennegrecida (fusible quemado)
+        c.create_rectangle(cx - 8 * s, cy - 12 * s, cx + 8 * s, cy + 5 * s,
+                           fill="#212121", outline="#8d6e00", tags="anim")
+        # rayo
+        bolt = [(1.5, -9), (-5, 0.5), (-1, 0.5), (-2.5, 8), (5, -2), (1, -2)]
+        k = 0.85 * s
+        pts = []
+        for bx, by in bolt:
+            pts += [cx + bx * k, cy - 3.5 * s + by * k]
+        c.create_polygon(*pts, fill="#ffeb3b", outline="#ff6f00", tags="anim")
+
+    def _draw_gripper(self, c, x, y, s, gap, flip=False):
+        """flip=False: muñeca arriba y mordazas hacia abajo; flip=True: al revés."""
+        k = -1 if flip else 1
+        jaw_w = 5 * s
+        # muñeca
+        c.create_rectangle(x - gap / 2 - jaw_w - 1 * s, y - k * 42 * s,
+                           x + gap / 2 + jaw_w + 1 * s, y - k * 24 * s,
+                           fill="#455a64", outline="#102027", tags="anim")
+        # mordazas
+        for sign in (-1, 1):
+            xi = x + sign * gap / 2
+            xo = x + sign * (gap / 2 + jaw_w)
+            c.create_rectangle(min(xi, xo), y - k * 26 * s, max(xi, xo), y + k * 6 * s,
+                               fill="#78909c", outline="#102027", tags="anim")
+
+    # ------------------------------------------------------------------ voz
+    VOICE_HELP = ("Di: «inserta el cable» · «extrae el fusible» · «para» · "
+                  "«reinicia la vista». Para confirmar: «sí» o «no».")
+
+    def _build_voice(self, parent):
+        vc = self.cfg.get("voice", {})
+        box = ttk.LabelFrame(parent, text="Control por voz", padding=8)
+        box.pack(fill="x", pady=(8, 0))
+
+        top = ttk.Frame(box)
+        top.pack(fill="x")
+        self.voice_btn = ttk.Button(top, text="🎤  Activar voz", command=self.toggle_voice)
+        self.voice_btn.pack(side="left")
+        self.voice_state = ttk.Label(top, text="Desactivada")
+        self.voice_state.pack(side="left", padx=10)
+
+        row = ttk.Frame(box)
+        row.pack(fill="x", pady=(6, 0))
+        ttk.Label(row, text="Idioma:").pack(side="left")
+        self.voice_lang = tk.StringVar(value=vc.get("lang", "es-ES"))
+        ttk.Combobox(row, textvariable=self.voice_lang, width=7,
+                     values=("es-ES", "es-MX", "en-US", "en-GB")).pack(side="left", padx=4)
+        ttk.Label(row, text="Micrófono:").pack(side="left", padx=(8, 0))
+        self.voice_mic = tk.StringVar(value=vc.get("mic") or "Predeterminado")
+        self.mic_combo = ttk.Combobox(row, textvariable=self.voice_mic, width=22,
+                                      values=("Predeterminado",),
+                                      postcommand=self._refresh_mics)
+        self.mic_combo.pack(side="left", padx=4, fill="x", expand=True)
+
+        opts = ttk.Frame(box)
+        opts.pack(fill="x", pady=(6, 0))
+        self.voice_confirm = tk.BooleanVar(value=bool(vc.get("confirm", True)))
+        self.voice_speak = tk.BooleanVar(value=bool(vc.get("speak", True)))
+        ttk.Checkbutton(opts, text="Pedir confirmación («sí»)",
+                        variable=self.voice_confirm).pack(side="left")
+        ttk.Checkbutton(opts, text="Respuesta hablada",
+                        variable=self.voice_speak).pack(side="left", padx=10)
+
+        self.voice_heard = ttk.Label(box, text="Oído: —", wraplength=420)
+        self.voice_heard.pack(fill="x", pady=(6, 0))
+        ttk.Label(box, text=self.VOICE_HELP, wraplength=420,
+                  foreground="#666666").pack(fill="x", pady=(2, 0))
+
+    def _refresh_mics(self):
+        if not HAS_SR:
+            return
+        try:
+            names = sr.Microphone.list_microphone_names()
+            self.mic_combo.configure(values=("Predeterminado", *names))
+        except Exception:
+            pass
+
+    def toggle_voice(self):
+        if self.voice_on:
+            self._voice_stop()
+        else:
+            self._voice_start()
+
+    def _voice_start(self):
+        if not HAS_SR:
+            messagebox.showerror(
+                "Falta SpeechRecognition",
+                "Para usar la voz instala, en el entorno donde ejecutas la GUI:\n\n"
+                "  pip install SpeechRecognition pyaudio\n\n"
+                "En Ubuntu puede hacer falta antes:\n"
+                "  sudo apt install portaudio19-dev flac espeak-ng")
+            return
+        self._voice_lang = self.voice_lang.get().strip() or "es-ES"
+        mic = self.voice_mic.get().strip()
+        self._voice_mic_name = "" if mic in ("", "Predeterminado") else mic
+        self.voice_on = True
+        self.voice_btn.config(text="🎤  Desactivar voz")
+        self.voice_state.config(text="Iniciando micrófono…")
+        self.save_settings(quiet=True)
+        threading.Thread(target=self._voice_worker, daemon=True).start()
+
+    def _voice_stop(self):
+        self.voice_on = False
+        self.pending = None
+        self.voice_btn.config(text="🎤  Activar voz")
+        self.voice_state.config(text="Desactivada")
+
+    def _voice_set_state(self, text):
+        if self.voice_on:
+            self.voice_state.config(text=text)
+
+    def _voice_failed(self, msg):
+        self.voice_on = False
+        self.pending = None
+        self.voice_btn.config(text="🎤  Activar voz")
+        self.voice_state.config(text="Error de micrófono")
+        self.write_log(f"[VOZ] No se pudo usar el micrófono: {msg}\n"
+                       "[VOZ] Comprueba que PyAudio está instalado y que el micrófono "
+                       "no está silenciado.\n")
+
+    def _voice_worker(self):
+        lang = self._voice_lang
+        mic_name = self._voice_mic_name
+        r = sr.Recognizer()
+        r.dynamic_energy_threshold = True
+        try:
+            idx = None
+            if mic_name:
+                names = sr.Microphone.list_microphone_names()
+                if mic_name in names:
+                    idx = names.index(mic_name)
+            with sr.Microphone(device_index=idx) as source:
+                r.adjust_for_ambient_noise(source, duration=1.0)
+                self.after(0, self._voice_set_state, "🎤 Escuchando…")
+                self.after(0, self.write_log,
+                           f"[VOZ] Micrófono listo ({mic_name or 'predeterminado'}), "
+                           f"umbral de ruido {r.energy_threshold:.0f}\n")
+                silent = 0
+                while self.voice_on:
+                    t0 = time.time()
+                    try:
+                        audio = r.listen(source, timeout=1, phrase_time_limit=6)
+                    except sr.WaitTimeoutError:
+                        silent += 1
+                        if silent >= 15:      # ~15 s sin detectar voz
+                            silent = 0
+                            self.after(0, self.write_log,
+                                       "[VOZ] No detecto voz: el nivel no supera el umbral "
+                                       f"({r.energy_threshold:.0f}). Habla más cerca, sube el "
+                                       "volumen de captura o prueba otro micrófono.\n")
+                        continue
+                    silent = 0
+                    # Descartar audio que coincide con la voz del propio programa
+                    if self.speaking or self.last_speech_end > t0:
+                        continue
+                    try:
+                        text = r.recognize_google(audio, language=lang)
+                    except sr.UnknownValueError:
+                        dur = len(audio.frame_data) / (audio.sample_rate * audio.sample_width)
+                        self.after(0, self.write_log,
+                                   f"[VOZ] Audio recibido pero no entendido "
+                                   f"({dur:.1f} s, nivel {_audio_level(audio)}, "
+                                   f"umbral {r.energy_threshold:.0f})\n")
+                        continue
+                    except sr.RequestError as e:
+                        self.after(0, self.write_log,
+                                   f"[VOZ] Error de reconocimiento (¿sin internet?): {e}\n")
+                        time.sleep(2)
+                        continue
+                    self.after(0, self._on_voice_text, text)
+        except Exception as e:  # micrófono no disponible, PyAudio ausente, etc.
+            self.after(0, self._voice_failed, str(e))
+
+    def _on_voice_text(self, text):
+        if not self.voice_on:
+            return
+        self.voice_heard.config(text=f"Oído: «{text}»")
+        cmd = parse_voice(text)
+        self.write_log(f"[VOZ] «{text}»" + (f" → {cmd}" if cmd else " (sin comando)") + "\n")
+        if cmd is None:
+            return
+
+        if cmd == "stop":
+            self.pending = None
+            if self.proc is not None:
+                self.stop_task()
+                self._say("Parando")
+            else:
+                self._say("No hay ninguna tarea en marcha")
+            return
+
+        if cmd in ("yes", "no"):
+            if not self.pending:
+                return
+            key, deadline = self.pending
+            self.pending = None
+            self._voice_set_state("🎤 Escuchando…")
+            if cmd == "yes" and time.time() <= deadline and self.proc is None:
+                self._say("De acuerdo")
+                self.start_task(key, confirmed=True)
+            else:
+                self._say("Cancelado")
+            return
+
+        if cmd == "reset":
+            self.reset_view()
+            self._say("Vista reiniciada")
+            return
+
+        if cmd in self.cfg["tasks"]:               # insertar / extraer
+            if self.proc is not None:
+                self._say("Ya hay una tarea en marcha")
+                return
+            label = self.cfg["tasks"][cmd]["label"]
+            if self.voice_confirm.get():
+                self.pending = (cmd, time.time() + 10)
+                self.voice_state.config(text=f"¿Confirmas «{label}»? Di sí o no")
+                self._say(f"¿Confirmas {label}? Di sí o no")
+            else:
+                self._say(label)
+                self.start_task(cmd, confirmed=True)
+
+    def _voice_tick(self):
+        if self.pending and time.time() > self.pending[1]:
+            self.pending = None
+            self.write_log("[VOZ] Confirmación caducada\n")
+            self._voice_set_state("🎤 Escuchando…")
+
+    def _say(self, text):
+        """Registra la respuesta y, si hay un sintetizador instalado, la dice en voz alta."""
+        self.write_log(f"[VOZ] ← {text}\n")
+        if not self.voice_speak.get():
+            return
+        short = (self.voice_lang.get().strip() or "es-ES")[:2]
+        if shutil.which("espeak-ng"):
+            cmd = ["espeak-ng", "-v", short, text]
+        elif shutil.which("espeak"):
+            cmd = ["espeak", "-v", short, text]
+        elif shutil.which("spd-say"):
+            cmd = ["spd-say", "-w", "-l", short, text]
+        else:
+            return
+
+        def run():
+            with self._speak_lock:
+                self._speak_n += 1
+                self.speaking = True
+            try:
+                subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                               timeout=20)
+            except Exception:
+                pass
+            finally:
+                with self._speak_lock:
+                    self._speak_n -= 1
+                    if self._speak_n == 0:
+                        self.speaking = False
+                        self.last_speech_end = time.time()
+
+        threading.Thread(target=run, daemon=True).start()
+
+    # ------------------------------------------------------------- acciones
+    def start_task(self, key, confirmed=False):
+        if self.proc is not None:
+            return
+        self.save_settings(quiet=True)
+        label = self.cfg["tasks"][key]["label"]
+        try:
+            cmd = self.build_command(key)
+        except ValueError as e:
+            messagebox.showerror("Error en los argumentos", str(e))
+            return
+
+        if not confirmed and not messagebox.askokcancel(
+            "Confirmar",
+            f"Se va a ejecutar «{label}».\n\n"
+            "Comprueba que la zona del brazo está despejada y "
+            "ten a mano el botón PARAR."):
+            return
+
+        self.write_log(f"\n[GUI] >>> {' '.join(shlex.quote(c) for c in cmd)}\n")
+        try:
+            kwargs = {}
+            if os.name == "nt":
+                kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+            env = dict(os.environ, PYTHONUNBUFFERED="1")
+            self.proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                text=True, bufsize=1, env=env, **kwargs)
+        except FileNotFoundError:
+            messagebox.showerror(
+                "No se encuentra lerobot-rollout",
+                "Lanza esta interfaz desde la terminal con el entorno activado "
+                "(conda activate lerobot) o indica el nombre del entorno conda "
+                "en la pestaña Robot.")
+            self.proc = None
+            return
+
+        # Al empezar, la tarea parte del estado inicial de su elemento
+        if key == "insertar":
+            self.cable_in = False
+        elif key == "extraer":
+            self.fuse_out = False
+
+        self.current_task = key
+        self.t_start = time.time()
+        self.t_anim0 = time.time()
+        for b in self.buttons.values():
+            b.config(state="disabled")
+        self.stop_btn.config(state="normal")
+        self.set_status(f"Ejecutando: {label}", "#2e7d32")
+        threading.Thread(target=self._reader, daemon=True).start()
+
+    def _reader(self):
+        proc = self.proc
+        for line in proc.stdout:
+            self.after(0, self.write_log, line)
+        code = proc.wait()
+        self.after(0, self._finished, code)
+
+    def _finished(self, code):
+        key = self.current_task
+        label = self.cfg["tasks"][key]["label"]
+        self.write_log(f"[GUI] Proceso terminado (código {code})\n")
+        if code == 0:
+            if key == "insertar":
+                self.cable_in = True
+            elif key == "extraer":
+                self.fuse_out = True
+        self.proc = None
+        self.current_task = None
+        for b in self.buttons.values():
+            b.config(state="normal")
+        self.stop_btn.config(state="disabled")
+        if code == 0:
+            self.set_status(f"Terminado: {label}", "#1565c0")
+        else:
+            self.set_status(f"Detenido / error: {label}", "#c62828")
+
+    def stop_task(self):
+        if self.proc is None:
+            return
+        self.write_log("[GUI] Deteniendo…\n")
+        try:
+            if os.name == "nt":
+                self.proc.send_signal(signal.CTRL_BREAK_EVENT)
+            else:
+                self.proc.send_signal(signal.SIGINT)  # parada limpia
+        except Exception:
+            self.proc.terminate()
+        self.after(5000, self._force_kill)
+
+    def _force_kill(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.write_log("[GUI] Forzando cierre del proceso\n")
+            self.proc.kill()
+
+    def _tick(self):
+        if self.proc is not None:
+            sec = int(time.time() - self.t_start)
+            self.timer_lbl.config(text=f"{sec // 60:02d}:{sec % 60:02d}")
+        self._voice_tick()
+        self.after(500, self._tick)
+
+    def on_close(self):
+        if self.proc is not None:
+            if not messagebox.askyesno("Salir", "Hay una tarea en marcha. ¿Pararla y salir?"):
+                return
+            self.stop_task()
+            time.sleep(1.0)
+        self.voice_on = False
+        try:
+            self.save_settings(quiet=True)
+        except Exception:
+            pass
+        self.destroy()
+
+
+if __name__ == "__main__":
+    App().mainloop()

lerobotberto-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: lerobotberto
+Version: 0.1.0
+Summary: Interfaz gráfica para ejecutar tareas entrenadas con LeRobot
+License-Expression: LicenseRef-LerobotBerto-Proprietary
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: imagenes
+Requires-Dist: Pillow==12.3.0; extra == "imagenes"
+Provides-Extra: voz
+Requires-Dist: SpeechRecognition==3.17.0; extra == "voz"
+Requires-Dist: PyAudio==0.2.14; extra == "voz"
+Provides-Extra: completo
+Requires-Dist: Pillow==12.3.0; extra == "completo"
+Requires-Dist: SpeechRecognition==3.17.0; extra == "completo"
+Requires-Dist: PyAudio==0.2.14; extra == "completo"
+Dynamic: license-file
+
+# LeRobotBerto
+
+Interfaz gráfica para ejecutar políticas entrenadas con LeRobot.
+
+## Requisitos
+
+- Python 3.12.
+- Linux o un sistema compatible con Tkinter.
+- LeRobot instalado en un entorno compatible.
+- Robot y cámaras configurados para el equipo correspondiente.
+
+Pillow permite mostrar imágenes adicionales. SpeechRecognition y PyAudio
+son opcionales y se utilizan para el control por voz.
+
+## Ejecutar la interfaz
+
+Una vez instalado el paquete:
+
+    lerobotberto
+
+También se puede ejecutar como módulo:
+
+    python -m lerobotberto
+
+## Dependencias de LeRobot
+
+Los archivos de `environments/` y `requirements/` contienen las referencias
+de dependencias exportadas desde el entorno Linux de desarrollo.
+
+No se deben instalar automáticamente en cualquier sistema operativo:
+algunas dependencias son específicas de Linux, del hardware o de CUDA.
+
+Antes de ejecutar tareas reales, hay que configurar los puertos, las cámaras,
+las políticas y los parámetros del robot en la interfaz.

lerobotberto-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+lerobotberto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lerobotberto/__main__.py,sha256=cuOke-HtgFcKIDHo1hRlTJsPc6y-CrtULHDBqayYREU,110
+lerobotberto/gui.py,sha256=bsYgdgMjibgeB02GnsqH1hCjvjNvfTfMu5kV8ly2gGc,48604
+lerobotberto-0.1.0.dist-info/licenses/LICENSE.txt,sha256=gupReBd-ERKxRqiOUQRyREfsNvVh3jQqUpijfSBZPIg,1748
+lerobotberto-0.1.0.dist-info/METADATA,sha256=x_SBr4kYer86kholKFutkZ2sIlfzvAUzLjKKL4ClmeI,1686
+lerobotberto-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lerobotberto-0.1.0.dist-info/entry_points.txt,sha256=gddRylDSIaCGnlTEjvbRrGbvnRKVQpaK6ClsMenskIw,60
+lerobotberto-0.1.0.dist-info/top_level.txt,sha256=N8u58qQWs1YL_lbhCDiGcQDPxG9h5fpifM3YFmJa-dM,13
+lerobotberto-0.1.0.dist-info/RECORD,,

lerobotberto-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lerobotberto-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lerobotberto = lerobotberto.__main__:main

lerobotberto-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,46 @@
+LEROBERTO PROPRIETARY LICENSE
+Copyright (c) 2026 Alberto Trujillo Sanz - FUSGEMENT S.L.U.
+All rights reserved.
+
+1. COPYRIGHT
+The software known as LeRobotBerto, including its source code,
+documentation and associated materials, is protected by copyright.
+All rights not expressly granted in this license are reserved by
+the copyright holder. 
+
+2. FREE LICENSE TO USE
+The copyright holder grants each recipient a non-exclusive,
+worldwide, royalty-free license to download, install and use the
+software for personal, educational, research or commercial purposes.
+
+3. RESTRICTIONS
+Unless the copyright holder gives prior written permission, recipients
+may not:
+- Sell, sublicense or commercially redistribute the software itself.
+- Publish or distribute modified or derivative versions of the software.
+- Redistribute copies of the software outside the distribution channels
+  authorized by the copyright holder.
+
+4. OWNERSHIP
+This license does not transfer ownership or copyright in the software.
+All rights not expressly granted remain with the copyright holder.
+
+5. FUTURE DISTRIBUTION
+The copyright holder may stop distributing the software, change the
+terms for future releases, or discontinue this license for future
+downloads and releases.
+
+Termination or withdrawal of distribution does not, by itself,
+automatically revoke permissions previously granted to recipients.
+Any termination of an existing recipient's license is subject to
+the applicable terms and law.
+
+6. NO WARRANTY
+The software is provided "AS IS", without warranty of any kind,
+to the fullest extent permitted by applicable law.
+
+7. APPLICABLE LAW
+The interpretation and enforceability of this license are subject
+to applicable law.
+
+8. You have to ACCEPT that BERTO is cool.

lerobotberto-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lerobotberto