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, Cartesian motion-force control, 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/lyrical-rdk-v1.9.4 https://github.com/NVIDIA-ISAAC-ROS/flexiv_ros2

  2. Import flexiv_description and flexiv_rdk at the versions the driver is released against:

    sudo apt-get install -y python3-vcstool
cd ${ISAAC_ROS_WS} && \
   vcs import src < src/flexiv_ros2/flexiv.lyrical.repos && \
   touch src/flexiv_rdk/COLCON_IGNORE

  3. Install ros2_control and ros2_controllers, then resolve the remaining ROS dependencies:

    sudo apt-get install -y \
   ros-lyrical-ros2-control \
   ros-lyrical-ros2-controllers
cd ${ISAAC_ROS_WS} && \
   rosdep update && \
   rosdep install \
      --from-paths src/flexiv_ros2 src/flexiv_description \
      --ignore-src \
      --rosdistro lyrical -r -y

  4. Install Zenoh and set it as the active RMW implementation:

    sudo apt-get install -y ros-lyrical-rmw-zenoh-cpp
source /opt/ros/lyrical/setup.bash
export RMW_IMPLEMENTATION=rmw_zenoh_cpp

  5. Select the RDK installation prefix:

    export FLEXIV_RDK_PREFIX=${ISAAC_ROS_WS}/rdk_install

  6. Build and install flexiv_rdk and its dependencies:

    cd ${ISAAC_ROS_WS}/src/flexiv_rdk/thirdparty && \
   bash build_and_install_dependencies.sh ${FLEXIV_RDK_PREFIX} $(nproc)
cd ${ISAAC_ROS_WS}/src/flexiv_rdk && \
   cmake -B build -DCMAKE_INSTALL_PREFIX=${FLEXIV_RDK_PREFIX} \
      -DCMAKE_PREFIX_PATH=${FLEXIV_RDK_PREFIX} && \
   cmake --build build --target install --config Release

  7. Build the Flexiv ROS 2 packages:

    cd ${ISAAC_ROS_WS} && \
   colcon build --symlink-install \
   --cmake-args \
      -DCMAKE_PREFIX_PATH=${FLEXIV_RDK_PREFIX} \
      -DCMAKE_BUILD_TYPE=Release \
      -DBUILD_TESTING=OFF \
   --packages-up-to-regex "flexiv_*" cartesian_motion_controller 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.

Sync the Robot-Specific Kinematics#

The nominal Flexiv description does not contain the calibrated kinematic parameters of a physical robot. On a Rizon 4s the difference reaches several millimeters at the flange, and because it accumulates along the kinematic chain it varies with pose and cannot be removed by a fixed TCP offset.

flexiv_calibration reads the measured parameters from a connected robot and writes them to a kinematics YAML. Write it under isaac_ros_assets so it is keyed by serial number and survives re-cloning flexiv_description:

mkdir -p ${ISAAC_ROS_WS}/isaac_ros_assets/<ROBOT_SN>
ros2 launch flexiv_calibration calibration_correction.launch.py \
   robot_sn:=<ROBOT_SN> \
   target_filename:=${ISAAC_ROS_WS}/isaac_ros_assets/<ROBOT_SN>/<ROBOT_SN>_kinematics.yaml

Replace <ROBOT_SN> with the serial number of the connected robot, for example Rizon4s-063867. The robot must be powered on, reachable on the network, and in Auto (Remote) mode, and ISAAC_ROS_WS must be set. On success the node reports the joints it synced:

Connected to [Rizon4s-063867], model [Rizon4s], software [v3.11.2], license [RDK-Professional...]
Synced 8 joints of [Rizon4s-063867] into [.../Rizon4s-063867_kinematics.yaml]

Run this once per robot, and again only after Flexiv performs a recalibration.

Note

Reading kinematic parameters requires an RDK professional license. The node reports the license it validated on connection.

Manipulation workflows pick the file up automatically from that path: both the driver’s robot description and the cuMotion planning description are generated from it, so the planner and the published TF share one kinematic model. Set flexiv_calibrated_kinematics_path only if the file is stored elsewhere; when it is absent, both fall back to the nominal description.

When retraining is required, convert the calibrated description 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).

Controller errors during DisplayPort cable insertion

  1. Ensure the robot is running in an impedance control mode when running the DisplayPort cable 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 LEAPP export used by Isaac ROS Deploy matches the trained policy’s observation layout, action representation, and TCP offset.

End-effector pose does not match the trained policy

  1. At a safe, fixed joint configuration, compare the end-effector pose computed using forward kinematics from the nominal URDF with the pose reported by RDK or Flexiv Elements. Make sure both poses use the same base frame, tool frame or TCP, units, and orientation convention.

  2. If the poses do not match, follow Sync the Robot-Specific Kinematics and use the calibrated model to generate the corresponding USD asset and retrain the policy in Isaac Lab.