Add autoconnect parameter to dashboard client (backport #1881) (#1889)

mergify[bot] · web-flow · commit bade17fcc647 · 2026-07-17T13:55:41.000+02:00
Defer primary version discovery and DashboardClient construction into
connect() so the node can start without a reachable robot when
autoconnect is false, then connect later via ~/connect.
diff --git a/ur_robot_driver/doc/dashboard_client.rst b/ur_robot_driver/doc/dashboard_client.rst
@@ -36,7 +36,7 @@ Close a safety popup on the teach pendant.
 connect (`std_srvs/Trigger <http://docs.ros.org/en/rolling/p/std_srvs/srv/Trigger.html>`_)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Service to reconnect to the dashboard server
+Service to connect or reconnect to the dashboard server. Required after startup when ``autoconnect`` is ``false``.
 
 download_program (`ur_dashboard_msgs/DownloadProgram <http://docs.ros.org/en/rolling/p/ur_dashboard_msgs/srv/DownloadProgram.html>`_)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -230,6 +230,14 @@ Defaults to saving to the programs folder
 Parameters
 ----------
 
+autoconnect (default: true)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If ``true`` (default), the dashboard client connects to the robot during startup and retries until
+the connection succeeds or ROS is shut down. If ``false``, the node starts without contacting the
+robot and only exposes the ``~/connect`` service until a connection succeeds; call ``~/connect``
+once the robot is available to register the remaining dashboard services.
+
 receive_timeout (default: 20.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/ur_robot_driver/include/ur_robot_driver/dashboard_client_ros.hpp b/ur_robot_driver/include/ur_robot_driver/dashboard_client_ros.hpp
@@ -200,8 +200,10 @@ class DashboardClientROS
                                       ur_dashboard_msgs::srv::GetPolyScopeVersion::Response::SharedPtr resp);
 
   bool connect();
+  void initServices(urcl::DashboardClient::ClientPolicy dashboard_policy);
 
   std::shared_ptr<rclcpp::Node> node_;
+  std::string robot_ip_;
   std::unique_ptr<urcl::DashboardClient> client_;
 
   urcl::comm::INotifier notifier_;
diff --git a/ur_robot_driver/launch/ur_dashboard_client.launch.py b/ur_robot_driver/launch/ur_dashboard_client.launch.py
@@ -49,10 +49,19 @@ def generate_launch_description():
             description="Timeout that the dashboard client will wait for a response from the robot.",
         )
     )
+    declared_arguments.append(
+        DeclareLaunchArgument(
+            "autoconnect",
+            default_value="true",
+            description="Automatically connect to the robot dashboard server on startup. "
+            "If false, call the ~/connect service after the robot is available.",
+        )
+    )
 
     # Initialize Arguments
     robot_ip = LaunchConfiguration("robot_ip")
     dashboard_receive_timeout = LaunchConfiguration("dashboard_receive_timeout")
+    autoconnect = LaunchConfiguration("autoconnect")
 
     dashboard_client_node = Node(
         package="ur_robot_driver",
@@ -63,6 +72,7 @@ def generate_launch_description():
         parameters=[
             {"robot_ip": robot_ip},
             {"receive_timeout": dashboard_receive_timeout},
+            {"autoconnect": autoconnect},
         ],
     )
 
diff --git a/ur_robot_driver/src/dashboard_client_ros.cpp b/ur_robot_driver/src/dashboard_client_ros.cpp
@@ -50,13 +50,59 @@
 namespace ur_robot_driver
 {
 DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, const std::string& robot_ip)
