Configuration du logiciel

Installation de votre SDK Booster

Le SDK Booster est distribué sous la forme booster_robotics_sdk_python sur PyPI. Il fournit des liaisons Python à l'interface de contrôle réseau du K1.

Créer un environnement virtuel (recommandé)

python3 -m venv ~/.venvs/booster-k1
source ~/.venvs/booster-k1/bin/activate

Installer le SDK

pip install booster_robotics_sdk_python

Vérifier l'installation

python3 -c "import booster_robotics_sdk; print('SDK ready')"

Configuration réseau

Le K1 communique via Ethernet filaire. Configurez l'interface réseau de votre PC hôte avant de vous connecter :

# Set your PC's Ethernet interface to 192.168.10.10
sudo ip addr add 192.168.10.10/24 dev eth0
sudo ip link set eth0 up

# Verify connectivity to the K1
ping 192.168.10.102

Interface de contrôle du corps entier ROS2

Le K1 est livré avec un nœud de pont ROS2 qui expose toutes les articulations en standard ros2_control interface matérielle. Cela permet l'intégration avec MoveIt2, les planificateurs de trajectoire et les contrôleurs personnalisés.

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 le package K1 ROS2

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

Lancez le pont K1

source ~/k1_ws/install/setup.bash
ros2 launch booster_ros2 k1_bringup.launch.py \
  robot_ip:=192.168.10.102

Inspecter les états communs

# List all available topics
ros2 topic list

# Stream joint states (22 joints at 500 Hz)
ros2 topic echo /joint_states

Lire et commander les États conjoints

Le SDK Python fournit un accès direct aux 22 articulations. Commencez toujours en mode DAMP avant de commander un mouvement.

Connectez et lisez les états communs

from booster_robotics_sdk import BoosterRobot, RobotMode

# Connect to the robot
robot = BoosterRobot(ip="192.168.10.102")
robot.connect()

# Enter DAMP mode (safe, low impedance)
robot.set_mode(RobotMode.DAMP)

# Read full joint state
state = robot.get_state()
print(f"Mode: {state.mode}")
print(f"Joint positions (rad): {state.joint_positions}")
print(f"Joint velocities (rad/s): {state.joint_velocities}")
print(f"Joint torques (Nm): {state.joint_torques}")
print(f"IMU euler (deg): {state.imu_euler}")

robot.disconnect()

Positions articulaires du bras de commande (mode PERSONNALISÉ)

Le mode CUSTOM permet un contrôle direct du bras au niveau des articulations. Nécessite un dispositif de levage : le robot ne doit pas supporter son propre poids. Voir le Page de sécurité.

from booster_robotics_sdk import BoosterRobot, RobotMode, ArmCommand
import numpy as np

robot = BoosterRobot(ip="192.168.10.102")
robot.connect()

# Transition: DAMP -> PREP -> CUSTOM
robot.set_mode(RobotMode.DAMP)
robot.set_mode(RobotMode.PREP)
import time; time.sleep(3)  # Wait for PREP stabilization
robot.set_mode(RobotMode.CUSTOM)

# Command right arm to a target configuration (7 DOF)
# Joints: shoulder_pitch, shoulder_roll, shoulder_yaw,
#         elbow_pitch, wrist_pitch, wrist_roll, wrist_yaw
target = [0.0, -0.3, 0.0, 0.8, 0.0, 0.0, 0.0]
cmd = ArmCommand(side="right", joint_positions=target, kp=60, kd=2)
robot.send_arm_command(cmd)

robot.disconnect()

Contrôle de la pose de la tête

from booster_robotics_sdk import BoosterRobot, HeadCommand

robot = BoosterRobot(ip="192.168.10.102")
robot.connect()
robot.set_mode(RobotMode.PREP)

# Head: yaw in [-90, 90] deg, pitch in [-40, 30] deg
cmd = HeadCommand(yaw_deg=15.0, pitch_deg=-10.0)
robot.send_head_command(cmd)

robot.disconnect()

Bases de l'API de locomotion

Le contrôleur de locomotion du K1 gère l'équilibre et la démarche de manière autonome. Vous commandez des cibles de vitesse ; le contrôleur intégré gère la stabilité. Ayez toujours un observateur présent.

