20180511

编写订阅器节点

代码解释

  34 void chatterCallback(const std_msgs::String::ConstPtr& msg)
  35 {
  36   ROS_INFO("I heard: [%s]", msg->data.c_str());
  37 }

这是一个回调函数，当接收到 
chatter
 话题的时候就会被调用。消息是以 
boost shared_ptr
 指针的形式传输，这就意味着你可以存储它而又不需要复制数据。

75   ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);

告诉 master 我们要订阅 chatter 话题上的消息。当有消息发布到这个话题时，ROS 就会调用 chatterCallback() 函数。第二个参数是队列大小，以防我们处理消息的速度不够快，当缓存达到 1000 条消息后，再有新的消息到来就将开始丢弃先前接收的消息。

NodeHandle::subscribe() 返回 ros::Subscriber 对象,你必须让它处于活动状态直到你不再想订阅该消息。当这个对象销毁时，它将自动退订 chatter 话题的消息。

  82   ros::spin();

ros::spin() 进入自循环，可以尽可能快的调用消息回调函数。如果没有消息到达，它不会占用很多 CPU，所以不用担心。一旦 ros::ok() 返回 false，ros::spin() 就会立刻跳出自循环。这有可能是 ros::shutdown() 被调用，或者是用户按下了 Ctrl-C，使得 master 告诉节点要终止运行。也有可能是节点被人为关闭的。

编译节点

  20 add_executable(talker src/talker.cpp)
  21 target_link_libraries(talker ${catkin_LIBRARIES})
  22 add_dependencies(talker beginner_tutorials_generate_messages_cpp)
  23 
  24 add_executable(listener src/listener.cpp)
  25 target_link_libraries(listener ${catkin_LIBRARIES})
  26 add_dependencies(listener beginner_tutorials_generate_messages_cpp)

add_executable() 和target_link_libraries()，这会生成两个可执行文件, talker 和 listener, 默认存储到 devel space 目录下,具体是在~/catkin_ws/devel/lib/<package name> 中.

add_dependencies()，为可执行文件添加对生成的消息文件的依赖。这样就可以确保自定义消息的头文件在被使用之前已经被生成。因为 catkin 把所有的 package 并行的编译，所以如果你要使用其他 catkin 工作空间中其他 package 的消息，你同样也需要添加对他们各自生成的消息文件的依赖。当然，如果在 *Groovy* 版本下，你可以使用下边的这个变量来添加对所有必须的文件依赖:

add_dependencies(talker ${catkin_EXPORTED_TARGETS})

# In your catkin workspace
$ catkin_make  

编写Service节点
这里，我们将创建一个简单的service节点(“add_two_ints_server”)，该节点将接收到两个整形数字，并返回它们的和。

cd ~/catkin_ws/src/beginner_tutorials

在beginner_tutorials包中创建src/add_two_ints_server.cpp文件。

在beginner_tutorials包中创建src/add_two_ints_client.cpp文件，

  15   ros::ServiceClient client = n.serviceClient<beginner_tutorials::AddTwoInts>("add_two_ints");

这段代码为add_two_ints service创建一个client。ros::ServiceClient 对象待会用来调用service。??

  16   beginner_tutorials::AddTwoInts srv;
  17   srv.request.a = atoll(argv[1]);
  18   srv.request.b = atoll(argv[2]);

这里，我们实例化一个由ROS编译系统自动生成的service类，并给其request成员赋值。一个service类包含两个成员request和response。同时也包括两个类定义Request和Response。

  19   if (client.call(srv))

  27 add_executable(add_two_ints_server src/add_two_ints_server.cpp)
  28 target_link_libraries(add_two_ints_server ${catkin_LIBRARIES})
  29 add_dependencies(add_two_ints_server beginner_tutorials_gencpp)
  30 
  31 add_executable(add_two_ints_client src/add_two_ints_client.cpp)
  32 target_link_libraries(add_two_ints_client ${catkin_LIBRARIES})
  33 add_dependencies(add_two_ints_client beginner_tutorials_gencpp)

$ rosrun beginner_tutorials add_two_ints_server     (C++)

$ rosrun beginner_tutorials add_two_ints_client 1 3     (C++)

如果你想做更深入的研究，或者是得到更多的操作示例，你可以从这个链接找到here. 一个简单的Client与Service的组合程序演示了自定义消息类型的使用方法. 如果Service节点是用C++写的，写Client用C++，Python或者是LISP都可以.

录制与回放数据

mkdir ~/bagfiles
cd ~/bagfiles
rosbag record -a

