Guide de configuration d'OpenArm 101

Avant de commencer

• Assurez-vous de disposer d'un espace de travail dégagé de 1 m × 1 m sur une surface stable
• Avoir un ordinateur portable avec Ubuntu 22.04 prêt (la VM fonctionne, natif préféré)
• Gardez le bras alimenté désactivé lors de l'inspection physique ci-dessous

Dans la boîte

Liste de contrôle d'inspection

• Les 8 joints tournent librement (pas de meulage ni de résistance)
• Le cheminement des câbles est intact le long du corps du bras
• Le connecteur d'alimentation n'est pas endommagé
• L'arrêt d'urgence est accessible et fonctionnel

Configuration système requise

• Ubuntu 22.04 LTS (recommandé) ou 20.04
• Python3.10+
• ROS2 Humble
• Adaptateur USB-CAN (CANable ou compatible — doit prendre en charge CAN FD pour un débit de données complet de 5 Mbit/s)

Étape 2a — Configuration de l'ID du moteur

Avant toute configuration logicielle, chaque moteur Damiao doit se voir attribuer son CAN ID. Il s'agit d'une étape unique effectuée sous Windows à l'aide du débogueur Damiao USB CAN.

Utilisez le tableau ci-dessous comme attribution d’ID canonique pour chaque articulation (J1 à J8) :

Étape 2b - Installer les packages OpenArm

Sur votre machine Ubuntu, installez tous les packages requis à partir du PPA officiel d'OpenArm :

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

Étape 2c - Configurer l'interface CAN (CAN FD)

Les moteurs OpenArm prennent en charge CAN 2.0 et CAN FD. CAN FD est recommandé — il exécute la phase de données à 5 Mbit/s et prend en charge jusqu'à 64 octets de charges utiles, nécessaires à la bande passante complète du moteur Damiao.

Recommandé : utilisez l'assistant OpenArm :

# 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

Commandes manuelles ip link (si vous n'utilisez pas l'assistant) :

# 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

Étape 2d — Commandes de contrôle du moteur et débogage

Utilisez-les cansend commandes pour le débogage de bas niveau. Surveillez d'abord le bus avant d'envoyer des commandes :

# 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

Contrôle moteur CAN 2.0 - remplacer 001 avec l'ID de l'émetteur de l'articulation cible indiqué dans le tableau ci-dessus :

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

Commande moteur CAN FD — notez le supplément #1 après ## (Drapeau BRS) :

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

État du voyant du moteur

Chaque moteur Damiao dispose d'une LED intégrée indiquant l'état actuel. Utilisez-le comme un contrôle de santé rapide après la mise sous tension :

Étape 2e — Installer les packages ROS2

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

Installer le SDK Python

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

Commencez avec du faux matériel (sûr – aucun mouvement physique)

Vérifiez toujours en simulation avant de déplacer le bras réel. Exécutez le fichier de lancement avec use_fake_hardware:=true — aucune connexion CAN nécessaire :

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

Ouvrez RViz pour vérifier que le bras simulé se déplace correctement sur la trajectoire de test. Les 8 articulations doivent s’animer de manière fluide.

Passer au vrai matériel

Une fois que la simulation semble correcte, branchez l'adaptateur CAN et allumez le bras :

ros2 launch openarm_ros2 openarm.launch.py

Envoyer la première commande de mouvement (position d'origine)

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

Les positions zéro communes doivent correspondre à la réalité physique pour un contrôle précis. Des joints mal calibrés entraînent des échecs politiques en aval – ne sautez pas cette étape.

Procédure de référencement

1. Allumez avec le bras dans une position sûre connue (à peu près étendu, loin des obstacles)
2. Exécutez le script de référencement :

   ros2 run openarm_ros2 homing

3. Le script vous demandera de guider manuellement chaque articulation jusqu'à sa butée – déplacez-vous lentement
4. Confirmez que la position zéro est enregistrée pour chaque articulation lorsque vous y êtes invité.

Vérifier l'étalonnage

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

Choisissez votre appareil opérateur

Connecter le périphérique de l'opérateur

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

Vérifier la latence

La latence cible de bout en bout est inférieure à 50 ms. Exécutez le test de latence et vérifiez :

ros2 run openarm_ros2 latency_check

Choisissez le format des données

• LeRobot (recommandé) - spécialement conçu pour l'apprentissage par imitation et la formation de modèles
• RLDS — compatible avec les ensembles de données Open-X-Embodiment et cross-robot

Commencer l'enregistrement

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

Chaque épisode est enregistré sous forme de fichier autonome avec les états communs, les images de caméra et les étiquettes d'action. Exécutez plusieurs épisodes, puis utilisez la plateforme SVRC pour examiner et filtrer.

Liste de contrôle de la qualité des épisodes

• Les flux de la caméra sont synchronisés (horodatages dans les 5 ms)
• États articulaires enregistrés à ≥ 50 Hz
• Les étiquettes d'action correspondent au comportement démontré
• Les épisodes ayant échoué sont marqués pour exclusion et non supprimés

Modèles recommandés pour OpenArm

• ACT (Transformateur de fragmentation d'action) - idéal pour le pick-and-place. Prédit les séquences d'action à partir des observations de la caméra.
• Politique de diffusion – idéal pour les tâches riches en contacts. Génère des trajectoires fluides via le débruitage.
• OuvertVLA – idéal pour les tâches conditionnées par le langage. Combine la compréhension du langage visuel avec les actions du robot.

Affinez ACT sur vos données

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

La formation sur un GPU grand public (RTX 3090 ou supérieur) prend généralement 2 à 4 heures pour 50 épisodes. Utilisez le --resume drapeau pour continuer à partir d'un point de contrôle.

Déployer sur Edge

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

Le nœud d'inférence lit les images de la caméra, exécute le modèle et publie des commandes conjointes à une fréquence de contrôle. La latence d'inférence cible est inférieure à 20 ms pour un contrôle en temps réel.