Release/v0.9

CMakeLists.txt

@@ -1,39 +1,36 @@
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.16.3)
 
 # ===================================================================
-#      PROJECT CONFIG
+#      PROJECT SETUP
 # ===================================================================
-project(flexiv_rdk VERSION 0.8.0)
-
-# C++14 required
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+project(flexiv_rdk VERSION 0.9.0)
 
 # Configure build type
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "CMake build type" FORCE)
 endif()
+set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Release" "Debug" "RelWithDebInfo")
 
 # Set static library
 message("OS: ${CMAKE_SYSTEM_NAME}")
 message("Processor: ${CMAKE_SYSTEM_PROCESSOR}")
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
-    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libFlexivRdk.x86_64-linux-gnu.a")
+    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libflexiv_rdk.x86_64-linux-gnu.a")
   elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
-    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libFlexivRdk.aarch64-linux-gnu.a")
+    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libflexiv_rdk.aarch64-linux-gnu.a")
   else()
     message(FATAL_ERROR "Linux with ${CMAKE_SYSTEM_PROCESSOR} processor is currently not supported.")
   endif()
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64")
-    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libFlexivRdk.arm64-darwin.a")
+    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libflexiv_rdk.arm64-darwin.a")
   else()
     message(FATAL_ERROR "Mac with ${CMAKE_SYSTEM_PROCESSOR} processor is currently not supported.")
   endif()
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "AMD64")
-    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/FlexivRdk.win_amd64.lib")
+    set(RDK_STATIC_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/lib/flexiv_rdk.win_amd64.lib")
   else()
     message(FATAL_ERROR "Windows with ${CMAKE_SYSTEM_PROCESSOR} processor is currently not supported.")
   endif()
@@ -42,12 +39,15 @@ endif()
 # ===================================================================
 #      PROJECT DEPENDENCIES
 # ===================================================================
-# pthread
+# Threads
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
+if(Threads_FOUND)
+  message(STATUS "Found Threads: HAVE_PTHREAD = ${THREADS_HAVE_PTHREAD_ARG}")
+endif()
 
 # ===================================================================
-#      PROJECT LIBRARIES
+#      CREATE LIBRARY
 # ===================================================================
 # Create an INTERFACE library with no source file to compile
 add_library(${PROJECT_NAME} INTERFACE)
@@ -67,10 +67,10 @@ target_link_libraries(${PROJECT_NAME} INTERFACE
 )
 
 # Use moderate compiler warning option 
-if(MSVC)
-  target_compile_options(${PROJECT_NAME} INTERFACE /W1)
-else()
+if(CMAKE_HOST_UNIX)
   target_compile_options(${PROJECT_NAME} INTERFACE -Wall -Wextra)
+else()
+  target_compile_options(${PROJECT_NAME} INTERFACE /W1)
 endif()
 
 # Install the INTERFACE library

README.md

@@ -11,11 +11,11 @@ Flexiv RDK (Robotic Development Kit), a key component of the Flexiv Robotic Soft
 
 ## Compatibility Overview
 
-| **Supported OS**               | **Supported processor** | **Supported language** | **Required compiler kit** |
-| ------------------------------ | ----------------------- | ---------------------- | ------------------------- |
-| Linux (Ubuntu 18/20/22 tested) | x86_64, arm64           | C++, Python            | build-essential           |
-| macOS 12 (Monterey)            | arm64                   | C++, Python            | Xcode Command Line Tools  |
-| Windows 10                     | x86_64                  | C++, Python            | MSVC 14.0+                |
+| **Supported OS**           | **Supported processor** | **Supported language** | **Required compiler kit** |
+| -------------------------- | ----------------------- | ---------------------- | ------------------------- |
+| Linux (Ubuntu 20.04/22.04) | x86_64, arm64           | C++, Python            | build-essential           |
+| macOS 12 (Monterey)        | arm64                   | C++, Python            | Xcode Command Line Tools  |
+| Windows 10                 | x86_64                  | C++, Python            | MSVC 14.0+                |
 
 ## Quick Start
 

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         = "0.8"
+PROJECT_NUMBER         = "0.9"
 
 # 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,8 +1,8 @@
-
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.16.3)
 project(flexiv_rdk-examples)
 
-set(CMAKE_CXX_STANDARD 14)
+# Show verbose build info
+SET(CMAKE_VERBOSE_MAKEFILE ON)
 
 message("OS: ${CMAKE_SYSTEM_NAME}")
 message("Processor: ${CMAKE_SYSTEM_PROCESSOR}")
