🤝 Proyecto final: robot asistente

# Robot asistente: texto (de la voz) -> plan en JSON (LLM) -> validación -> ejecución.
# Modo --simular: sin LLM ni hardware, para probar la lógica y los bloqueos.
import argparse, json, subprocess, sys, time, urllib.request

OBJETOS = {"cubo": "outputs/train/act-cubo/checkpoints/last/pretrained_model",
           "bola": "outputs/train/act-bola/checkpoints/last/pretrained_model"}
SOLTAR = "outputs/train/act-soltar/checkpoints/last/pretrained_model"
LUGARES = ["mesa", "sala", "base"]
ACOES = {  # lista cerrada: nombre -> argumentos permitidos
    "ir_para": {"lugar": LUGARES},
    "pegar": {"objeto": list(OBJETOS)},
    "entregar": {},
    "falar": {"texto": None},
    "parar": {},
}
MAX_PASSOS = 6

PROMPT = ("Controlas un robot con brazo y base móvil. Responde SOLO con JSON en el formato "
          ' {"passos": [{"acao": "...", ...}]}. Acciones permitidas: ' + json.dumps(ACOES, ensure_ascii=False) +
          ". Si la solicitud no se puede resolver con estas acciones, responde con una sola acción hablar explicando.")

def planejar_simulado(texto):
    t = texto.lower()
    if "pare" in t or "parar" in t:
        return {"passos": [{"acao": "parar"}]}
    for obj in OBJETOS:
        if obj in t:
            return {"passos": [{"acao": "ir_para", "lugar": "mesa"}, {"acao": "pegar", "objeto": obj},
                               {"acao": "ir_para", "lugar": "sala"}, {"acao": "entregar"},
                               {"acao": "falar", "texto": f"Listo, traje: {obj}."}]}
    if "janela" in t:  # simula un LLM que inventa una acción fuera de la lista
        return {"passos": [{"acao": "abrir_janela"}]}
    return {"passos": [{"acao": "falar", "texto": "No sé hacer eso."}]}

def planejar_ollama(texto, modelo):
    corpo = json.dumps({"model": modelo, "stream": False, "format": "json", "options": {"temperature": 0},
                        "messages": [{"role": "system", "content": PROMPT}, {"role": "user", "content": texto}]})
    req = urllib.request.Request("http://localhost:11434/api/chat", corpo.encode(), {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=60) as r:
        return json.loads(json.loads(r.read())["message"]["content"])

def validar(plano):
    passos = plano.get("passos") if isinstance(plano, dict) else None
    if not isinstance(passos, list) or not 1 <= len(passos) <= MAX_PASSOS:
        return None, "plan vacío o demasiado largo"
    for p in passos:
        regra = ACOES.get(p.get("acao"))
        if regra is None:
            return None, f"acción fuera de la lista: {p.get('acao')}"
        for arg, permitidos in regra.items():
            if arg not in p:
                return None, f"falta '{arg}' en {p['acao']}"
            if permitidos is not None and p[arg] not in permitidos:
                return None, f"valor no permitido: {arg}={p[arg]}"
    return passos, "ok"

def executar(passo, simular, porta_base):
    a = passo["acao"]
    if simular:
        print("  [SIM]", json.dumps(passo, ensure_ascii=False)); time.sleep(0.2); return True
    if a in ("pegar", "entregar"):  # brazo: políticas entrenadas en el 5.4
        politica = OBJETOS[passo["objeto"]] if a == "pegar" else SOLTAR
        tarefa = f"Tomar el {passo['objeto']}." if a == "pegar" else "Soltar el objeto en la mano de la persona."
        cmd = ["lerobot-rollout", "--strategy.type=base", f"--policy.path={politica}",
               "--robot.type=so101_follower", "--robot.port=/dev/ttyACM0", "--robot.id=seguidor",
               f"--task={tarefa}", "--duration=20"]
        return subprocess.run(cmd).returncode == 0
    if a in ("ir_para", "parar"):  # base móvil: ESP32 de la Trilha 3 por serial
        import serial
        with serial.Serial(porta_base, 115200, timeout=30) as s:
            s.write((f"{a.upper()} {passo.get('lugar', '')}".strip() + "\n").encode())
            return s.readline().decode().strip() == "OK"
    if a == "falar":
        print("  ROBÔ:", passo["texto"]); return True  # cambia por el Piper del 5.2
    return False

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--texto", required=True, help="solicitud (viene de Whisper en el 5.2)")
    ap.add_argument("--simular", action="store_true")
    ap.add_argument("--modelo", default="<seu_modelo_ollama>")
    ap.add_argument("--porta-base", default="/dev/ttyUSB0")
    args = ap.parse_args()
    print("PEDIDO:", args.texto)
    plano = planejar_simulado(args.texto) if args.simular else planejar_ollama(args.texto, args.modelo)
    passos, motivo = validar(plano)
    if passos is None:
        print("RECUSADO:", motivo); sys.exit(2)
    print(f"PLAN ({len(passos)} pasos):", [p["acao"] for p in passos])
    if not args.simular and input("¿Confirmar ejecución? (s/n) ").strip().lower() != "s":
        print("CANCELADO por el operador"); sys.exit(0)
    for i, p in enumerate(passos, 1):
        print(f"paso {i}/{len(passos)}: {p['acao']}")
        if not executar(p, args.simular, args.porta_base):
            print("FALLÓ en el paso", i, "- parando"); executar({"acao": "parar"}, args.simular, args.porta_base); sys.exit(1)
    print("COMPLETADO")

if __name__ == "__main__":
    main()

// Base del robot asistente (ESP32, paquete esp32 3.x): protocolo de líneas con el orquestador.
const unsigned long LIMITE_MS = 15000;   // ningún recorrido supera este tiempo: se detiene solo

void pararMotores() { /* llama aquí a la parada de tu rover (velocidad 0 en las dos ruedas) */ }
void andarRumo(const String &lugar) { /* ruta fija, seguidor de línea o punto de Nav2 */ }
bool chegou(unsigned long t0) { return millis() - t0 > 2000; }  // simulación: 2 s de recorrido

bool irPara(const String &lugar) {
  if (lugar != "mesa" && lugar != "sala" && lugar != "base") return false;
  unsigned long t0 = millis();
  andarRumo(lugar);
  while (!chegou(t0)) {
    if (Serial.available() && Serial.readStringUntil('\n').startsWith("PARAR")) { pararMotores(); return false; }
    if (millis() - t0 > LIMITE_MS) { pararMotores(); return false; }
    delay(10);
  }
  pararMotores();
  return true;
}

void setup() { Serial.begin(115200); pararMotores(); Serial.println("BASE LISTA"); }

void loop() {
  if (!Serial.available()) return;
  String linha = Serial.readStringUntil('\n');
  linha.trim();
  if (linha.startsWith("IR_PARA ")) Serial.println(irPara(linha.substring(8)) ? "OK" : "ERRO");
  else if (linha == "PARAR") { pararMotores(); Serial.println("OK"); }
  else Serial.println("ERROR comando desconocido");
}