有没有办法在两个 ROS 节点之间有优先级？

Question

我问你是否有办法在两个 ROS 节点之间设置优先级。特别是，我有一个 ROS 节点，它输出一个包含 60 个数据的文本文件，并且每次都会重新创建它，因为数据在变化。然后我有一个节点必须分析该文本文件。基本上，我需要做的是做一些改变，当写入器节点运行ning 时，有一个停止分析器节点的机制，然后它必须向分析器节点发送一个信号，使其能够 [=24] =] 并分析文本文件。然后写入器节点必须 return 让我们说 "in charge" 才能再次重写文本文件。所以，简单来说，就是一个循环。有人告诉我，一个可能的解决方案可以是类似于 "semaphore" 主题，其中编写器节点写入，例如，布尔值 1 在进行文本文件的打开、写入和关闭时，所以分析器节点知道无法进行详细说明，因为文件尚未准备好。并且，当编写器完成并关闭文本文件时，它必须发布一个值 0，以允许分析器节点进行分析。我搜索了布尔值的发布，我发现了一个代码，可以是这样的：

ros::Publisher pub = n.advertise<std_msgs::Bool>("semaphore", 1000);
std_msgs::Bool state;
state.data = 1;

我不知道我是否只需要在编写器节点中使用发布者和在分析器节点中使用订阅者。也许我必须在两个节点中同时使用它们，例如：编写器在主题信号量中放置一个 1，以便分析器知道无法访问文本文件，创建文本文件，然后在主题中放置一个 0 并订阅话题再等一个1；分析仪做了类似但相反的事情。我把这两个代码放在下面，因为我不知道将发布者和订阅者放在哪里以及如何使它们正常工作。如果可能的话，我必须在我的代码中保留这种工作流程结构。注意：几乎每 10 秒创建一个新的文本文件，因为在文本文件中写入的数据来自另一个 ROS 主题，并且编写器中的代码有一种机制来进行这种详细说明。先感谢您！！！编辑：正如我在上一条评论中所解释的那样，现在使用基于主题的解决方案更正了代码。

作者代码：

#include "ros/ros.h"
#include "std_msgs/String.h"
#include "std_msgs/Bool.h"
#include "../include/heart_rate_monitor/wfdb.h"
#include <stdio.h>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <deque>
#include "heart_rate_monitor/analyse_heart_rate.h"

using namespace std;



static std::deque<std::string> queue_buffer;
static int entries_added_since_last_write = 0;

ros::Publisher pub;

void write_data_to_file()
{
// open file;
std::ofstream data_file("/home/marco/catkin_ws/src/heart_rate_monitor/my_data_file.txt");
if (data_file.is_open())
{
for (int i = 0; i < queue_buffer.size(); ++i)
{
  data_file << queue_buffer[i] << std::endl;
}
}
else
{
std::cout << "Error - Cannot open file." << std::endl;
exit(1);
}
data_file.close();

std_msgs::Bool state;
state.data = 0;

pub.publish(state);

}

void process_message(const std_msgs::String::ConstPtr& string_msg)
{
std_msgs::Bool state;
state.data = 1;

pub.publish(state);

// if buffer has already 60 entries, throw away the oldest one
if (queue_buffer.size() == 60)
{
queue_buffer.pop_front();
}

// add the new data at the end
queue_buffer.push_back(string_msg->data);

// check if 10 elements have been added and write to file if so
entries_added_since_last_write++;

if (entries_added_since_last_write >= 10
  && queue_buffer.size() == 60)
{
// write data to file and reset counter
write_data_to_file();
entries_added_since_last_write = 0;
}

}


int main(int argc, char **argv)
{

ros::init(argc, argv, "writer");

ros::NodeHandle n;

ros::Subscriber sub = n.subscribe("/HeartRateInterval", 1000, process_message);
pub = n.advertise<std_msgs::Bool>("/semaphore", 1000);

ros::spin();

return 0;
}

分析器代码：

#include "ros/ros.h"
#include "std_msgs/String.h"
#include "std_msgs/Bool.h"
#include "../include/heart_rate_monitor/wfdb.h"
#include <stdio.h>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <deque>
#include "heart_rate_monitor/analyse_heart_rate.h"

void orderCallback(const std_msgs::Bool::ConstPtr& msg)
{

if (msg->data == 0)
{
chdir("/home/marco/catkin_ws/src/heart_rate_monitor");

system("get_hrv -R my_data_file.txt >doc.txt");
}
}


int main(int argc, char **argv)
{

ros::init(argc, argv, "analyzer");

ros::NodeHandle n;

ros::Subscriber sub = n.subscribe("/semaphore", 1000, orderCallback);

ros::spin();

return 0;
}

Answer 1

这可以简单地使用 ROS services 来完成。基本上，当您的节点 A 收到消息时，它会执行所需的操作（写入文件），然后向节点 B 请求服务（分析文件）。

我看到的唯一缺点是节点 A 必须等待节点 B 服务完成。如果B不需要太多时间，就不会出问题。

代码片段：

Srv :

在您的包的 srv 文件夹中创建一个名为“analyse_heart_rate.srv”的服务（我认为它的名称是“heart_rate_monitor”）。

在文件中指定request/response您的服务结构：

string filename
---
bool result

CMakeLists :

添加以下行：

add_service_files(
  FILES
  analyse_heart_rate.srv
)

服务服务器:

 #include "ros/ros.h"
 #include "heart_rate_monitor/analyse_heart_rate.h"


bool analyse(heart_rate_monitor::analyse_heart_rate::Request  &req,
     heart_rate_monitor::analyse_heart_rate::Response &res)

{
  res.result = analyse_text_file(req.filename);
  return true;
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "heart_rate_analyser_server");
  ros::NodeHandle n;

  ros::ServiceServer service = n.advertiseService("heart_rate_analyser", analyse);
  ROS_INFO("Ready to analyse requests.");
  ros::spin();

  return 0;
}

服务客户端

#include "ros/ros.h"
#include "heart_rate_monitor/analyse_heart_rate.h"

void process_message(const std_msgs::String::ConstPtr& string_msg)
{
    std::string output_filename;
    do_staff_with_message();
    write_data_to_file_(output_filename);

     heart_rate_monitor::analyse_heart_rate srv;
     srv.filename = output_filename ;
     if (client.call(srv))
     {
        ROS_INFO("Result: %d", (bool)srv.response.result);
     }
     else
     {
        ROS_ERROR("Failed to call service heart_rate_analyser");
     }
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "add_two_ints_client");
  ros::NodeHandle n;
  ros::ServiceClient client = n.serviceClient<heart_rate_monitor::analyse_heart_rate>("heart_rate_analyser");
  ros::Subscriber sub = n.subscribe("/HeartRateInterval", 1000, process_message);

  return 0;
}

这样，每当消息进入节点“服务客户端”时，它都会对其进行处理并最终将其写入文件。然后它要求“服务服务器”处理之前创建的文件...

当然，这只是一个片段，根据您的需要进行定制。

干杯。

有没有办法在两个 ROS 节点之间有优先级？

Is there a way to have a precedence between two ROS nodes?

c++

arrays

text

messages

ros