Merge remote-tracking branch 'upstream/humble' into humble

GregoryLeMasurier · GregoryLeMasurier · commit d6e1b38e96ec · 2026-01-21T17:47:53.000-05:00
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -19,10 +19,10 @@ jobs:
     steps:
     - name: Build and run tests
       id: action-ros-ci
-      uses: ros-tooling/action-ros-ci@v0.3
+      uses: ros-tooling/action-ros-ci@v0.4
       with:
         target-ros2-distro: ${{ matrix.ros_distro }}
-    - uses: actions/upload-artifact@v1
+    - uses: actions/upload-artifact@v4
       with:
         name: colcon-logs
         path: ros_ws/log
diff --git a/Doxyfile b/Doxyfile
diff --git a/behaviortree_ros2/CMakeLists.txt b/behaviortree_ros2/CMakeLists.txt
@@ -27,15 +27,21 @@ generate_parameter_library(
 add_library(${PROJECT_NAME}
     src/bt_ros2.cpp
     src/bt_utils.cpp
-    src/tree_execution_server.cpp )
-
-ament_target_dependencies(${PROJECT_NAME} ${THIS_PACKAGE_DEPS})
+    src/tree_execution_server.cpp
+    src/bt_ros_logger.cpp )
 
 target_include_directories(${PROJECT_NAME} PUBLIC
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
         $<INSTALL_INTERFACE:include>)
 
-target_link_libraries(${PROJECT_NAME}  bt_executor_parameters)
+target_link_libraries(${PROJECT_NAME} PUBLIC
+    rclcpp::rclcpp
+    rclcpp_action::rclcpp_action
+    ament_index_cpp::ament_index_cpp
+    behaviortree_cpp::behaviortree_cpp
+    ${btcpp_ros2_interfaces_TARGETS}
+    bt_executor_parameters
+)
 
 
 ######################################################
diff --git a/behaviortree_ros2/bt_executor_parameters.md b/behaviortree_ros2/bt_executor_parameters.md
@@ -5,11 +5,11 @@ Default Config
 bt_server:
   ros__parameters:
     action_name: bt_execution
