🧠 El modelo de lenguaje como cerebro

{
  "acao": "girar",
  "parametros": { "graus": -90 },
  "motivo": "el usuario pidió girar a la izquierda"
}

ollama pull <modelo>          # reemplaza por el nombre elegido
ollama list                     # el modelo debe aparecer aquí
curl http://localhost:11434/api/chat -d '{"model": "<modelo>", "stream": false,
  "messages": [{"role": "user", "content": "Responda só: ok"}]}'
python3 -m venv ~/robo-ia && source ~/robo-ia/bin/activate
pip install pyserial

#!/usr/bin/env python3
"""Cérebro com modelo local: o modelo ESCOLHE uma ação da lista fechada,
o código VALIDA e só então manda uma linha de texto ao ESP32 pela serial.
Uso: python3 cerebro_llm.py            (com ESP32)
     python3 cerebro_llm.py --simular  (sem hardware: só imprime)"""
import json, sys, time, urllib.request, urllib.error

OLLAMA_URL = "http://localhost:11434/api/chat"
MODELO = "<modelo>"          # reemplaza por el nombre que aparece en: ollama list
PORTA = "/dev/ttyUSB0"       # USB: /dev/ttyUSB0 o /dev/ttyACM0 · UART de Pi: /dev/serial0 · Windows: COM3
BAUD = 115200
CONFIRMAR_ACIMA_CM = 50        # para avanzar más que esto, hay que presionar "s" en el teclado

# Lista cerrada: acción -> {parámetro: (mínimo, máximo)} o {parámetro: [valores permitidos]}
ACOES = {
    "andar": {"cm": (5, 100)},
    "girar": {"graus": (-180, 180)},
    "garra": {"estado": ["abrir", "fechar"]},
    "parar": {},
}

ESQUEMA = {
    "type": "object",
    "properties": {
        "acao": {"type": "string", "enum": list(ACOES)},
        "parametros": {"type": "object"},
        "motivo": {"type": "string"},
    },
    "required": ["acao", "parametros"],
}

SISTEMA = (
    "Controlas un robot pequeño. Elige UNA acción y responde solo en JSON.\n"
    "Acciones: andar {cm: 5 a 100, no existe el valor negativo}; girar {grados: -180 a 180, "
    "negativo = izquierda}; garra {estado: abrir o cerrar}; parar {}.\n"
    "Si el pedido no corresponde a ninguna acción o es peligroso, usa parar y explícalo en el motivo."
)

def perguntar_modelo(pedido):
    """Envía el pedido a Ollama y devuelve el diccionario de la respuesta (o genera un error)."""
    corpo = {
        "model": MODELO,
        "messages": [{"role": "system", "content": SISTEMA},
                     {"role": "user", "content": pedido}],
        "stream": False,           # una respuesta completa, no fragmentos
        "format": ESQUEMA,          # fuerza el formato JSON
        "options": {"temperature": 0},
    }
    req = urllib.request.Request(OLLAMA_URL, data=json.dumps(corpo).encode(),
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=120) as r:
        dados = json.loads(r.read())
    return json.loads(dados["message"]["content"])

def validar(resp):
    """Devuelve (ok, línea_o_motivo, necesita_confirmar). Nunca confíes en el modelo."""
    if not isinstance(resp, dict):
        return False, "la respuesta no es un objeto JSON", False
    acao = resp.get("acao")
    if acao not in ACOES:
        return False, f"la acción '{acao}' no está en la lista", False
    params = resp.get("parametros") or {}
    if not isinstance(params, dict):
        return False, "los parámetros no son un objeto", False
    sobra = set(params) - set(ACOES[acao])
    if sobra:
        return False, f"parámetro desconocido: {', '.join(sorted(sobra))}", False
    valores = []
    for nome, regra in ACOES[acao].items():
        if nome not in params:
            return False, f"falta el parámetro '{nome}'", False
        v = params[nome]
        if isinstance(regra, list):                      # valores permitidos
            if v not in regra:
                return False, f"'{v}' no está permitido para {nome}", False
            valores.append(str(v).upper())
        else:                                            # rango numérico
            if isinstance(v, bool) or not isinstance(v, (int, float)):
                return False, f"{nome} debe ser un número", False
            minimo, maximo = regra
            if not (minimo <= v <= maximo):
                return False, f"{nome}={v} fuera del límite ({minimo} a {maximo})", False
            valores.append(str(int(round(v))))
    linha = " ".join([acao.upper()] + valores)         # ej.: ANDAR 30 · GARRA ABRIR · PARAR
    confirmar = acao == "andar" and params["cm"] > CONFIRMAR_ACIMA_CM
    return True, linha, confirmar

def abrir_serial(simular):
    if simular:
        return None
    import serial                                       # pip install pyserial
    s = serial.Serial(PORTA, BAUD, timeout=2)
    time.sleep(2)                                       # abrir el puerto reinicia el ESP32: espera
    s.reset_input_buffer()
    return s

