ब्रेन की रेवो II सेटअप गाइड

पायथन निर्भरताएँ स्थापित करें

pip install pyserial websockets

पोर्ट को कनेक्ट करें और पहचानें

रेवो II को USB के माध्यम से कनेक्ट करें। लिनक्स पर डिवाइस इस प्रकार गणना करता है /dev/ttyACM0 (या ttyACM1 यदि अन्य ACM डिवाइस मौजूद हैं)। विंडोज़ पर, COM पोर्ट के लिए डिवाइस मैनेजर की जाँच करें।

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

Linux पर अनुमतियाँ ठीक करें

यदि आपको अनुमति अस्वीकृत त्रुटि मिलती है, तो अपने उपयोगकर्ता को इसमें जोड़ें dialout समूह बनाएं, फिर लॉग आउट करें और वापस आएं:

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

वही JSON कमांड प्रोटोकॉल BLE GATT पर काम करता है। वायरलेस परिनियोजन के लिए इस पथ का उपयोग करें.

BLE लाइब्रेरी स्थापित करें

pip install bleak

रेवो 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

बीएलई गैट यूयूआईडी

• सेवा: 0000ffe0-0000-1000-8000-00805f9b34fb
• विशेषता लिखें: 0000ffe1-0000-1000-8000-00805f9b34fb
• सूचित करें विशेषता: 0000ffe2-0000-1000-8000-00805f9b34fb

कनेक्ट करें और 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())

JSON प्रोटोकॉल में स्थिति मान पूर्णांक 0-100 (प्रतिशत समापन) हैं। पायथन एसडीके सामान्यीकृत फ्लोट्स 0.0-1.0 का उपयोग करता है और आंतरिक रूप से परिवर्तित होता है।

कच्चे धारावाहिक आदेश

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

फिंगर इंडेक्स मैपिंग

• 0 - अंगूठा (2 डीओएफ: लचीलापन + घुमाव = लचीलापन × 0.4)
• 1 - सूचकांक (1 डीओएफ फ्लेक्सन)
• 2 - मध्य (1 डीओएफ फ्लेक्सन)
• 3 - रिंग (1 डीओएफ फ्लेक्सन)
• 4 - पिंकी (1 डीओएफ फ्लेक्सन)

एकल उंगली सेट करें

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

कैलिब्रेशन फ़र्मवेयर में प्रति-उंगली यात्रा सीमा स्थापित करता है। पहले कनेक्शन के बाद और किसी भी यांत्रिक समायोजन के बाद इसे चलाएँ।

अंशांकन अनुक्रम (स्वचालित)

1. सभी उंगलियां 0% बंद होने तक खुलती हैं
2. यांत्रिक निपटान के लिए 300 एमएस तक प्रतीक्षा करें
3. प्रत्येक उंगली के लिए (अंगूठा → तर्जनी → मध्य → अंगूठी → पिंकी):
   • 90% समापन के करीब - 120 एमएस प्रतीक्षा करें
   • 0% समापन तक खुला - 120 एमएस प्रतीक्षा करें
4. सभी उंगलियाँ होवर स्थिति पर स्थिर हो जाती हैं (15% बंद)
5. भेजना {"cmd": "calibrate"} फ़र्मवेयर सीमाएँ लॉक करने के लिए

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

The brainco_revo_agent.py वेबसॉकेट के माध्यम से रेवो II को रोबोटिक्ससेंटर प्लेटफॉर्म से जोड़ता है, जो एक ब्राउज़र से रिमोट ऑपरेशन, उंगली की स्थिति की निगरानी और प्रदर्शन डेटा संग्रह को सक्षम करता है।

एजेंट लॉन्च करें

# 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

मंच के माध्यम से पियानो मोड

ट्रिगर पियानो कुंजी ब्राउज़र टेलोप पैनल से दबाती है। प्रत्येक प्रेस 4-चरण अनुक्रम निष्पादित करता है: विस्तार (20 एमएस) → ड्राइव (30 एमएस) → होल्ड → वापस लेना (20 एमएस)। समवर्ती फिंगर प्रेस समर्थित हैं।

उच्च स्तरीय एसडीके एपीआई

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