在这里我们先建立一个用于录制的临时目录，然后在该目录下运行
rosbag record
命令，并附加
-a
选项，该选项表示将当前发布的所有话题数据都录制保存到一个bag文件中。

现在我们已经使用rosbag record命令录制了一个bag文件，接下来我们可以使用rosbag info检查看它的内容，使用rosbag play命令回放出来。

rosbag info <your bagfile>

rosbag play <your bagfile>

rosbag play命令在公告每条消息后会等待一小段时间（0.2秒）后才真正开始发布bag文件中的内容。等待一段时间的过程可以通知消息订阅器消息已经公告了消息数据可能会马上到来。如果rosbag play在公告消息后立即发布，订阅器可能会接收不到几条最先发布的消息。等待时间可以通过-d选项来指定。

rosbag play -r 2 <your bagfile>

录制数据子集

rosbag record命令支持只录制某些特别指定的话题到单个bag文件中，这样就允许用户只录制他们感兴趣的话题。

rosbag record -O subset /turtle1/command_velocity /turtle1/pose

上述命令中的-O参数告诉rosbag record将数据记录保存到名为subset.bag的文件中，同时后面的话题参数告诉rosbag record只能录制这两个指定的话题。然后通过键盘控制turtle随处移动几秒钟，最后按Ctrl+C退出rosbag record命令。

roswtf入门

roswtf 可以检查你的ROS系统并尝试发现问题，我们来试看：

$ roscd
$ roswtf

“Static checks summary”: 这是有关文件系统问题的检查报告，现在的检查结果表示文件系统没问题。

roswtf还可以发现很多其它类型的问题。如果你发现自己被一个编译或者通信之类的问题困扰的时候，可以尝试运行roswtf看能否帮你解决。

20180510

理解ROS服务和参数

rosservice使用 ROS 客户端/服务器框架提供的服务

rosservice list         输出可用服务的信息
rosservice call         调用带参数的服务
rosservice type         输出服务类型
rosservice find         依据类型寻找服务find services by service type
rosservice uri          输出服务的ROSRPC uri

调用服务

rosservice call [service] [args]

查看topic spawn的类型（组成）在rossrv show查看消息组成

$ rosservice type spawn| rossrv show

通过调用service spawn创建乌龟

$ rosservice call spawn 2 2 0.2 ""

rosparam
使得我们能够存储并操作ROS 
参数服务器（Parameter Server）
上的数据。

$ rosparam list

rosparam set background_r 150

上述指令修改了参数的值，现在我们调用清除服务使得修改后的参数生效：

$ rosservice call clear

获取背景的绿色通道的值：

$ rosparam get background_g 

可以使用rosparam get /来显示参数服务器上的所有内容：

$ rosparam get /

存储这些信息以备今后重新读取。这通过rosparam很容易就可以实现:

rosparam dump [file_name]
rosparam load [file_name] [namespace]

$ rosparam dump params.yaml

甚至可以将yaml文件重载入新的命名空间，比如说
copy
空间:

$ rosparam load params.yaml copy
$ rosparam get copy/background_b

☆使用rqt_console 和roslaunch

rqt_console属于ROS日志框架(logging framework)的一部分，用来显示节点的输出信息。rqt_logger_level允许我们修改节点运行时输出信息的日志等级（logger levels）（包括 DEBUG、WARN、INFO和ERROR）。

$ rosrun rqt_console rqt_console

$ rosrun rqt_logger_level rqt_logger_level

roslaunch可以用来启动定义在launch文件中的多个节点

指明launch file文件位置的方式有两种： 
第一种是直接指明launch file的绝对路径位置 
第二种是指明软件包名称和放在软件包目录中的launch file，这种情况下roslaunch会在软件包目录中寻找和指定文件匹配的launch file

$ roslaunch [package] [filename.launch]

创建launch文件

   1 <launch>
   2 
   3   <group ns="turtlesim1">
   4     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   5   </group>
   6 
   7   <group ns="turtlesim2">
   8     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   9   </group>
  10 
  11   <node pkg="turtlesim" name="mimic" type="mimic">
  12     <remap from="input" to="turtlesim1/turtle1"/>
  13     <remap from="output" to="turtlesim2/turtle1"/>
  14   </node>
  15 
  16 </launch>

