Configuration du logiciel

Installation de votre SDK

Le SDK LinkerBot O6 fournit des liaisons Python à l'interface de bus CAN du bras. Il est inclus dans le package de la plateforme RoboticsCenter.

Créer un environnement virtuel (recommandé)

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

Installer le SDK

pip install roboticscenter

Vérifier l'installation

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

Installer à partir des sources (facultatif)

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

Configuration du pilote CAN

Le LinkerBot O6 utilise la même architecture SocketCAN que l'OpenArm 101. Si vous avez configuré CAN pour OpenArm, ce processus est identique. Les pilotes de bus CAN sont intégrés au noyau Linux.

Charger les modules du noyau

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

Afficher l'interface 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

Vérifiez que l'interface est active

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

Testeur de communication CAN

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

Rendre persistant lors des redémarrages

Créez un service systemd ou ajoutez-le à /etc/rc.local. Voir le Guide de configuration de SocketCAN — la procédure est identique pour l'O6.

Configuration du contrôleur ROS2

Le linkerbot_ros2 Le package fournit une interface matérielle ros2_control complète pour l'O6. Il inclut un faux mode matériel pour tester sans le bras.

Installateur ROS2 humble

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

Cloner et créer 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

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

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

Lancez-vous avec du vrai matériel

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

Vérifier les états communs

ros2 topic echo /joint_states

Intégration LeRobot pour O6

LeRobot prend en charge nativement le LinkerBot O6. Configurez votre type de robot et suivez le flux de travail standard LeRobot pour l'enregistrement et la formation.

Installer LeRobot

pip install lerobot

Configurez votre robot O6

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

Enregistrer un ensemble de données

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"

Télécharger sur le hub HuggingFace

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

Voir le Page de collecte de données pour le flux de travail complet, y compris les contrôles de qualité.

Exemples d'API Python

Le SDK LinkerBot Python fournit un contrôle conjoint direct sans nécessiter ROS2. Même modèle que le SDK OpenArm.

Contrôle conjoint de base

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

Lire toutes les articulations dans une boucle de contrôle

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

Exécution de trajectoire

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

Les 3 principaux problèmes courants

# 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

Toujours bloqué ? Publier dans le Forum SVRC ou visitez le WikiO6.