Flexiv Robots#

Set Up Flexiv Robot#

  1. Complete the hardware setup and boot up the robot by following the Set Up the Robot guide in the Flexiv RDK documentation.

  2. Connect the UI tablet (teach pendant) and verify you can enable the robot using Flexiv Elements.

  3. Activate the RDK Server on the robot.

  4. Enter Remote mode by setting the robot to Auto (Remote) mode on the teach pendant.

  5. Connect the user computer to the same network as the robot and verify connectivity.

  6. Note the robot serial number (e.g., Rizon4s-062839). This is required for all launch commands and should be substituted for <ROBOT_SN> in the instructions below.

Note

The following Flexiv Rizon models have been tested with Isaac ROS Manipulation:

  • Rizon 4s with Grav gripper (Flexiv-GN01)

The following software versions have been tested:

  • Flexiv Software Package: v3.11

  • Flexiv Elements Studio: v3.11

Other versions may work but have not been verified.

Build Flexiv Drivers from Source#

This section describes how to build the Flexiv ROS 2 robot driver from source. The flexiv_ros2 packages provide hardware interface, gripper control, streaming position controller, and MoveIt configuration for Flexiv Rizon robots.

  1. Clone the NVIDIA Isaac ROS fork of flexiv_ros2 under ${ISAAC_ROS_WS}/src:

    cd ${ISAAC_ROS_WS}/src && \
   git clone -b nvidia/jazzy-rdk-v1.9.2 https://github.com/NVIDIA-ISAAC-ROS/flexiv_ros2

  2. Initialize submodules:

    cd ${ISAAC_ROS_WS}/src/flexiv_ros2 && \
   git submodule update --init --recursive

  3. Import ros2_control and ros2_controllers at ABI-compatible git tags so they are built from source alongside the driver:

    sudo apt-get install -y python3-vcstool
cd ${ISAAC_ROS_WS} && \
   vcs import src < src/flexiv_ros2/flexiv.repos
bash ${ISAAC_ROS_WS}/src/flexiv_ros2/scripts/apply_source_fixes.sh

  4. Install the ROS dependencies (including those of the source-built ros2_control and ros2_controllers):

    cd ${ISAAC_ROS_WS} && \
   rosdep update && \
   rosdep install --from-paths src/flexiv_ros2 src/third_party/ros2_control src/third_party/ros2_controllers --ignore-src --rosdistro jazzy -r -y

  5. Install Cyclone DDS and set it as the active RMW implementation:

    sudo apt-get install -y ros-jazzy-rmw-cyclonedds-cpp
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp

  6. Build and install third-party dependencies required by flexiv_rdk:

    cd ${ISAAC_ROS_WS}/src/flexiv_ros2/flexiv_hardware/rdk/thirdparty && \
   bash build_and_install_dependencies_not_in_ros2.sh ${ISAAC_ROS_WS}/rdk_install $(nproc)

  7. Build and install the flexiv_rdk library:

    cd ${ISAAC_ROS_WS}/src/flexiv_ros2/flexiv_hardware/rdk && \
   mkdir -p build && cd build && \
   cmake .. \
     -DCMAKE_INSTALL_PREFIX=${ISAAC_ROS_WS}/rdk_install \
     -DCMAKE_PREFIX_PATH=${ISAAC_ROS_WS}/rdk_install \
     -DRDK_SUPPORT_ROS2_JAZZY=ON && \
   cmake --build . -j$(nproc) && \
   cmake --install .

  8. Build the Flexiv ROS 2 packages:

    cd ${ISAAC_ROS_WS} && \
   colcon build --symlink-install \
   --cmake-args -DCMAKE_PREFIX_PATH=${ISAAC_ROS_WS}/rdk_install -DCMAKE_BUILD_TYPE=Release \
   --packages-up-to-regex "flexiv_*" gpio_controller streaming_position_controller && \
   source install/setup.bash

Note

Ensure the Flexiv robot has RDK enabled on the robot server and that the workstation PC can reach the robot over the network. Refer to the Flexiv RDK documentation for network setup details.

Configure Grav Gripper#

The Flexiv Grav gripper is automatically initialized when launching the Flexiv driver with the load_gripper:=true argument.

  1. Verify the gripper is physically attached to the Flexiv Rizon robot.

  2. When launching the Flexiv driver, include the gripper:

    ros2 launch flexiv_bringup rizon.launch.py robot_sn:=<ROBOT_SN> load_gripper:=true

    Replace <ROBOT_SN> with your robot’s serial number.

  3. In Flexiv Elements, confirm that the active tool frame is set to the gripper TCP, not the flange. Insertion policies and grasp poses are defined relative to the gripper TCP.

Export the Robot-Specific URDF#

The nominal Flexiv URDF might not contain the calibrated kinematic parameters for the physical robot. After building the Flexiv drivers, export a robot-specific calibrated kinematics model with the flexiv_hardware script:

sudo apt install -y python3-pip && python3 -m pip install --break-system-packages flexivrdk==1.9.2
cd ${ISAAC_ROS_WS}/src/flexiv_ros2/flexiv_hardware/scripts
python3 export_calibrated_model.py --robot-sn Rizon4s-063459

Replace Rizon4s-063459 with the serial number of the connected robot. The robot must be powered on and reachable on the network, and ISAAC_ROS_WS must be set. The script connects to the robot, reads the factory-calibrated kinematics, and writes the result to:

${ISAAC_ROS_WS}/isaac_ros_assets/<ROBOT_SN>/<ROBOT_SN>_calibrated_kinematics.urdf

Run this once per robot, and re-run only after Flexiv performs a recalibration. When retraining is required, convert this calibrated URDF to the corresponding USD robot asset and train the insertion policy with that asset in Isaac Lab.

Troubleshooting#

The Flexiv driver fails to connect to the robot

  1. Verify that the robot is in Auto (Remote) mode on the teach pendant.

  2. Ensure the workstation and robot are on the same subnet and the robot can be pinged from the workstation.

  3. Verify the robot serial number is correct and does not contain spaces (e.g., Rizon4s-062839).

The gripper does not respond

  1. Ensure the gripper is physically connected and the gripper is lighting up.

  2. Check that the gripper model name matches your hardware. The default is Flexiv-GN01 (Grav gripper).

Joint controller errors during gear insertion

  1. Ensure you are using rdk_control_mode:=joint_impedance when running the gear insertion workflow. The impedance mode provides the compliant behavior required for contact-rich tasks.

  2. If you see overshooting or unstable behavior, verify that the action_scale_joint_space in isaac_ros_assets/isaac_ros_manipulation_dnn_policy/flexiv/params/env.yaml is set to 0.00625 for all joints.