ros 消息队列与缓冲区_[ROS] [笔记(1)] 一个最简单的例子：Hello Robot（消息、发布者与订阅者）...

本例程包含如下内容：

1)创建编译 Package；

2)自定义消息；

3)发布者与订阅者。

0、Hello Robot 的场景：

我们想要完成这样一个场景：

1)有一系列 robot 排成一排(publisher)向管理员(subscriber)报道，每个人都发一个消息(robotID)，包含 name 和 id 类似：

name=robot id=0

name=robot id=1

name=robot id=2

2)有一个管理员订阅了这个消息(robotID)，然后读取消息内容并且和每个机器人打招呼：

hello robot 0

hello robot 1

hello robot 2

要完成以上的功能，我们需要创建消息(robotID)、发送消息的发送者(publisher)、接收消息的订阅者(subscriber)。他们之间的关系是这样的：

1、创建 ros 目录：

先我们为所有的 ROS 工程创建如下路径：

Shell

mkdir ~/ROS

1mkdir~/ROS

以后的笔记里面，我们把这一路径称作 ROS_PATH，这一路径就是我们所有 ros 工程的基本路径。

2、创建 workspace 和 package：

一个典型的 ros 工程是在一个 workspace 下包含若干个包，每一个包应该完成一套独立的功能。它的路径通常类似于：

workspace_folder/ -- WORKSPACE

src/ -1- SOURCE SPACE

CMakeLists.txt -- 'Toplevel' CMake file, provided by catkin

package_1/

CMakeLists.txt -- CMakeLists.txt file for package_1

package.xml -- Package manifest for package_1

...

package_n/

CMakeLists.txt -- CMakeLists.txt file for package_n

package.xml -- Package manifest for package_n

我们的 workspace 命名为 hellorobot_ws，我们将所有有关这一工程的包都放在 hellorobot_ws/src 路径下，现在进入 ROS_PATH 创建这个目录：

1) 创建 workspace：

Shell

mkdir -p hellorobot_ws/src/

cd hellorobot_ws/src

2mkdir-phellorobot_ws/src/

cdhellorobot_ws/src

2)创建 package：

我们在该 workspace 的 src 目录下创建一个名为 hellorobot 的 package：

Shell

catkin_create_pkg hellorobot std_msgs rospy roscpp

1catkin_create_pkghellorobotstd_msgsrospyroscpp

这里面 std_msgs rospy roscpp 是我们通常一个最基本的C++包之中需要的依赖项。后面这些依赖项均可以通过配置 package.xml 进行更改。

3)编译 package：

即使什么都不写我们已经可以编译这个包了。编译包需要在 workspace 路径下

Shell

cd ..

catkin_make

2cd..

catkin_make

编译成功后在 ROS_PTAH/hellorobot_ws 下就可以看到如下目录结构已经生成了：

build

devel

src

顺便说一下大家在网上下git代码，其实都是其中一个包的src的部分，相当于我们的 ROS_PTAH/hellorobot_ws/src/hellorobot/src，因此只要放入这一目录再按照此步骤运行 catkin_make 即可。

3、创建自定义消息：

1)创建 robotMsg.msg 文件：

在这里我们需要一个消息，包含 name 和 id 两个字段，其中 name 自然都是 robot。我们在 ROS_PTAH/hellorobot_ws/src/hellorobot 路径下创建 msg 文件夹，然后新建 robotMsg.msg 文件：

Shell

mkdir msg

cd msg

vi robotMsg.msg

3mkdirmsg

cdmsg

virobotMsg.msg

文件内容如下：

Header header

string name

int32 id

3Headerheader

stringname

int32id

2)在 package.xml 添加 message 依赖：

在 package.xml 中找到如下两行代码并且取消注释：

XHTML

message_generation

message_runtime

2message_generation

message_runtime

这两行分别表示在编译和运行时的 message 依赖。

3)在 CMakeList.txt 添加编译依赖：

找到 find_package 添加 message_generation，结果如下：

find_package(catkin REQUIRED COMPONENTS

roscpp

rospy

std_msgs

message_generation

)

6find_package(catkinREQUIREDCOMPONENTS

roscpp

rospy

std_msgs

message_generation

)

找到 add_message_files ，去掉注释并添加 robotMsg.msg 消息文件：

## Generate messages in the 'msg' folder

add_message_files(

FILES

robotMsg.msg

# Message2.msg

)

6## Generate messages in the 'msg' folder

add_message_files(

FILES

robotMsg.msg

# Message2.msg

)

