Add CI step for running the examples

The default behavior is to find a run all the examples
For this it was needed to change the examples to not run forever

Author: urrsk

.github/workflows/ci.yml

@@ -39,6 +39,8 @@ jobs:
         run: cmake --build build --config Debug
       - name: test
         run: cd build && ctest --output-on-failure
+      - name: run examples
+        run: run-parts -v --exit-on-error -a "192.168.56.101" -a "1"  ./build/examples
       - name: install gcovr
         run: sudo apt-get install -y gcovr
       - name: gcovr
@@ -69,4 +71,3 @@ jobs:
     steps:
       - uses: actions/checkout@v1
       - uses: ./.github/actions/rosdoc_lite_action
-

examples/CMakeLists.txt

@@ -29,3 +29,8 @@ add_executable(rtde_client_example
   rtde_client.cpp)
 target_compile_options(rtde_client_example PUBLIC ${CXX17_FLAG})
 target_link_libraries(rtde_client_example ur_client_library::urcl)
+
+add_executable(dashboard_example
+  dashboard_example.cpp)
+target_compile_options(dashboard_example PUBLIC ${CXX17_FLAG})
+target_link_libraries(dashboard_example ur_client_library::urcl)

examples/full_driver.cpp

@@ -28,6 +28,7 @@
  */
 //----------------------------------------------------------------------
 
+#include <ur_client_library/ur/dashboard_client.h>
 #include <ur_client_library/ur/ur_driver.h>
 #include <ur_client_library/types.h>
 
@@ -38,13 +39,14 @@ using namespace urcl;
 
 // In a real-world example it would be better to get those values from command line parameters / a
 // better configuration system such as Boost.Program_options
-const std::string ROBOT_IP = "192.168.56.101";
+const std::string DEFAULT_ROBOT_IP = "127.0.0.1";
 const std::string SCRIPT_FILE = "resources/external_control.urscript";
 const std::string OUTPUT_RECIPE = "examples/resources/rtde_output_recipe.txt";
 const std::string INPUT_RECIPE = "examples/resources/rtde_input_recipe.txt";
 const std::string CALIBRATION_CHECKSUM = "calib_12788084448423163542";
 
 std::unique_ptr<UrDriver> g_my_driver;
+std::unique_ptr<DashboardClient> my_dashboard;
 vector6d_t g_joint_positions;
 
 // We need a callback function to register. See UrDriver's parameters for details.
@@ -56,15 +58,71 @@ void handleRobotProgramState(bool program_running)
 
 int main(int argc, char* argv[])
 {
+  urcl::setLogLevel(urcl::LogLevel::INFO);
+
+  // Parse the ip arguments if given
+  std::string robot_ip = DEFAULT_ROBOT_IP;
+  if (argc > 1)
+  {
+    robot_ip = std::string(argv[1]);
+  }
+
+  // Making the robot ready for the program by:
+  // Connect the the robot Dashboard
+  my_dashboard.reset(new DashboardClient(robot_ip));
+  if (!my_dashboard->connect())
+  {
+    URCL_LOG_ERROR("Could not connect to dashboard");
+    return 1;
+  }
+
+  // Stop program, if there is one running
+  if (!my_dashboard->commandStop())
+  {
+    URCL_LOG_ERROR("Could not send stop program command");
+    return 1;
+  }
+
+  // Power it on
+  if (!my_dashboard->commandPowerOff())
+  {
+    URCL_LOG_ERROR("Could not send Power off command");
+    return 1;
+  }
+
+  // Power it on
+  if (!my_dashboard->commandPowerOn())
+  {
+    URCL_LOG_ERROR("Could not send Power on command");
+    return 1;
+  }
+
+  // Release the brakes
+  if (!my_dashboard->commandBreakeRelease())
+  {
+    URCL_LOG_ERROR("Could not send BreakeRelease command");
+    return 1;
+  }
+
+  // Now the robot is ready to receive a program
+
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  g_my_driver.reset(new UrDriver(ROBOT_IP, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, false,
+  const bool HEADLESS = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
                                  std::move(tool_comm_setup), CALIBRATION_CHECKSUM));
+
   // Once RTDE communication is started, we have to make sure to read from the interface buffer, as
   // otherwise we will get pipeline overflows. Therefor, do this directly before starting your main
   // loop.
+
   g_my_driver->startRTDECommunication();
+
   double increment = 0.01;
-  while (true)
+
+  bool passed_slow_part = false;
+  bool passed_fast_part = false;
+  URCL_LOG_INFO("Start moving the robot");
+  while (!(passed_slow_part && passed_fast_part))
   {
     // Read latest RTDE package. This will block for a hard-coded timeout (see UrDriver), so the
     // robot will effectively be in charge of setting the frequency of this loop.
@@ -84,20 +142,28 @@ int main(int argc, char* argv[])
       // Simple motion command of last joint
       if (g_joint_positions[5] > 3)
       {
+        passed_fast_part = increment > 0.01 || passed_fast_part;
         increment = -3;  // this large jump will activate speed scaling
       }
       else if (g_joint_positions[5] < -3)
       {
+        passed_slow_part = increment < 0.01 || passed_slow_part;
         increment = 0.02;
       }
       g_joint_positions[5] += increment;
-      g_my_driver->writeJointCommand(g_joint_positions, comm::ControlMode::MODE_SERVOJ);
-      std::cout << data_pkg->toString() << std::endl;
+      bool ret = g_my_driver->writeJointCommand(g_joint_positions, comm::ControlMode::MODE_SERVOJ);
+      if (!ret)
+      {
+        URCL_LOG_ERROR("Could not send joint command. Is the robot in remote control?");
+        return 1;
+      }
+      URCL_LOG_DEBUG("data_pkg:\n%s", data_pkg->toString());
     }
     else
     {
-      std::cout << "Could not get fresh data package from robot" << std::endl;
+      URCL_LOG_WARN("Could not get fresh data package from robot");
     }
   }
