petermp's profile - activity

I have a need to implement a nodelet that subscribes for messages from a topic, process them and then publish to another topic.

Can this be done using a single nodelet?

Edit: I tried the below demo, but see only publishing msgs. Sub's callback are not invoked.

#include <chrono>
#include <iostream>
#include <memory>

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

using namespace std::chrono_literals;

namespace composition
{

// Create a Talker "component" that subclasses the generic rclcpp::Node base class.
// Components get built into shared libraries and as such do not write their own main functions.
// The process using the component's shared library will instantiate the class as a ROS node.
Peter::Peter()
: Node("peter"), count_(0)
{
  // Create a publisher of "std_mgs/String" messages on the "chatter" topic.
  pub_ = create_publisher<std_msgs::msg::String>("chatter");

  // Use a timer to schedule periodic message publishing.
  timer_ = create_wall_timer(1s, std::bind(&Peter::on_timer, this));

  // Create a callback function for when messages are received.
  // Variations of this function also exist using, for example, UniquePtr for zero-copy transport.
  auto callback =
    [this](const typename std_msgs::msg::String::SharedPtr msg) -> void
    {
      RCLCPP_INFO(this->get_logger(), "I heard: [%s]", msg->data.c_str())
      std::flush(std::cout);
    };

  // Create a subscription to the "chatter" topic which can be matched with one or more
  // compatible ROS publishers.
  // Note that not all publishers on the same topic with the same type will be compatible:
  // they must have compatible Quality of Service policies.
  auto sub_ = create_subscription<std_msgs::msg::String>("chatter", callback);
}

void Peter::on_timer()
{
  auto msg = std::make_shared<std_msgs::msg::String>();
  msg->data = "Peter is here: " + std::to_string(++count_);
  RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", msg->data.c_str())
  std::flush(std::cout);

  // Put the message into a queue to be processed by the middleware.
  // This call is non-blocking.
  pub_->publish(msg);
}

}  // namespace composition

#include "class_loader/class_loader_register_macro.h"

// Register the component with class_loader.
// This acts as a sort of entry point, allowing the component to be discoverable when its library
// is being loaded into a running process.
CLASS_LOADER_REGISTER_CLASS(composition::Peter, rclcpp::Node)

I invoke the rostopic command from a bash file to send the message to the subscribing node. The rostopic command termina

It is a simple example, out of ros tutorial, the app starts and waits for message that triggers a callback. The callback

receiving messages of previous run Are there anything wrong with my subscribing statement below? ros::Subscriber builde

I found the answer in the file rclcpp/rclcpp/include/rclcpp/executors/multi_threaded_executor.hpp, which defines the cl

I am in search of the same answer :) Hope someone will pay attention to your question with a helpful tip.

Thanks. I am new to the forum and apparently made some edit mistakes. I am able to get the code working and confirm th

include <chrono> include <iostream> include <memory> include "rclcpp/rclcpp.hpp" include "std_msgs

I tried the below demo, but see only publishing msgs. Sub's callback are not invoked.

include "composition/peter_component.hpp" I did as in the demo code below, but the subscriber's callback is not invoked

Can subscriber and publisher be used in the same nodelet I need to implement a nodelet receiving messages, process it an

Using pubisher and subscriber in the same nodelet I wonder if I can implement a nodelet that subscribes to one topic and

Can a subscriber and publisher co-exist in a single nodelet? I have a need to implement a nodelet that subscribes for me