-    behavior_trees: '{}'
-    groot2_port: 1667.0
-    plugins: '{}'
-    ros_plugins_timeout: 1000.0
-    tick_frequency: 100.0
+    behavior_trees: []
+    groot2_port: 1667
+    plugins: []
+    ros_plugins_timeout: 1000
+    tick_frequency: 100
 
 ```
 
diff --git a/behaviortree_ros2/include/behaviortree_ros2/bt_action_node.hpp b/behaviortree_ros2/include/behaviortree_ros2/bt_action_node.hpp
@@ -17,6 +17,7 @@
 
 #include <memory>
 #include <string>
+#include <optional>
 #include <rclcpp/executors.hpp>
 #include <rclcpp/allocator/allocator_common.hpp>
 #include "behaviortree_cpp/action_node.h"
@@ -103,6 +104,10 @@ class RosActionNode : public BT::ActionNodeBase
    * @brief Any subclass of RosActionNode that has ports must implement a
    * providedPorts method and call providedBasicPorts in it.
    *
+   * The basic ports:
+   *
+   * - `action_name` Action server name
+   *
    * @param addition Additional ports to add to BT port list
    * @return PortsList containing basic ports along with node-specific ports
    */
@@ -152,8 +157,15 @@ class RosActionNode : public BT::ActionNodeBase
   }
 
   /** Callback invoked when something goes wrong.
+   * The result is provided if it is available.
    * It must return either SUCCESS or FAILURE.
    */
+  virtual BT::NodeStatus onFailure(ActionNodeErrorCode error,
+                                   const std::optional<WrappedResult>&)
+  {
+    return onFailure(error);
+  }
+
   virtual BT::NodeStatus onFailure(ActionNodeErrorCode /*error*/)
   {
     return NodeStatus::FAILURE;
@@ -244,7 +256,7 @@ RosActionNode<T>::ActionClientInstance::ActionClientInstance(
     std::shared_ptr<rclcpp::Node> node, const std::string& action_name)
 {
   callback_group =
-      node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
+      node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive, false);
   callback_executor.add_callback_group(callback_group, node->get_node_base_interface());
   action_client = rclcpp_action::create_client<T>(node, action_name, callback_group);
 }
@@ -309,7 +321,7 @@ inline bool RosActionNode<T>::createClient(const std::string& action_name)
   if(it == registry.end() || it->second.expired())
   {
     client_instance_ = std::make_shared<ActionClientInstance>(node, action_name);
-    registry.insert({ action_client_key_, client_instance_ });
+    registry.insert_or_assign(action_client_key_, client_instance_);
   }
   else
   {
@@ -360,8 +372,8 @@ inline NodeStatus RosActionNode<T>::tick()
 
   if(!client_instance_)
   {
-    throw BT::RuntimeError("RosActionNode: no client was specified neither as default or "
-                           "in the ports");
+    throw BT::RuntimeError("RosActionNode: no client was specified, neither as default "
+                           "nor in the ports");
   }
 
   auto& action_client = client_instance_->action_client;
@@ -390,7 +402,7 @@ inline NodeStatus RosActionNode<T>::tick()
 
     if(!setGoal(goal))
     {
-      return CheckStatus(onFailure(INVALID_GOAL));
+      return CheckStatus(onFailure(INVALID_GOAL, {}));
     }
 
     typename ActionClient::SendGoalOptions goal_options;
@@ -432,7 +444,7 @@ inline NodeStatus RosActionNode<T>::tick()
     // Check if server is ready
     if(!action_client->action_server_is_ready())
     {
-      return onFailure(SERVER_UNREACHABLE);
+      return onFailure(SERVER_UNREACHABLE, {});
     }
 
     future_goal_handle_ = action_client->async_send_goal(goal, goal_options);
@@ -459,7 +471,7 @@ inline NodeStatus RosActionNode<T>::tick()
       {
         if((now() - time_goal_sent_) > timeout)
         {
-          return CheckStatus(onFailure(SEND_GOAL_TIMEOUT));
+          return CheckStatus(onFailure(SEND_GOAL_TIMEOUT, {}));
         }
         else
         {
@@ -490,11 +502,11 @@ inline NodeStatus RosActionNode<T>::tick()
     {
       if(result_.code == rclcpp_action::ResultCode::ABORTED)
       {
-        return CheckStatus(onFailure(ACTION_ABORTED));
+        return CheckStatus(onFailure(ACTION_ABORTED, result_));
       }
       else if(result_.code == rclcpp_action::ResultCode::CANCELED)
       {
-        return CheckStatus(onFailure(ACTION_CANCELLED));
+        return CheckStatus(onFailure(ACTION_CANCELLED, result_));
       }
       else
       {
diff --git a/behaviortree_ros2/include/behaviortree_ros2/bt_ros_logger.hpp b/behaviortree_ros2/include/behaviortree_ros2/bt_ros_logger.hpp
@@ -0,0 +1,32 @@
+#ifndef BT_ROS_LOGGER_H
+#define BT_ROS_LOGGER_H
+
+#include <cstring>
+#include <rclcpp/executors.hpp>
+#include <rclcpp/allocator/allocator_common.hpp>
+#include <rclcpp/logging.hpp>
+#include "behaviortree_cpp/loggers/abstract_logger.h"
+
+namespace BT
+{
+/**
+ * @brief RosLogger is a very simple logger that
+ * displays all the transitions on the console.
+ */
+
+class RosLogger : public StatusChangeLogger
+{
+public:
+  RosLogger(const BT::Tree& tree, std::shared_ptr<rclcpp::Node> node);
+  ~RosLogger() override;
+
+  virtual void flush() override;
+
+private:
+  virtual void callback(Duration timestamp, const TreeNode& node, NodeStatus prev_status,
+                        NodeStatus status) override;
+  std::weak_ptr<rclcpp::Node> node_;
+};
+}  // namespace BT
+
+#endif  // BT_ROS_LOGGER_H
diff --git a/behaviortree_ros2/include/behaviortree_ros2/bt_service_node.hpp b/behaviortree_ros2/include/behaviortree_ros2/bt_service_node.hpp
@@ -19,6 +19,8 @@
 #include <string>
 #include <rclcpp/executors.hpp>
 #include <rclcpp/allocator/allocator_common.hpp>
+#include <rclcpp/version.h>
+#include <rclcpp/qos.hpp>
 #include "behaviortree_cpp/bt_factory.h"
 
 #include "behaviortree_ros2/ros_node_params.hpp"
@@ -216,8 +218,14 @@ inline RosServiceNode<T>::ServiceClientInstance::ServiceClientInstance(
       node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive, false);
   callback_executor.add_callback_group(callback_group, node->get_node_base_interface());
 
+// For Jazzy and Later Support
+#if RCLCPP_VERSION_GTE(28, 0, 0)
+  service_client =
+      node->create_client<T>(service_name, rclcpp::ServicesQoS(), callback_group);
+#else
   service_client = node->create_client<T>(service_name, rmw_qos_profile_services_default,
                                           callback_group);
+#endif
 }
 
 template <class T>
@@ -275,7 +283,7 @@ inline bool RosServiceNode<T>::createClient(const std::string& service_name)
   if(it == registry.end() || it->second.expired())
   {
     srv_instance_ = std::make_shared<ServiceClientInstance>(node, service_name);
-    registry.insert({ client_key, srv_instance_ });
+    registry.insert_or_assign(client_key, srv_instance_);
 
     RCLCPP_INFO(logger(), "Node [%s] created service client [%s]", name().c_str(),
                 service_name.c_str());
diff --git a/behaviortree_ros2/include/behaviortree_ros2/bt_topic_sub_node.hpp b/behaviortree_ros2/include/behaviortree_ros2/bt_topic_sub_node.hpp
@@ -264,7 +264,7 @@ inline bool RosTopicSubNode<T>::createSubscriber(const std::string& topic_name,
   if(it == registry.end() || it->second.expired())
   {
     sub_instance_ = std::make_shared<SubscriberInstance>(node, topic_name, qos_profile);
-    registry.insert({ subscriber_key_, sub_instance_ });
+    registry.insert_or_assign(subscriber_key_, sub_instance_);
 
     RCLCPP_INFO(logger(), "Node [%s] created Subscriber to topic [%s]", name().c_str(),
                 topic_name.c_str());
diff --git a/behaviortree_ros2/include/behaviortree_ros2/bt_utils.hpp b/behaviortree_ros2/include/behaviortree_ros2/bt_utils.hpp
@@ -11,17 +11,18 @@
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+#pragma once
+
 #include <functional>
 #include <memory>
 #include <thread>
 
-// auto-generated header, created by generate_parameter_library
-#include "bt_executor_parameters.hpp"
-
 #include "btcpp_ros2_interfaces/msg/node_status.hpp"
 
 #include "behaviortree_cpp/bt_factory.h"
 
+// auto-generated header, created by generate_parameter_library
+#include "behaviortree_ros2/bt_executor_parameters.hpp"
 #include "behaviortree_ros2/plugins.hpp"
 #include "behaviortree_ros2/ros_node_params.hpp"
 
diff --git a/behaviortree_ros2/include/behaviortree_ros2/tree_execution_server.hpp b/behaviortree_ros2/include/behaviortree_ros2/tree_execution_server.hpp
@@ -11,6 +11,8 @@
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+#pragma once
+
 #include <memory>
 #include <optional>
 
@@ -28,6 +30,11 @@ namespace BT
  * @brief TreeExecutionServer class hosts a ROS Action Server that is able
  * to load Behavior plugins, BehaviorTree.xml files and execute them.
  *
+ * These are named in the ROS2 node's parameters, see
+ * @link bt_executor_parameters.md @endlink
+ *
+ * A `BT::Groot2Publisher` is included inside (see BehaviorTree.CPP for more information).
+ *
  * It can be customized by overriding its virtual functions.
  */
 class TreeExecutionServer
@@ -72,7 +79,7 @@ class TreeExecutionServer
   /// @brief Pointer to the global blackboard
   BT::Blackboard::Ptr globalBlackboard();
 
-  /// @brief Pointer to the global blackboard
+  /// @brief The behavior tree factory
   BT::BehaviorTreeFactory& factory();
 
 protected:
diff --git a/behaviortree_ros2/package.xml b/behaviortree_ros2/package.xml
@@ -1,6 +1,6 @@
 <package format="3">
   <name>behaviortree_ros2</name>
-  <version>0.2.0</version>
+  <version>0.3.0</version>
   <description>
   This package provides a ROS2 wrapper, on top of BehaviorTree.CPP.
   </description>
diff --git a/behaviortree_ros2/src/bt_ros_logger.cpp b/behaviortree_ros2/src/bt_ros_logger.cpp
@@ -0,0 +1,37 @@
+#include "behaviortree_ros2/bt_ros_logger.hpp"
+
+namespace BT
+{
+
+RosLogger::RosLogger(const BT::Tree& tree, std::shared_ptr<rclcpp::Node> node)
+  : StatusChangeLogger(tree.rootNode()), node_(node)
+{}
+RosLogger::~RosLogger()
+{}
+
+void RosLogger::callback(Duration timestamp, const TreeNode& node, NodeStatus prev_status,
+                         NodeStatus status)
+{
+  using namespace std::chrono;
+
+  // get ros node pointer
+  auto ros_node = node_.lock();
+
+  if(ros_node)
+  {
+    constexpr const char* whitespaces = "                         ";
+    constexpr const size_t ws_count = 25;
+
+    double since_epoch = duration<double>(timestamp).count();
+
+    RCLCPP_DEBUG(ros_node->get_logger(), "[%.3f]: %s%s %s -> %s", since_epoch,
+                 node.name().c_str(),
+                 &whitespaces[std::min(ws_count, node.name().size())],
+                 toStr(prev_status, true).c_str(), toStr(status, true).c_str());
+  }
+}
+
+void RosLogger::flush()
+{}
+
+}  // namespace BT
diff --git a/behaviortree_ros2/src/tree_execution_server.cpp b/behaviortree_ros2/src/tree_execution_server.cpp
@@ -20,13 +20,15 @@
 #include <thread>
 #endif
 
+// auto-generated header, created by generate_parameter_library
+#include "behaviortree_ros2/bt_executor_parameters.hpp"
 #include "behaviortree_ros2/tree_execution_server.hpp"
 #include "behaviortree_ros2/bt_utils.hpp"
 
 #include "behaviortree_cpp/loggers/groot2_publisher.h"
 
-// generated file
-#include "bt_executor_parameters.hpp"
+#include "btcpp_ros2_interfaces/srv/get_trees.hpp"
+
 namespace
 {
 static const auto kLogger = rclcpp::get_logger("bt_action_server");
@@ -35,6 +37,8 @@ static const auto kLogger = rclcpp::get_logger("bt_action_server");
 namespace BT
 {
 
+using GetTrees = btcpp_ros2_interfaces::srv::GetTrees;
+
 struct TreeExecutionServer::Pimpl
 {
   rclcpp_action::Server<ExecuteTree>::SharedPtr action_server;
@@ -43,6 +47,8 @@ struct TreeExecutionServer::Pimpl
   std::shared_ptr<bt_server::ParamListener> param_listener;
   bt_server::Params params;
 
+  rclcpp::Service<GetTrees>::SharedPtr get_trees_service;
+
   BT::BehaviorTreeFactory factory;
   std::shared_ptr<BT::Groot2Publisher> groot_publisher;
 
@@ -88,6 +94,12 @@ TreeExecutionServer::TreeExecutionServer(const rclcpp::Node::SharedPtr& node)
     p_->single_shot_timer->cancel();
   };
 
+  p_->get_trees_service = node_->create_service<GetTrees>(
+      "get_loaded_trees", [this](const std::shared_ptr<GetTrees::Request> _,
+                                 std::shared_ptr<GetTrees::Response> response) {
+        response->tree_ids = p_->factory.registeredBehaviorTrees();
+      });
+
   p_->single_shot_timer =
       node_->create_wall_timer(std::chrono::milliseconds(1), callback);
 }
diff --git a/btcpp_ros2_interfaces/CMakeLists.txt b/btcpp_ros2_interfaces/CMakeLists.txt
@@ -9,6 +9,7 @@ find_package(rosidl_default_generators REQUIRED)
 
 rosidl_generate_interfaces(btcpp_ros2_interfaces
     "msg/NodeStatus.msg"
+    "srv/GetTrees.srv"
     "action/ExecuteTree.action"
     "action/Sleep.action")
 
diff --git a/btcpp_ros2_interfaces/package.xml b/btcpp_ros2_interfaces/package.xml
@@ -1,6 +1,6 @@
 <package format="3">
   <name>btcpp_ros2_interfaces</name>
-  <version>0.2.0</version>
+  <version>0.3.0</version>
   <description>
   ROS2 interfaces, mostly used to demonstrate behaviortree_ros2
   </description>
diff --git a/btcpp_ros2_interfaces/srv/GetTrees.srv b/btcpp_ros2_interfaces/srv/GetTrees.srv
diff --git a/btcpp_ros2_samples/CMakeLists.txt b/btcpp_ros2_samples/CMakeLists.txt
diff --git a/btcpp_ros2_samples/package.xml b/btcpp_ros2_samples/package.xml

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`
`18`	`18`	`#include <memory>`
`19`	`19`	`#include <string>`
	`20`	`+#include <optional>`
