Guia de Configuração do BrainCo Revo II

Instale as dependências do Python

pip install pyserial websockets

Conecte e identifique a porta

Conecte o Revo II via USB. No Linux, o dispositivo é enumerado como /dev/ttyACM0 (ou ttyACM1 se outros dispositivos ACM estiverem presentes). No Windows, verifique o Gerenciador de Dispositivos para a porta COM.

ls /dev/ttyACM*          # Linux — find the device
# Windows: check Device Manager → Ports (COM & LPT)

Corrija as permissões no Linux

Se você receber um erro de permissão negada, adicione seu usuário ao dialout grupo, então saia e entre novamente:

sudo usermod -aG dialout $USER
# Log out and back in for the change to take effect

O mesmo protocolo de comando JSON funciona sobre BLE GATT. Use este caminho para implantações sem fio.

Instale a biblioteca BLE

pip install bleak

Procure pelo Revo II

import asyncio
from bleak import BleakScanner

async def scan():
    devices = await BleakScanner.discover(timeout=5.0)
    for d in devices:
        print(d.address, d.name)

asyncio.run(scan())
# Look for a device named "BrainCo" or similar — note its address

UUIDs BLE GATT

• Serviço: 0000ffe0-0000-1000-8000-00805f9b34fb
• Recurso escrito: 0000ffe1-0000-1000-8000-00805f9b34fb
• Característica de notificação: 0000ffe2-0000-1000-8000-00805f9b34fb

Conecte e envie um comando via BLE

import asyncio, json
from bleak import BleakClient

WRITE_CHAR = "0000ffe1-0000-1000-8000-00805f9b34fb"
ADDRESS = "AA:BB:CC:DD:EE:FF"   # replace with your device address

async def main():
    async with BleakClient(ADDRESS) as client:
        # Close all fingers to 50%
        cmd = json.dumps({"cmd": "set_pose", "positions": [50,50,50,50,50]})
        await client.write_gatt_char(WRITE_CHAR, cmd.encode("utf-8"), response=False)
        await asyncio.sleep(1.0)
        # Open all fingers
        cmd2 = json.dumps({"cmd": "set_pose", "positions": [0,0,0,0,0]})
        await client.write_gatt_char(WRITE_CHAR, cmd2.encode("utf-8"), response=False)

asyncio.run(main())

Os valores de posição no protocolo JSON são inteiros de 0 a 100 (porcentagem de fechamento). O SDK Python usa floats normalizados de 0,0 a 1,0 e converte internamente.

Comandos seriais brutos

import serial, json, time

port = serial.Serial("/dev/ttyACM0", baudrate=115200, timeout=1.0)

def set_pose(positions):
    pcts = [int(p * 100) for p in positions]
    cmd = json.dumps({"cmd": "set_pose", "positions": pcts}) + "\n"
    port.write(cmd.encode("utf-8"))

# Open all fingers
set_pose([0.0, 0.0, 0.0, 0.0, 0.0])
time.sleep(1.0)

# Point with thumb extended, close others
set_pose([0.0, 0.8, 0.8, 0.8, 0.8])
time.sleep(1.0)

# Fist
set_pose([1.0, 1.0, 1.0, 1.0, 1.0])
time.sleep(1.0)

# Open again
set_pose([0.0] * 5)
port.close()

Mapeamento do índice do dedo

• 0 — Polegar (2 DOF: flexão + rotação = flexão × 0,4)
• 1 — Indicador (1 DOF flexão)
• 2 — Médio (1 DOF flexão)
• 3 — Anelar (1 DOF flexão)
• 4 — Mínimo (1 DOF flexão)

Definir dedo único

# Set index finger to 75% closure
cmd = json.dumps({"cmd": "set_finger", "finger": 1, "position": 75}) + "\n"
port.write(cmd.encode("utf-8"))

A calibração estabelece limites de deslocamento por dedo no firmware. Execute isso após a primeira conexão e após qualquer ajuste mecânico.

Sequência de calibração (automática)

1. Todos os dedos abertos a 0% de fechamento
2. Aguarde 300 ms para estabilização mecânica
3. Para cada dedo (polegar → indicador → médio → anelar → mínimo):
   • Fechar a 90% de fechamento — aguarde 120 ms
   • Abrir a 0% de fechamento — aguarde 120 ms
4. Todos os dedos estabilizam na posição de flutuação (15% de fechamento)
5. Enviar {"cmd": "calibrate"} bloquear os limites de firmware

Executar calibração via SDK

import asyncio
from brainco_revo_agent import BrainCoReVoController

async def calibrate():
    ctrl = BrainCoReVoController(mock=False)
    await ctrl.connect("/dev/ttyACM0")
    await ctrl.calibrate()   # runs full wave then sends calibrate cmd
    print("Calibration complete")
    await ctrl.disconnect()

asyncio.run(calibrate())

A brainco_revo_agent.py conecta o Revo II à plataforma RoboticsCenter via WebSocket, permitindo operação remota, monitoramento da posição dos dedos e coleta de dados de demonstração a partir de um navegador.

Iniciar o agente

# Real hardware (USB)
python brainco_revo_agent.py \
  --backend wss://your-backend.run.app \
  --session YOUR_SESSION_ID \
  --device /dev/ttyACM0

# Real hardware (BLE)
python brainco_revo_agent.py \
  --backend wss://your-backend.run.app \
  --session YOUR_SESSION_ID \
  --ble AA:BB:CC:DD:EE:FF

# Mock mode — no hardware required
python brainco_revo_agent.py \
  --backend ws://localhost:8000 \
  --session test-session \
  --mock

Caminho plano via plataforma

Acionar pressionamentos de teclas do piano a partir do painel de teleop do navegador. Cada pressionamento executa a sequência de 4 fases: estender (20 ms) → dirigir (30 ms) → segurar → retrair (20 ms). Pressionamentos de dedos simultâneos são suportados.

API SDK de alto nível

import asyncio
from brainco_revo_agent import BrainCoReVoController

async def main():
    ctrl = BrainCoReVoController(mock=False)
    await ctrl.connect("/dev/ttyACM0")

    # Set all fingers to 60% closure
    await ctrl.set_hand_pose([0.6, 0.6, 0.6, 0.6, 0.6])
    await asyncio.sleep(0.5)

    # Read current state
    snap = await ctrl.snapshot()
    print(snap["positions_dict"])   # {"thumb":0.6, "index":0.6, ...}

    await ctrl.disconnect()

asyncio.run(main())