Séquence de transition de mode

from booster_robotics_sdk import BoosterRobot, RobotMode, LocomotionCommand
import time

robot = BoosterRobot(ip="192.168.10.102")
robot.connect()

# Step 1: Enter DAMP (zero torque, safe to handle)
robot.set_mode(RobotMode.DAMP)
time.sleep(1)

# Step 2: Enter PREP (stand up to PREP posture)
robot.set_mode(RobotMode.PREP)
time.sleep(5)  # Wait for full PREP stabilization — do not skip

# Step 3: Enter WALK
robot.set_mode(RobotMode.WALK)
time.sleep(2)

Locomotion commandée (mode vitesse)

# Walk forward at 0.3 m/s
cmd = LocomotionCommand(
    vx=0.3,    # forward/back (m/s), range: [-0.5, 0.5]
    vy=0.0,    # lateral (m/s),      range: [-0.3, 0.3]
    vyaw=0.0   # rotation (rad/s),   range: [-1.0, 1.0]
)
robot.send_locomotion_command(cmd)
time.sleep(2)

# Stop
robot.send_locomotion_command(LocomotionCommand(vx=0, vy=0, vyaw=0))
time.sleep(1)

# Return to PREP then DAMP
robot.set_mode(RobotMode.PREP)
time.sleep(3)
robot.set_mode(RobotMode.DAMP)
robot.disconnect()

Arrêt d'urgence dans le logiciel

# Call from any thread — immediately enters DAMP mode
robot.emergency_stop()

Préférez toujours le bouton d’arrêt d’urgence matériel en cas d’urgence. Le logiciel e-stop est uniquement une sauvegarde.

Simulation humanoïde MuJoCo

Le modèle K1 URDF est inclus dans le SDK. Utilisez MuJoCo pour développer et tester des politiques de locomotion et de manipulation avant le déploiement du matériel.

Installer MuJoCo

pip install mujoco

Cloner l'environnement du gymnase K1

git clone https://github.com/BoosterRobotics/booster_gym.git
cd booster_gym
pip install -e .

Exécutez la simulation de marche

python examples/walk_sim.py --render

Isaac Sim (avancé)

NVIDIA Isaac Sim fournit une simulation parallèle accélérée par GPU pour la formation aux politiques à grande échelle. Le K1 URDF s'importe proprement dans Isaac Sim 4.x. Nécessite un GPU NVIDIA (16 Go de VRAM recommandé) et une licence Isaac Sim. Voir le Article de comparaison humanoïde pour les tests de simulation.

Les 3 principaux problèmes liés à la configuration humanoïde

# 1. Verify your PC's interface is on the correct subnet
ip addr show eth0
# Should show 192.168.10.10/24

# 2. Set it if not configured
sudo ip addr flush dev eth0
sudo ip addr add 192.168.10.10/24 dev eth0
sudo ip link set eth0 up

# 3. Ping the robot
ping -c 4 192.168.10.102

# 4. If ping fails, verify the K1 is fully booted
# The K1 takes ~60 seconds to boot. Look for the LED sequence
# to complete before attempting connection.

# Always wait at least 5 seconds in PREP before WALK
robot.set_mode(RobotMode.PREP)
time.sleep(5)  # Do not reduce this

# Verify PREP is fully active before proceeding
state = robot.get_state()
assert state.mode == RobotMode.PREP, "PREP not confirmed"

# Have your spotter positioned with the e-stop
robot.set_mode(RobotMode.WALK)

# 1. Install missing ros2_control packages
sudo apt install ros-humble-ros2-control \
  ros-humble-ros2-controllers -y

# 2. Rebuild the workspace
cd ~/k1_ws && colcon build --symlink-install

# 3. Source both ROS2 and your workspace
source /opt/ros/humble/setup.bash
source ~/k1_ws/install/setup.bash

# 4. Verify robot_ip matches actual K1 IP
ros2 launch booster_ros2 k1_bringup.launch.py \
  robot_ip:=192.168.10.102

# 5. Check the K1 is connected and responding
ping 192.168.10.102

Toujours bloqué ? Publier dans le Forum SVRC avec votre version Ubuntu, le message d'erreur exact et la version du SDK (pip show booster_robotics_sdk_python).