在这里我们创建了两个节点分组并以’命名空间（namespace)’标签来区分，其中一个名为turtulesim1，另一个名为turtlesim2，两个组里面都使用相同的turtlesim节点并命名为’sim’。这样可以让我们同时启动两个turtlesim模拟器而不会产生命名冲突。

  11   <node pkg="turtlesim" name="mimic" type="mimic">
  12     <remap from="input" to="turtlesim1/turtle1"/>
  13     <remap from="output" to="turtlesim2/turtle1"/>
  14   </node>

在这里我们启动模仿节点，并将所有话题的输入和输出分别重命名为turtlesim1和turtlesim2，这样就会使turtlesim2模仿turtlesim1。

<remap from=”input” to=”turtlesim1/turtle1″/>的意思就是将当前节点mimic订阅的话题input映射到话题turtlesim1/turtle1；

<remap from=”output” to=”turtlesim2/turtle1″/>的意思就是将当前节点mimic发布的话题映射到话题turtlesim2/turtle1

？？

一个node element包含三个必须的属性：pkg, type, name.

pkg和type属性指出ROS应该运行哪个pkg中的哪个node，注意：此处的type是可执行文件的名称，而name则是可以任意给出的，它覆盖了原有文件中ros::init指定的node name。

 参考博客 ：https://blog.csdn.net/column/details/12719.html

使用rosed编辑ROS中的文件

rosed 是 rosbash 的一部分。利用它可以直接通过package名来获取到待编辑的文件而无需指定该文件的存储路径了。

$ rosed [package_name] [filename]

创建ROS消息和ROS服务

• 消息(msg): msg文件就是一个描述ROS中所使用消息类型的简单文本。它们会被用来生成不同语言的源代码。

• 服务(srv): 一个srv文件描述一项服务。它包含两个部分：请求和响应。

msg文件存放在package的msg目录下，srv文件则存放在srv目录下。

msg文件实际上就是每行声明一个数据类型和变量名。可以使用的数据类型如下：

• int8, int16, int32, int64 (plus uint*)
• float32, float64
• string
• time, duration
• other msg files
• variable-length array[] and fixed-length array[C]

    在ROS中有一个特殊的数据类型：
Header
，它含有时间戳和坐标系信息。在msg文件的第一行经常可以看到
Header header
的声明.

    eg：

  Header header
  string child_frame_id
  geometry_msgs/PoseWithCovariance pose
  geometry_msgs/TwistWithCovariance twist

    
srv文件分为请求和响应两部分，由’—‘分隔。下面是srv的一个样例：

int64 A
int64 B
---
int64 Sum

其中 A 和 B 是请求, 而Sum 是响应。

创建一个 msg

1、在package目录下建立msg文件夹，在此文件夹里添加新的消息。

2、关键的一步：我们要确保msg文件被转换成为C++，Python和其他语言的源代码：
查看package.xml, 确保它包含一下两条语句:

  <build_depend>message_generation</build_depend>
  <run_depend>message_runtime</run_depend>

在 
CMakeLists.txt
文件中，在find_packag函数中增加对
message_generation
的依赖。直接写在find_package（）中。

catkin_package(
  ...
  CATKIN_DEPENDS message_runtime ...
  ...)

add_message_files(
  FILES
  Num.msg
)

手动添加.msg文件后，我们要确保CMake知道在什么时候重新配置我们的project。 确保添加了如下代码：

generate_messages()

就可以生成自己的消息源代码了。

注意：kinetic版本<run_depend>应该改为<exec_depend>message_runtime</exec_depend>，然后才能catkin_make通过

    我在编译过后用rosmsg show 并没有找到Num.msg，后发现是环境变量没添加：

    echo $ROS_PACKAGE_PATH 显示当前ROS资源路径，应将自己之前新建的catkin_ws工作空间加进去：在工作空间目录下，source devel/setup.sh

创建一个srv

在刚刚那个package中创建一个服务：

$ roscd beginner_tutorials
$ mkdir srv

这次我们不再手动创建服务，而是从其他的package中复制一个服务。 
roscp
是一个很实用的命令行工具，它实现了将文件从一个package复制到另外一个package的功能。

$ roscp [package_name] [file_to_copy_path] [copy_path]

现在我们可以从
rospy_tutorials
 package中复制一个服务文件了：

$ roscp rospy_tutorials AddTwoInts.srv srv/AddTwoInts.srv

在CMakeLists.txt
文件中增加了对
message_generation
的依赖。
(对的, 
message_generation
 对
msg
和
srv
都起作用)

修改 add_service_files()

add_service_files(
  FILES
  AddTwoInts.srv
)

$ rossrv show beginner_tutorials/AddTwoInts

$ rossrv show AddTwoInts

