Software-Setup

SDK-Installation

Das OpenArm SDK wird als verteilt roboticscenter Python-Paket. Es beinhaltet openarm_can (die Low-Level-CAN-Schnittstellenbibliothek) und alle unterstützenden Dienstprogramme.

Erstellen Sie eine virtuelle Umgebung (empfohlen)

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

Installieren Sie das SDK

pip install roboticscenter

Überprüfen Sie die Installation

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

Sie sollten eine Versionszeichenfolge sehen. Wenn Sie einen Importfehler sehen, lesen Sie die Abschnitt zur Fehlerbehebung.

Von der Quelle installieren (optional)

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

SocketCAN-Treiber-Setup

OpenArm kommuniziert über den CAN-Bus mit SocketCAN – einem Linux-Kernel-Subsystem. Die Treiber sind bereits im Kernel; Sie müssen lediglich die Module laden und die Schnittstelle aufrufen.

Laden Sie Kernelmodule

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

Rufen Sie die CAN-Schnittstelle auf

Für den mitgelieferten CANable 2.0 USB-Adapter:

# 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

Stellen Sie sicher, dass die Schnittstelle aktiv ist

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

Sorgen Sie dafür, dass es über Neustarts hinweg dauerhaft bleibt

Erstellen Sie einen systemd-Dienst oder fügen Sie ihn hinzu /etc/rc.local. Siehe die SocketCAN-Setup-Anleitung für eine vollständige systemd-Dienstvorlage.

CAN-Kommunikation testen

# 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-Integration

OpenArm wird mit geliefert openarm_ros2, ein vollständiges ros2_control-basiertes Paket. Es unterstützt den Fake-Hardware-Modus zum Testen ohne den physischen Arm.

Installieren Sie ROS2 Humble (Ubuntu 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

Klonen und erstellen Sie 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

Starten Sie im Fake-Hardware-Modus (kein Arm erforderlich)

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

Starten Sie mit echter Hardware

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

Senden Sie einen Testbewegungsbefehl

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

Siehe die ROS2-Steuerungshandbuch für vollständige Controller-Konfiguration, Startdateioptionen und Flugbahnoptimierung.

LeRobot-Integration

LeRobot (von HuggingFace) ist das primäre Datenerfassungs- und Richtlinienschulungs-Framework für OpenArm. Es übernimmt die Aufzeichnung von Episoden, die Formatierung von Datensätzen und ist direkt mit ACT und Diffusion Policy verbunden.

Installieren Sie LeRobot

pip install lerobot

Konfigurieren Sie Ihren Roboter

Erstellen Sie eine Roboterkonfigurationsdatei für OpenArm. LeRobot verwendet eine YAML-basierte Roboterkonfiguration:

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

Zeichnen Sie einen Datensatz auf

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"

Auf HuggingFace Hub hochladen

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

Siehe die Seite zur Datenerfassung für den gesamten Episodenaufzeichnungs-Workflow und Qualitätsprüfungen.

Python-API-Schnellstart

Der openarm_can Die Bibliothek bietet direkten Low-Level-Zugriff auf alle 8 Gelenke über SocketCAN. Für die Grundsteuerung ist kein ROS2 erforderlich.

Grundlegende gemeinsame Kontrolle

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

MEIN Steuermodus

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

Sensordaten in einer Schleife auslesen

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

Simulationsunterstützung

OpenArm unterstützt drei Simulationsumgebungen. Alle teilen identische Zustandsdefinitionen und Aktionsräume mit der realen Hardware und ermöglichen so eine Übertragung von der Simulation zur Realität.

ROS2 Fake Hardware (integriert – keine Installation)

Der schnellste Weg, Software ohne den physischen Arm zu testen. Der Status spiegelt die reale Hardwareschnittstelle wider.

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

MuJoCo

Kalibriertes Physikmodell. Ideal für Richtlinienschulungen und Simulation-zu-Realität-Übertragung.

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 Isaac Sim

GPU-beschleunigte Simulation für die Generierung synthetischer Daten in großem Maßstab. Erfordert eine NVIDIA-GPU und eine Isaac-Sim-Lizenz. Sehen Der Artikel zur datenzentrierten Plattform für Isaac Sim-Konfigurationsdetails.

Die drei häufigsten Probleme

# 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

Stecken Sie immer noch fest? Fragen Sie auf der OpenArm-Forum oder vorhandene prüfen GitHub-Probleme.