+  URCL_LOG_INFO("Movement done");
   return 0;
 }

examples/primary_pipeline.cpp

@@ -34,12 +34,29 @@ using namespace urcl;
 
 // In a real-world example it would be better to get those values from command line parameters / a better configuration
 // system such as Boost.Program_options
-const std::string ROBOT_IP = "192.168.56.101";
+const std::string DEFAULT_ROBOT_IP = "127.0.0.1";
 
 int main(int argc, char* argv[])
 {
+  // Set the loglevel to info get print out the DH parameters
+  urcl::setLogLevel(urcl::LogLevel::INFO);
+
+  // Parse the ip arguments if given
+  std::string robot_ip = DEFAULT_ROBOT_IP;
+  if (argc > 1)
+  {
+    robot_ip = std::string(argv[1]);
+  }
+
+  // Parse how may seconds to run
+  int second_to_run = -1;
+  if (argc > 2)
+  {
+    second_to_run = std::stoi(argv[2]);
+  }
+
   // First of all, we need a stream that connects to the robot
-  comm::URStream<primary_interface::PrimaryPackage> primary_stream(ROBOT_IP, urcl::primary_interface::UR_PRIMARY_PORT);
+  comm::URStream<primary_interface::PrimaryPackage> primary_stream(robot_ip, urcl::primary_interface::UR_PRIMARY_PORT);
 
   // This will parse the primary packages
   primary_interface::PrimaryParser parser;
@@ -62,9 +79,9 @@ int main(int argc, char* argv[])
 
   // Package contents will be printed while not being interrupted
   // Note: Packages for which the parsing isn't implemented, will only get their raw bytes printed.
-  while (true)
+  do
   {
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-  }
+    std::this_thread::sleep_for(std::chrono::seconds(second_to_run));
+  } while (second_to_run < 0);
   return 0;
 }

examples/rtde_client.cpp

@@ -29,21 +29,36 @@
 
 #include <iostream>
 #include <memory>
+#include <ctime>
 
 using namespace urcl;
 
 // In a real-world example it would be better to get those values from command line parameters / a better configuration
 // system such as Boost.Program_options
-const std::string ROBOT_IP = "192.168.56.101";
+const std::string DEFAULT_ROBOT_IP = "127.0.0.1";
 const std::string OUTPUT_RECIPE = "examples/resources/rtde_output_recipe.txt";
 const std::string INPUT_RECIPE = "examples/resources/rtde_input_recipe.txt";
 const std::chrono::milliseconds READ_TIMEOUT{ 100 };
 
 int main(int argc, char* argv[])
 {
+  // Parse the ip arguments if given
+  std::string robot_ip = DEFAULT_ROBOT_IP;
+  if (argc > 1)
+  {
+    robot_ip = std::string(argv[1]);
+  }
+
+  // Parse how may seconds to run
+  int second_to_run = -1;
+  if (argc > 2)
+  {
+    second_to_run = std::stoi(argv[2]);
+  }
+
   // TODO: Write good docstring for notifier
   comm::INotifier notifier;
-  rtde_interface::RTDEClient my_client(ROBOT_IP, notifier, OUTPUT_RECIPE, INPUT_RECIPE);
+  rtde_interface::RTDEClient my_client(robot_ip, notifier, OUTPUT_RECIPE, INPUT_RECIPE);
   my_client.init();
 
   // We will use the speed_slider_fraction as an example how to write to RTDE
@@ -54,7 +69,9 @@ int main(int argc, char* argv[])
   // otherwise we will get pipeline overflows. Therefor, do this directly before starting your main
   // loop.
   my_client.start();
-  while (true)
+
+  unsigned long startTime = clock();
+  while (second_to_run < 0 || ((clock() - startTime) / CLOCKS_PER_SEC) < static_cast<unsigned int>(second_to_run))
   {
     // Read latest RTDE package. This will block for READ_TIMEOUT, so the
     // robot will effectively be in charge of setting the frequency of this loop unless RTDE
@@ -69,6 +86,7 @@ int main(int argc, char* argv[])
     else
     {
       std::cout << "Could not get fresh data package from robot" << std::endl;
+      return 1;
     }
 
     if (!my_client.getWriter().sendSpeedSlider(speed_slider_fraction))
@@ -78,6 +96,7 @@ int main(int argc, char* argv[])
       std::cout << "\033[1;31mSending RTDE data failed."
                 << "\033[0m\n"
                 << std::endl;
+      return 1;
     }
 
     // Change the speed slider so that it will move between 0 and 1 all the time. This is for
@@ -96,5 +115,8 @@ int main(int argc, char* argv[])
     speed_slider_fraction += speed_slider_increment;
   }
 
+  // Resetting the speedslider back to 100%
+  my_client.getWriter().sendSpeedSlider(1);
+
   return 0;
 }