Guide d'installation de BrainCo Revo II

Installer les dépendances Python

pip install pyserial websockets

Connectez et identifiez le port

Connectez le Revo II via USB. Sous Linux, le périphérique est répertorié comme /dev/ttyACM0 (ou ttyACM1 si d'autres périphériques ACM sont présents). Sous Windows, vérifiez le Gestionnaire de périphériques pour le port COM.

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

Corriger les autorisations sous Linux

Si vous obtenez une erreur d'autorisation refusée, ajoutez votre utilisateur au dialout groupe, puis déconnectez-vous et reconnectez-vous :

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

Le même protocole de commande JSON fonctionne sur BLE GATT. Utilisez ce chemin pour les déploiements sans fil.

Installez la bibliothèque BLE

pip install bleak

Recherchez le 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

L'UUID A ÉTÉ ACCEPTÉ

• Service: 0000ffe0-0000-1000-8000-00805f9b34fb
• Caractéristique d'écriture : 0000ffe1-0000-1000-8000-00805f9b34fb
• Notifier la caractéristique : 0000ffe2-0000-1000-8000-00805f9b34fb

Connectez-vous et envoyez une commande 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())

Les valeurs de position dans le protocole JSON sont des entiers compris entre 0 et 100 (pourcentage de fermeture). Le SDK Python utilise des flottants normalisés 0,0 à 1,0 et effectue des conversions en interne.

Commandes série brutes

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

Cartographie de l'index des doigts

• 0 — Pouce (2 DOF : flexion + rotation = flexion × 0,4)
• 1 — Indice (flexion 1 DOF)
• 2 — Milieu (flexion 1 DDL)
• 3 — Anneau (flexion 1 DOF)
• 4 — Pinky (flexion de 1 DOF)

Définir un seul doigt

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

L'étalonnage établit des limites de déplacement par doigt dans le micrologiciel. Exécutez-le après la première connexion et après tout réglage mécanique.

Séquence d'étalonnage (automatique)

1. Tous les doigts ouverts à 0 % de fermeture
2. Attendez 300 ms pour le réglage mécanique
3. Pour chaque doigt (pouce → index → ​​majeur → annulaire → petit doigt) :
   • Fermeture proche de 90 % — attendez 120 ms
   • Ouverture à 0% fermeture — attendre 120 ms
4. Tous les doigts se placent en position de survol (fermeture à 15 %)
5. Envoyer {"cmd": "calibrate"} pour verrouiller les limites du firmware

Exécuter l'étalonnage via le 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())

Le brainco_revo_agent.py relie le Revo II à la plate-forme RoboticsCenter via WebSocket, permettant le fonctionnement à distance, la surveillance de la position des doigts et la collecte de données de démonstration à partir d'un navigateur.

Lancer l'agent

# 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

Mode lentement via plateforme

Déclenchez les pressions sur les touches du piano à partir du panneau de téléopération du navigateur. Chaque pression exécute la séquence en 4 phases : extension (20 ms) → entraînement (30 ms) → maintien → rétraction (20 ms). Les pressions simultanées des doigts sont prises en charge.

API SDK de haut niveau

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