-  : node_(node), primary_client_(robot_ip, notifier_)
+  : node_(node), robot_ip_(robot_ip), primary_client_(robot_ip, notifier_)
 {
   node_->declare_parameter<double>("receive_timeout", 20);
+  node_->declare_parameter<bool>("autoconnect", true);
 
   param_callback_handle_ = node_->add_on_set_parameters_callback(
       std::bind(&DashboardClientROS::parametersCallback, this, std::placeholders::_1));
 
+  reconnect_service_ = node_->create_service<std_srvs::srv::Trigger>(
+      "~/connect",
+      [&](const std_srvs::srv::Trigger::Request::SharedPtr /*req*/, std_srvs::srv::Trigger::Response::SharedPtr resp) {
+        try {
+          resp->success = connect();
+        } catch (const urcl::UrException& e) {
+          RCLCPP_ERROR(rclcpp::get_logger("Dashboard_Client"), "Service Call failed: '%s'", e.what());
+          resp->message = e.what();
+          resp->success = false;
+        }
+        return true;
+      });
+
+  if (node_->get_parameter("autoconnect").as_bool()) {
+    while (!connect()) {
+      RCLCPP_ERROR(node_->get_logger(),
+                   "Failed to connect to Dashboard Server at %s. Please check the IP address and ensure the robot is "
+                   "powered on and has the dashboard server enabled. Retrying in 5 seconds.",
+                   robot_ip_.c_str());
+      if (rclcpp::ok()) {
+        rclcpp::sleep_for(std::chrono::seconds(5));
+      } else {
+        RCLCPP_ERROR(node_->get_logger(), "ROS is shutting down, exiting now.");
+        return;
+      }
+    }
+  } else {
+    RCLCPP_INFO(node_->get_logger(),
+                "Dashboard client started with autoconnect disabled. Call the ~/connect service to connect to %s.",
+                robot_ip_.c_str());
+  }
+}
+
+bool DashboardClientROS::connect()
+{
+  if (client_) {
+    timeval tv;
+    double time_buffer = 0;
+    node_->get_parameter("receive_timeout", time_buffer);
+    tv.tv_sec = time_buffer;
+    tv.tv_usec = (time_buffer - static_cast<int>(time_buffer)) * 1e6;
+    client_->setReceiveTimeout(tv);
+    return client_->connect();
+  }
+
   primary_client_.start(10, std::chrono::seconds(10));
   auto robot_version = primary_client_.getRobotVersion();
   primary_client_.stop();
@@ -73,25 +119,36 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
     dashboard_policy = urcl::DashboardClient::ClientPolicy::POLYSCOPE_X;
   }
 
-  RCLCPP_INFO(node_->get_logger(), "Connecting to Dashboard Server at %s with policy %s", robot_ip.c_str(),
+  RCLCPP_INFO(node_->get_logger(), "Connecting to Dashboard Server at %s with policy %s", robot_ip_.c_str(),
               dashboard_policy == urcl::DashboardClient::ClientPolicy::G5 ? "G5" : "Polyscope X");
-  client_ = std::make_unique<urcl::DashboardClient>(robot_ip, dashboard_policy);
-
-  while (!connect()) {
-    RCLCPP_ERROR(node_->get_logger(),
-                 "Failed to connect to Dashboard Server at %s. Please check the IP address and ensure the robot is "
-                 "powered on and has the dashboard server enabled. Retrying in 5 seconds.",
-                 robot_ip.c_str());
-    if (rclcpp::ok()) {
-      rclcpp::sleep_for(std::chrono::seconds(5));
-    } else {
-      RCLCPP_ERROR(node_->get_logger(), "ROS is shutting down, exiting now.");
-      return;
-    }
+  client_ = std::make_unique<urcl::DashboardClient>(robot_ip_, dashboard_policy);
+
+  timeval tv;
+  // Timeout after which a call to the dashboard server will be considered failure if no answer has been received.
+  double time_buffer = 0;
+  node_->get_parameter("receive_timeout", time_buffer);
+  tv.tv_sec = time_buffer;
+  tv.tv_usec = (time_buffer - static_cast<int>(time_buffer)) * 1e6;
+  bool connected = false;
+  try {
+    client_->setReceiveTimeout(tv);
+    connected = client_->connect();
+  } catch (const urcl::UrException& e) {
+    RCLCPP_ERROR(rclcpp::get_logger("Dashboard_Client"), "Connect failed: '%s'", e.what());
   }
+  if (!connected) {
+    client_.reset();
+    return false;
+  }
+
   RCLCPP_INFO(node_->get_logger(), "Successfully connected to Dashboard Server at %s. Robot has version %s",
-              robot_ip.c_str(), robot_version->toString().c_str());
+              robot_ip_.c_str(), robot_version->toString().c_str());
+  initServices(dashboard_policy);
+  return true;
+}
 
