Adding function to interact with the robot through the dashboard

Adding short function to make it easier to:
- Power off
- Power on
- Brake release
- Load a program
- Play
- Pause
- Stop
- Close popup
- Close safety popup
- Restart safety
- Unlock protective stop
- Shutdown

Author: urrsk

examples/dashboard_example.cpp

@@ -0,0 +1,127 @@
+// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-
+
+// -- BEGIN LICENSE BLOCK ----------------------------------------------
+// Copyright 2022 Universal Robots A/S
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -- END LICENSE BLOCK ------------------------------------------------
+
+#include <ur_client_library/log.h>
+#include <ur_client_library/ur/dashboard_client.h>
+
+#include <iostream>
+#include <memory>
+
+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 DEFAULT_ROBOT_IP = "127.0.0.1";
+
+std::unique_ptr<DashboardClient> my_dashboard;
+
+// We need a callback function to register. See UrDriver's parameters for details.
+void handleRobotProgramState(bool program_running)
+{
+  // Print the text in green so we see it better
+  std::cout << "\033[1;32mProgram running: " << std::boolalpha << program_running << "\033[0m\n" << std::endl;
+}
+
+int main(int argc, char* argv[])
+{
+  urcl::setLogLevel(urcl::LogLevel::DEBUG);
+
+  // 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;
+  }
+
+  if (!my_dashboard->commandPowerOff())
+  {
+    URCL_LOG_ERROR("Could not send power off");
+    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;
+  }
+
+  // Load existing program
+  const std::string program_file_name_to_be_loaded("wait_program.urp");
+  if (!my_dashboard->commandLoadProgram(program_file_name_to_be_loaded))
+  {
+    URCL_LOG_ERROR("Could not load %s program", program_file_name_to_be_loaded.c_str());
+    return 1;
+  }
+
+  // Play loaded program
+  if (!my_dashboard->commandPlay())
+  {
+    URCL_LOG_ERROR("Could not play program");
+    return 1;
+  }
+
+  // Pause running program
+  if (!my_dashboard->commandPause())
+  {
+    URCL_LOG_ERROR("Could not pause program");
+    return 1;
+  }
+
+  // Play loaded program
+  if (!my_dashboard->commandPlay())
+  {
+    URCL_LOG_ERROR("Could not play program");
+    return 1;
+  }
+
+  // Stop program
+  if (!my_dashboard->commandStop())
+  {
+    URCL_LOG_ERROR("Could not stop program");
+    return 1;
+  }
+
+  // Power it off
+  if (!my_dashboard->commandPowerOff())
+  {
+    URCL_LOG_ERROR("Could not send Power off command");
+    return 1;
+  }
+
+  // Now the robot is ready to receive a program
+
+  return 0;
+}

include/ur_client_library/ur/dashboard_client.h

@@ -78,6 +78,131 @@ class DashboardClient : public comm::TCPSocket
    */
   std::string sendAndReceive(const std::string& command);
 
+  /*!
+   * \brief Sends command and compare it with the expected answer
+   *
+   * \param command Command that will be sent to the server. It is important, that the command sent is finished with a
+   * '\n' (newline) so it will be processed by the server.
+   * \param expected Expected replay
+   *
+   * \return True if the reply to the command is as expected
+   */
+  bool sendRequest(const std::string& command, const std::string& expected);
+
+  /*!
+   * \brief brief Sends a command and wait until it returns the expected answer
+   *
+   * \param command Command that will be sent to the server
+   * \param expected Expected replay
+   * \param timeout Timeout time in seconds
+   *
+   *  \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);
+
+  /*!
+   * \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
+   *
+   * \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);
+
+  /*!
+   * \brief Send Power off command
+   *
+   * \return True succeeded
+   */
+  bool commandPowerOff();
+
+  /*!
+   * \brief Send Power on command
+   *
+   * \param timeout Timeout in seconds
+   *
+   * \return True succeeded
+   */
+  bool commandPowerOn(unsigned int timeout = 1200);
+
+  /*!
+   * \brief Send Brake release command
+   *
+   * \return True succeeded
+   */
+  bool commandBreakeRelease();
+
+  /*!
+   * \brief Send Load program command
+   *
+   * \param program_file_name The urp program file name with the urp extension
+   *
+   * \return True succeeded
+   */
+  bool commandLoadProgram(const std::string& program_file_name);
+
+  /*!
+   * \brief Send Play program command
+   *
+   * \return True succeeded
+   */
+  bool commandPlay();
+
+  /*!
+   * \brief Send Pause program command
+   *
+   * \return True succeeded
+   */
+  bool commandPause();
+
+  /*!
+   * \brief Send Stop program command
+   *
+   * \return True succeeded
+   */
+  bool commandStop();
+
+  /*!
+   * \brief Send Close popup command
+   *
+   * \return True succeeded
+   */
+  bool commandClosePopup();
+
+  /*!
+   * \brief Send Close safety popup command
+   *
+   * \return True succeeded
+   */
+  bool commandCloseSafetyPopup();
+
+  /*!
+   * \brief Send Restart Safety command
+   *
+   * \return True succeeded
+   */
+  bool commandRestartSafety();
+
+  /*!
+   * \brief Send Unlock Protective stop popup command
+   *
+   * \return True succeeded
+   */
+  bool commandUnlockProtectiveStop();
+
+  /*!
+   * \brief Send Shutdown command
+   *
+   * \return True succeeded
+   */
+  bool commandShutdown();
+
 protected:
   virtual bool open(int socket_fd, struct sockaddr* address, size_t address_len)
   {
@@ -87,11 +212,7 @@ class DashboardClient : public comm::TCPSocket
 private:
   bool send(const std::string& text);
   std::string read();
-
-  void rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
-  {
-    str.erase(str.find_last_not_of(chars) + 1);
-  }
+  void rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ");
 
   std::string host_;
   int port_;