Onav 2823

docs_outdoornav_user_manual/api/api_endpoints/all_other_endpoints.mdx

@@ -0,0 +1,190 @@
+---
+title: All Other Endpoints
+sidebar_label: All Other Endpoints
+sidebar_position: 6
+toc_min_heading_level: 2
+toc_max_heading_level: 4
+---
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+## Topics
+
+<details>
+<summary>localization/datum</summary>
+
+The lat/lon coordinate of the datum. This value is sotred in persistent memory and loaded at runtime.
+
+- Topic Name: **localization/datum**
+
+- Topic Type: [sensor_msgs/msg/NavSatFix](https://github.com/ros2/common_interfaces/blob/jazzy/sensor_msgs/msg/NavSatFix.msg)
+
+- Topic QoS: 
+
+<Tabs groupId="localization_datum">
+  <TabItem value="Python" label="Python" default>
+
+```python
+import rclpy
+from rclpy.node import Node
+
+from sensor_msgs.msg import NavSatFix
+
+
+class Datum(Node):
+
+    def __init__(self):
+        super().__init__('datum_sub')
+        self.datum_sub = self.create_subscription(
+            NavSatFix, 'localization/datum', self.datum_cb, 10)
+        self.datum_sub  # prevent unused variable warning
+
+    def datum_cb(self, msg):
+        self.last_datum_msg = msg
+
+if __name__ == '__main__':
+    rclpy.init(args=args)
+    datum_sub = Datum()
+    rclpy.spin(datum_sub)
+    datum_sub.destroy_node()
+    rclpy.shutdown()
+```
+  </TabItem>
+  <TabItem value="C++" label="C++">
+
+```cpp
+#include <memory>
+
+#include "rclcpp/rclcpp.hpp"
+#include "sensor_msgs/msg/nav_sat_fix.hpp"
+
+class Datum : public rclcpp::Node
+{
+public:
+  Datum()
+  : Node("datum_sub")
+  {
+    auto datum_cb =
+      [this](sensor_msgs::msg::NavSatFix::UniquePtr msg) -> void {
+        last_datum_msg_ = msg;
+      };
+
+    datum_sub_ = this->create_subscription<sensor_msgs::msg::NavSatFix>("localization/datum", 10, datum_cb);
+  }
+
+private:
+  rclcpp::Subscription<sensor_msgs::msg::NavSatFix>::SharedPtr datum_sub_;
+  sensor_msgs::msg::NavSatFix::UniquePtr last_datum_msg_;
+};
+
+int main(int argc, char * argv[])
+{
+  rclcpp::init(argc, argv);
+  rclcpp::spin(std::make_shared<Datum>());
+  rclcpp::shutdown();
+  return 0;
+}
+```
+  </TabItem>
+
+</Tabs>
+</details>
+
+
+## Services
+
+<details>
+<summary>control_selection/set_mode</summary>
+
+Switch the control mode of the platform. Options are: ('AUTONOMY', 'MANUAL', 'NEUTRAL')
+
+- Service Name: **control_selection/set_mode**
+
+- Service Type: [clearpath_control_msgs/srv/SetControlMode](pathname:///api/html/clearpath_control_msgs/srv/SetControlMode.html)
+
+<Tabs groupId="control_selection_set_mode">
+  <TabItem value="Python" label="Python" default>
+
+```python
+import rclpy
+from rclpy.node import Node
+
+from clearpath_control_msgs.srv import SetControlMode,
+from clearpath_control_msgs.msg import ControlMode
+
+
+class SetControlMode(Node):
+
+    def __init__(self):
+        super().__init__('set_control_mode_client')
+        self._srv_client = self.create_client(SetControlMode, 'control_selection/set_mode')
+        while not self._srv_client.wait_for_service(timeout_sec=1.0):
+            self.get_logger().info('service not available, waiting again...')
+        self.req = SetControlMode.Request()
+
+    def send_request(self, mode):
+        # set to manual mode
+        self.req.mode.mode = mode
+        self.future = self._srv_client.call_async(self.req)
+        rclpy.spin_until_future_complete(self, self.future)
+        return self.future.result()
+
+if __name__ == '__main__':
+    rclpy.init(args=args)
+    set_control_mode_client = SetControlMode()
+    response = set_control_mode_client.send_request(ControlMode.MANUAL)
+    set_control_mode_client.get_logger().info('Control mode set to MANUAL mode.'))
+    set_control_mode_client.destroy_node()
+    rclpy.shutdown()
+```
+  </TabItem>
+  <TabItem value="C++" label="C++">
+
+```cpp
+#include "rclcpp/rclcpp.hpp"
+#include "clearpath_control_msgs/srv/set_control_mode.hpp"
+#include "clearpath_control_msgs/msg/control_mode.hpp"
+
+#include <chrono>
+#include <cstdlib>
+#include <memory>
+
+using namespace std::chrono_literals;
+
+int main(int argc, char **argv)
+{
+  rclcpp::init(argc, argv);
+
+  std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("set_control_mode_client");
+  rclcpp::Client<std_srvs::srv::SetControlMode>::SharedPtr client =                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+    node->create_client<std_srvs::srv::SetControlMode>("control_selection/set_mode");
+
+  auto request = std::make_shared<std_srvs::srv::SetControlMode::Request>();
+  request-> mode.mode = clearpath_control_msgs::ControlMode::MANUAL;
+
+  while (!client->wait_for_service(1s)) {
+    if (!rclcpp::ok()) {
+      RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Interrupted while waiting for the service. Exiting.");
+      return 0;
+    }
+    RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "service not available, waiting again...");
+  }
+
+  auto result = client->async_send_request(request);
+  // Wait for the result.
+  if (rclcpp::spin_until_future_complete(node, result) ==
+    rclcpp::FutureReturnCode::SUCCESS)
+  {
+      RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "Control mode set to MANUAL mode");
+  } else {
+    RCLCPP_ERROR(rclcpp::get_logger("rclcpp"), "Failed to call service control_selection/set_mode");
+  }
+
+  rclcpp::shutdown();
+  return 0;
+}
+```
+  </TabItem>
+
+</Tabs>
+</details>

docs_outdoornav_user_manual/api/api_endpoints/autonomy/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "Autonomy",
+  "position": 1
+}