找到 generate_messages 函数去掉注释，结果如下：

## Generate added messages and services with any dependencies listed here

generate_messages(

DEPENDENCIES

std_msgs

)

5## Generate added messages and services with any dependencies listed here

generate_messages(

DEPENDENCIES

std_msgs

)

找到 catkin_package 添加如下行并启用该部分，结果如下：

catkin_package(

# INCLUDE_DIRS include

# LIBRARIES hellorobot

# CATKIN_DEPENDS roscpp rospy std_msgs

CATKIN_DEPENDS message_runtime

# DEPENDS system_lib

)

7catkin_package(

# INCLUDE_DIRS include

# LIBRARIES hellorobot

# CATKIN_DEPENDS roscpp rospy std_msgs

CATKIN_DEPENDSmessage_runtime

# DEPENDS system_lib

)

顺便说下，如果你运行 catkin_make 以后，这个消息的头文件生成在：

devel/include/hellorobot/robotMsg.h

目录下。

4、创建发布者 publisher：

我们在 ROS_PTAH/hellorobot_ws/src/hellorobot/src 目录下创建 publisher.cpp 文件，代码内容如下：

C++

#include "ros/ros.h"

//#include "std_msgs/String.h"

#include "hellorobot/robotMsg.h"

#include

/**

* This tutorial demonstrates simple sending of messages over the ROS system.

int main(int argc, char **argv)

{

/**

* The ros::init() function needs to see argc and argv so that it can perform

* any ROS arguments and name remapping that were provided at the command line.

* For programmatic remappings you can use a different version of init() which takes

* remappings directly, but for most command-line programs, passing argc and argv is

* the easiest way to do it. The third argument to init() is the name of the node.

* You must call one of the versions of ros::init() before using any other

* part of the ROS system.

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

/**

* NodeHandle is the main access point to communications with the ROS system.

* The first NodeHandle constructed will fully initialize this node, and the last

* NodeHandle destructed will close down the node.

ros::NodeHandle n;

/**

* The advertise() function is how you tell ROS that you want to

* publish on a given topic name. This invokes a call to the ROS

* master node, which keeps a registry of who is publishing and who

* is subscribing. After this advertise() call is made, the master

* node will notify anyone who is trying to subscribe to this topic name,

* and they will in turn negotiate a peer-to-peer connection with this

* node. advertise() returns a Publisher object which allows you to

* publish messages on that topic through a call to publish(). Once

* all copies of the returned Publisher object are destroyed, the topic

* will be automatically unadvertised.

* The second parameter to advertise() is the size of the message queue

* used for publishing messages. If messages are published more quickly

* than we can send them, the number here specifies how many messages to

* buffer up before throwing some away.

ros::Publisher chatter_pub = n.advertise<:robotmsg>("robotID", 1000);

ros::Rate loop_rate(10);

/**

* A count of how many messages we have sent. This is used to create

* a unique string for each message.

int32_t count = 0;

while (ros::ok())

{

/**

* This is a message object. You stuff it with data, and then publish it.

//std_msgs::String msg;

hellorobot::robotMsg msg;

msg.header.stamp = ros::Time::now();

msg.header.frame_id = "/robot";

msg.id = count;

msg.name = "Robot";

//std::stringstream ss;

//ss << "hello world " << count;

//msg.data = ss.str();

ROS_INFO("I am %s %d", msg.name.c_str(), msg.id);

/**

* The publish() function is how you send messages. The parameter

* is the message object. The type of this object must agree with the type

* given as a template parameter to the advertise<>() call, as was done

* in the constructor above.

chatter_pub.publish(msg);

ros::spinOnce();

loop_rate.sleep();

++count;

}

return 0;

}

93#include "ros/ros.h"

//#include "std_msgs/String.h"

#include "hellorobot/robotMsg.h"

#include

/**

* This tutorial demonstrates simple sending of messages over the ROS system.

intmain(intargc,char**argv)

{

/**

* The ros::init() function needs to see argc and argv so that it can perform

* any ROS arguments and name remapping that were provided at the command line.

* For programmatic remappings you can use a different version of init() which takes

* remappings directly, but for most command-line programs, passing argc and argv is

* the easiest way to do it. The third argument to init() is the name of the node.

* You must call one of the versions of ros::init() before using any other

* part of the ROS system.

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

/**

* NodeHandle is the main access point to communications with the ROS system.

* The first NodeHandle constructed will fully initialize this node, and the last

* NodeHandle destructed will close down the node.

ros::NodeHandlen;