OpenArm 101-Setup-Anleitung

Bevor Sie beginnen

• Stellen Sie sicher, dass Sie einen freien Arbeitsbereich von 1 m × 1 m auf einer stabilen Oberfläche haben
• Halten Sie einen Laptop mit Ubuntu 22.04 bereit (VM funktioniert, nativ bevorzugt)
• Halten Sie den Arm mit Strom versorgt aus während der körperlichen Inspektion unten

In der Box

Inspektions-Checkliste

• Alle 8 Gelenke drehen sich frei (kein Schleifen oder Widerstand)
• Die Kabelführung entlang des Armkörpers ist intakt
• Der Stromanschluss ist unbeschädigt
• Der Not-Aus-Schalter ist zugänglich und funktionsfähig

Systemanforderungen

• Ubuntu 22.04 LTS (empfohlen) oder 20.04
• Python 3.10+
• ROS2 Bescheiden
• USB-CAN-Adapter (CAN-fähig oder kompatibel – muss CAN FD für die volle Datenrate von 5 Mbit/s unterstützen)

Schritt 2a – Motor-ID-Konfiguration

Vor jedem Software-Setup muss jedem Damiao-Motor seine CAN-ID zugewiesen werden. Dies ist ein einmaliger Schritt, der unter Windows mit dem Damiao USB CAN Debugger ausgeführt wird.

Verwenden Sie die folgende Tabelle als kanonische ID-Zuweisung für jedes Gelenk (J1–J8):

Schritt 2b – OpenArm-Pakete installieren

Installieren Sie auf Ihrem Ubuntu-Rechner alle erforderlichen Pakete vom offiziellen OpenArm PPA:

sudo apt install -y software-properties-common
sudo add-apt-repository -y ppa:openarm/main
sudo apt update
sudo apt install -y \
  can-utils \
  iproute2 \
  libeigen3-dev \
  libopenarm-can-dev \
  liborocos-kdl-dev \
  liburdfdom-dev \
  liburdfdom-headers-dev \
  libyaml-cpp-dev \
  openarm-can-utils

Schritt 2c – Einrichten der CAN-Schnittstelle (CAN FD)

OpenArm-Motoren unterstützen sowohl CAN 2.0 als auch CAN FD. CAN FD wird empfohlen — Es führt die Datenphase mit 5 Mbit/s aus und unterstützt bis zu 64 Byte Nutzdaten, die für die volle Bandbreite des Damiao-Motors erforderlich sind.

Empfohlen – verwenden Sie den OpenArm-Helfer:

# CAN FD, 1M nominal / 5M data (recommended for single arm)
openarm-can-configure-socketcan can0 -fd -b 1000000 -d 5000000

# CAN 2.0 fallback (1M baud, no FD)
openarm-can-configure-socketcan can0

# 4-arm bimanual setup (can0–can3)
openarm-can-configure-socketcan-4-arms -fd

# Verify the interface is UP
ip link show can0

Manuelle IP-Link-Befehle (wenn Sie den Helfer nicht verwenden):

# CAN 2.0
sudo ip link set can0 down
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

# CAN FD — 1M nominal / 5M data
sudo ip link set can0 down
sudo ip link set can0 type can bitrate 1000000 dbitrate 5000000 fd on
sudo ip link set can0 up

Schritt 2d – Motorsteuerungsbefehle und Debugging

Nutzen Sie diese cansend Befehle für Low-Level-Debugging. Überwachen Sie zunächst den Bus, bevor Sie Befehle senden:

# Monitor all CAN frames
candump -x can0

# Change motor baudrate (replace 1 with target motor CAN ID)
openarm-can-change-baudrate --baudrate 5000000 --canid 1 --socketcan can0
# Persist across power cycles (max ~10,000 flash writes per motor — use sparingly)
openarm-can-change-baudrate --baudrate 5000000 --canid 1 --socketcan can0 --flash

CAN 2.0 Motorsteuerung - ersetzen 001 mit der Sender-ID des Zielgelenks aus der Tabelle oben:

# Clear motor error
cansend can0 001#FFFFFFFFFFFFFFFB
# Enable motor
cansend can0 001#FFFFFFFFFFFFFFFC
# Disable motor
cansend can0 001#FFFFFFFFFFFFFFFD

CAN-FD-Motorsteuerung – Beachten Sie das Extra #1 nach ## (BRS-Flagge):

# Clear motor error
cansend can0 001##1FFFFFFFFFFFFFFFB
# Enable motor
cansend can0 001##1FFFFFFFFFFFFFFFC
# Disable motor
cansend can0 001##1FFFFFFFFFFFFFFFD

Motor-LED-Status

Jeder Damiao-Motor verfügt über eine integrierte LED, die den aktuellen Status anzeigt. Verwenden Sie dies als schnellen Gesundheitscheck nach dem Einschalten:

Schritt 2e – ROS2-Pakete installieren

sudo apt install ros-humble-ros2-control ros-humble-ros2-controllers
git clone https://github.com/enactic/openarm_ros2
cd openarm_ros2 && colcon build

Installieren Sie das Python SDK

pip install roboticscenter
python -c "import roboticscenter; print('SDK ready')"

Beginnen Sie mit gefälschter Hardware (sicher – keine physische Bewegung)

Überprüfen Sie dies immer in der Simulation, bevor Sie den realen Arm bewegen. Führen Sie die Startdatei mit aus use_fake_hardware:=true — keine CAN-Verbindung erforderlich:

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

Öffnen Sie RViz, um zu überprüfen, ob sich der simulierte Arm korrekt durch die Testbahn bewegt. Alle 8 Gelenke sollten reibungslos animieren.

Wechseln Sie zu echter Hardware

Sobald die Simulation korrekt aussieht, schließen Sie den CAN-Adapter an und schalten Sie den Arm ein:

ros2 launch openarm_ros2 openarm.launch.py

Ersten Bewegungsbefehl senden (Ausgangsposition)

ros2 action send_goal /joint_trajectory_controller/follow_joint_trajectory \
  control_msgs/action/FollowJointTrajectory "{...}"

Für eine genaue Steuerung müssen die Nullpositionen der Gelenke mit der physikalischen Realität übereinstimmen. Falsch kalibrierte Verbindungen verursachen nachgelagerte Richtlinienverstöße – überspringen Sie diesen Schritt nicht.

Homing-Vorgang

1. Schalten Sie das Gerät ein, während sich der Arm in einer bekannten sicheren Position befindet (ungefähr ausgestreckt, entfernt von Hindernissen).
2. Führen Sie das Homing-Skript aus:

   ros2 run openarm_ros2 homing

3. Das Skript fordert Sie auf, jedes Gelenk manuell bis zum Anschlag zu führen – bewegen Sie sich also langsam
4. Bestätigen Sie, dass die Nullposition für jedes Gelenk gespeichert wird, wenn Sie dazu aufgefordert werden

Kalibrierung überprüfen

ros2 topic echo /joint_states  # check all positions read near zero

Wählen Sie Ihr Bediengerät

Bediengerät anschließen

ros2 launch openarm_ros2 teleop.launch.py operator:=wuji_hand

Überprüfen Sie die Latenz

Die angestrebte End-to-End-Latenz liegt unter 50 ms. Führen Sie den Latenztest durch und überprüfen Sie Folgendes:

ros2 run openarm_ros2 latency_check

Wählen Sie Datenformat

• LeRobot (empfohlen) – speziell für Nachahmungslernen und Modelltraining entwickelt
• RLDS – kompatibel mit Open-X-Embodiment und roboterübergreifenden Datensätzen

Starten Sie die Aufnahme

ros2 launch openarm_ros2 record.launch.py \
  output_format:=lerobot \
  task_name:=pick_and_place \
  episode_id:=0

Jede Episode wird als eigenständige Datei mit Gelenkzuständen, Kamerabildern und Aktionsbezeichnungen gespeichert. Führen Sie mehrere Episoden aus und verwenden Sie dann die SVRC-Plattform zum Überprüfen und Filtern.

Checkliste für die Episodenqualität

• Kamera-Feeds werden synchronisiert (Zeitstempel innerhalb von 5 ms)
• Gelenkzustände werden bei ≥ 50 Hz aufgezeichnet
• Aktionsbezeichnungen stimmen mit demonstriertem Verhalten überein
• Fehlgeschlagene Episoden werden zum Ausschluss markiert und nicht gelöscht

Empfohlene Modelle für OpenArm

• ACT (Action Chunking Transformer) – am besten für Pick-and-Place geeignet. Prognostiziert Aktionsblöcke aus Kamerabeobachtungen.
• Verbreitungspolitik — am besten für kontaktreiche Aufgaben geeignet. Erzeugt glatte Flugbahnen durch Rauschunterdrückung.
• OpenVLA – am besten für sprachbedingte Aufgaben geeignet. Kombiniert Vision-Sprachverständnis mit Roboteraktionen.

Optimieren Sie ACT anhand Ihrer Daten

pip install lerobot
python train.py --config act_openarm --data-path ./recordings/

Das Training auf einer Consumer-GPU (RTX 3090 oder besser) dauert normalerweise 2–4 Stunden für 50 Episoden. Benutzen Sie die --resume Flagge, um von einem Kontrollpunkt aus fortzufahren.

Auf Edge bereitstellen

ros2 launch openarm_ros2 inference.launch.py \
  model_path:=./checkpoints/best.pt

Der Inferenzknoten liest Kamerabilder, führt das Modell aus und veröffentlicht gemeinsame Befehle mit der Steuerfrequenz. Die Latenz der Zielinferenz beträgt für die Echtzeitsteuerung weniger als 20 ms.