🤝 Projeto final: robô assistente

# Robô assistente: texto (da voz) -> plano em JSON (LLM) -> validação -> execução.
# Modo --simular: sem LLM e sem hardware, para testar a lógica e as travas.
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 fechada: nome -> argumentos permitidos
    "ir_para": {"lugar": LUGARES},
    "pegar": {"objeto": list(OBJETOS)},
    "entregar": {},
    "falar": {"texto": None},
    "parar": {},
}
MAX_PASSOS = 6

PROMPT = ("Você controla um robô com braço e base móvel. Responda SÓ com JSON no formato "
          '{"passos": [{"acao": "...", ...}]}. Ações permitidas: ' + json.dumps(ACOES, ensure_ascii=False) +
          ". Se o pedido não couber nessas ações, responda com uma única ação falar 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"Pronto, trouxe: {obj}."}]}
    if "janela" in t:  # simula um LLM que inventa uma ação fora da lista
        return {"passos": [{"acao": "abrir_janela"}]}
    return {"passos": [{"acao": "falar", "texto": "Não sei fazer isso."}]}

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, "plano vazio ou longo demais"
    for p in passos:
        regra = ACOES.get(p.get("acao"))
        if regra is None:
            return None, f"ação fora da lista: {p.get('acao')}"
        for arg, permitidos in regra.items():
            if arg not in p:
                return None, f"falta '{arg}' em {p['acao']}"
            if permitidos is not None and p[arg] not in permitidos:
                return None, f"valor não 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"):  # braço: políticas treinadas no 5.4
        politica = OBJETOS[passo["objeto"]] if a == "pegar" else SOLTAR
        tarefa = f"Pegar o {passo['objeto']}." if a == "pegar" else "Soltar o objeto na mão da pessoa."
        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óvel: ESP32 da 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  # troque pelo Piper do 5.2
    return False

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--texto", required=True, help="pedido (vem do Whisper no 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"PLANO ({len(passos)} passos):", [p["acao"] for p in passos])
    if not args.simular and input("Confirmar execução? (s/n) ").strip().lower() != "s":
        print("CANCELADO pelo operador"); sys.exit(0)
    for i, p in enumerate(passos, 1):
        print(f"passo {i}/{len(passos)}: {p['acao']}")
        if not executar(p, args.simular, args.porta_base):
            print("FALHOU no passo", i, "- parando"); executar({"acao": "parar"}, args.simular, args.porta_base); sys.exit(1)
    print("CONCLUÍDO")

if __name__ == "__main__":
    main()

// Base do robô assistente (ESP32, pacote esp32 3.x): protocolo de linhas com o orquestrador.
const unsigned long LIMITE_MS = 15000;   // nenhuma viagem passa disso: para sozinha

void pararMotores() { /* chame aqui a parada do seu rover (velocidade 0 nas duas rodas) */ }
void andarRumo(const String &lugar) { /* rota fixa, seguidor de linha ou ponto do Nav2 */ }
bool chegou(unsigned long t0) { return millis() - t0 > 2000; }  // simulação: 2 s de viagem

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 PRONTA"); }

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("ERRO comando desconhecido");
}