Modernize timeout interface

This should be more clear to API users what the timeouts actually mean and
this should be more platform independent to use std::this_thread::sleep_for
instead of usleep.

Author: Felix Exner

include/ur_client_library/ur/dashboard_client.h

@@ -94,26 +94,30 @@ class DashboardClient : public comm::TCPSocket
    *
    * \param command Command that will be sent to the server
    * \param expected Expected replay
-   * \param timeout Timeout time in seconds
+   * \param timeout Timeout to wait before the command is considered failed.
    *
    *  \return True if the reply was as expected within the timeout time
    */
-  bool waitForReply(const std::string& command, const std::string& expected, double timeout = 30.0);
+  bool waitForReply(const std::string& command, const std::string& expected,
+                    std::chrono::duration<double> timeout = std::chrono::seconds(30));
 
   /*!
-   * \brief Keep Sending the requesting Command and wait until it returns the expected answer
+   * \brief Keep Sending the requesting Command and wait until it returns the expected answer.
    *
    * \param requestCommand Request command that will be sent to the server
    * \param requestExpectedResponse The expected reply to the request
    * \param waitRequest The status request
    * \param waitExpectedResponse The expected reply on the status
-   * \param timeout Timeout time in seconds
+   * \param timeout Timeout before the command is ultimately considered failed
+   * \param retry_period Retries will be done with this period
    *
    * \return True when both the requested command was receive with the expected reply as well as the resulting status
    * also is as expected within the timeout time
    */
   bool retryCommand(const std::string& requestCommand, const std::string& requestExpectedResponse,
-                    const std::string& waitRequest, const std::string& waitExpectedResponse, unsigned int timeout);
+                    const std::string& waitRequest, const std::string& waitExpectedResponse,
+                    const std::chrono::duration<double> timeout,
+                    const std::chrono::duration<double> retry_period = std::chrono::seconds(1));
 
   /*!
    * \brief Send Power off command
@@ -125,11 +129,12 @@ class DashboardClient : public comm::TCPSocket
   /*!
    * \brief Send Power on command
    *
-   * \param timeout Timeout in seconds
+   * \param timeout Timeout in seconds - The robot might take some time to boot before this call can
+   * be made successfully.
    *
    * \return True succeeded
    */
-  bool commandPowerOn(unsigned int timeout = 1200);
+  bool commandPowerOn(const std::chrono::duration<double> timeout = std::chrono::seconds(300));
 
   /*!
    * \brief Send Brake release command

src/ur/dashboard_client.cpp

@@ -27,11 +27,14 @@
 //----------------------------------------------------------------------
 
 #include <regex>
+#include <thread>
 #include <unistd.h>
 #include <ur_client_library/log.h>
 #include <ur_client_library/ur/dashboard_client.h>
 #include <ur_client_library/exceptions.h>
 
+using namespace std::chrono_literals;
+
 namespace urcl
 {
 DashboardClient::DashboardClient(const std::string& host) : host_(host), port_(DASHBOARD_SERVER_PORT)
@@ -131,14 +134,15 @@ bool DashboardClient::sendRequest(const std::string& command, const std::string&
   return ret;
 }
 
-bool DashboardClient::waitForReply(const std::string& command, const std::string& expected, double timeout)
+bool DashboardClient::waitForReply(const std::string& command, const std::string& expected,
+                                   const std::chrono::duration<double> timeout)
 {
-  const unsigned int TIME_STEP_SIZE_US(100000);  // 100ms
+  const std::chrono::duration<double> wait_period = 100ms;
 
-  double count = 0;
+  std::chrono::duration<double> time_done(0);
   std::string response;
 
-  while (count < timeout)
+  while (time_done < timeout)
   {
     // Send the request
     response = sendAndReceive(command + "\n");
@@ -150,8 +154,8 @@ bool DashboardClient::waitForReply(const std::string& command, const std::string
     }
 
     // wait 100ms before trying again
-    usleep(TIME_STEP_SIZE_US);
-    count = count + (0.000001 * TIME_STEP_SIZE_US);
+    std::this_thread::sleep_for(wait_period);
+    time_done += wait_period;
   }
 
   URCL_LOG_WARN("Did not got the expected \"%s\" respone within the timeout. Last respone was: \"%s\"",
@@ -161,20 +165,20 @@ bool DashboardClient::waitForReply(const std::string& command, const std::string
 
 bool DashboardClient::retryCommand(const std::string& requestCommand, const std::string& requestExpectedResponse,
                                    const std::string& waitRequest, const std::string& waitExpectedResponse,
-                                   unsigned int timeout)
+                                   const std::chrono::duration<double> timeout,
+                                   const std::chrono::duration<double> retry_period)
 {
-  const double RETRY_EVERY_SECOND(1.0);
-  unsigned int count(0);
+  std::chrono::duration<double> time_done(0);
   do
   {
     sendRequest(requestCommand, requestExpectedResponse);
-    count++;
+    time_done += retry_period;
 
-    if (waitForReply(waitRequest, waitExpectedResponse, RETRY_EVERY_SECOND))
+    if (waitForReply(waitRequest, waitExpectedResponse, retry_period))
     {
       return true;
     }
-  } while (count < timeout);
+  } while (time_done < timeout);
   return false;
 }
 
@@ -183,7 +187,7 @@ bool DashboardClient::commandPowerOff()
   return sendRequest("power off", "Powering off") && waitForReply("robotmode", "Robotmode: POWER_OFF");
 }
 
-bool DashboardClient::commandPowerOn(unsigned int timeout)
+bool DashboardClient::commandPowerOn(const std::chrono::duration<double> timeout)
 {
   return retryCommand("power on", "Powering on", "robotmode", "Robotmode: IDLE", timeout);
 }