refactoring to demonstrate services and node composition

Author: zig-robotics

.clang-format

@@ -0,0 +1,19 @@
+Language: Cpp
+BasedOnStyle: Google
+
+AccessModifierOffset: -2
+AlignAfterOpenBracket: AlwaysBreak
+BraceWrapping:
+  AfterClass: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterEnum: true
+BreakBeforeBraces: Custom
+ColumnLimit: 100
+ConstructorInitializerIndentWidth: 0
+ContinuationIndentWidth: 2
+DerivePointerAlignment: false
+PointerAlignment: Middle
+ReflowComments: false
+

README.md

@@ -1,3 +1,24 @@
-# ZigROS rclcpp examples
+# ZigROS rclcpp example
+
+This repo contains an example C++ node built with zig and ZigROS.
+It showcases the suggested single executable use case for ZigROS by writing nodes as libraries and composing them by hand into a single executable.
+
+Checkout the ZigROS repo for a more in depth intro to the ZigROS library.
+
+## How to build
+
+The only dependency this repo has is on the zig compiler.
+Make sure you have zig 0.13 available on your system, then simply build with:
+
+```
+zig build -Doptimize=ReleaseFast -Dtarget=x86_64-linux-musl
+```
+
+Then run with
+
+```
+./zig-out/bin/node
+```
+
+The build.zig file shows some suggested build tricks, such as stripping the binary if not in debug mode, and setting the section flags if building with the release small flag. 
 
-This repo contains an example C++ node built with zig and zigros.

build.zig

@@ -19,9 +19,13 @@ pub fn build(b: *std.Build) void {
     });
 
     pub_sub_node.want_lto = true;