去掉注释并附加上所有你消息文件所依赖的那些含有
.msg
文件的package（这个例子是依赖
std_msgs
,不要添加roscpp,rospy)，结果如下:

generate_messages(
  DEPENDENCIES
  std_msgs
)

重新编译package

catkin_make

所有在msg路径下的.msg文件都将转换为ROS所支持语言的源代码。生成的C++头文件将会放置在~/catkin_ws/devel/include/beginner_tutorials/。 Python脚本语言会在 ~/catkin_ws/devel/lib/python2.7/dist-packages/beginner_tutorials/msg 目录下创建。 lisp文件会出现在 ~/catkin_ws/devel/share/common-lisp/ros/beginner_tutorials/msg/ 路径下.

总结：msg和srv的一般步骤

• 首先是修改package.xml文件，确保该文件中与message有关的内容没有被注释掉。
• 然后修改CMakeist.txt文件： 
  • 在find_package函数中加入message_generation依赖；
  • 在catkin_package函数中加入message_runtime依赖；
  • 修改add_message_file函数，添加入自己创建的Num.msg文件；或者在add_service_file函数中添加入自己创建的srv文件；
  • 确保generate_messages函数被调用运行，去掉注释符号#；
• 重新编译生成软件包。

回顾命令：

• rospack = ros+pack(age) : provides information related to ROS packages
• rosstack = ros+stack : provides information related to ROS stacks

• roscd = ros+cd : changes directory to a ROS package or stack

• rosls = ros+ls : lists files in a ROS package

• roscp = ros+cp : copies files from/to a ROS package

• rosmsg = ros+msg : provides information related to ROS message definitions
• rossrv = ros+srv : provides information related to ROS service definitions
• rosmake = ros+make : makes (compiles) a ROS package

编写简单的消息发布器和订阅器 (C++)

在 beginner_tutorials package 路径下创建一个src文件夹：

这个文件夹将会用来放置 beginner_tutorials package 的所有源代码。

talker.cpp放在src中

代码解释：

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

初始化 ROS 。它允许 ROS 通过命令行进行名称重映射——然而这并不是现在讨论的重点。在这里，我们也可以指定节点的名称——运行过程中，节点的名称必须唯一。

这里的名称必须是一个 base name ，也就是说，名称内不能包含 / 等符号。

ros::NodeHandle n;

为这个进程的节点创建一个句柄。第一个创建的 
NodeHandle
 会为节点进行初始化，最后一个销毁的 
NodeHandle
 则会释放该节点所占用的所有资源。

 ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

告诉 master 我们将要在 chatter（话题名） 上发布 std_msgs/String 消息类型的消息。这样 master 就会告诉所有订阅了 chatter 话题的节点，将要有数据发布。第二个参数是发布序列的大小。如果我们发布的消息的频率太高，缓冲区中的消息在大于 1000 个的时候就会开始丢弃先前发布的消息。

NodeHandle::advertise() 返回一个 ros::Publisher 对象,它有两个作用： 1) 它有一个 publish() 成员函数可以让你在topic上发布消息； 2) 如果消息类型不对,它会拒绝发布。

  75   ros::Rate loop_rate(10);

ros::Rate
 对象可以允许你指定自循环的频率。它会追踪记录自上一次调用 
Rate::sleep()
 后时间的流逝，并休眠直到一个频率周期的时间。

在这个例子中，我们让它以 10Hz 的频率运行。