def enviar(s, linha):
    if s is None:
        return f"(simulado) {linha}"
    s.write((linha + "\n").encode())
    return s.readline().decode(errors="replace").strip() or "(sin respuesta del ESP32)"

def main():
    simular = "--simular" in sys.argv
    s = abrir_serial(simular)
    print("Cerebro listo. Escribe un pedido (o 'salir').")
    while True:
        pedido = input("Tú: ").strip()
        if pedido.lower() in ("sair", "exit"):
            break
        if not pedido:
            continue
        try:
            resp = perguntar_modelo(pedido)
        except urllib.error.URLError as e:
            print(f"Ollama no respondió ({e}). ¿Está en ejecución? Prueba: ollama list"); continue
        except (json.JSONDecodeError, KeyError) as e:
            print(f"Rechazado: respuesta ilegible ({e})."); continue
        print("Modelo:", json.dumps(resp, ensure_ascii=False))
        ok, linha, confirmar = validar(resp)
        if not ok:
            print("Recusado:", linha); continue
        if confirmar and input(f"¿Confirmas '{linha}'? (s/n) ").strip().lower() != "s":
            print("Cancelado por ti."); continue
        print("ESP32:", enviar(s, linha))
    if s:
        s.write(b"PARAR\n"); s.close()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Toma una foto y pregunta al VLM local qué hay en ella. pip install opencv-python"""
import base64, json, sys, urllib.request
import cv2

MODELO_VISAO = "<modelo-de-visao>"   # un modelo con 'vision' en ollama.com/library
PERGUNTA = sys.argv[1] if len(sys.argv) > 1 else "Enumera los objetos sobre la mesa, con su color y posición (izquierda, centro, derecha)."

cam = cv2.VideoCapture(0)                # 0 = primera cámara
for _ in range(5):                       # descarta los cuadros oscuros del inicio
    ok, quadro = cam.read()
cam.release()
if not ok:
    sys.exit("No se pudo abrir la cámara: comprueba el índice (0, 1...) y el cable.")
quadro = cv2.resize(quadro, (640, 480))   # imagen más pequeña = respuesta más rápida
cv2.imwrite("foto.jpg", quadro)
_, jpg = cv2.imencode(".jpg", quadro)

corpo = {
    "model": MODELO_VISAO, "stream": False, "options": {"temperature": 0},
    "messages": [{"role": "user", "content": PERGUNTA + " Responde en español, en hasta 3 frases.",
                  "images": [base64.b64encode(jpg.tobytes()).decode()]}],
}
req = urllib.request.Request("http://localhost:11434/api/chat", data=json.dumps(corpo).encode(),
                             headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req, timeout=180) as r:
    print(json.loads(r.read())["message"]["content"])

// Ejecutor seguro: recibe "ANDAR 30", "GIRAR -90", "GARRA ABRIR", "PARAR" (ESP32, paquete esp32 3.x)
const int PINO_PARADA = 13;              // botón a GND (usa el pull-up interno)
const unsigned long WATCHDOG_MS = 2000;  // sin comando durante 2 s: se detiene
unsigned long ultimoComando = 0;
bool movendo = false;

void pararMotores() { movendo = false; Serial.println("# motores detenidos"); }  // reemplaza por tu driver
void andar(int cm)    { movendo = true; Serial.printf("# avanzando %d cm\n", cm); }
void girar(int graus) { movendo = true; Serial.printf("# girando %d grados\n", graus); }
void garra(bool abrir) { Serial.println(abrir ? "# abriendo la garra" : "# cerrando la garra"); }

void setup() {
  Serial.begin(115200);
  pinMode(PINO_PARADA, INPUT_PULLUP);
  pararMotores();
  Serial.println("PRONTO");
}

void loop() {
  if (digitalRead(PINO_PARADA) == LOW) { pararMotores(); while (digitalRead(PINO_PARADA) == LOW) delay(10); }
  if (movendo && millis() - ultimoComando > WATCHDOG_MS) pararMotores();
  if (!Serial.available()) return;
  String linha = Serial.readStringUntil('\n'); linha.trim();
  if (linha.length() == 0 || linha.length() > 32) { Serial.println("ERROR línea inválida"); return; }
  ultimoComando = millis();
  int esp = linha.indexOf(' ');
  String cmd = esp < 0 ? linha : linha.substring(0, esp);
  String arg = esp < 0 ? "" : linha.substring(esp + 1);
  if (cmd == "PARAR") { pararMotores(); Serial.println("OK PARAR"); }
  else if (cmd == "ANDAR") { int v = arg.toInt(); if (v < 5 || v > 100) Serial.println("ERROR límite"); else { andar(v); Serial.println("OK ANDAR"); } }
  else if (cmd == "GIRAR") { int v = arg.toInt(); if (v < -180 || v > 180) Serial.println("ERROR límite"); else { girar(v); Serial.println("OK GIRAR"); } }
  else if (cmd == "GARRA" && (arg == "ABRIR" || arg == "FECHAR")) { garra(arg == "ABRIR"); Serial.println("OK GARRA"); }
  else { pararMotores(); Serial.println("ERROR comando desconocido"); }
}