Guía de Configuración del BrainCo Revo II

Instalar dependencias de Python

pip install pyserial websockets

Conectar e identificar el puerto

Conectar el Revo II a través de USB. En Linux, el dispositivo se enumera como /dev/ttyACM0 (o ttyACM1 si hay otros dispositivos ACM presentes). En Windows, verifica el Administrador de dispositivos para el puerto COM.

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

Arreglar permisos en Linux

Si obtienes un error de permiso denegado, añade tu usuario al dialout grupo, luego cierra sesión y vuelve a iniciar sesión:

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

El mismo protocolo de comando JSON funciona sobre BLE GATT. Usa esta ruta para implementaciones inalámbricas.

Instalar la biblioteca BLE

pip install bleak

Escanear para el 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

Los UUID FUERON ACEPTADOS

• Servicio: 0000ffe0-0000-1000-8000-00805f9b34fb
• Característica de escritura: 0000ffe1-0000-1000-8000-00805f9b34fb
• Característica de notificación: 0000ffe2-0000-1000-8000-00805f9b34fb

Conectar y enviar un comando a través de 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())

Los valores de posición en el protocolo JSON son enteros de 0 a 100 (porcentaje de cierre). El SDK de Python utiliza flotantes normalizados de 0.0 a 1.0 y convierte internamente.

Comandos seriales en bruto

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()

Mapeo del índice del dedo

• 0 — Pulgar (2 DOF: flexión + rotación = flexión × 0.4)
• 1 — Índice (1 DOF flexión)
• 2 — Medio (1 DOF flexión)
• 3 — Anular (1 DOF flexión)
• 4 — Meñique (1 DOF flexión)

Establecer dedo individual

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

La calibración establece límites de desplazamiento por dedo en el firmware. Ejecuta esto después de la primera conexión y después de cualquier ajuste mecánico.

Secuencia de calibración (automática)

1. Todos los dedos abiertos al 0% de cierre
2. Espera 300 ms para el asentamiento mecánico
3. Para cada dedo (pulgar → índice → medio → anular → meñique):
   • Cerrar al 90% de cierre — espera 120 ms
   • Abrir al 0% de cierre — espera 120 ms
4. Todos los dedos se asientan en la posición de flotación (15% de cierre)
5. para enviar {"cmd": "calibrate"} bloquear los límites del firmware

Ejecutar calibración a través del 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())

La brainco_revo_agent.py conecta el Revo II a la plataforma RoboticsCenter a través de WebSocket, permitiendo operación remota, monitoreo de la posición de los dedos y recopilación de datos de demostración desde un navegador.

Lanzar el 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

modo piano a través de la plataforma

Activar las pulsaciones de las teclas del piano desde el panel de teleoperación del navegador. Cada pulsación ejecuta la secuencia de 4 fases: extender (20 ms) → conducir (30 ms) → mantener → retraer (20 ms). Se admiten pulsaciones concurrentes de los dedos.

API de SDK de alto nivel

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())