-    pub_sub_node.link_function_sections = true;
-    pub_sub_node.link_data_sections = true;
-    pub_sub_node.link_gc_sections = true;
+
+    //  The core ZigROS libraries will also set these flags if ReleaseSmall is used.
+    if (optimize == .ReleaseSmall) {
+        pub_sub_node.link_function_sections = true;
+        pub_sub_node.link_data_sections = true;
+        pub_sub_node.link_gc_sections = true;
+    }
 
     const zigros = ZigRos.init(b.dependency("zigros", .{
         .target = target,
@@ -35,9 +39,15 @@ pub fn build(b: *std.Build) void {
     zigros.linkRmwCycloneDds(&pub_sub_node.root_module);
     zigros.linkLoggerSpd(&pub_sub_node.root_module);
 
+    pub_sub_node.addIncludePath(b.path("include"));
     pub_sub_node.addCSourceFiles(.{
         .root = b.path("src"),
-        .files = &.{"main.cpp"},
+        .files = &.{
+            "main.cpp",
+            "subscription.cpp",
+            "publisher.cpp",
+            "service.cpp",
+        },
         .flags = &.{
             "--std=c++17",
             "-Wno-deprecated-declarations",
@@ -49,11 +59,15 @@ pub fn build(b: *std.Build) void {
         "zigros_example_interface",
         .{ .target = target, .optimize = optimize, .linkage = linkage },
     );
-    interface.addInterfaces(b.path(""), &.{"msg/Example.msg"});
+    interface.addInterfaces(b.path(""), &.{
+        "msg/Example.msg",
+        "srv/Example.srv",
+    });
 
     // the example message uses the standard header message, so we must add builtin_interfaces
     // as a dependency
     interface.addDependency("builtin_interfaces", zigros.ros_libraries.builtin_interfaces);
+    interface.addDependency("service_msgs", zigros.ros_libraries.service_msgs);
     interface.artifacts.linkCpp(&pub_sub_node.root_module);
 
     b.installArtifact(pub_sub_node);

include/zigros_examples/publisher.hpp

@@ -0,0 +1,20 @@
+#ifndef ZIGROS_EXAMPLES_PUBLISHER_HPP
+#define ZIGROS_EXAMPLES_PUBLISHER_HPP
+
+#include "rclcpp/rclcpp.hpp"
+#include "zigros_example_interface/msg/example.hpp"
+
+namespace zigros_examples
+{
+
+class Publisher
+{
+public:
+  Publisher(rclcpp::NodeOptions options = rclcpp::NodeOptions());
+
+  rclcpp::Node node_;
+  std::shared_ptr<rclcpp::Publisher<zigros_example_interface::msg::Example>> publisher_;
+  std::shared_ptr<rclcpp::TimerBase> timer_;
+};
+}  // namespace zigros_examples
+#endif  // ZIGROS_EXAMPLES_PUBLISHER_HPP

include/zigros_examples/service.hpp

@@ -0,0 +1,18 @@
+#ifndef ZIGROS_EXAMPLES_SERVICE_HPP
+#define ZIGROS_EXAMPLES_SERVICE_HPP
+
+#include "rclcpp/rclcpp.hpp"
+#include "zigros_example_interface/srv/example.hpp"
+
+namespace zigros_examples
+{
+
+class Service
+{
+public:
+  Service(rclcpp::NodeOptions options = rclcpp::NodeOptions());
+  rclcpp::Node node_;
+  std::shared_ptr<rclcpp::Service<zigros_example_interface::srv::Example>> server_;
+};
+}  // namespace zigros_examples
+#endif  // ZIGROS_EXAMPLES_SERVICE_HPP

include/zigros_examples/subscription.hpp

@@ -0,0 +1,21 @@
+#ifndef ZIGROS_EXAMPLES_SUBSCRIPTION_HPP
+#define ZIGROS_EXAMPLES_SUBSCRIPTION_HPP
+
+#include "rclcpp/rclcpp.hpp"
+#include "zigros_example_interface/msg/example.hpp"
+#include "zigros_example_interface/srv/example.hpp"
+
+namespace zigros_examples
+{
+
+class Subscription
+{
+public:
+  Subscription(rclcpp::NodeOptions options = rclcpp::NodeOptions());
+  rclcpp::Node node_;
+  std::shared_ptr<rclcpp::Subscription<zigros_example_interface::msg::Example>> subscription_;
+  std::shared_ptr<rclcpp::Client<zigros_example_interface::srv::Example>> client_;
+  std::shared_ptr<const zigros_example_interface::msg::Example> prev_msg_;
+};
+}  // namespace zigros_examples
+#endif  // ZIGROS_EXAMPLES_SUBSCRIPTION_HPP

src/main.cpp

@@ -1,32 +1,29 @@
-#include "rclcpp/rclcpp.hpp"
-#include "zigros_example_interface/msg/example.hpp"
-#include <iostream>
+#include "zigros_examples/publisher.hpp"
+#include "zigros_examples/service.hpp"
+#include "zigros_examples/subscription.hpp"
 
-int main(int argc, char *argv[]) {
+int main(int argc, char * argv[])
+{
   rclcpp::init(argc, argv);
-  const auto node = std::make_shared<rclcpp::Node>("example_node", rclcpp::NodeOptions().use_intra_process_comms(true));
-  const auto publisher = rclcpp::create_publisher<zigros_example_interface::msg::Example>(node, "test", 1);
-  const auto subscription = rclcpp::create_subscription<zigros_example_interface::msg::Example>(
-    node,
-    "test",
-    1,
-    [node](zigros_example_interface::msg::Example::ConstSharedPtr msg) {
-      RCLCPP_INFO_STREAM(node->get_logger(), "Time: " << msg->time.sec);
-    });
 
-  const auto timer = rclcpp::create_timer(
-    node,
-    node->get_clock(),
-    rclcpp::Duration::from_seconds(1.0),
-    [publisher, node](){
-      auto msg = zigros_example_interface::msg::Example();
-      msg.time = node->now();
-      publisher->publish(msg);
-    }
-  );
+  auto node_options = rclcpp::NodeOptions().use_intra_process_comms(true);
 
+  // instantiate your applicatin nodes.
+  // this replaces your launch file.
+  // all normal launch arguments can be passed using the node options
+  auto publisher = zigros_examples::Publisher(node_options);
+  auto subscription = zigros_examples::Subscription(node_options);
+  auto service = zigros_examples::Service(node_options);
+
+  // For simplicity all nodes are added to the same executor.
+  // In a more complex example where parallel execution is required, each node would typically get its own executor and be spun in its own thread.
+  // your exact threading structure will depend on your application.
+  // Fewer executors/threads will have less overhead, but potentially increae latency.
+  // If callbacks depend on each other, they need to be in separate executors.
   auto executor = rclcpp::experimental::executors::EventsExecutor();
-  executor.add_node(node);
+  executor.add_node(publisher.node_.get_node_base_interface());
+  executor.add_node(subscription.node_.get_node_base_interface());
+  executor.add_node(service.node_.get_node_base_interface());
   executor.spin();
 
   rclcpp::shutdown();

src/publisher.cpp

@@ -0,0 +1,20 @@
+#include "zigros_examples/publisher.hpp"
+
+#include "rclcpp/rclcpp.hpp"
+#include "zigros_example_interface/msg/example.hpp"
+
+namespace zigros_examples
+{
+
+Publisher::Publisher(rclcpp::NodeOptions options)
+: node_{"publisher", options},
+  publisher_{node_.create_publisher<zigros_example_interface::msg::Example>("test", 1)},
+  timer_{
+    rclcpp::create_timer(&node_, node_.get_clock(), rclcpp::Duration::from_seconds(1.0), [this]() {
+      auto msg = zigros_example_interface::msg::Example();
+      msg.time = node_.now();
+      publisher_->publish(msg);
+    })}
+{
+}
+}  // namespace zigros_examples

src/service.cpp

@@ -0,0 +1,16 @@
+#include "zigros_examples/service.hpp"
+
+namespace zigros_examples
+{
+
+Service::Service(rclcpp::NodeOptions options)
+: node_{"service", options},
+  server_{node_.create_service<zigros_example_interface::srv::Example>(
+    "example", [this](
+                 zigros_example_interface::srv::Example::Request::ConstSharedPtr request,
+                 zigros_example_interface::srv::Example::Response::SharedPtr response) {
+      response->diff = rclcpp::Time(request->a) - rclcpp::Time(request->b);
+    })}
+{
+}
+}  // namespace zigros_examples

src/subscription.cpp

@@ -0,0 +1,32 @@
+#include "zigros_examples/subscription.hpp"
+
+namespace zigros_examples
+{
+
+Subscription::Subscription(rclcpp::NodeOptions options)
+: node_{"subscription", options},
+  subscription_{node_.create_subscription<zigros_example_interface::msg::Example>(
+    "test", 1,
+    [this](zigros_example_interface::msg::Example::ConstSharedPtr msg) {
+      RCLCPP_INFO_STREAM(node_.get_logger(), "Time: " << msg->time.sec);
+      if (prev_msg_) {
+        auto request = std::make_shared<zigros_example_interface::srv::Example::Request>();
+        request->a = msg->time;
+        request->b = prev_msg_->time;
+        client_->async_send_request(
+          request,
+          [this](rclcpp::Client<zigros_example_interface::srv::Example>::SharedFuture future) {
+            if (future.valid()) {
+              auto result = future.get();
+              RCLCPP_INFO_STREAM(
+                node_.get_logger(),
+                "Service responce: " << rclcpp::Duration(result->diff).seconds());
+            }
+          });
+      }
+      prev_msg_ = msg;
+    })},
+  client_{node_.create_client<zigros_example_interface::srv::Example>("example")}
+{
+}
+}  // namespace zigros_examples