`20`	`21`	`#include <rclcpp/executors.hpp>`
`21`	`22`	`#include <rclcpp/allocator/allocator_common.hpp>`
`22`	`23`	`#include "behaviortree_cpp/action_node.h"`
`@@ -103,6 +104,10 @@ class RosActionNode : public BT::ActionNodeBase`
`103`	`104`	`* @brief Any subclass of RosActionNode that has ports must implement a`
`104`	`105`	`* providedPorts method and call providedBasicPorts in it.`
`105`	`106`	`*`
	`107`	`+ * The basic ports:`
	`108`	`+ *`
	`109`	+ * - `action_name` Action server name
	`110`	`+ *`
`106`	`111`	`* @param addition Additional ports to add to BT port list`
`107`	`112`	`* @return PortsList containing basic ports along with node-specific ports`
`108`	`113`	`*/`
`@@ -152,8 +157,15 @@ class RosActionNode : public BT::ActionNodeBase`
`152`	`157`	`}`
`153`	`158`
`154`	`159`	`/** Callback invoked when something goes wrong.`
	`160`	`+ * The result is provided if it is available.`
`155`	`161`	`* It must return either SUCCESS or FAILURE.`
`156`	`162`	`*/`
	`163`	`+ virtual BT::NodeStatus onFailure(ActionNodeErrorCode error,`
	`164`	`+ const std::optional<WrappedResult>&)`
	`165`	`+ {`
	`166`	`+ return onFailure(error);`
	`167`	`+ }`
	`168`	`+`
