Guía de Configuración de OpenArm 101

Antes de comenzar

• Asegúrate de tener un espacio de trabajo claro de 1m × 1m en una superficie estable
• Ten una laptop con Ubuntu 22.04 lista (funciona VM, preferido nativo)
• Mantén el brazo alimentado apagado durante la inspección física a continuación

En la caja

Lista de verificación de inspección

• Todas las 8 articulaciones giran libremente (sin roce ni resistencia)
• El enrutamiento de cables está intacto a lo largo del cuerpo del brazo
• El conector de alimentación no está dañado
• El botón de parada de emergencia es accesible y funcional

Requisitos del sistema

• Ubuntu 22.04 LTS (recomendado) o 20.04
• Python 3.10+
• ROS2 Humble
• Adaptador USB-CAN (CANable o compatible — debe soportar CAN FD para una tasa de datos completa de 5 Mbit/s)

Paso 2a — Configuración de ID del motor

Antes de cualquier configuración de software, cada motor Damiao debe tener asignado su ID de CAN. Este es un paso único realizado en Windows utilizando el depurador USB CAN de Damiao.

Use la tabla a continuación como la asignación de ID canónica para cada articulación (J1–J8):

Paso 2b — Instalar paquetes de OpenArm

En su máquina Ubuntu, instale todos los paquetes requeridos del PPA oficial de 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

Paso 2c — Configurar la interfaz CAN (CAN FD)

Los motores OpenArm soportan tanto CAN 2.0 como CAN FD. Se recomienda CAN FD — ejecuta la fase de datos a 5 Mbit/s y soporta cargas útiles de hasta 64 bytes, requeridas para el ancho de banda completo del motor Damiao.

Recomendado — use el asistente 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

Comandos manuales de enlace ip (si no se usa el asistente):

# 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

Paso 2d — Comandos de control del motor y depuración

Use estos cansend comandos para depuración de bajo nivel. Monitoree el bus primero antes de enviar cualquier comando:

# 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

control de motor CAN 2.0 — reemplazar 001 con el ID del transmisor de la articulación objetivo de la tabla anterior:

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

control de motor CAN FD — nota la extra #1 después ## (bandera BRS):

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

Estado del LED del motor

Cada motor Damiao tiene un LED a bordo que indica el estado actual. Utiliza esto como una verificación rápida de salud después de encender:

Paso 2e — Instalar paquetes 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

Instalar el SDK de Python

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

Comienza con Hardware Falso (Seguro — Sin Movimiento Físico)

Siempre verifica en simulación antes de mover el brazo real. Ejecuta el archivo de lanzamiento con use_fake_hardware:=true — no se necesita conexión CAN:

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

Abre RViz para verificar que el brazo simulado se mueva correctamente a través de la trayectoria de prueba. Todas las 8 articulaciones deben animarse suavemente.

Cambiar a Hardware Real

Una vez que la simulación se vea correcta, conecta el adaptador CAN y enciende el brazo:

ros2 launch openarm_ros2 openarm.launch.py

Envía el Primer Comando de Movimiento (Posición de Inicio)

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

Las posiciones cero de las articulaciones deben coincidir con la realidad física para un control preciso. Las articulaciones mal calibradas causan fallos en la política más adelante — no omitas este paso.

Procedimiento de Homing

1. Enciende con el brazo en una posición segura conocida (aproximadamente extendido, alejado de obstáculos)
2. Ejecuta el script de homing:

   ros2 run openarm_ros2 homing

3. El script te pedirá que guíes manualmente cada articulación hasta su tope duro — muévete lentamente
4. Confirma que la posición cero se guarda para cada articulación cuando se te pida

Verifica la Calibración

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

Elija su Dispositivo de Operador

Conectar Dispositivo de Operador

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

Verificar Latencia

La latencia objetivo de extremo a extremo es inferior a 50 ms. Ejecute la prueba de latencia y verifique:

ros2 run openarm_ros2 latency_check

Elegir Formato de Datos

• LeRobot (recomendado) — diseñado específicamente para el aprendizaje por imitación y entrenamiento de modelos
• RLDS — compatible con Open-X-Embodiment y conjuntos de datos entre robots

Comenzar a Grabar

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

Cada episodio se guarda como un archivo independiente con estados de articulaciones, cuadros de cámara y etiquetas de acción. Ejecuta múltiples episodios, luego usa la plataforma SVRC para revisar y filtrar.

Lista de Verificación de Calidad del Episodio

• Las transmisiones de la cámara están sincronizadas (marcas de tiempo dentro de 5 ms)
• Estados de articulaciones grabados a ≥ 50 Hz
• Las etiquetas de acción coinciden con el comportamiento demostrado
• Los episodios fallidos se marcan para exclusión, no se eliminan

Modelos recomendados para OpenArm

• ACT (Transformador de Fragmentación de Acción) — mejor para pick-and-place. Predice fragmentos de acción a partir de observaciones de la cámara.
• Política de Difusión — mejor para tareas ricas en contacto. Genera trayectorias suaves a través de la eliminación de ruido.
• OpenVLA — mejor para tareas condicionadas por lenguaje. Combina la comprensión de visión-lenguaje con acciones de robot.

Ajusta finamente el ACT en tus datos

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

El entrenamiento en una GPU de consumo (RTX 3090 o mejor) generalmente toma de 2 a 4 horas para 50 episodios. Usa el --resume bandera para continuar desde un punto de control.

Desplegar en el Edge

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

El nodo de inferencia lee los fotogramas de la cámara, ejecuta el modelo y publica comandos conjuntos a la frecuencia de control. La latencia de inferencia objetivo es inferior a 20 ms para control en tiempo real.