All Other Endpoints
Topics
localization/datum
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
-
Topic QoS:
- Python
- C++
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()
#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;
}
Services
control_selection/set_mode
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
- Python
- C++
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()
#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;
}