`157`	`169`	`virtual BT::NodeStatus onFailure(ActionNodeErrorCode /error/)`
`158`	`170`	`{`
`159`	`171`	`return NodeStatus::FAILURE;`
`@@ -244,7 +256,7 @@ RosActionNode<T>::ActionClientInstance::ActionClientInstance(`
`244`	`256`	`std::shared_ptr<rclcpp::Node> node, const std::string& action_name)`
`245`	`257`	`{`
`246`	`258`	`callback_group =`
`247`		`- node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);`
	`259`	`+ node->create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive, false);`
`248`	`260`	`callback_executor.add_callback_group(callback_group, node->get_node_base_interface());`
`249`	`261`	`action_client = rclcpp_action::create_client<T>(node, action_name, callback_group);`
`250`	`262`	`}`
`@@ -309,7 +321,7 @@ inline bool RosActionNode<T>::createClient(const std::string& action_name)`
`309`	`321`	`if(it == registry.end() \|\| it->second.expired())`
`310`	`322`	`{`
`311`	`323`	`client_instance_ = std::make_shared<ActionClientInstance>(node, action_name);`
`312`		`- registry.insert({ action_client_key_, client_instance_ });`
	`324`	`+ registry.insert_or_assign(action_client_key_, client_instance_);`
`313`	`325`	`}`
`314`	`326`	`else`
`315`	`327`	`{`
`@@ -360,8 +372,8 @@ inline NodeStatus RosActionNode<T>::tick()`
`360`	`372`
`361`	`373`	`if(!client_instance_)`
`362`	`374`	`{`
`363`		`- throw BT::RuntimeError("RosActionNode: no client was specified neither as default or "`
`364`		`- "in the ports");`
	`375`	`+ throw BT::RuntimeError("RosActionNode: no client was specified, neither as default "`
	`376`	`+ "nor in the ports");`
