Configuración del software

Instalación del SDK

El SDK de LinkerBot O6 proporciona enlaces de Python a la interfaz del bus CAN del brazo. Está incluido en el paquete de la plataforma RoboticsCenter.

Crea un entorno virtual (recomendado)

python3 -m venv ~/.venvs/linkerbot-o6
source ~/.venvs/linkerbot-o6/bin/activate

Instala el SDK

pip install roboticscenter

Verifica la instalación

python3 -c "from linkerbot import LinkerBotO6; print('SDK ready')"

Instalar desde el código fuente (opcional)

git clone https://github.com/linkerbot/linkerbot_sdk.git
cd linkerbot_sdk
pip install -e .

Configuración del controlador CAN

El LinkerBot O6 utiliza la misma arquitectura SocketCAN que el OpenArm 101. Si has configurado CAN para OpenArm, este proceso es idéntico. Los controladores del bus CAN están integrados en el núcleo de Linux.

Cargar módulos del núcleo

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

Activa la interfaz CAN

# Find the USB serial device
ls /dev/ttyACM*

# Bring up CAN interface at 1 Mbps
sudo slcand -o -c -s8 /dev/ttyACM0 can0
sudo ip link set up can0

Verificar que la interfaz esté activa

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

Probar la comunicación CAN

sudo apt install can-utils -y
candump can0
# Power on the O6 and look for motor heartbeat packets

Hacer persistente entre reinicios

Crear un servicio systemd o agregar a /etc/rc.localVer el Guía de configuración de SocketCAN — el procedimiento es idéntico para el O6.

Configuración del controlador ROS2

La linkerbot_ros2 El paquete proporciona una interfaz de hardware ros2_control completa para el O6. Incluye un modo de hardware falso para pruebas sin el brazo.

Instalada ROS2 Humilde

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 jammy 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

Clonar y construir linkerbot_ros2

mkdir -p ~/o6_ws/src && cd ~/o6_ws/src
git clone https://github.com/linkerbot/linkerbot_ros2.git
cd ~/o6_ws
source /opt/ros/humble/setup.bash
colcon build --symlink-install

Lanzar en modo de hardware falso (no se requiere brazo)

source ~/o6_ws/install/setup.bash
ros2 launch linkerbot_ros2 o6.launch.py use_fake_hardware:=true

Lanzar con hardware real

ros2 launch linkerbot_ros2 o6.launch.py \
  use_fake_hardware:=false \
  can_interface:=can0

Verificar estados de las articulaciones

ros2 topic echo /joint_states

Integración de LeRobot para O6

LeRobot soporta LinkerBot O6 de forma nativa. Configura tu tipo de robot y sigue el flujo de trabajo estándar de LeRobot para grabación y entrenamiento.

Instalar LeRobot

pip install lerobot

Configuras el robot O6

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

Grabar un conjunto de datos

python -m lerobot.scripts.control_robot \
  --robot.type=linkerbot_o6 \
  --control.type=record \
  --control.fps=30 \
  --control.repo_id=your-username/o6-pick-place \
  --control.num_episodes=50 \
  --control.single_task="Pick up the red cube"

Subir al HuggingFace Hub

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

Ver el Página de recolección de datos para el flujo de trabajo completo incluyendo controles de calidad.

Ejemplos de API de Python

El SDK de Python de LinkerBot proporciona control directo de las articulaciones sin requerir ROS2. Mismo patrón que el SDK de OpenArm.

Control básico de articulaciones

from linkerbot import LinkerBotO6

# Connect to the arm
arm = LinkerBotO6(can_interface="can0")
arm.connect()
arm.enable_all()

# Move joint 1 to 45 degrees (0.785 rad)
arm.set_position(joint_id=1, position=0.785, kp=50, kd=1)

# Read current state
state = arm.get_state()
print(f"Positions (rad): {state.positions}")
print(f"Velocities (rad/s): {state.velocities}")
print(f"Torques (Nm): {state.torques}")

# Safe shutdown
arm.disable_all()
arm.disconnect()

Leer todas las articulaciones en un bucle de control

import time
from linkerbot import LinkerBotO6

arm = LinkerBotO6(can_interface="can0", control_rate_hz=500)
arm.connect()
arm.enable_all()

for _ in range(500):  # 1 second at 500 Hz
    state = arm.get_state()
    print(state.positions)
    time.sleep(1 / 500)

arm.disable_all()
arm.disconnect()

Ejecución de trayectorias

from linkerbot import LinkerBotO6, JointTrajectory
import numpy as np

arm = LinkerBotO6(can_interface="can0")
arm.connect()
arm.enable_all()

# Define a waypoint trajectory
waypoints = [
    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    [0.5, -0.3, 0.8, 0.0, 0.4, 0.0],
    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
]
durations = [2.0, 2.0, 2.0]  # seconds per segment

traj = JointTrajectory(waypoints=waypoints, durations=durations)
arm.execute_trajectory(traj)

arm.disable_all()
arm.disconnect()

3 problemas comunes principales

# 1. Verify USB adapter is detected
lsusb | grep -i "can\|serial"

# 2. Load the kernel 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 — O6 requires 24V @ 150W minimum

# 3. Scan for motors and verify IDs
python3 -c "from linkerbot import LinkerBotO6; a=LinkerBotO6('can0'); a.scan_motors()"

# 4. Power cycle the arm and retry

# 1. Verify CAN interface is up before starting LeRobot
ip link show can0

# 2. Verify config file path and format
cat ~/.lerobot/robots/linkerbot_o6.yaml

# 3. Test direct SDK connection first
python3 -c "
from linkerbot import LinkerBotO6
a = LinkerBotO6(can_interface='can0')
a.connect()
print('Connected:', a.get_state())
a.disconnect()"

# 4. Then retry LeRobot
python -m lerobot.scripts.control_robot \
  --robot.type=linkerbot_o6 \
  --control.type=teleoperate

¿Aún atascado? Publica en el Foro SVRC o visite el Wiki O6.