सॉफ्टवेयर सेटअप

एसडीके स्थापना

OpenArm SDK को इस प्रकार वितरित किया जाता है roboticscenter पायथन पैकेज. इसमें शामिल है openarm_can (निम्न-स्तरीय CAN इंटरफ़ेस लाइब्रेरी) और सभी सहायक उपयोगिताएँ।

एक आभासी वातावरण बनाएं (अनुशंसित)

python3 -m venv ~/.venvs/openarm
source ~/.venvs/openarm/bin/activate

एसडीके स्थापित करें

pip install roboticscenter

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

python3 -c "import openarm_can; print(openarm_can.__version__)"

आपको एक संस्करण स्ट्रिंग देखनी चाहिए. यदि आपको कोई आयात त्रुटि दिखाई देती है, तो देखें समस्या निवारण अनुभाग.

स्रोत से इंस्टॉल करें (वैकल्पिक)

git clone https://github.com/reazon-research/openarm.git
cd openarm
pip install -e .

सॉकेटकैन ड्राइवर सेटअप

OpenArm सॉकेटकैन - एक लिनक्स कर्नेल सबसिस्टम का उपयोग करके CAN बस पर संचार करता है। ड्राइवर पहले से ही कर्नेल में हैं; आपको बस मॉड्यूल लोड करने और इंटरफ़ेस लाने की आवश्यकता है।

कर्नेल मॉड्यूल लोड करें

sudo modprobe can
sudo modprobe can_raw
sudo modprobe slcan   # for USB-serial CAN adapters (CANable)

CAN इंटरफ़ेस लाएँ

शामिल किए गए CANable 2.0 USB अडैप्टर के लिए:

# Find the USB serial device (usually /dev/ttyACM0 or /dev/ttyUSB0)
ls /dev/ttyACM*

# Bring up CAN interface at 1 Mbps
sudo slcand -o -c -s8 /dev/ttyACM0 can0
sudo ip link set up can0

सत्यापित करें कि इंटरफ़ेस चालू है

ip link show can0
# Expected output: can0: <NOARP,UP,LOWER_UP> mtu 16 ...

इसे रिबूट के दौरान लगातार बनाए रखें

एक सिस्टमडी सेवा बनाएं या जोड़ें /etc/rc.local. देखें सॉकेटकैन सेटअप गाइड पूर्ण सिस्टमडी सेवा टेम्पलेट के लिए।

CAN संचार का परीक्षण करें

# Install can-utils
sudo apt install can-utils -y

# Listen for CAN packets
candump can0

# In another terminal, power on the arm and look for motor heartbeats

ROS2 एकीकरण

ओपनआर्म जहाज के साथ openarm_ros2, एक पूर्ण ros2_control-आधारित पैकेज। यह भौतिक बांह के बिना परीक्षण के लिए नकली हार्डवेयर मोड का समर्थन करता है।

ROS2 विनम्र स्थापित करें (उबंटू 22.04)

sudo apt update && sudo apt install software-properties-common curl -y
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | \
  sudo apt-key add -
sudo sh -c 'echo "deb http://packages.ros.org/ros2/ubuntu $(lsb_release -cs) main" \
  > /etc/apt/sources.list.d/ros2.list'
sudo apt update
sudo apt install ros-humble-desktop ros-humble-ros2-control \
  ros-humble-ros2-controllers ros-humble-joint-state-publisher-gui -y

क्लोन करें और openarm_ros2 बनाएं

mkdir -p ~/openarm_ws/src && cd ~/openarm_ws/src
git clone https://github.com/reazon-research/openarm_ros2.git
cd ~/openarm_ws
source /opt/ros/humble/setup.bash
colcon build --symlink-install

नकली हार्डवेयर मोड में लॉन्च करें (हाथ की आवश्यकता नहीं)

source ~/openarm_ws/install/setup.bash
ros2 launch openarm_ros2 openarm.launch.py use_fake_hardware:=true

वास्तविक हार्डवेयर के साथ लॉन्च करें

ros2 launch openarm_ros2 openarm.launch.py \
  use_fake_hardware:=false \
  can_interface:=can0

एक परीक्षण गति आदेश भेजें

ros2 topic pub /joint_trajectory_controller/joint_trajectory \
  trajectory_msgs/msg/JointTrajectory \
  '{joint_names: ["joint1"], points: [{positions: [0.5], time_from_start: {sec: 2}}]}'

देखें ROS2 नियंत्रण गाइड पूर्ण नियंत्रक कॉन्फ़िगरेशन, लॉन्च फ़ाइल विकल्प और प्रक्षेपवक्र ट्यूनिंग के लिए।

लेरोबोट एकीकरण

लेरोबोट (हगिंगफेस द्वारा) ओपनआर्म के लिए प्राथमिक डेटा संग्रह और नीति प्रशिक्षण ढांचा है। यह एपिसोड रिकॉर्डिंग, डेटासेट फ़ॉर्मेटिंग और सीधे ACT और डिफ्यूज़न पॉलिसी के साथ इंटरफेस को संभालता है।

लेरोबोट स्थापित करें

pip install lerobot

अपने रोबोट को कॉन्फ़िगर करें

OpenArm के लिए एक रोबोट कॉन्फ़िगरेशन फ़ाइल बनाएं। LeRobot YAML-आधारित रोबोट कॉन्फ़िगरेशन का उपयोग करता है:

# ~/.lerobot/robots/openarm.yaml
robot_type: openarm
can_interface: can0
num_joints: 8
camera_names:
  - wrist_cam
  - overhead_cam

एक डेटासेट रिकॉर्ड करें

