No version for distro humble showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro kilted showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro lyrical showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro rolling showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro ardent showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro bouncy showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro crystal showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro eloquent showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro dashing showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro galactic showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro foxy showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro iron showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro lunar showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro jade showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro indigo showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro hydro showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro kinetic showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro melodic showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file

No version for distro noetic showing jazzy. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/brukg/SO-100-arm.git
VCS Type git
VCS Version main
Last Updated 2026-07-18
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

README

SO-100 Robot Arm ROS2 Package

This package provides ROS2 support for the SO-100 robot arm, available in 5-DOF configuration. It is based on the open-source 3D printable SO-ARM100 project by The Robot Studio. This implementation includes URDF models, Gazebo simulation support, and MoveIt2 integration.

The original ROS1 implementation can be found at: https://github.com/TheRobotStudio/SO-ARM100

Features

  • Robot arm URDF models
    • 5-DOF configuration with gripper
  • Gazebo Harmonic simulation support
  • ROS2 Control integration
    • Joint trajectory controller
    • Gripper action controller
  • MoveIt2 motion planning capabilities (In Progress)
    • Basic configuration generated
    • Integration with Gazebo pending
    • Motion planning testing pending

Prerequisites

ROS2 and Dependencies

  • ROS2 Humble
  • Gazebo Garden
  • MoveIt2
  • ros2_control
  • gz_ros2_control

Hardware Requirements

For using the physical robot:

  • SO-ARM-100 robot arm (5-DOF)
  • Feetech SMS/STS series servos
  • USB-to-Serial converter (CH340 chip)
  • so_arm_100_hardware package — install one of the following:

    Option A — apt (ROS 2 Jazzy):

  sudo apt install ros-jazzy-so-arm-100-hardware
  

Option B — from source:

  cd ~/ros2_ws/src
  git clone git@github.com:brukg/so_arm_100_hardware.git
  cd ~/ros2_ws
  colcon build --packages-select so_arm_100_hardware
  source install/setup.bash
  

Calibrating the Arm

The hardware interface converts servo ticks to radians. Without a calibration file it falls back to a generic (ticks − 2048)·2π/4096 mapping, which produces the wrong joint range (most visible on the gripper — RViz shows it half-open at full physical open). Calibrate before first use:

  1. Run the calibration tool and follow the prompts to record min / center / max ticks for each joint:
   ros2 run so_arm_100_hardware calibrate_arm.py
   

This writes so_arm_100_hardware/config/calibration.yaml.

  1. Make sure the hardware plugin loads it. In so_arm_100_description/ros2_control/so_arm_100_5dof_position.ros2_control.xacro, inside the real-hardware <hardware> block, add:
   <param name="calibration_file">$(find so_arm_100_hardware)/config/calibration.yaml</param>
   
  1. Rebuild and relaunch. If a joint’s range still doesn’t match the URDF after calibration, adjust the corresponding <limit> in so_arm_100_description/urdf/so_arm_100_5dof_arm.urdf.xacro (and the matching entry in so_arm_100_moveit_config/config/hardware_controllers.yaml) to match the value reported on /joint_states at the physical end-stop.

Installation

Create a ROS2 workspace (if you don’t have one)

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Clone the repository

git clone git@github.com:brukg/SO-100-arm.git

Install dependencies

cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y

Build the package

```bash colcon build –packages-select so_arm_100

File truncated at 100 lines see the full file