BrainCo Revo II-Setup-Anleitung

Installieren Sie Python-Abhängigkeiten

pip install pyserial websockets

Verbinden und identifizieren Sie den Port

Schließen Sie den Revo II über USB an. Unter Linux wird das Gerät als aufgelistet /dev/ttyACM0 (oder ttyACM1, wenn andere ACM-Geräte vorhanden sind). Suchen Sie unter Windows im Geräte-Manager nach dem COM-Port.

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

Korrigieren Sie die Berechtigungen unter Linux

Wenn Sie die Fehlermeldung „Berechtigung verweigert“ erhalten, fügen Sie Ihren Benutzer hinzu dialout Gruppe, dann abmelden und wieder anmelden:

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

Das gleiche JSON-Befehlsprotokoll funktioniert über BLE GATT. Verwenden Sie diesen Pfad für drahtlose Bereitstellungen.

Installieren Sie die BLE-Bibliothek

pip install bleak

Suchen Sie nach dem 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

BLE GATT UUIDs

• Service: 0000ffe0-0000-1000-8000-00805f9b34fb
• Schreibeigenschaft: 0000ffe1-0000-1000-8000-00805f9b34fb
• Merkmal benachrichtigen: 0000ffe2-0000-1000-8000-00805f9b34fb

Verbinden Sie sich und senden Sie einen Befehl über 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())

Positionswerte im JSON-Protokoll sind ganze Zahlen von 0–100 (prozentualer Abschluss). Das Python SDK verwendet normalisierte Floats 0,0–1,0 und konvertiert intern.

Rohe serielle Befehle

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

Finger-Index-Mapping

• 0 — Daumen (2 DOF: Flexion + Rotation = Flexion × 0,4)
• 1 — Index (1 DOF-Flexion)
• 2 — Mitte (1 DOF-Flexion)
• 3 — Ring (1 DOF-Flexion)
• 4 — Pinky (1 DOF-Beugung)

Einzelnen Finger einstellen

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

Durch die Kalibrierung werden in der Firmware Bewegungsgrenzen pro Finger festgelegt. Führen Sie dies nach dem ersten Anschluss und nach jeder mechanischen Anpassung durch.

Kalibrierungssequenz (automatisch)

1. Alle Finger öffnen sich bis zu 0 % Schließung
2. Warten Sie 300 ms auf die mechanische Beruhigung
3. Für jeden Finger (Daumen → Zeigefinger → Mittelfinger → Ring → kleiner Finger):
   • Nahezu 90 % Schließung – 120 ms warten
   • Öffnen bis 0 % Schließung – 120 ms warten
4. Alle Finger bleiben in der Schwebeposition (15 % Schließung)
5. Schicken {"cmd": "calibrate"} um Firmware-Grenzwerte festzulegen

Führen Sie die Kalibrierung über das SDK durch

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

Der brainco_revo_agent.py verbindet den Revo II über WebSocket mit der RoboticsCenter-Plattform und ermöglicht so den Fernbetrieb, die Überwachung der Fingerposition und die Erfassung von Demonstrationsdaten über einen Browser.

Starten Sie den Agenten

# 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

Klaviermodus über Plattform

Lösen Sie Klaviertastendrücke über das Teleop-Panel des Browsers aus. Bei jedem Drücken wird die 4-Phasen-Sequenz ausgeführt: Ausfahren (20 ms) → Fahren (30 ms) → Halten → Einfahren (20 ms). Gleichzeitiges Drücken mit dem Finger wird unterstützt.

High-Level-SDK-API

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