python -m lerobot.scripts.control_robot \
  --robot.type=openarm \
  --control.type=record \
  --control.fps=30 \
  --control.repo_id=your-username/openarm-pick-place \
  --control.num_episodes=50 \
  --control.single_task="Pick up the red cube"

हगिंगफेस हब पर अपलोड करें

huggingface-cli login
python -m lerobot.scripts.push_dataset_to_hub \
  --repo_id=your-username/openarm-pick-place

देखें डेटा संग्रहण पृष्ठ संपूर्ण एपिसोड रिकॉर्डिंग वर्कफ़्लो और गुणवत्ता जांच के लिए।

पायथन एपीआई क्विकस्टार्ट

The openarm_can लाइब्रेरी सॉकेटकैन के माध्यम से सभी 8 जोड़ों तक सीधी निम्न-स्तरीय पहुंच प्रदान करती है। बुनियादी नियंत्रण के लिए कोई ROS2 आवश्यक नहीं है।

बुनियादी संयुक्त नियंत्रण

from openarm_can import OpenArm

# Connect to the arm
arm = OpenArm(can_interface="can0")
arm.connect()

# Enable all joints
arm.enable_all()

# Move joint 1 to 45 degrees (in radians: ~0.785)
arm.set_position(joint_id=1, position=0.785, kp=50, kd=1)

# Read current state
state = arm.get_state()
print(f"Joint positions: {state.positions}")
print(f"Joint velocities: {state.velocities}")
print(f"Joint torques: {state.torques}")

# Zero torque (safe shutdown)
arm.disable_all()
arm.disconnect()

मेरा नियंत्रण मोड

from openarm_can import OpenArm, MITCommand

arm = OpenArm(can_interface="can0")
arm.connect()
arm.enable_all()

# Send a MIT control command: position + velocity + torque feedforward
cmd = MITCommand(
    joint_id=1,
    position=0.5,      # rad
    velocity=0.0,      # rad/s
    kp=80.0,           # position gain
    kd=2.0,            # velocity gain
    torque_ff=0.0      # feedforward torque (Nm)
)
arm.send_mit_command(cmd)

arm.disable_all()
arm.disconnect()

एक लूप में सेंसर डेटा पढ़ना

import time
from openarm_can import OpenArm

arm = OpenArm(can_interface="can0", control_rate_hz=500)
arm.connect()
arm.enable_all()

for _ in range(1000):  # 2 seconds at 500 Hz
    state = arm.get_state()
    print(state.positions)
    time.sleep(1 / 500)

arm.disable_all()
arm.disconnect()

सिमुलेशन समर्थन

ओपनआर्म तीन सिमुलेशन वातावरणों का समर्थन करता है। सभी वास्तविक हार्डवेयर के साथ समान स्थिति परिभाषाएँ और एक्शन स्पेस साझा करते हैं, जिससे सिम-टू-रियल ट्रांसफर सक्षम होता है।

ROS2 नकली हार्डवेयर (अंतर्निहित - कोई इंस्टॉल नहीं)

भौतिक हाथ के बिना सॉफ़्टवेयर का परीक्षण करने का सबसे तेज़ तरीका। राज्य वास्तविक हार्डवेयर इंटरफ़ेस को प्रतिबिंबित करता है।

ros2 launch openarm_ros2 openarm.launch.py use_fake_hardware:=true

म्यूजोको

कैलिब्रेटेड भौतिकी मॉडल. नीति प्रशिक्षण और सिम-टू-रियल स्थानांतरण के लिए आदर्श।

pip install mujoco
# Clone the OpenArm MuJoCo model
git clone https://github.com/reazon-research/openarm_mujoco.git
# Run the default sim
python openarm_mujoco/examples/run_sim.py

एनवीडिया इसहाक सिम

बड़े पैमाने पर सिंथेटिक डेटा उत्पादन के लिए जीपीयू-त्वरित सिमुलेशन। NVIDIA GPU और Isaac सिम लाइसेंस की आवश्यकता है। देखना डेटा-केंद्रित प्लेटफ़ॉर्म लेख इसहाक सिम कॉन्फ़िगरेशन विवरण के लिए।

शीर्ष 3 सामान्य मुद्दे

# 1. Check if the USB adapter is detected
lsusb | grep -i "can\|serial"

# 2. Load the modules
sudo modprobe can && sudo modprobe can_raw && sudo modprobe slcan

# 3. Bring up the interface
sudo slcand -o -c -s8 /dev/ttyACM0 can0
sudo ip link set up can0

# 4. Verify
ip link show can0

# 1. Check for CAN error frames
candump can0 | grep -i "error"

# 2. Check power supply — arm requires 24V @ 150W minimum
# Voltage sag under load causes motor timeouts

# 3. Verify motor CAN IDs match your config
python3 -c "from openarm_can import OpenArm; a=OpenArm('can0'); a.scan_motors()"

# 4. Reset the arm (power cycle) and retry

# 1. Install missing packages
sudo apt install ros-humble-ros2-control \
  ros-humble-ros2-controllers \
  ros-humble-joint-state-publisher-gui -y

# 2. Rebuild the workspace
cd ~/openarm_ws && colcon build --symlink-install

# 3. Source both ROS2 and your workspace (order matters)
source /opt/ros/humble/setup.bash
source ~/openarm_ws/install/setup.bash

# 4. Retry launch
ros2 launch openarm_ros2 openarm.launch.py use_fake_hardware:=true

अभी भी अटके हुए हैं? पर पूछें ओपनआर्म फोरम या मौजूदा की जाँच करें गिटहब मुद्दे.