Release/v2.0 (#187)

Release note:
https://github.com/flexivrobotics/flexiv_rdk/releases/tag/v2.0

Author: pzhu-flexiv

.github/workflows/shared_steps/action.yml

@@ -15,7 +15,7 @@ runs:
       run: |
         cmake --version
         cd thirdparty
-        bash build_and_install_dependencies.sh ~/rdk_install 4
+        bash build_and_install_dependencies.sh ~/rdk_install 8
 
     # Configure CMake, then build and install flexiv_rdk library to RDK installation directory.
     - name: Build and install library
@@ -32,7 +32,7 @@ runs:
         cd example
         mkdir -p build && cd build
         cmake .. -DCMAKE_PREFIX_PATH=~/rdk_install
-        cmake --build . --config Release -j 4
+        cmake --build . --config Release -j 8
 
     # Find and link to flexiv_rdk library, then build all test programs.
     - name: Build tests
@@ -41,4 +41,4 @@ runs:
         cd test
         mkdir -p build && cd build
         cmake .. -DCMAKE_PREFIX_PATH=~/rdk_install
-        cmake --build . --config Release -j 4
+        cmake --build . --config Release -j 8

CMakeLists.txt

@@ -1,9 +1,9 @@
-cmake_minimum_required(VERSION 3.16.3)
+cmake_minimum_required(VERSION 3.22.1)
 
 # ===================================================================
 #      PROJECT SETUP
 # ===================================================================
-project(flexiv_rdk VERSION 1.9.1)
+project(flexiv_rdk VERSION 2.0)
 
 # Configure build type
 if(NOT CMAKE_BUILD_TYPE)
@@ -46,23 +46,6 @@ else()
   message(FATAL_ERROR "${CMAKE_SYSTEM_NAME} is currently not supported.")
 endif()
 
-# Option to support ROS2 Jazzy
-option(RDK_SUPPORT_ROS2_JAZZY "Use RDK library compatible with ROS2 Jazzy" OFF)
-if(RDK_SUPPORT_ROS2_JAZZY)
-  if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
-      set(RDK_LIB "libflexiv_rdk.x86_64-linux-gnu.ros2-jazzy.a")
-    elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
-      set(RDK_LIB "libflexiv_rdk.aarch64-linux-gnu.ros2-jazzy.a")
-    else()
-      message(FATAL_ERROR 
-        "Compatibility with ROS2 Jazzy is currently not supported on Linux with ${CMAKE_SYSTEM_PROCESSOR} processor.")
-    endif()
-  else()
-    message(FATAL_ERROR "Compatibility with ROS2 Jazzy is currently not supported on ${CMAKE_SYSTEM_NAME}.")
-  endif()
-endif()
-
 # Parse expected hash of the library file
 file(READ ${CMAKE_CURRENT_SOURCE_DIR}/lib/${RDK_LIB}.sha256 EXPECTED_HASH)
 
@@ -90,24 +73,24 @@ find_package(Threads REQUIRED)
 message(STATUS "Found Threads")
 
 # Eigen3
-find_package(Eigen3 REQUIRED)
+find_package(Eigen3 3.4.0 REQUIRED)
 message(STATUS "Found Eigen3 v${Eigen3_VERSION}: ${Eigen3_DIR}")
 
 # spdlog
-find_package(spdlog REQUIRED)
+find_package(spdlog 1.9.2 REQUIRED)
 message(STATUS "Found spdlog v${spdlog_VERSION}: ${spdlog_DIR}")
 
-# Fast-DDS (Fast-RTPS)
-find_package(fastrtps REQUIRED)
-message(STATUS "Found fastrtps v${fastrtps_VERSION}: ${fastrtps_DIR}")
+# Fast-DDS
+find_package(fastdds 3.5.0 REQUIRED)
+message(STATUS "Found fastdds v${fastdds_VERSION}: ${fastdds_DIR}")
 
 # Fast-CDR
-find_package(fastcdr REQUIRED)
+find_package(fastcdr 2.3.5 REQUIRED)
 message(STATUS "Found fastcdr v${fastcdr_VERSION}: ${fastcdr_DIR}")
 
 # RBDyn
 set(Boost_USE_STATIC_LIBS OFF)
-find_package(RBDyn REQUIRED)
+find_package(RBDyn 1.9.3 REQUIRED)
 message(STATUS "Found RBDyn v${RBDyn_VERSION}: ${RBDyn_DIR}")
 
 # ===================================================================
@@ -130,7 +113,7 @@ target_link_libraries(${PROJECT_NAME} PUBLIC
   Threads::Threads
   Eigen3::Eigen
   spdlog::spdlog
-  fastrtps
+  fastdds
   fastcdr
   RBDyn::RBDyn
   RBDyn::Parsers

README.md

@@ -17,7 +17,7 @@ For AI-assisted code generation in this repository, see [llms.txt](llms.txt).
 
 | **OS**                | **Platform**    | **C++ compiler kit** | **Python interpreter** |
 | --------------------- | --------------- | -------------------- | ---------------------- |
-| Linux (Ubuntu 22.04+) | x86_64, aarch64 | GCC   v11.4+         | 3.10, 3.12, 3.13       |
+| Linux (Ubuntu 22.04+) | x86_64, aarch64 | GCC   v11.4+         | 3.10, 3.12, 3.14       |
 | macOS 12+             | arm64           | Clang v14.0+         | 3.10, 3.12             |
 | Windows 10+           | x86_64          | MSVC  v14.2+         | 3.10, 3.12             |
 | QNX 8.0.3+            | x86_64, aarch64 | QCC   v12.2+         | Not supported          |

cmake/flexiv_rdk-config.cmake.in

@@ -4,11 +4,11 @@ include(CMakeFindDependencyMacro)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 set(Boost_USE_STATIC_LIBS OFF)
 find_dependency(Threads REQUIRED)
-find_dependency(Eigen3 REQUIRED)
-find_dependency(spdlog REQUIRED)
-find_dependency(fastrtps REQUIRED)
-find_dependency(fastcdr REQUIRED)
-find_dependency(RBDyn REQUIRED)
+find_dependency(Eigen3 3.4.0 REQUIRED)
+find_dependency(spdlog 1.9.2 REQUIRED)
+find_dependency(fastdds 3.5.0 REQUIRED)
+find_dependency(fastcdr 2.3.5 REQUIRED)
+find_dependency(RBDyn 1.9.3 REQUIRED)
 
 # Add targets file
 include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")

doc/Doxyfile.in

@@ -38,7 +38,7 @@ PROJECT_NAME           = "Flexiv RDK APIs"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 1.9.1
+PROJECT_NUMBER         = 2.0
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

example/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16.3)
+cmake_minimum_required(VERSION 3.22.1)
 project(flexiv_rdk-examples)
 
 # Show verbose build info

example/basics10_logging_behavior.cpp

@@ -1,7 +1,7 @@
 /**
  * @example basics10_logging_behavior.cpp
  * This tutorial shows how to change the logging behaviors of RDK client.
- * @copyright Copyright (C) 2016-2025 Flexiv Ltd. All Rights Reserved.
+ * @copyright Copyright (C) 2016-2026 Flexiv Ltd. All Rights Reserved.
  * @author Flexiv
  */
 

example/basics1_display_robot_states.cpp

@@ -2,7 +2,7 @@
  * @example basics1_display_robot_states.cpp
  * This tutorial does the very first thing: check connection with the robot server and print
  * received robot states.
- * @copyright Copyright (C) 2016-2025 Flexiv Ltd. All Rights Reserved.
+ * @copyright Copyright (C) 2016-2026 Flexiv Ltd. All Rights Reserved.
  * @author Flexiv
  */
 
@@ -30,12 +30,21 @@ void PrintHelp()
 void PrintRobotStates(rdk::Robot& robot)
 {
     while (true) {
+        // Print Available joint groups
+        std::string joint_groups_str;
+        for (const auto& group : robot.groups()) {
+            joint_groups_str += "[" + rdk::kJointGroupNames.at(group) + "] ";
+        }
+        spdlog::info("Available joint groups: {}", joint_groups_str);
+
         // Print all robot states in JSON format using the built-in ostream operator overloading
-        spdlog::info("Current robot states:");
-        std::cout << robot.states() << std::endl;
+        for (const auto& [group, states] : robot.states()) {
+            spdlog::info("[{}] robot states:", rdk::kJointGroupNames.at(group));
+            std::cout << states << std::endl;
+        }
 
         // Print digital inputs
-        spdlog::info("Current digital inputs:");
+        spdlog::info("Digital inputs:");
         std::cout << rdk::utility::Arr2Str(robot.digital_inputs()) << std::endl;
         std::this_thread::sleep_for(std::chrono::seconds(1));
     }

example/basics2_clear_fault.cpp

@@ -1,7 +1,7 @@
 /**
  * @example basics2_clear_fault.cpp
  * This tutorial clears minor or critical faults, if any, of the connected robot.
- * @copyright Copyright (C) 2016-2025 Flexiv Ltd. All Rights Reserved.
+ * @copyright Copyright (C) 2016-2026 Flexiv Ltd. All Rights Reserved.
  * @author Flexiv
  */
 

example/basics3_primitive_execution.cpp

@@ -2,7 +2,7 @@
  * @example basics3_primitive_execution.cpp
  * This tutorial executes several basic robot primitives (unit skills). For detailed documentation
  * on all available primitives, please see [Flexiv Primitives](https://www.flexiv.com/primitives/).
- * @copyright Copyright (C) 2016-2025 Flexiv Ltd. All Rights Reserved.
+ * @copyright Copyright (C) 2016-2026 Flexiv Ltd. All Rights Reserved.
  * @author Flexiv
  */
 
@@ -13,6 +13,7 @@
 #include <iostream>
 #include <iomanip>
 #include <thread>
+#include <algorithm>
 
 using namespace flexiv;
 
@@ -74,6 +75,9 @@ int main(int argc, char* argv[])
 
         // Execute Primitives
         // =========================================================================================
+        // All available joint groups of the robot
+        const auto joint_groups = robot.groups();
+
         // Switch to primitive execution mode
         robot.SwitchMode(rdk::Mode::NRT_PRIMITIVE_EXECUTION);
 
@@ -84,10 +88,17 @@ int main(int argc, char* argv[])
         spdlog::info("Executing primitive: Home");
 
         // Send command to robot
-        robot.ExecutePrimitive("Home", std::map<std::string, rdk::FlexivDataTypes> {});
+        std::map<rdk::JointGroup, rdk::PrimitiveArgs> pt_args;
+        for (const auto& group : joint_groups) {
+            pt_args[group] = rdk::PrimitiveArgs("Home", {});
+        }
+        robot.ExecutePrimitive(pt_args);
 
         // Wait for reached target
-        while (!std::get<int>(robot.primitive_states()["reachedTarget"])) {
+        while (!std::all_of(joint_groups.begin(), joint_groups.end(), [&robot](const auto& group) {
+            return std::get<int>(
+                robot.primitive_states().at(group).names_and_values.at("reachedTarget"));
+        })) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }
 
@@ -103,24 +114,35 @@ int main(int argc, char* argv[])
         spdlog::info("Executing primitive: MoveJ");
 
         // Send command to robot
-        robot.ExecutePrimitive("MoveJ",
-            {
-                {"target", rdk::JPos({30, -45, 0, 90, 0, 40, 30}, {-50, 30})},
-                {"waypoints",
-                    std::vector<rdk::JPos> {rdk::JPos({10, -30, 10, 30, 10, 15, 10}, {-15, 10}),
-                        rdk::JPos({20, -60, -10, 60, -10, 30, 20}, {-30, 20})}},
-            });
+        pt_args.clear();
+        for (const auto& group : joint_groups) {
+            pt_args[group] = rdk::PrimitiveArgs("MoveJ",
+                {
+                    {"target", rdk::JPos({30, -45, 0, 90, 0, 40, 30}, {-50, 30})},
+                    {"waypoints",
+                        std::vector<rdk::JPos> {rdk::JPos({10, -30, 10, 30, 10, 15, 10}, {-15, 10}),
+                            rdk::JPos({20, -60, -10, 60, -10, 30, 20}, {-30, 20})}},
+                });
+        }
+        robot.ExecutePrimitive(pt_args);
 
         // Most primitives won't exit by themselves and require users to explicitly trigger
         // transitions based on specific primitive states. Here we check if the primitive state
         // [reachedTarget] becomes true and trigger the transition manually by sending a new
         // primitive command.
-        while (!std::get<int>(robot.primitive_states()["reachedTarget"])) {
+        while (!std::all_of(joint_groups.begin(), joint_groups.end(), [&robot](const auto& group) {
+            return std::get<int>(
+                robot.primitive_states().at(group).names_and_values.at("reachedTarget"));
+        })) {
             // Print current primitive states
             spdlog::info("Current primitive states:");
-            for (const auto& st : robot.primitive_states()) {
-                std::cout << st.first << ": " << rdk::utility::FlexivTypes2Str(st.second);
-                std::cout << std::endl;
+            for (const auto& group : joint_groups) {
+                std::cout << rdk::kJointGroupNames.at(group) << ":" << std::endl;
+                const auto primitive_states = robot.primitive_states().at(group).names_and_values;
+                for (const auto& st : primitive_states) {
+                    std::cout << st.first << ": " << rdk::utility::FlexivTypes2Str(st.second);
+                    std::cout << std::endl;
+                }
             }
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }
@@ -138,19 +160,25 @@ int main(int argc, char* argv[])
         spdlog::info("Executing primitive: MoveL");
 
         // Send command to robot
-        robot.ExecutePrimitive("MoveL",
-            {
-                {"target", rdk::Coord({0.65, -0.3, 0.2}, {180, 0, 180}, {"WORLD", "WORLD_ORIGIN"})},
-                {"waypoints",
-                    std::vector<rdk::Coord> {
-                        rdk::Coord({0.45, 0.1, 0.2}, {180, 0, 180}, {"WORLD", "WORLD_ORIGIN"}),
-                        rdk::Coord({0.45, -0.3, 0.2}, {180, 0, 180}, {"WORLD", "WORLD_ORIGIN"})}},
-                {"vel", 0.6},
-                {"zoneRadius", "Z50"},
-            });
+        pt_args.clear();
+        for (const auto& group : joint_groups) {
+            pt_args[group] = rdk::PrimitiveArgs("MoveL",
+                {{"target",
+                     rdk::Coord({0.3, -0.1, 0.2}, {160, 20, 180}, {"WORLD", "WORLD_ORIGIN"})},
+                    {"waypoints",
+                        std::vector<rdk::Coord> {rdk::Coord({0.1, 0.1, 0.1}, {-160, -20, 180},
+                                                     {"WORLD", "WORLD_ORIGIN"}),
+                            rdk::Coord({0.3, 0.2, 0.1}, {180, 0, 180}, {"WORLD", "WORLD_ORIGIN"})}},
+
+                    {"vel", 0.6}, {"zoneRadius", "Z50"}});
+        }
+        robot.ExecutePrimitive(pt_args);
 
         // Wait for reached target
-        while (!std::get<int>(robot.primitive_states()["reachedTarget"])) {
+        while (!std::all_of(joint_groups.begin(), joint_groups.end(), [&robot](const auto& group) {
+            return std::get<int>(
+                robot.primitive_states().at(group).names_and_values.at("reachedTarget"));
+        })) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }
 
@@ -166,13 +194,20 @@ int main(int argc, char* argv[])
         auto targetEulerDeg = rdk::utility::Rad2Deg(rdk::utility::Quat2EulerZYX(targetQuat));
 
         // Send command to robot. This motion will hold current TCP position and only do rotation
-        robot.ExecutePrimitive(
-            "MoveL", {
-                         {"target", rdk::Coord({0.0, 0.0, 0.0}, targetEulerDeg, {"TRAJ", "START"})},
-                         {"vel", 0.2},
-                     });
+        pt_args.clear();
+        for (const auto& group : joint_groups) {
+            pt_args[group] = rdk::PrimitiveArgs("MoveL",
+                {
+                    {"target", rdk::Coord({0.0, 0.0, 0.0}, targetEulerDeg, {"TRAJ", "START"})},
+                    {"vel", 0.2},
+                });
+        }
+        robot.ExecutePrimitive(pt_args);
         // Wait for reached target
-        while (!std::get<int>(robot.primitive_states()["reachedTarget"])) {
+        while (!std::all_of(joint_groups.begin(), joint_groups.end(), [&robot](const auto& group) {
+            return std::get<int>(
+                robot.primitive_states().at(group).names_and_values.at("reachedTarget"));
+        })) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }