Synchronizing ROS Topic Publishing and Subscribing with Timers in Custom C++ Nodes

8 August 2024

Creating Custom ROS Nodes in C++

When working with the Robot Operating System (ROS), one of the key aspects is creating custom nodes that can communicate effectively with other nodes through topics. These custom nodes are usually written in C++ to leverage the performance and control needed for complex robotic tasks. Here, we’re going to discuss a specific scenario where you might want to publish messages on a ROS topic at regular intervals (using a timer) while also subscribing to another topic for input or feedback.

The Need for Synchronization

In many robotic applications, it’s essential that certain actions happen at the same time each second. For instance, publishing sensor data could coincide with taking specific measurements or controlling motors in sync with some external signal. This is where using a timer within your ROS node becomes crucial, as you can ensure that any action (like publishing messages) happens at the desired frequency.

Implementing a Timer for Synchronization

To implement this synchronization using a ROS node written in C++, we’ll use ros::Timer to periodically call a callback function. This allows us to publish messages or execute other tasks at regular intervals, alongside subscribing to topics and handling incoming data as needed.

#include <ros/ros.h>
#include <std_msgs/String.h> // Assuming your message type is std_msgs/String
class CustomROSNode {
private:
    ros::NodeHandle nh_;
    ros::Subscriber subscriber_; // For example, subscribe to topic '/input'
    ros::Publisher publisher_;     // Publish messages on '/output'
    ros::Timer timer_;             // Timer for synchronizing actions
public:
    void callback(const std_msgs::String::ConstPtr& msg) {
        // Process incoming data from the subscribed topic
    }
    void publishMessage() {
        // This function is called at regular intervals (set by the timer)
        // Publish messages on '/output' here.
        std_msgs::String message;
        message.data = "This message was published at ";
        publisher_.publish(message);
    }
    void startTimer(int period) {
        // Start a ros::Timer to call publishMessage() every 'period' seconds
        timer_ = nh_.createTimer(ros::Duration(period), &CustomROSNode::publishMessage, this);
    }
};

Running the Custom ROS Node

To run your custom ROS node with synchronization using timers, you’ll first need to compile and generate a ROS package. Then, in your main function, create an instance of CustomROSNode, subscribe to any necessary topics, set up a timer for synchronization, and start running the node.

int main(int argc, char** argv) {
    ros::init(argc, argv, "custom_ros_node");
    CustomROSNode custom_node;
    custom_node.nh_.subscribe("/input", 10, &CustomROSNode::callback, &custom_node);
    custom_node.startTimer(1); // Start a timer to call publishMessage() every second
    ros::spin();
    return 0;
}

Conclusion

Implementing synchronization using timers within your custom ROS nodes in C++ allows for precise control over the timing of tasks such as publishing messages or executing actions. This is particularly useful when working with robotics and real-time systems where predictability and consistency are crucial. By combining timer-based synchronization with topic subscription and publication, you can create robust and reliable ROS applications that meet the demands of complex robotic tasks.

Poespas Blog