🧠 Modelo de linguagem como cérebro

{
  "acao": "girar",
  "parametros": { "graus": -90 },
  "motivo": "o usuário pediu para virar à esquerda"
}

ollama pull <modelo>          # troque pelo nome escolhido
ollama list                     # o modelo deve aparecer aqui
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>"          # troque pelo nome que aparece em: ollama list
PORTA = "/dev/ttyUSB0"       # USB: /dev/ttyUSB0 ou /dev/ttyACM0 · UART do Pi: /dev/serial0 · Windows: COM3
BAUD = 115200
CONFIRMAR_ACIMA_CM = 50        # andar mais que isso pede "s" no teclado

# Lista fechada: ação -> {parâmetro: (mínimo, máximo)} ou {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 = (
    "Você controla um robô pequeno. Escolha UMA ação e responda só em JSON.\n"
    "Ações: andar {cm: 5 a 100, negativo não existe}; girar {graus: -180 a 180, "
    "negativo = esquerda}; garra {estado: abrir ou fechar}; parar {}.\n"
    "Se o pedido não couber em nenhuma ação, ou for perigoso, use parar e explique no motivo."
)

def perguntar_modelo(pedido):
    """Manda o pedido ao Ollama e devolve o dicionário da resposta (ou levanta erro)."""
    corpo = {
        "model": MODELO,
        "messages": [{"role": "system", "content": SISTEMA},
                     {"role": "user", "content": pedido}],
        "stream": False,           # uma resposta inteira, não pedaços
        "format": ESQUEMA,          # força o molde 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):
    """Devolve (ok, linha_ou_motivo, precisa_confirmar). Nunca confia no modelo."""
    if not isinstance(resp, dict):
        return False, "resposta não é um objeto JSON", False
    acao = resp.get("acao")
    if acao not in ACOES:
        return False, f"ação '{acao}' não está na lista", False
    params = resp.get("parametros") or {}
    if not isinstance(params, dict):
        return False, "parâmetros não são um objeto", False
    sobra = set(params) - set(ACOES[acao])
    if sobra:
        return False, f"parâmetro desconhecido: {', '.join(sorted(sobra))}", False
    valores = []
    for nome, regra in ACOES[acao].items():
        if nome not in params:
            return False, f"falta o parâmetro '{nome}'", False
        v = params[nome]
        if isinstance(regra, list):                      # valores permitidos
            if v not in regra:
                return False, f"'{v}' não é permitido para {nome}", False
            valores.append(str(v).upper())
        else:                                            # faixa numérica
            if isinstance(v, bool) or not isinstance(v, (int, float)):
                return False, f"{nome} precisa ser número", False
            minimo, maximo = regra
            if not (minimo <= v <= maximo):
                return False, f"{nome}={v} fora do limite ({minimo} a {maximo})", False
            valores.append(str(int(round(v))))
    linha = " ".join([acao.upper()] + valores)         # ex.: 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 a porta reinicia o ESP32: espere
    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 "(sem resposta do ESP32)"

def main():
    simular = "--simular" in sys.argv
    s = abrir_serial(simular)
    print("Cérebro pronto. Escreva um pedido (ou 'sair').")
    while True:
        pedido = input("Você: ").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 não respondeu ({e}). Ele está rodando? Teste: ollama list"); continue
        except (json.JSONDecodeError, KeyError) as e:
            print(f"Recusado: resposta ilegível ({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"Confirma '{linha}'? (s/n) ").strip().lower() != "s":
            print("Cancelado por você."); continue
        print("ESP32:", enviar(s, linha))
    if s:
        s.write(b"PARAR\n"); s.close()

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tira uma foto e pergunta ao VLM local o que há nela. pip install opencv-python"""
import base64, json, sys, urllib.request
import cv2

MODELO_VISAO = "<modelo-de-visao>"   # um modelo com 'vision' em ollama.com/library
PERGUNTA = sys.argv[1] if len(sys.argv) > 1 else "Liste os objetos sobre a mesa, com cor e posição (esquerda, centro, direita)."

cam = cv2.VideoCapture(0)                # 0 = primeira câmera
for _ in range(5):                       # descarta quadros escuros do começo
    ok, quadro = cam.read()
cam.release()
if not ok:
    sys.exit("Câmera não abriu: confira o índice (0, 1...) e o cabo.")
quadro = cv2.resize(quadro, (640, 480))   # imagem menor = resposta mais 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 + " Responda em português, em até 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"])

// Executor seguro: recebe "ANDAR 30", "GIRAR -90", "GARRA ABRIR", "PARAR" (ESP32, pacote esp32 3.x)
const int PINO_PARADA = 13;              // botão para o GND (usa pull-up interno)
const unsigned long WATCHDOG_MS = 2000;  // sem comando por 2 s: para
unsigned long ultimoComando = 0;
bool movendo = false;

void pararMotores() { movendo = false; Serial.println("# motores parados"); }  // troque pelo seu driver
void andar(int cm)    { movendo = true; Serial.printf("# andando %d cm\n", cm); }
void girar(int graus) { movendo = true; Serial.printf("# girando %d graus\n", graus); }
void garra(bool abrir) { Serial.println(abrir ? "# garra abrindo" : "# garra fechando"); }

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("ERRO linha invalida"); 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("ERRO limite"); else { andar(v); Serial.println("OK ANDAR"); } }
  else if (cmd == "GIRAR") { int v = arg.toInt(); if (v < -180 || v > 180) Serial.println("ERRO limite"); 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("ERRO comando desconhecido"); }
}