`365`	`377`	`}`
`366`	`378`
`367`	`379`	`auto& action_client = client_instance_->action_client;`
`@@ -390,7 +402,7 @@ inline NodeStatus RosActionNode<T>::tick()`
`390`	`402`
`391`	`403`	`if(!setGoal(goal))`
`392`	`404`	`{`
`393`		`- return CheckStatus(onFailure(INVALID_GOAL));`
	`405`	`+ return CheckStatus(onFailure(INVALID_GOAL, {}));`
`394`	`406`	`}`
`395`	`407`
`396`	`408`	`typename ActionClient::SendGoalOptions goal_options;`
`@@ -432,7 +444,7 @@ inline NodeStatus RosActionNode<T>::tick()`
`432`	`444`	`// Check if server is ready`
`433`	`445`	`if(!action_client->action_server_is_ready())`
`434`	`446`	`{`
`435`		`- return onFailure(SERVER_UNREACHABLE);`
	`447`	`+ return onFailure(SERVER_UNREACHABLE, {});`
`436`	`448`	`}`
`437`	`449`
`438`	`450`	`future_goal_handle_ = action_client->async_send_goal(goal, goal_options);`
`@@ -459,7 +471,7 @@ inline NodeStatus RosActionNode<T>::tick()`
`459`	`471`	`{`
`460`	`472`	`if((now() - time_goal_sent_) > timeout)`
`461`	`473`	`{`
`462`		`- return CheckStatus(onFailure(SEND_GOAL_TIMEOUT));`
	`474`	`+ return CheckStatus(onFailure(SEND_GOAL_TIMEOUT, {}));`
