For ROS 2 users to easily work with RDK, the APIs of RDK are wrapped into ROS packages in flexiv_ros2
. Key functionalities like real-time joint torque and position control are supported, and the integration with ros2_control
framework and MoveIt! 2 is also implemented.
Flexiv RDK main webpage contains important information like RDK user manual and network setup.
Supported OS | Supported ROS 2 distribution |
---|---|
Ubuntu 20.04 | Foxy Fitzroy |
Ubuntu 22.04 | Humble Hawksbill |
ROS 2 Distro | Foxy | Humble |
---|---|---|
Branch | foxy | humble |
Release Status |
This project was developed for ROS 2 Foxy (Ubuntu 20.04) and Humble (Ubuntu 22.04). Other versions of Ubuntu and ROS 2 may work, but are not officially supported.
-
Install ROS 2 Humble via Debian Packages
-
Install
colcon
and additional ROS packages:sudo apt install -y \ python3-colcon-common-extensions \ python3-rosdep2 \ libeigen3-dev \ ros-humble-xacro \ ros-humble-tinyxml2-vendor \ ros-humble-ros2-control \ ros-humble-realtime-tools \ ros-humble-control-toolbox \ ros-humble-moveit \ ros-humble-ros2-controllers \ ros-humble-test-msgs \ ros-humble-joint-state-publisher \ ros-humble-joint-state-publisher-gui \ ros-humble-robot-state-publisher \ ros-humble-rviz2
-
Setup workspace:
mkdir -p ~/flexiv_ros2_ws/src cd ~/flexiv_ros2_ws/src git clone https://github.com/flexivrobotics/flexiv_ros2.git cd flexiv_ros2/ git submodule update --init --recursive
-
Install dependencies:
cd ~/flexiv_ros2_ws rosdep update rosdep install --from-paths src --ignore-src --rosdistro humble -r -y
Note
Skip step 5 and 6 if you have compile and install flexiv_rdk.
-
Choose a directory for installing
flexiv_rdk
library and all its dependencies. For example, a new folder namedrdk_install
under the home directory:~/rdk_install
. Compile and install to the installation directory:cd ~/flexiv_ros2_ws/src/flexiv_ros2/flexiv_hardware/rdk/thirdparty bash build_and_install_dependencies.sh ~/rdk_install
-
Configure and install
flexiv_rdk
:cd ~/flexiv_ros2_ws/src/flexiv_ros2/flexiv_hardware/rdk mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=~/rdk_install cmake --build . --target install --config Release
-
Build and source the workspace:
cd ~/flexiv_ros2_ws source /opt/ros/humble/setup.bash colcon build --symlink-install --cmake-args -DCMAKE_PREFIX_PATH=~/rdk_install source install/setup.bash
Note
Remember to source the setup file and the workspace whenever a new terminal is opened:
source /opt/ros/humble/setup.bash
source ~/flexiv_ros2_ws/install/setup.bash
Note
The instruction below is only a quick reference, see the Flexiv ROS 2 Documentation for more information.
The prerequisites of using ROS 2 with Flexiv Rizon robot are enable RDK on the robot server and establish connection between the workstation PC and the robot.
The main launch file to start the robot driver is the rizon.launch.py
- it loads and starts the robot hardware, joint states broadcaster, Flexiv robot states broadcasters, and robot controller and opens RViZ. The arguments for the launch file are as follows:
robot_sn
(required) - Serial number of the robot to connect to. Remove any space, for example: Rizon4s-123456rizon_type
(default: rizon4) - type of the Flexiv Rizon robot. (rizon4, rizon4s, rizon10 or rizon10s)load_gripper
(default: false) - loads the Flexiv Grav gripper as the end-effector of the robot and the gripper control node.use_fake_hardware
(default: false) - startsFakeSystem
instead of real hardware. This is a simple simulation that mimics joint command to their states.start_rviz
(deafult: true) - starts RViz automatically with the launch file.fake_sensor_commands
(default: false) - enables fake command interfaces for sensors used for simulations. Used only ifuse_fake_hardware
parameter is true.robot_controller
(default: rizon_arm_controller) - robot controller to start. Available controllers: forward_position_controller, rizon_arm_controller, joint_impedance_controller.
(Details about other launch files can be found in flexiv_bringup
)
-
Start robot, or fake hardware:
-
Test with real robot:
ros2 launch flexiv_bringup rizon.launch.py robot_sn:=[robot_sn] rizon_type:=rizon4
-
Test with fake hardware (
ros2_control
capability):ros2 launch flexiv_bringup rizon.launch.py robot_sn:=dont-care use_fake_hardware:=true
-
Tip
To test whether the connection between ROS and the robot is established, you could disable the starting of RViz first by setting the start_rviz
launch argument to false.
-
Publish commands to controllers
-
To send the goal position to the controller by using the node from
flexiv_test_nodes
, start the following command in a new terminal:ros2 launch flexiv_bringup test_joint_trajectory_controller.launch.py
The joint position goals can be changed in
flexiv_bringup/config/joint_trajectory_position_publisher.yaml
-
To test another controller, define it using the
robot_controller
launch argument, for example thejoint_impedance_controller
:ros2 launch flexiv_bringup rizon.launch.py robot_sn:=[robot_sn] robot_controller:=joint_impedance_controller
Open a new terminal and run the launch file:
ros2 launch flexiv_bringup sine_sweep_impedance.launch.py
The robot should run a sine-sweep motion with joint impedance control.
-
Note
The command starts the robot in the joint torque mode. In this mode, gravity and friction are compensated only for the robot without any attached objects (e.g. the gripper, camera).
Note
Joint impedance control is not supported in fake/simulated hardware.
You can also run the MoveIt example and use the MotionPlanning
plugin in RViZ to start planning:
ros2 launch flexiv_bringup rizon_moveit.launch.py robot_sn:=[robot_sn]
Test with fake hardware:
ros2 launch flexiv_bringup rizon_moveit.launch.py robot_sn:=dont-care use_fake_hardware:=true
The robot driver (rizon.launch.py
) publishes the following feedback states to the respective ROS topics:
-
/${robot_sn}/flexiv_robot_states
: Flexiv robot states including the joint- and Cartesian-space robot states. [flexiv_msgs/msg/RobotStates.msg
] -
/joint_states
: Measured joint states of the robot: joint position, velocity and torque. [sensor_msgs/JointState.msg
] -
/flexiv_robot_states_broadcaster/tcp_pose
: Measured TCP pose expressed in world frame$^{0}T_{TCP}$ in position$[m]$ and quaternion. [geometry_msgs/PoseStamped.msg
] -
/flexiv_robot_states_broadcaster/external_wrench_in_tcp
: Estimated external wrench applied on TCP and expressed in TCP frame$^{TCP}F_{ext}$ in force$[N]$ and torque$[Nm]$ . [geometry_msgs/WrenchStamped.msg
] -
/flexiv_robot_states_broadcaster/external_wrench_in_world
: Estimated external wrench applied on TCP and expressed in world frame$^{0}F_{ext}$ in force$[N]$ and torque$[Nm]$ . [geometry_msgs/WrenchStamped.msg
]
All digital inputs on the robot control box can be accessed via the ROS topic /gpio_controller/gpio_inputs
, which publishes the current state of all the 18 (16 on control box + 2 inside the wrist connector) digital input ports (True: port high, false: port low).
The digital output ports on the control box can be set by publishing to the topic /gpio_controller/gpio_outputs
. For example:
ros2 topic pub /gpio_controller/gpio_outputs flexiv_msgs/msg/GPIOStates "{states: [{pin: 0, state: true}, {pin: 2, state: true}]}"
The gripper control is implemented in the flexiv_gripper
package to interface with the gripper that is connected to the robot.
Start the flexiv_gripper_node
with the following launch file:
ros2 launch flexiv_gripper flexiv_gripper.launch.py robot_sn:=[robot_sn]
Or, you can also start the gripper control with the robot driver if the gripper is Flexiv Grav:
ros2 launch flexiv_bringup rizon.launch.py robot_sn:=[robot_sn] load_gripper:=true
In a new terminal, send the gripper action move
goal to open or close the gripper:
# Closing the gripper
ros2 action send_goal /flexiv_gripper_node/move flexiv_msgs/action/Move "{width: 0.01, velocity: 0.1, max_force: 20}"
# Opening the gripper
ros2 action send_goal /flexiv_gripper_node/move flexiv_msgs/action/Move "{width: 0.09, velocity: 0.1, max_force: 20}"
The grasp
action enables the gripper to grasp with direct force control, but it requires the mounted gripper to support direct force control. Send a grasp
command to the gripper:
ros2 action send_goal /flexiv_gripper_node/grasp flexiv_msgs/action/Grasp "{force: 0}"
To stop the gripper, send a stop
service call:
ros2 service call /flexiv_gripper_node/stop std_srvs/srv/Trigger {}