Software Setup

Booster SDK Installation

The Booster SDK is distributed as booster_robotics_sdk_python on PyPI. It provides Python bindings to the K1's network control interface.

Create a virtual environment (recommended)

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

Install the SDK

pip install booster_robotics_sdk_python

Verify the installation

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

Network configuration

The K1 communicates over wired Ethernet. Configure your host PC's network interface before connecting:

# 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

ROS2 Whole-Body Control Interface

The K1 ships with a ROS2 bridge node that exposes all joints as a standard ros2_control hardware interface. This enables integration with MoveIt2, trajectory planners, and custom controllers.

Install 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

Clone and build the K1 ROS2 package

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

Launch the K1 bridge

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

Inspect joint states

# List all available topics
ros2 topic list

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

Reading and Commanding Joint States

The Python SDK provides direct access to all 22 joints. Always start in DAMP mode before commanding motion.

Connect and read joint states

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

Command arm joint positions (CUSTOM mode)

CUSTOM mode allows direct joint-level control of the arm. Requires a lifting fixture — the robot must not be supporting its own weight. See the Safety page.

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

Head pose control

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

Locomotion API Basics

The K1's locomotion controller manages balance and gait autonomously. You command velocity targets; the onboard controller handles stability. Always have a spotter present.

Mode transition sequence

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)

Command locomotion (velocity mode)

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

Emergency stop in software

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

Always prefer the hardware e-stop button for emergencies. The software e-stop is a backup only.

MuJoCo Humanoid Simulation

The K1 URDF model is included in the SDK. Use MuJoCo to develop and test locomotion and manipulation policies before hardware deployment.

Install MuJoCo

pip install mujoco

Clone the K1 gym environment

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

Run the walking simulation

python examples/walk_sim.py --render

Isaac Sim (advanced)

NVIDIA Isaac Sim provides GPU-accelerated parallel simulation for large-scale policy training. The K1 URDF imports cleanly into Isaac Sim 4.x. Requires an NVIDIA GPU (16 GB VRAM recommended) and Isaac Sim license. See the Humanoid Comparison article for simulation benchmarks.

Top 3 Issues for Humanoid Setup

# 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

Still stuck? Post in the SVRC Forum with your Ubuntu version, exact error message, and SDK version (pip show booster_robotics_sdk_python).