Skip checking whether there already is a program running

Author: urfeex

include/ur_client_library/exceptions.h

@@ -32,7 +32,6 @@
 #include <chrono>
 #include <stdexcept>
 #include <sstream>
-#include <string>
 #include "ur/version_information.h"
 
 #ifdef _WIN32
@@ -204,22 +203,5 @@ class MissingArgument : public UrException
     return text_.c_str();
   }
 };
-
-class InvalidStateForCommand : public UrException
-{
-private:
-  std::string text_;
-
-public:
-  explicit InvalidStateForCommand() = delete;
-  explicit InvalidStateForCommand(std::string text) : std::runtime_error(text)
-  {
-    text_ = text;
-  }
-  virtual const char* what() const noexcept override
-  {
-    return text_.c_str();
-  }
-};
 }  // namespace urcl
 #endif  // ifndef UR_CLIENT_LIBRARY_EXCEPTIONS_H_INCLUDED

include/ur_client_library/primary/primary_client.h

@@ -146,20 +146,14 @@ class PrimaryClient
   /*!
    * /brief Stop execution of a running or paused program
    *
-   * Blocks until the robot has come to a standstill (while following
-   * the program path) and stopped program execution.
-   *
-   * \param already_stopped_ok If true, the function will return true if the robot is already
-   * stopped.
    * \param validate If true, the function will block until the robot has stopped or the timeout
    * passed by.
    * \param timeout The maximum time to wait for the robot to stop the program.
    *
    * \throws urcl::UrException if the command cannot be sent to the robot.
    * \throws urcl::TimeoutException if the robot doesn't stop the program within the given timeout.
    */
-  void commandStop(const bool already_stopped_ok = false, const bool validate = true,
-                   const std::chrono::milliseconds timeout = std::chrono::seconds(2));
+  void commandStop(const bool validate = true, const std::chrono::milliseconds timeout = std::chrono::seconds(2));
 
   /*!
    * \brief Get the latest robot mode.

src/primary/primary_client.cpp

@@ -238,28 +238,14 @@ void PrimaryClient::commandUnlockProtectiveStop(const bool validate, const std::
   }
 }
 
-void PrimaryClient::commandStop(const bool already_stopped_ok, const bool validate,
-                                const std::chrono::milliseconds timeout)
+void PrimaryClient::commandStop(const bool validate, const std::chrono::milliseconds timeout)
 {
   std::shared_ptr<RobotModeData> robot_mode_data = consumer_->getRobotModeData();
   if (robot_mode_data == nullptr)
   {
     throw UrException("Stopping a program while robot state is unknown. This should not happen");
   }
 
-  if (!(robot_mode_data->is_program_running_ || robot_mode_data->is_program_paused_))
-  {
-    if (already_stopped_ok)
-    {
-      URCL_LOG_DEBUG("Program halt requested, but program is already stopped, skipping.");
-      return;
-    }
-    else
-    {
-      throw InvalidStateForCommand("Cannot halt program execution, as no program is running or paused on the robot.");
-    }
-  }
-
   if (!sendScript("stop program"))
   {
     throw UrException("Failed to send the command `stop program` to robot");

tests/test_primary_client.cpp

@@ -153,15 +153,22 @@ TEST_F(PrimaryClientTest, test_stop_command)
   EXPECT_NO_THROW(client_->commandStop());
   EXPECT_FALSE(client_->getRobotModeData()->is_program_running_);
 
-  // Without a program running it should throw an exception
-  EXPECT_THROW(client_->commandStop(), InvalidStateForCommand);
+  // Without a program running it should not throw an exception
+  EXPECT_NO_THROW(client_->commandStop());
 
-  // We can specifically allow to be stopped already
-  EXPECT_NO_THROW(client_->commandStop(true));
+  EXPECT_TRUE(client_->sendScript(script_code));
+  waitFor([this]() { return client_->getRobotModeData()->is_program_running_; }, std::chrono::seconds(5));
+  EXPECT_THROW(client_->commandStop(true, std::chrono::milliseconds(1)), TimeoutException);
+  EXPECT_NO_THROW(waitFor(
+      [this]() {
+        return !client_->getRobotModeData()->is_program_running_ && !client_->getRobotModeData()->is_program_paused_;
+      },
+      std::chrono::seconds(5)));
 
+  // without validation
   EXPECT_TRUE(client_->sendScript(script_code));
   waitFor([this]() { return client_->getRobotModeData()->is_program_running_; }, std::chrono::seconds(5));
-  EXPECT_THROW(client_->commandStop(true, true, std::chrono::milliseconds(1)), TimeoutException);
+  EXPECT_NO_THROW(client_->commandStop(false));
   EXPECT_NO_THROW(waitFor(
       [this]() {
         return !client_->getRobotModeData()->is_program_running_ && !client_->getRobotModeData()->is_program_paused_;