ROS 2 Composable Node Pass NodeHandler

edit

The way you pass a Node from one C++ class to another is with shared_from_this() and std::shared_ptr.

Example:

Class A inherits from rclcpp::Node. Get the node pointer like this:

auto node_ptr = shared_from_this();

Pass to another class (Class B) like this:

shared_pointer_to_class_b_object = std::make_shared<ClassB>(node_ptr);

The constructor of Class B should take a rclcpp::Node::SharedPtr node:

ClassB(rclcpp::Node::SharedPtr node) : node_(node)
{
}

And it should have a private member variable:

  // Pointer to the ROS node
  std::shared_ptr<rclcpp::Node> node_;

ROS2 documentation is still lacking and it helps to be a C++ guru :/

In ROS1, the ros::NodeHandle was provided as a protected member of the ros::Nodelet class. In contrast, in ROS2, it is expected that user will create their own rclcpp::Node from the rclcpp::NodeOptions structure passed into the user's constructor.

In the composition paradigm, the thing that you want to compose will either directly inherit from rclcpp::Node or keep a rclcpp::Node as a member.

A demonstration of an object that inherits from rclcpp::Node is available in the ROS2 Demos package:

• talker_component.hpp
• talker_component.cpp

Adding comments above from AndyZe, yes you need to get the node pointer and pass it to another class. But if you do this in the class constructor, a bad_weak_ptr error will always show up. You can prevent this by initiating the class in callback.

I'm gonna use ClassA and ClassB example above, say you want to extend the node to ClassB to use ClassB functions from ClassA. Here's the header code of ClassB:

class ClassB {
  public:
    ClassB(rclcpp::Node::SharedPtr node); // constructor

    // your code here

  private:
    rclcpp::Node::SharedPtr node_;

    // your code here

and here's the definition code of ClassB:

// constructor
ClassB::ClassB(rclcpp::Node::SharedPtr node) : node_(node) {

    // your code here
}

Then in ClassA file:

class ClassA : public rclcpp::Node {
  public:
    ClassA() : Node("class_a") {

      // your code here

      // use one-time timer to initiate class B 
      timer = this->create_wall_timer(500ms, std::bind(&ClassA::initialization, this));
    }

  private:

    rclcpp::TimerBase::SharedPtr timer;

    std::shared_ptr<ClassB> class_b;

    void initialization() {
      // get node pointer, pass into Class B
      class_b = std::make_shared<ClassB>(shared_from_this());

      // replace timer with loop callback after initialization finished
      timer = this->create_wall_timer(500ms, std::bind(&UsingLibCpp::timer_callback, this)); 
    }

    void timer_callback() {
      // your code here

      // use Class B function
      class_b->class_b_function();
    }

I finally got it work after 2 weeks of digging. Too bad ROS2 documentation is still lacking in program style like this. Hope it helps