81   int count = 0;
  82   while (ros::ok())
  83   {

roscpp 会默认生成一个 SIGINT 句柄，它负责处理 Ctrl-C 键盘操作——使得 ros::ok() 返回 false。

如果下列条件之一发生，ros::ok() 返回false：

• SIGINT 被触发 (Ctrl-C)
• 被另一同名节点踢出 ROS 网络

• ros::shutdown() 被程序的另一部分调用

• 节点中的所有 ros::NodeHandles 都已经被销毁

一旦 ros::ok() 返回 false, 所有的 ROS 调用都会失效。

chatter_pub.publish(msg);

这里，我们向所有订阅 chatter 话题的节点发送消息。

ROS_INFO("%s", msg.data.c_str());

ROS_INFO
 和其他类似的函数可以用来代替 
printf
/
cout
 等函数。具体可以参考 
rosconsole documentation
，以获得更多信息。

ros::spinOnce();

在这个例子中并不是一定要调用 
ros::spinOnce()
，因为我们不接受回调。然而，如果你的程序里包含其他回调函数，最好在这里加上 
ros::spinOnce()
这一语句，否则你的回调函数就永远也不会被调用了。

loop_rate.sleep();

这条语句是调用 
ros::Rate
 对象来休眠一段时间以使得发布频率为 10Hz。

对上边的内容进行一下总结：

• 初始化 ROS 系统

• 在 ROS 网络内广播我们将要在 chatter 话题上发布 std_msgs/String 类型的消息

• 以每秒 10 次的频率在 chatter 上发布消息

20180509

打开turtlesim的键盘控制节点

$ rosrun turtlesim turtle_teleop_key

打开ROS Graph，可以看到各个节点，topic的名字

$ rosrun rqt_graph rqt_graph

获取topic相关信息

$ rostopic -h

rostopic echo [topic]

列出topic publish and subscribe发布和订阅信息

rostopic list -v

查看topic上的message消息类型

rostopic type [topic]

查看message消息详细情况

$ rosmsg show turtlesim/Velocity

将数据发布到当前某个正在广播的话题上

rostopic pub [topic] [msg_type] [args]

$ rostopic pub -1 /turtle1/cmd_vel geometry_msgs/Twist -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'

这些参数其实是按照YAML语法格式编写的，这在YAML文档中有更多的描述。

-h for help. -1发一次退出 -r固定频率发

注意参数 -r 1没有-

$ rostopic pub /turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'

查看topic数据发布频率

$ rostopic hz /turtle1/pose

使用rqt_plot可绘制topic参数图形

$ rosrun rqt_plot rqt_plot

20180508 

wiki.ros.org

基本概念

        ROS 是一个适用于机器人的开源的元操作系统。它提供了操作系统应有的服务，包括硬件抽象，底层设备控制，常用函数的实现，进程间消息传递，以及包管理。在某些方面ROS相当于一种“机器人框架（robot frameworks）”类似的“机器人框架”有：Player，YARP，Orocos，CARMEN，Orca，MOOS和 Microsoft Robotics Studio。ROS 运行时的“蓝图”是一种基于ROS通信基础结构的松耦合点对点进程网络。ROS实现了几种不同的通信方式，包括基于同步RPC样式通信的服务（services）机制，基于异步流媒体数据的话题（topics）机制以及用于数据存储的参数服务器（Parameter Server）。

１、ROS文件系统层

Packages : 主要单元，包含节点ROS runtime processes\  ROS-dependent library \  datasets \ configuration files等。

metapackages, package manifests, respositories

message(msg) types: 存储在my_package/msg/MyMessageType.msg的Message文件，主要定义了ROS系统的messages传输的数据结构。

service (srv) types: 存储在 my_package/srv/MyServiceType.srv的服务services文件，定义了ROS的服务通信时的请求（request ）和响应（response ）相关的数据结构。

２、ROS计算图层 Computation Graph

    计算图是ROS在点对点网络里整合并处理数据的过程。基本计算图概念是 节点, 主机, 参数服务器, 消息, 服务, 话题, and 数据包，它们通过不同的方式提供数据给图层。

    这些概念是在ros_comm库里实现的。

    Node: 节点主要执行计算处理。例如一个节点控制激光测距仪，一个节点控制电机，一个执行定位，一个提供系统图形界面。通过client library编写。

    Master:  provides name registration \ lookup to Computation Graph \ nodes can find each other, exchange messages, invoke serivces

    Parameter Server:  part of the Master, store data by key in a central location.

    Messages: nodes communication by passing messages.  A data structure, support standard types, structures and arrays.

   Topics: messages routs on topics. A node sends out a message by publishing it to a given topic. Logically, a topic just like a strongly typed message bus. Each bus has a name, and only who are the right type can connect to the bus to send or receive messages.

    Services: Request/reply is done via services. (distributed system). A providing note offers a service under a name and a client users the service by sending the request message and awaiting the reply. ROS presents this interaction as if it were a remote procedure call.

    Bags:  a format for saving and playing back ROS messages. storing data such as sensor data.

    ROS Master在ROS计算图中作为nameservice，为Nodes存储topics and services的注册信息registration information。nodes report to master and master gives callbacks,  which allows nodes to dynamically create connnections as new nodes are run.

    Nodes直接连接其他Nodes，the master只提供lookup信息，像一个DNS server。Nodes publish topic ，属于这个topic的nodes 会请求连接，通过一种ROS叫做TCPROS的标准TCP/IP sockets。

    ROS客户端支持命令行name重映射，使得编译的程序可以在运行时重新配置，以适应不同的计算图。

３、Names

    Graph Resource Names图资源名称：提供用于ROS计算图中的所有资源的分层命名结构，例如节点、参数、主题和服务

    例子：

    / (the global namespace)

    /foo

    /stanford/robot/name

    /wg/node1

    图资源名称是ROS提供封装的一个重要机制。每个资源resource都在一个命名空间namespace里定义，资源在命名空间内创建资源，可以访问空间内及以上的资源。Ｎａｍｅｓ是相对单独解析，资源不需要知道他们的命名空间，因此ｎｏｄｅｓ集成到更大的系统中时，它们被定义到它们的代码集合的命名空间中，即时这些nodes里面有相同名字的节点也不会发生冲突。

    Graph Resource Names：分４种类型，base,relative,global,private.

    examples:

    base
    relative/name
    /global/name
    ~private/name

    解析是相对于节点的命名空间进行的,例如/wg/node1在namespace　/wg下，所以node1将解析为/wg/node1

    没有/是base。/后面的名称是global的，they fully resolved。~开头的是private的，they convert into a namespace。private对于通过参数服务器传参给特定节点非常有用。

    examples:

    Node                                    Relative(default)                                Global                                    Private

 /node1            bar -> /bar                /bar -> /bar       ~bar -> /node1/bar

 /wg/node2         bar -> /wg/bar             /bar -> /bar       ~bar -> /wg/node2/bar

 /wg/node3         foo/bar -> /wg/foo/bar     /foo/bar -> /foo/bar ~foo/bar -> /wg/node3/foo/bar

    例如，/wg/node2节点下的bar，无/默认是解析为/wg/bar下，有/时解析为global的/bar，有～时解析为/wg/node2/bar。

    remapping 重新映射:当节点在命令行启动时，ROS节点中的任何名称都可以重新映射。

    Package Resource Names 包资源名：包资源名在ROS中使用文件系统级概念，以简化在磁盘上引用文件和数据类型的过程。包资源名称非常简单：它们只是资源所包含的包的名称加上资源的名称。例如，“STDYMSGs/String”的名称是指“STDYMSGS”包中的“String”消息类型。

    可以使用包资源名称引用的一些

    Message (msg) types
    Service (srv) types
    Node types

    package资源名称和文件路径相似，例如，消息描述总是存储在MSG子目录中并具有.MSG扩展名，因此STDYMSGs/String是PAT/OT/STDYMSGs/MSG/String .MSG的简写。类似的，foo/bar则是相当于在foo package里搜索一个叫bar的文件（用可执行权限）。

高级概念

    1、coordinate frames/transforms 坐标帧和坐标系变换

    tf package    http://wiki.ros.org/tf

    ２、action/tasks 动作/任务

    actionlib package 定义了一个给予topic的可抢占任务的接口。http://wiki.ros.org/actionlib

    ３、message ontology 消息实体

     common_msgs stack堆栈提供了ROS基本消息本体。它定义了几类消息：

    actionlib_msgs: 表现动作的message.
    diagnostic_msgs: 发送诊断数据的msg.
    geometry_msgs: 表现基本几何的msg.
    nav_msgs: 导航的msg.

    sensor_msgs: 传感器的msg.

    4、plugins 插件

    pluginlib提供动态加载c++代码的功能。

    ５、Filters　滤波器

    The filters package 提供了包含一系列处理数据的滤波器的c++库。.

    ６、Robot Model　机器人模型

    The urdf package 定义了一个xml格式的表示机器人的模型，以及一个c++解析器。

客户端函数库Client libraries

    １、概述：ROS client library.  These libraries let you write ROS nodes, publish and subscribe to topics, write and call services, and use the Parameter Server. 　由c++ and python编写。

　２、main client lib：

　　roscpp: roscpp是ROS C++客户端库。

       rospy:纯Python客户端库,可以运用该库快速地在ROS中原型化和测试算法,并且 ideal for non-critical-path code, such as configuration and initialization code。

        roslisp: lisp客户端库，用于开发planning lib。支持在运行的ROS系统中独立创建节点和交互使用。

　３、experimental client lib: rosjava, roslua, roscs,roseus,PhaRos,rosR

技术概述Technical Overview

    TBC..

Tutorials

辅助命令rospack find， roscd，rosls

创建catkin程序包,

 catkin_create_pkg beginner_tutorials std_msgs rospy roscpp

catkin_make  

roscore

rosnode list

rosnode info /rosout

rosrun [package_name] [node_name]

rosrun turtlesim turtlesim_node __name:=my_turtle