Add set_software_trigger_enabled param and service

docs/all_available_service_for_camera_control.md

@@ -326,3 +326,9 @@ ros2 service call /camera/set_sync_interleaverlaser orbbec_camera_msgs/srv/SetIn
 ```
 ros2 service call /camera/set_sync_hosttime std_srvs/srv/SetBool '{data: true}'
 ```
+
+* `/camera/set_software_trigger_enabled`
+
+```
+ros2 service call /camera/set_software_trigger_enabled std_srvs/srv/SetBool '{data: true}'
+```

docs/launch_parameters.md

@@ -151,6 +151,8 @@ The following are the launch parameters available:
   * The delay time of the trigger signal output after receiving the capture command or trigger signal in microseconds,this parameter is usually used [multi camera synced](../orbbec_camera/examples/multi_camera_synced/README.MD)
 * **trigger_out_enabled**
   * Enable the trigger out signal,this parameter is usually used [multi camera synced](../orbbec_camera/examples/multi_camera_synced/README.MD)
+* **software_trigger_enabled**
+  * Enable the software trigger out signal,this parameter is usually used [multi camera synced](../orbbec_camera/examples/multi_camera_synced/README.MD)
 * **frames_per_trigger**
   * The frame number of each stream after each trigger in triggering mode,this parameter is usually used [multi camera synced](../orbbec_camera/examples/multi_camera_synced/README.MD)
 * **software_trigger_period**

orbbec_camera/include/orbbec_camera/ob_camera_node.h

@@ -313,6 +313,9 @@ class OBCameraNode {
                          std::shared_ptr<SetFilter ::Response>& response);
   void setSYNCHostimeCallback(const std::shared_ptr<std_srvs::srv::SetBool::Request>& request,
                               std::shared_ptr<std_srvs::srv::SetBool::Response>& response);
+  void setSoftwareTriggerEnabledCallback(
+      const std::shared_ptr<std_srvs::srv::SetBool::Request>& request,
+      std::shared_ptr<std_srvs::srv::SetBool::Response>& response);
 
   bool toggleSensor(const stream_index_pair& stream_index, bool enabled, std::string& msg);
 
@@ -493,6 +496,7 @@ class OBCameraNode {
   rclcpp::Service<std_srvs::srv::SetBool>::SharedPtr set_reset_timestamp_srv_;
   rclcpp::Service<SetInt32>::SharedPtr set_interleaver_laser_sync_srv_;
   rclcpp::Service<std_srvs::srv::SetBool>::SharedPtr set_sync_host_time_srv_;
+  rclcpp::Service<std_srvs::srv::SetBool>::SharedPtr set_software_trigger_enabled_srv_;
   rclcpp::Service<SetFilter>::SharedPtr set_filter_srv_;
 
   bool enable_sync_output_accel_gyro_ = false;
@@ -582,6 +586,7 @@ class OBCameraNode {
   int trigger2image_delay_us_ = 0;
   int trigger_out_delay_us_ = 0;
   bool trigger_out_enabled_ = false;
+  bool software_trigger_enabled_ = false;
   int frames_per_trigger_ = 2;
   bool enable_ptp_config_ = false;
   std::string depth_precision_str_;

orbbec_camera/launch/gemini_330_series.launch.py

@@ -178,6 +178,7 @@ def generate_launch_description():
         DeclareLaunchArgument('trigger2image_delay_us', default_value='0'),
         DeclareLaunchArgument('trigger_out_delay_us', default_value='0'),
         DeclareLaunchArgument('trigger_out_enabled', default_value='true'),
+        DeclareLaunchArgument('software_trigger_enabled', default_value='true'),
         DeclareLaunchArgument('frames_per_trigger', default_value='2'),
         DeclareLaunchArgument('software_trigger_period', default_value='33'),  # ms
         DeclareLaunchArgument('enable_ptp_config', default_value='false'),#Only for Gemini 335Le

orbbec_camera/src/ob_camera_node.cpp

@@ -299,8 +299,11 @@ void OBCameraNode::setupDevices() {
       RCLCPP_INFO_STREAM(logger_, "Frames per trigger: " << sync_config.framesPerTrigger);
       RCLCPP_INFO_STREAM(logger_,
                          "Software trigger period " << software_trigger_period_.count() << " ms");
-      software_trigger_timer_ = node_->create_wall_timer(
+      software_trigger_timer_ = node_->create_wall_timer(software_trigger_period_, [this]() {
-          software_trigger_period_, [this]() { TRY_EXECUTE_BLOCK(device_->triggerCapture()); });
+        if (software_trigger_enabled_) {
+          TRY_EXECUTE_BLOCK(device_->triggerCapture());
+        }
+      });
     }
   }
   if (device_->isPropertySupported(OB_DEVICE_PTP_CLOCK_SYNC_ENABLE_BOOL,
@@ -1652,7 +1655,8 @@ void OBCameraNode::getParameters() {
   setAndGetNodeParameter<int>(color_delay_us_, "color_delay_us", 0);
   setAndGetNodeParameter<int>(trigger2image_delay_us_, "trigger2image_delay_us", 0);
   setAndGetNodeParameter<int>(trigger_out_delay_us_, "trigger_out_delay_us", 0);
-  setAndGetNodeParameter<bool>(trigger_out_enabled_, "trigger_out_enabled", false);
+  setAndGetNodeParameter<bool>(trigger_out_enabled_, "trigger_out_enabled", true);
+  setAndGetNodeParameter<bool>(software_trigger_enabled_, "software_trigger_enabled", true);
   setAndGetNodeParameter<bool>(enable_ptp_config_, "enable_ptp_config", false);
   setAndGetNodeParameter<std::string>(cloud_frame_id_, "cloud_frame_id", "");
   if (enable_colored_point_cloud_ || enable_d2c_viewer_) {

orbbec_camera/src/ros_service.cpp

@@ -206,6 +206,11 @@ void OBCameraNode::setupCameraCtrlServices() {
                                   std::shared_ptr<SetBool::Response> response) {
         setSYNCHostimeCallback(request, response);
       });
+  set_software_trigger_enabled_srv_ = node_->create_service<SetBool>(
+      "set_software_trigger_enabled", [this](const std::shared_ptr<SetBool::Request> request,
+                                             std::shared_ptr<SetBool::Response> response) {
+        setSoftwareTriggerEnabledCallback(request, response);
+      });
   set_write_customerdata_srv_ = node_->create_service<SetString>(
       "set_write_customer_data", [this](const std::shared_ptr<SetString::Request> request,
                                         std::shared_ptr<SetString::Response> response) {
@@ -1058,6 +1063,24 @@ void OBCameraNode::setSYNCHostimeCallback(
   }
 }
 
+void OBCameraNode::setSoftwareTriggerEnabledCallback(
+    const std::shared_ptr<std_srvs::srv::SetBool::Request>& request,
+    std::shared_ptr<std_srvs::srv::SetBool::Response>& response) {
+  try {
+    software_trigger_enabled_ = request->data;
+    response->success = true;
+  } catch (const ob::Error& e) {
+    response->message = e.getMessage();
+    response->success = false;
+  } catch (const std::exception& e) {
+    response->message = e.what();
+    response->success = false;
+  } catch (...) {
+    response->message = "unknown error";
+    response->success = false;
+  }
+}
+
 void OBCameraNode::setWriteCustomerData(const std::shared_ptr<SetString::Request>& request,
                                         std::shared_ptr<SetString::Response>& response) {
   if (request->data.empty()) {