`463`	`475`	`}`
`464`	`476`	`else`
`465`	`477`	`{`
`@@ -490,11 +502,11 @@ inline NodeStatus RosActionNode<T>::tick()`
`490`	`502`	`{`
`491`	`503`	`if(result_.code == rclcpp_action::ResultCode::ABORTED)`
`492`	`504`	`{`
`493`		`- return CheckStatus(onFailure(ACTION_ABORTED));`
	`505`	`+ return CheckStatus(onFailure(ACTION_ABORTED, result_));`
`494`	`506`	`}`
`495`	`507`	`else if(result_.code == rclcpp_action::ResultCode::CANCELED)`
`496`	`508`	`{`
`497`		`- return CheckStatus(onFailure(ACTION_CANCELLED));`
	`509`	`+ return CheckStatus(onFailure(ACTION_CANCELLED, result_));`
`498`	`510`	`}`
`499`	`511`	`else`
`500`	`512`	`{`
Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ inline bool RosTopicSubNode<T>::createSubscriber(const std::string& topic_name,`
`264`	`264`	`if(it == registry.end() \|\| it->second.expired())`
`265`	`265`	`{`
`266`	`266`	`sub_instance_ = std::make_shared<SubscriberInstance>(node, topic_name, qos_profile);`
`267`		`- registry.insert({ subscriber_key_, sub_instance_ });`
	`267`	`+ registry.insert_or_assign(subscriber_key_, sub_instance_);`
`268`	`268`
`269`	`269`	`RCLCPP_INFO(logger(), "Node [%s] created Subscriber to topic [%s]", name().c_str(),`
`270`	`270`	`topic_name.c_str());`