@@ -44,4 +44,8 @@ find_package(flexiv_rdk REQUIRED)
 foreach(example ${EXAMPLE_LIST})
   add_executable(${example} ${example}.cpp)
   target_link_libraries(${example} flexiv::flexiv_rdk)
+  # C++14 required
+  set_target_properties(${example} PROPERTIES 
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED ON)
 endforeach()

example/basics1_display_robot_states.cpp

@@ -99,14 +99,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 

example/basics3_primitive_execution.cpp

@@ -82,14 +82,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 

example/basics4_plan_execution.cpp

@@ -87,14 +87,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 
@@ -136,7 +130,9 @@ int main(int argc, char* argv[])
                     log.info("Enter plan index to execute:");
                     int index;
                     std::cin >> index;
-                    robot.executePlan(index);
+                    // Allow the plan to continue its execution even if the RDK program is closed or
+                    // the connection is lost
+                    robot.executePlan(index, true);
 
                     // Print plan info while the current plan is running
                     while (robot.isBusy()) {
@@ -151,7 +147,9 @@ int main(int argc, char* argv[])
                     log.info("Enter plan name to execute:");
                     std::string name;
                     std::cin >> name;
-                    robot.executePlan(name);
+                    // Allow the plan to continue its execution even if the RDK program is closed or
+                    // the connection is lost
+                    robot.executePlan(name, true);
 
                     // Print plan info while the current plan is running
                     while (robot.isBusy()) {

example/basics5_zero_force_torque_sensors.cpp

@@ -82,14 +82,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 

example/basics6_gripper_control.cpp

@@ -106,14 +106,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 

example/basics7_auto_recovery.cpp

@@ -74,14 +74,10 @@ int main(int argc, char* argv[])
         // process is done, so just wait long enough for the process to finish
         std::this_thread::sleep_for(std::chrono::seconds(8));
 
-        // Start auto recovery if the system is in recovery state, the involved joints will start to
+        // Run auto recovery if the system is in recovery state, the involved joints will start to
         // move back into allowed position range
         if (robot.isRecoveryState()) {
-            robot.startAutoRecovery();
-            // Block forever, must reboot the robot and restart user program after recovery is done
-            while (true) {
-                std::this_thread::sleep_for(std::chrono::seconds(1));
-            }
+            robot.runAutoRecovery();
         }
         // Otherwise the system is normal, do nothing
         else {

example/intermediate1_realtime_joint_position_control.cpp

@@ -157,14 +157,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 
@@ -198,6 +192,9 @@ int main(int argc, char* argv[])
         // Start all added tasks, this is by default a blocking method
         scheduler.start();
 
+        // Wait a bit for any last-second robot log message to arrive and get printed
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
     } catch (const flexiv::Exception& e) {
         log.error(e.what());
         return 1;

example/intermediate2_realtime_joint_torque_control.cpp

@@ -170,14 +170,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 
@@ -211,6 +205,9 @@ int main(int argc, char* argv[])
         // Start all added tasks, this is by default a blocking method
         scheduler.start();
 
+        // Wait a bit for any last-second robot log message to arrive and get printed
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
     } catch (const flexiv::Exception& e) {
         log.error(e.what());
         return 1;

example/intermediate3_realtime_joint_floating.cpp

@@ -69,7 +69,7 @@ void periodicTask(flexiv::Robot& robot, flexiv::Scheduler& scheduler, flexiv::Lo
 
         // Add some velocity damping
         for (size_t i = 0; i < robotDOF; ++i) {
-            targetTorque[i] = -k_floatingDamping[i] * robotStates.dtheta[i];
+            targetTorque[i] += -k_floatingDamping[i] * robotStates.dtheta[i];
         }
 
         // Send target joint torque to RDK server, enable gravity compensation
@@ -131,14 +131,8 @@ int main(int argc, char* argv[])
         robot.enable();
 
         // Wait for the robot to become operational
-        int secondsWaited = 0;
         while (!robot.isOperational()) {
             std::this_thread::sleep_for(std::chrono::seconds(1));
-            if (++secondsWaited == 10) {
-                log.warn(
-                    "Still waiting for robot to become operational, please check that the robot 1) "
-                    "has no fault, 2) is in [Auto (remote)] mode");
-            }
         }
         log.info("Robot is now operational");
 
@@ -166,6 +160,9 @@ int main(int argc, char* argv[])
         // Start all added tasks, this is by default a blocking method
         scheduler.start();
 
+        // Wait a bit for any last-second robot log message to arrive and get printed
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
     } catch (const flexiv::Exception& e) {
         log.error(e.what());
         return 1;