Configuration du logiciel

Installation de votre SDK

Le SDK OpenArm est distribué en tant que roboticscenter Paquet Python. Il comprend openarm_can (la bibliothèque d'interface CAN de bas niveau) et tous les utilitaires de support.

Créer un environnement virtuel (recommandé)

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

Installer le SDK

pip install roboticscenter

Vérifier l'installation

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

Vous devriez voir une chaîne de version. Si vous voyez une erreur d'importation, consultez le Section Dépannage.

Installer à partir des sources (facultatif)

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

Configuration du pilote SocketCAN

OpenArm communique via le bus CAN à l'aide de SocketCAN, un sous-système du noyau Linux. Les pilotes sont déjà dans le noyau ; il vous suffit de charger les modules et d'afficher l'interface.

Charger les modules du noyau

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

Afficher l'interface CAN

Pour l'adaptateur USB CANable 2.0 inclus :

# 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

Vérifiez que l'interface est active

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

Rendre persistant lors des redémarrages

Créez un service systemd ou ajoutez-le à /etc/rc.local. Voir le Guide de configuration de SocketCAN pour un modèle de service systemd complet.

Testeur de communication 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

Intégration ROS2

OpenArm est livré avec openarm_ros2, un package complet basé sur ros2_control. Il prend en charge le mode matériel factice pour les tests sans bras physique.

Installateur 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

Cloner et construire 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

Lancement en mode matériel factice (aucun bras requis)

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

Lancez-vous avec du vrai matériel

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

Envoyer une commande de mouvement de test

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

Voir le Guide de contrôle ROS2 pour la configuration complète du contrôleur, les options du fichier de lancement et le réglage de la trajectoire.

Intégration LeRobot

LeRobot (par HuggingFace) est le principal cadre de collecte de données et de formation aux politiques pour OpenArm. Il gère l'enregistrement des épisodes, le formatage des ensembles de données et s'interface directement avec ACT et Diffusion Policy.

Installer LeRobot

pip install lerobot

Configurez votre robot

Créez un fichier de configuration de robot pour OpenArm. LeRobot utilise une configuration de robot basée sur YAML :

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

Enregistrer un ensemble de données

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"

Télécharger sur le hub HuggingFace

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

Voir le Page de collecte de données pour le flux de travail d'enregistrement complet de l'épisode et les contrôles de qualité.

Démarrage rapide de l'API Python

Le openarm_can La bibliothèque fournit un accès direct de bas niveau aux 8 articulations via SocketCAN. Aucun ROS2 requis pour le contrôle de base.

Contrôle conjoint de base

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

MON mode de contrôle

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

Lecture des données du capteur en boucle

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

Prise en charge des simulations

OpenArm prend en charge trois environnements de simulation. Tous partagent des définitions d'état et des espaces d'action identiques avec le matériel réel, permettant un transfert de simulation à réel.

ROS2 Fake Hardware (intégré - pas d'installation)

Le moyen le plus rapide de tester des logiciels sans le bras physique. L'état reflète la véritable interface matérielle.

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

MuJoCo

Modèle physique calibré. Idéal pour la formation aux politiques et le transfert de simulation vers réel.

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

Simulation accélérée par GPU pour la génération de données synthétiques à grande échelle. Nécessite un GPU NVIDIA et une licence Isaac Sim. Voir l'article sur la plateforme centrée sur les données pour les détails de configuration d'Isaac Sim.

Les 3 principaux problèmes courants

# 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

Toujours bloqué ? Demandez sur le Forum OpenArm ou vérifiez existant Problèmes GitHub.