+void DashboardClientROS::initServices(urcl::DashboardClient::ClientPolicy dashboard_policy)
+{
   // Service to release the brakes. If the robot is currently powered off, it will get powered on on the fly.
   brake_release_service_ = createDashboardTriggerSrv(
       "~/brake_release", std::bind(&urcl::DashboardClient::commandBrakeReleaseWithResponse, client_.get()));
@@ -183,7 +240,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Load a robot program from a file
-  load_program_service_ = node->create_service<ur_dashboard_msgs::srv::Load>(
+  load_program_service_ = node_->create_service<ur_dashboard_msgs::srv::Load>(
       "~/load_program", [&](const ur_dashboard_msgs::srv::Load::Request::SharedPtr req,
                             ur_dashboard_msgs::srv::Load::Response::SharedPtr resp) {
         auto dashboard_response = dashboardCallWithChecks(
@@ -231,7 +288,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to get serial number of the robot
-  get_serial_number_service_ = node->create_service<ur_dashboard_msgs::srv::GetSerialNumber>(
+  get_serial_number_service_ = node_->create_service<ur_dashboard_msgs::srv::GetSerialNumber>(
       "~/get_serial_number", [&](const ur_dashboard_msgs::srv::GetSerialNumber::Request::SharedPtr /*unused*/,
                                  ur_dashboard_msgs::srv::GetSerialNumber::Response::SharedPtr resp) {
         auto dashboard_response =
@@ -258,14 +315,14 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       std::bind(&DashboardClientROS::handleRobotModeQuery, this, std::placeholders::_1, std::placeholders::_2));
 
   // Service to add a message to the robot's log
-  add_to_log_service_ = node->create_service<ur_dashboard_msgs::srv::AddToLog>(
+  add_to_log_service_ = node_->create_service<ur_dashboard_msgs::srv::AddToLog>(
       "~/add_to_log", [&](const ur_dashboard_msgs::srv::AddToLog::Request::SharedPtr req,
                           ur_dashboard_msgs::srv::AddToLog::Response::SharedPtr resp) {
         dashboardCallWithChecks([this, req]() { return client_->commandAddToLogWithResponse(req->message); }, resp);
         return true;
       });
   // Service to get the polyscope version running on the robot
-  get_polyscope_version_service_ = node->create_service<ur_dashboard_msgs::srv::GetPolyScopeVersion>(
+  get_polyscope_version_service_ = node_->create_service<ur_dashboard_msgs::srv::GetPolyScopeVersion>(
       "~/get_polyscope_version", std::bind(&DashboardClientROS::handleGetPolyScopeVersionQuery, this,
                                            std::placeholders::_1, std::placeholders::_2));
 
@@ -282,20 +339,6 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
         return true;
       });
 
-  // Service to reconnect to the dashboard server
-  reconnect_service_ = node_->create_service<std_srvs::srv::Trigger>(
-      "~/connect",
-      [&](const std_srvs::srv::Trigger::Request::SharedPtr req, std_srvs::srv::Trigger::Response::SharedPtr resp) {
-        try {
-          resp->success = connect();
-        } catch (const urcl::UrException& e) {
-          RCLCPP_ERROR(rclcpp::get_logger("Dashboard_Client"), "Service Call failed: '%s'", e.what());
-          resp->message = e.what();
-          resp->success = false;
-        }
-        return true;
-      });
-
   // Disconnect from the dashboard service.
   quit_service_ =
       createDashboardTriggerSrv("~/quit", std::bind(&urcl::DashboardClient::commandQuitWithResponse, client_.get()));
@@ -370,7 +413,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to set the user role on the robot (Only valid for CB3 robots)
-  set_user_role_service_ = node->create_service<ur_dashboard_msgs::srv::SetUserRole>(
+  set_user_role_service_ = node_->create_service<ur_dashboard_msgs::srv::SetUserRole>(
       "~/set_user_role", [&](const ur_dashboard_msgs::srv::SetUserRole::Request::SharedPtr req,
                              ur_dashboard_msgs::srv::SetUserRole::Response::SharedPtr resp) {
         dashboardCallWithChecks([this, req]() { return client_->commandSetUserRoleWithResponse(req->user_role.role); },
@@ -379,7 +422,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to get the current user role (Only valid for CB3)
-  get_user_role_service_ = node->create_service<ur_dashboard_msgs::srv::GetUserRole>(
+  get_user_role_service_ = node_->create_service<ur_dashboard_msgs::srv::GetUserRole>(
       "~/get_user_role", [&](const ur_dashboard_msgs::srv::GetUserRole::Request::SharedPtr /*unused*/,
                              ur_dashboard_msgs::srv::GetUserRole::Response::SharedPtr resp) {
         auto dashboard_response =
@@ -395,7 +438,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to set the operational mode. (e-series only)
-  set_operational_mode_service_ = node->create_service<ur_dashboard_msgs::srv::SetOperationalMode>(
+  set_operational_mode_service_ = node_->create_service<ur_dashboard_msgs::srv::SetOperationalMode>(
       "~/set_operational_mode", [&](const ur_dashboard_msgs::srv::SetOperationalMode::Request::SharedPtr req,
                                     ur_dashboard_msgs::srv::SetOperationalMode::Response::SharedPtr resp) {
         dashboardCallWithChecks(
@@ -404,7 +447,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to get the current operational mode (e-series only)
-  get_operational_mode_service_ = node->create_service<ur_dashboard_msgs::srv::GetOperationalMode>(
+  get_operational_mode_service_ = node_->create_service<ur_dashboard_msgs::srv::GetOperationalMode>(
       "~/get_operational_mode", [&](const ur_dashboard_msgs::srv::GetOperationalMode::Request::SharedPtr /*unused*/,
                                     ur_dashboard_msgs::srv::GetOperationalMode::Response::SharedPtr resp) {
         auto dashboard_response =
@@ -420,7 +463,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to get the robot model as a string
-  get_robot_model_service_ = node->create_service<ur_dashboard_msgs::srv::GetRobotModel>(
+  get_robot_model_service_ = node_->create_service<ur_dashboard_msgs::srv::GetRobotModel>(
       "~/get_robot_model", [&](const ur_dashboard_msgs::srv::GetRobotModel::Request::SharedPtr /*unused*/,
                                ur_dashboard_msgs::srv::GetRobotModel::Response::SharedPtr resp) {
         auto dashboard_response =
@@ -436,12 +479,12 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to get robot safety status as a string
-  get_safety_status_service_ = node->create_service<ur_dashboard_msgs::srv::GetSafetyStatus>(
+  get_safety_status_service_ = node_->create_service<ur_dashboard_msgs::srv::GetSafetyStatus>(
       "~/get_safety_status",
       std::bind(&DashboardClientROS::handleSafetyStatusQuery, this, std::placeholders::_1, std::placeholders::_2));
 
   // Service to generate flight report, defaults to system type
-  generate_flight_report_service_ = node->create_service<ur_dashboard_msgs::srv::GenerateFlightReport>(
+  generate_flight_report_service_ = node_->create_service<ur_dashboard_msgs::srv::GenerateFlightReport>(
       "~/generate_flight_report", [&](const ur_dashboard_msgs::srv::GenerateFlightReport::Request::SharedPtr req,
                                       ur_dashboard_msgs::srv::GenerateFlightReport::Response::SharedPtr resp) {
         auto dashboard_response = dashboardCallWithChecks(
@@ -462,7 +505,7 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 
   // Service to generate support file, defaults to saving the file in /programs
-  generate_support_file_service_ = node->create_service<ur_dashboard_msgs::srv::GenerateSupportFile>(
+  generate_support_file_service_ = node_->create_service<ur_dashboard_msgs::srv::GenerateSupportFile>(
       "~/generate_support_file", [&](const ur_dashboard_msgs::srv::GenerateSupportFile::Request::SharedPtr req,
                                      ur_dashboard_msgs::srv::GenerateSupportFile::Response::SharedPtr resp) {
         auto dashboard_response = dashboardCallWithChecks(
@@ -483,18 +526,6 @@ DashboardClientROS::DashboardClientROS(const rclcpp::Node::SharedPtr& node, cons
       });
 }
 
-bool DashboardClientROS::connect()
-{
-  timeval tv;
-  // Timeout after which a call to the dashboard server will be considered failure if no answer has been received.
-  double time_buffer = 0;
-  node_->get_parameter("receive_timeout", time_buffer);
-  tv.tv_sec = time_buffer;
-  tv.tv_usec = (time_buffer - static_cast<int>(time_buffer)) * 1e6;
-  client_->setReceiveTimeout(tv);
-  return client_->connect();
-}
-
 bool DashboardClientROS::handleRunningQuery(const ur_dashboard_msgs::srv::IsProgramRunning::Request::SharedPtr req,
                                             ur_dashboard_msgs::srv::IsProgramRunning::Response::SharedPtr resp)
 {
@@ -720,12 +751,14 @@ DashboardClientROS::parametersCallback(const std::vector<rclcpp::Parameter>& par
 
   for (const auto& parameter : parameters) {
     if (parameter.get_name() == "receive_timeout") {
-      timeval tv;
-      double time_buffer = parameter.as_double();
-      tv.tv_sec = time_buffer;
-      tv.tv_usec = (time_buffer - static_cast<int>(time_buffer)) * 1e6;
-      client_->setReceiveTimeout(tv);
-      RCLCPP_INFO(node_->get_logger(), "Set receive_timeout to %f seconds", time_buffer);
+      if (client_) {
+        timeval tv;
+        double time_buffer = parameter.as_double();
+        tv.tv_sec = time_buffer;
+        tv.tv_usec = (time_buffer - static_cast<int>(time_buffer)) * 1e6;
+        client_->setReceiveTimeout(tv);
+      }
+      RCLCPP_INFO(node_->get_logger(), "Set receive_timeout to %f seconds", parameter.as_double());
     } else {
       result.successful = false;
       result.reason = "Requested to change parameter '" + parameter.get_name() +
diff --git a/ur_robot_driver/test/dashboard_client.py b/ur_robot_driver/test/dashboard_client.py
@@ -40,25 +40,32 @@
 sys.path.append(os.path.dirname(__file__))
 from test_common import (  # noqa: E402
     DashboardInterface,
+    connect_dashboard_client,
     generate_dashboard_test_description,
 )
 
 
 @pytest.mark.launch_test
 @launch_testing.parametrize(
-    "ursim_version, ur_type",
-    [("latest", "ur30"), ("10.12.0", "ur15"), ("3.15.8", "ur10")],
+    "ursim_version, ur_type, autoconnect",
+    [
+        ("latest", "ur30", "false"),
+        ("10.12.0", "ur15", "true"),
+        ("3.15.8", "ur10", "true"),
+    ],
 )
-def generate_test_description(ursim_version, ur_type):
-    return generate_dashboard_test_description(ursim_version, ur_type)
+def generate_test_description(ursim_version, ur_type, autoconnect):
+    return generate_dashboard_test_description(ursim_version, ur_type, autoconnect)
 
 
 class DashboardClientTest(unittest.TestCase):
     @classmethod
-    def setUpClass(cls, ursim_version):
+    def setUpClass(cls, ursim_version, autoconnect):
         # Initialize the ROS context
         rclpy.init()
         cls.node = Node("dashboard_client_test")
+        if autoconnect == "false":
+            connect_dashboard_client(cls.node)
         cls.init_robot(cls, ursim_version)
 
     @classmethod
diff --git a/ur_robot_driver/test/test_common.py b/ur_robot_driver/test/test_common.py
