本文已参与「新人创作礼」活动，一起开启创作之路。

1 ROS的安装

本节参考

2 ROS的文件系统命令rosls、roscd、rospack find的快速使用

首先说明（本节参考），rosls、roscd、rospack find命令和我们平时使用的ls、cd、find功能几乎是一样的，唯一的区别就是能够快速定位到ros系统文件的位置，下面来快速学习一下吧！

2.1 rosls：快速列举ros文件目录下的文件

1、ros通信技术ls <要查看的目录名>

(base) shl@zhihui-mint:~$ rosls roscpp_tutorials/
cmake  launch  package.xml  srv
(base) shl@zhihui-mint:~$ 

注意：

目录名工作流程模板如果记不太清楚，可以通过按ta测试抑郁程度的问卷b键进行补全

2.2 roscd：快速切换到ros文件系统的指定目录

roscd有两种用法：

1、roscd不加参数：不带参数时roscd直接进入环境变量 $ROS_ROOT定义的目录.

(base) shl@zhihui-mint:~$ roscd
(base) shl@zhihui-mint:/opt/ros/melodic$ 

2、roscd <目录名>：切换到指定的目录下

(base) shl@zhihui-mint:/opt/ros/melodic$ roscd roscpp_tutorials/
(base) shl@zhihui-mint:/opt/ros/melodic/share/roscpp_tutorials$ 

注意：

目录名如果记不太清楚，可以通过按tab键进行补全

2.google谷歌搜索主页3 rospack find <文件名/目录名>查找指定文件或目录的路径

(base) shl@zhihui-mint:~$ rospack find roscpp_tutorials
/opt/ros/melodic/share/roscpp_tutorials
(base) shl@zhihui-mint:~$ 

rospack fin工作流d命令和rosstack find命令的使用是差不多的，通信达也是快速查找ros文件系统中的文件或目录的路径：

(base) shl@zhihui-mint:~$ rosstack find roscpp_tutorials
/opt/ros/melodic/share/roscpp_tutorials
(base) shl@zhihui-mint:~$ 

注意：

目录名如果记不太清楚，可以通过按tab键进行补google服务框架全

3 创建ROS程序包

• 本节参考

本教程介绍如何使用roscreate-pkg或catkin创建一个新程序包，并使用rospack查看程序包的依赖关系。

3.1 一个catkin程序包有哪些文件组成？

一个程序包要想称为catkin程序包必须符合以下要求：

• 1）该程序包必须包含catkin compliant package.xml文件，这个package.xml文件提供有关程序包的元信息。

• 2）程序包必须包含一个catkin 版本的CMakeLists.txt文件，而Catkin metapackag测试手机是否被监控es中必须包含一个对CMakeList.txt文件的引用。

• 3）每个目录开源代码网站github下只能有一个程序包。这意味着在同一个目录下不能有嵌套的或者多个程序包存在。

my_package/
├── CMakeLists.txt
└── package.xml

3.2 在catkin工作空间中的程序包

开发catkin程序包的一个推荐方法是使用catkin工作空间，一个简单的工作空间也许看起来像这样：

(base) shl@zhihui-mint:~$ tree catkin_ws/
catkin_ws/   # 工作空间
└── src     # 源码目录
    ├── package_1
    │   ├── CMakeLists.txt
    │   └── package.xml
    ├── package_2
    │   ├── CMakeLists.txt
    │   └── package.xml
    └── package_n
        ├── CMakeLists.txt
        └── package.xml
4 directories, 6 files
(base) shl@zhihui-mint:~$ 

3.3 创建一个测试工程师catkin程序包开源阅读

本部分教程将演示如何使用catkin_create_pkg命令来创建一个新的catkin程序包以及创建开源是什么意思之后都能做些什么。

1、首先把路径切换到源码目录下

cd ~/catkin_ws/src

2、现在使用catkgoogle谷歌搜索主页in_c开源众包r开源阅读app下载安装eate_pkg命令来创建一个名为beginner_tutor测试抑郁症的20道题ials的新程序包，工作流程怎么写这个程序包依赖于std_msgs、roscpp和rospy这三个package：

catkin_create开源节流是什么意思_pkg begingoogle服务框架ner_tutorials std_ms通信地址gs rospy roscpp

其中：

• rospy：rospy是Python的客户端库
• rogoogle商店scpp：roscpp是开源是什么意思C++的客户端库

执行上面的命令：

• 会创建一个名为beginner测试你的自卑程度_tutorials的文件夹
• 这个文件夹里面包含一个package.xml文件和一个CMakeLists.txt文件
• 这两个文件都已经自动包含了部分你在执行catkin_creat测试e_pkg通信行程卡下载app命令时提供的信息。
• 如果你还需要其他的程序包依赖，可以在后面继续添加

创建新的程序包后，生成的文件目录结果如下：

(base) shl@zhihui-mint:~$ tree catkin_ws/
catkin_ws/
└── src
1 directory, 0 files
(base) shl@zhihui-mint:~$ cd ~/catkin_ws/src/
(base) shl@zhihui-mint:~/catkin_ws/src$ catkin_create_pkg beginner_tutorials std_msgs rospy roscpp
Created file beginner_tutorials/package.xml
Created file beginner_tutorials/CMakeLists.txt
Created folder beginner_tutorials/include/beginner_tutorials
Created folder beginner_tutorials/src
Successfully created files in /home/shl/catkin_ws/src/beginner_tutorials. Please adjust the values in package.xml.
(base) shl@zhihui-mint:~/catkin_ws/src$ tree ~/catkin_ws/
/home/shl/catkin_ws/
└── src
    └── beginner_tutorials
        ├── CMakeLists.txt
        ├── include
        │   └── beginner_tutorials
        ├── package.xml
        └── src
5 directories, 2 files
(base) shl@zhihui-mint:~/catkin_ws/src$ 

可以看到生成了程序包beginner开源阅读app下载安装_tutorials，下面我们来看一下CMakeLisgoogle服务框架ts.txt和package.xml文件中有哪些内容：

• 1）CMakeLists.txt文件中的内容：

(base) shl@zhihui-mint:~/catkin_ws/src$ cat beginner_tutorials/CMakeLists.txt
cmake_minimum_required(VERSION 3.0.2)
project(beginner_tutorials)
## Compile as C++11, supported in ROS Kinetic and newer
# add_compile_options(-std=c++11)
## Find catkin macros and libraries
## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
## is used, also find other catkin packages
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
)
## System dependencies are found with CMake's conventions
# find_package(Boost REQUIRED COMPONENTS system)
## Uncomment this if the package has a setup.py. This macro ensures
## modules and global scripts declared therein get installed
## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
# catkin_python_setup()
################################################
## Declare ROS messages, services and actions ##
################################################
## To declare and build messages, services or actions from within this
## package, follow these steps:
## * Let MSG_DEP_SET be the set of packages whose message types you use in
##   your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...).
## * In the file package.xml:
##   * add a build_depend tag for "message_generation"
##   * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET
##   * If MSG_DEP_SET isn't empty the following dependency has been pulled in
##     but can be declared for certainty nonetheless:
##     * add a exec_depend tag for "message_runtime"
## * In this file (CMakeLists.txt):
##   * add "message_generation" and every package in MSG_DEP_SET to
##     find_package(catkin REQUIRED COMPONENTS ...)
##   * add "message_runtime" and every package in MSG_DEP_SET to
##     catkin_package(CATKIN_DEPENDS ...)
##   * uncomment the add_*_files sections below as needed
##     and list every .msg/.srv/.action file to be processed
##   * uncomment the generate_messages entry below
##   * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...)
## Generate messages in the 'msg' folder
# add_message_files(
#   FILES
#   Message1.msg
#   Message2.msg
# )
## Generate services in the 'srv' folder
# add_service_files(
#   FILES
#   Service1.srv
#   Service2.srv
# )
## Generate actions in the 'action' folder
# add_action_files(
#   FILES
#   Action1.action
#   Action2.action
# )
## Generate added messages and services with any dependencies listed here
# generate_messages(
#   DEPENDENCIES
#   std_msgs
# )
################################################
## Declare ROS dynamic reconfigure parameters ##
################################################
## To declare and build dynamic reconfigure parameters within this
## package, follow these steps:
## * In the file package.xml:
##   * add a build_depend and a exec_depend tag for "dynamic_reconfigure"
## * In this file (CMakeLists.txt):
##   * add "dynamic_reconfigure" to
##     find_package(catkin REQUIRED COMPONENTS ...)
##   * uncomment the "generate_dynamic_reconfigure_options" section below
##     and list every .cfg file to be processed
## Generate dynamic reconfigure parameters in the 'cfg' folder
# generate_dynamic_reconfigure_options(
#   cfg/DynReconf1.cfg
#   cfg/DynReconf2.cfg
# )
###################################
## catkin specific configuration ##
###################################
## The catkin_package macro generates cmake config files for your package
## Declare things to be passed to dependent projects
## INCLUDE_DIRS: uncomment this if your package contains header files
## LIBRARIES: libraries you create in this project that dependent projects also need
## CATKIN_DEPENDS: catkin_packages dependent projects also need
## DEPENDS: system dependencies of this project that dependent projects also need
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES beginner_tutorials
#  CATKIN_DEPENDS roscpp rospy std_msgs
#  DEPENDS system_lib
)
###########
## Build ##
###########
## Specify additional locations of header files
## Your package locations should be listed before other locations
include_directories(
# include
  ${catkin_INCLUDE_DIRS}
)
## Declare a C++ library
# add_library(${PROJECT_NAME}
#   src/${PROJECT_NAME}/beginner_tutorials.cpp
# )
## Add cmake target dependencies of the library
## as an example, code may need to be generated before libraries
## either from message generation or dynamic reconfigure
# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Declare a C++ executable
## With catkin_make all packages are built within a single CMake context
## The recommended prefix ensures that target names across packages don't collide
# add_executable(${PROJECT_NAME}_node src/beginner_tutorials_node.cpp)
## Rename C++ executable without prefix
## The above recommended prefix causes long target names, the following renames the
## target back to the shorter version for ease of user use
## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node"
# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")
## Add cmake target dependencies of the executable
## same as for the library above
# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
## Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node
#   ${catkin_LIBRARIES}
# )
#############
## Install ##
#############
# all install targets should use catkin DESTINATION variables
# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html
## Mark executable scripts (Python etc.) for installation
## in contrast to setup.py, you can choose the destination
# catkin_install_python(PROGRAMS
#   scripts/my_python_script
#   DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )
## Mark executables for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html
# install(TARGETS ${PROJECT_NAME}_node
#   RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
# )
## Mark libraries for installation
## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
# install(TARGETS ${PROJECT_NAME}
#   ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
#   LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
#   RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
# )
## Mark cpp header files for installation
# install(DIRECTORY include/${PROJECT_NAME}/
#   DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
#   FILES_MATCHING PATTERN "*.h"
#   PATTERN ".svn" EXCLUDE
# )
## Mark other files for installation (e.g. launch and bag files, etc.)
# install(FILES
#   # myfile1
#   # myfile2
#   DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
# )
#############
## Testing ##
#############
## Add gtest based cpp test target and link libraries
# catkin_add_gtest(${PROJECT_NAME}-test test/test_beginner_tutorials.cpp)
# if(TARGET ${PROJECT_NAME}-test)
#   target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
# endif()
## Add folders to be run by python nosetests
# catkin_add_nosetests(test)
(base) shl@zhihui-mint:~/catkin_ws/src$ 

• 2）package.xml文件中的内容：

(base) shl@zhihui-mint:~/catkin_ws/src$ cat beginner_tutorials/package.xml
<?xml version="1.0"?>
<package format="2">
  <name>beginner_tutorials</name>
  <version>0.0.0</version>
  <description>The beginner_tutorials package</description>
  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <maintainer email="shl@todo.todo">shl</maintainer>
  <!-- One license tag required, multiple allowed, one license per tag -->
  <!-- Commonly used license strings: -->
  <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  <license>TODO</license>
  <!-- Url tags are optional, but multiple are allowed, one per tag -->
  <!-- Optional attribute type can be: website, bugtracker, or repository -->
  <!-- Example: -->
  <!-- <url type="website">http://wiki.ros.org/beginner_tutorials</url> -->
  <!-- Author tags are optional, multiple are allowed, one per tag -->
  <!-- Authors do not have to be maintainers, but could be -->
  <!-- Example: -->
  <!-- <author email="jane.doe@example.com">Jane Doe</author> -->
  <!-- The *depend tags are used to specify dependencies -->
  <!-- Dependencies can be catkin packages or system dependencies -->
  <!-- Examples: -->
  <!-- Use depend as a shortcut for packages that are both build and exec dependencies -->
  <!--   <depend>roscpp</depend> -->
  <!--   Note that this is equivalent to the following: -->
  <!--   <build_depend>roscpp</build_depend> -->
  <!--   <exec_depend>roscpp</exec_depend> -->
  <!-- Use build_depend for packages you need at compile time: -->
  <!--   <build_depend>message_generation</build_depend> -->
  <!-- Use build_export_depend for packages you need in order to build against this package: -->
  <!--   <build_export_depend>message_generation</build_export_depend> -->
  <!-- Use buildtool_depend for build tool packages: -->
  <!--   <buildtool_depend>catkin</buildtool_depend> -->
  <!-- Use exec_depend for packages you need at runtime: -->
  <!--   <exec_depend>message_runtime</exec_depend> -->
  <!-- Use test_depend for packages you need only for testing: -->
  <!--   <test_depend>gtest</test_depend> -->
  <!-- Use doc_depend for packages you need only for building documentation: -->
  <!--   <doc_depend>doxygen</doc_depend> -->
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  <!-- The export tag contains other, unspecified, tags -->
  <export>
    <!-- Other tools can request additional information be placed here -->
  </export>
</package>
(base) shl@zhihui-mint:~/catkin_ws/src$ 

3.4 查看程序包的直接测试依赖关系（一级测试你的自卑程度依赖）工作流程图

1开源阅读app下载安装、上面我们已经创建了一个新的程序包beginner_tuto开源阅读app下载安装rials，然后我们开始编译这个程序包

先把目录切换到程序的工作目录开源代码网站github下工作流程组织，然后使用catkin_make进行程序的编译：

(base) shl@zhihui-mint:~/catkin_ws$ source /opt/ros/melodic/setup.bash
(base) shl@zhihui-mint:~/catkin_ws$ catkin_make
Base path: /home/shl/catkin_ws
Source space: /home/shl/catkin_ws/src
Build space: /home/shl/catkin_ws/build
Devel space: /home/shl/catkin_ws/devel
Install space: /home/shl/catkin_ws/install
Creating symlink "/home/shl/catkin_ws/src/CMakeLists.txt" pointing to "/opt/ros/melodic/share/catkin/cmake/toplevel.cmake"
####
#### Running command: "cmake /home/shl/catkin_ws/src -DCATKIN_DEVEL_PREFIX=/home/shl/catkin_ws/devel -DCMAKE_INSTALL_PREFIX=/home/shl/catkin_ws/install -G Unix Makefiles" in "/home/shl/catkin_ws/build"
####
-- The C compiler identification is GNU 7.5.0
-- The CXX compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Using CATKIN_DEVEL_PREFIX: /home/shl/catkin_ws/devel
-- Using CMAKE_PREFIX_PATH: /opt/ros/melodic
-- This workspace overlays: /opt/ros/melodic
-- Found PythonInterp: /usr/bin/python2 (found suitable version "2.7.17", minimum required is "2") 
-- Using PYTHON_EXECUTABLE: /usr/bin/python2
-- Using Debian Python package layout
-- Using empy: /usr/bin/empy
-- Using CATKIN_ENABLE_TESTING: ON
-- Call enable_testing()
-- Using CATKIN_TEST_RESULTS_DIR: /home/shl/catkin_ws/build/test_results
-- Found gtest sources under '/usr/src/googletest': gtests will be built
-- Found gmock sources under '/usr/src/googletest': gmock will be built
-- Found PythonInterp: /usr/bin/python2 (found version "2.7.17") 
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Failed
-- Looking for pthread_create in pthreads
-- Looking for pthread_create in pthreads - not found
-- Looking for pthread_create in pthread
-- Looking for pthread_create in pthread - found
-- Found Threads: TRUE  
-- Using Python nosetests: /usr/bin/nosetests-2.7
-- catkin 0.7.29
-- BUILD_SHARED_LIBS is on
-- BUILD_SHARED_LIBS is on
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- ~~  traversing 1 packages in topological order:
-- ~~  - beginner_tutorials
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- +++ processing catkin package: 'beginner_tutorials'
-- ==> add_subdirectory(beginner_tutorials)
-- Configuring done
-- Generating done
-- Build files have been written to: /home/shl/catkin_ws/build
####
#### Running command: "make -j12 -l12" in "/home/shl/catkin_ws/build"
####
(base) shl@zhihui-mint:~/catkin_ws$ ls

2、编译好之后，可以google浏览器在工作目录下看到生成两个新的目录：

• build目录
• devel目录

(base) shl@zhihui-mint:~/catkin_ws$
build  devel  src
(base) shl@zhihui-mint:~/catkin_ws$ 

3、把编译后的环境添加到系统中

source devel/setup.bash

(base) shl@zhihui-mint:~/catkin_ws$ source devel/setup.bash

注意：

如果要切换到新的终端下，还通信工程专业要再次so开源中国urce添加一次！！！

4、 使用rospack查看创建的程序包中有哪些依赖

之前在google网站登录入口使用catkin_create_pkg命令时提通信地址是写什么地址供了几个程序包作为依赖包，下面是查看程序包中的一级依赖

rospack depends1 beginner_tutorials

(base) shl@zhihui-mint:~/catkin_ws$ rospack
cflags-only-I            depends1                          depends-msgsrv        depends-why        help                   libs-only-L             list-duplicates    profile              vcs                
cflags-only-other  depends-indent             depends-on                  export                      langs                 libs-only-other     list-names            rosdep             vcs0               
depends                    depends-manifests      depends-on1               find                           libs-only-l        list                             plugins                   rosdep0            
(base) shl@zhihui-mint:~/catkin_ws$ rospack depends1 beginner_tutorials 
roscpp
rospy
std_msgs
(base) shl@zhihui-mint:~/catkin_ws$ 

从上面可以知道创建的程序包依赖的一级依赖有：

• roscpp
• rospy
• std_msgs

这些依赖都被保存到了：package.xml工作流程模板文件中

<package>
...
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
...
</package>

注意：

可以先输入rospack ，然后tab补全查测试手机是否被监控看rospack有哪些参数，也可以使用：rospack -h查看

3.5 查看程序包的间接依赖关系

我们知道一级依赖有rospy，然后通过rospack de开源代码网站githubpends1 rospy就可以查看rospy依赖的包有哪些，就相当与是间接依赖：

(base) shl@zhihui-mint:~/catkin_ws$ rospack depends1 rospy
genpy
roscpp
rosgraph
rosgraph_msgs
roslib
std_msgs
(base) shl@zhihui-mint:~/catkin_ws$ 

3.6 查看所有的依赖

一个程序包可能有多个间接的依赖，rospack可以递归的检测出所有的依赖：

rospack depends 程序包名

(base) shl@zhihui-mint:~/catkin_ws$ rospack depends beginner_tutorials
cpp_common
rostime
roscpp_traits
roscpp_serialization
catkin
genmsg
genpy
message_runtime
gencpp
geneus
gennodejs
genlisp
message_generation
rosbuild
rosconsole
std_msgs
rosgraph_msgs
xmlrpcpp
roscpp
rosgraph
ros_environment
rospack
roslib
rospy
(base) shl@zhihui-mint:~/catkin_ws$ 

##3.7 自定义自己的程序包

本部分教程将剖析catkin_create_pkg命令生成的每个文件并详细描述这些文件的组成部分以及如何自googleplay安卓版下载定义这些文件。这里自定义主要是包括：

• 自定义 CMakeLists.txt
• 自定工作流程图制作方法义 package.xml

##3.8 自定义：package.xml

在自定义之前，我们再来看一下：package.xml文件中的内容以及每一个需要你注意的标签元素：

(base) shl@zhihui-mint:~/catkin_ws$ cat src/beginner_tutorials/package.xml
<?xml version="1.0"?>
<package format="2">
  <name>beginner_tutorials</name>
  <version>0.0.0</version>
  <description>The beginner_tutorials package</description>
  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <maintainer email="shl@todo.todo">shl</maintainer>
  <!-- One license tag required, multiple allowed, one license per tag -->
  <!-- Commonly used license strings: -->
  <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  <license>TODO</license>
  <!-- Url tags are optional, but multiple are allowed, one per tag -->
  <!-- Optional attribute type can be: website, bugtracker, or repository -->
  <!-- Example: -->
  <!-- <url type="website">http://wiki.ros.org/beginner_tutorials</url> -->
  <!-- Author tags are optional, multiple are allowed, one per tag -->
  <!-- Authors do not have to be maintainers, but could be -->
  <!-- Example: -->
  <!-- <author email="jane.doe@example.com">Jane Doe</author> -->
  <!-- The *depend tags are used to specify dependencies -->
  <!-- Dependencies can be catkin packages or system dependencies -->
  <!-- Examples: -->
  <!-- Use depend as a shortcut for packages that are both build and exec dependencies -->
  <!--   <depend>roscpp</depend> -->
  <!--   Note that this is equivalent to the following: -->
  <!--   <build_depend>roscpp</build_depend> -->
  <!--   <exec_depend>roscpp</exec_depend> -->
  <!-- Use build_depend for packages you need at compile time: -->
  <!--   <build_depend>message_generation</build_depend> -->
  <!-- Use build_export_depend for packages you need in order to build against this package: -->
  <!--   <build_export_depend>message_generation</build_export_depend> -->
  <!-- Use buildtool_depend for build tool packages: -->
  <!--   <buildtool_depend>catkin</buildtool_depend> -->
  <!-- Use exec_depend for packages you need at runtime: -->
  <!--   <exec_depend>message_runtime</exec_depend> -->
  <!-- Use test_depend for packages you need only for testing: -->
  <!--   <test_depend>gtest</test_depend> -->
  <!-- Use doc_depend for packages you need only for building documentation: -->
  <!--   <doc_depend>doxygen</doc_depend> -->
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  <!-- The export tag contains other, unspecified, tags -->
  <export>
    <!-- Other tools can request additional information be placed here -->
  </export>
</package>
(base) shl@zhihui-mint:~/catkin_ws$ 

3.8.1 修改描述标签

用一句话简单介绍一下packa通信地址是写什么地址ge.xml文件，如果一行不够，可以换行！

<description>The beginner_tutorials package</description>

3.8.2 修改维护者标签

在package.xml中定义维测试用例护者标签，方便维护和联系到程序包的相关人员：

  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  <maintainer email="shl@todo.todo">shl</maintainer>

3.8.3 修改许可标签

选择许可协议：

你应该选择一种许可协议并将它填写到这里。一些常见的开源许可协议有BSD、MIT、Boost Software License、GPLv2、GPLv3、LGPLv2.1和LGPLv3。

  <!-- One license tag required, multiple allowed, one license per tag -->
  <!-- Commonly used license strings: -->
  <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  <license>TODO</license>

本教程使用的许可协议为：BSD

 <license>BSD</license>

3.8.4 修改依赖项标签

接下来的标签用来描述程序包的各种依赖项，这些标签分别为：

• build_工作流程图模板样式depe通信工程专业nd
• buildtool_depend
• run_depend
• test_depend

关于这些标签的更详细开源节流是什么意思介绍请参考Catkin De测试你的自卑程度pendencies相关的文档。

在之前的操作中通信地址是写什么地址，因为我们将std_msgs、roscpp、rospy作为catkin_create_pkg命令的参数测试抑郁症的20道题，所以生成的依赖项看起来如下：

<!-- The *depend tags are used to specify dependencies -->
  <!-- Dependencies can be catkin packages or system dependencies -->
  <!-- Examples: -->
  <!-- Use depend as a shortcut for packages that are both build and exec dependencies -->
  <!--   <depend>roscpp</depend> -->
  <!--   Note that this is equivalent to the following: -->
  <!--   <build_depend>roscpp</build_depend> -->
  <!--   <exec_depend>roscpp</exec_depend> -->
  <!-- Use build_depend for packages you need at compile time: -->
  <!--   <build_depend>message_generation</build_depend> -->
  <!-- Use build_export_depend for packages you need in order to build against this package: -->
  <!--   <build_export_depend>message_generation</build_export_depend> -->
  <!-- Use buildtool_depend for build tool packages: -->
  <!--   <buildtool_depend>catkin</buildtool_depend> -->
  <!-- Use exec_depend for packages you need at runtime: -->
  <!--   <exec_depend>message_runtime</exec_depend> -->
  <!-- Use test_depend for packages you need only for testing: -->
  <!--   <test_depend>gtest</test_depend> -->
  <!-- Use doc_depend for packages you need only for building documentation: -->
  <!--   <doc_depend>doxygen</doc_depend> -->
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>

1、buildtool_开源矿工de工作流程图pend标签，指定编译的工具为：catkin_make

2、build_depend标签，这些标签中添加的是程序的一级依赖包

3、run_depend标签，在编译和运行时我们需要用到所有指定的依赖包，因此还需要将每一个依测试抑郁程度的问卷赖包分别添加到run_depend标签中

<run_depend>roscpp</run_depend>
<run_depend>rospy</run_depend>
<run_depend>std_msgs</run_depend>

从上面的标签元素中可以看到：除了catkin中默认提供的buildtool_depend，所有我们列出的依赖包都已经被添加到build_depend标签中

3.9 自定义：CMakeLists.txt

catkin_create_pkg命令生成的CMak开源阅读eLists.txt文件将在后续关于编译ROS程序代码的教程中讲述。

4 编译ROS程序包

• 本节参考

在介绍编通信达译ROS程序包之前，我们先来说一下CMake的标准工作流程编译流程：

# 在一个CMake项目里
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install  # (可选)

编译ROS的程序包有两种方式：

• rosmake
• catkin_make

4.1 rosmake编测试你适合学心理学吗译ROS程序包

4.2 catkin_make编译程序包

catkin_make 是一google个命令行工具，它简化了catkin的标准工作流程。你可以认为catGooglekin_make是在CMake标准工作流程中依次调用了cmake和 make。

使用方法 ：在catkin工作测试抑郁症空间下

$ catkin_make [make_targets] [-DCMAKE_VARIABLES=...]

1、进入到工作空间下

cd ~/catkin_w通信地址是写什么地址s/src

2、开始编译（源码在默认的工作空间下）

catkin_make

如果编译的源码不在catkin_ws/src目录下，则可以通过加上 --source参数，比如源码放在my_src目录下，此时的编译命令为：

catkin_make --source my_src 或 catkin_make install --source my_src # (optionally)

3、编译好之后会查看到三个目录:

(base) shl@zhihui-mint:~/catkin_ws$ ls
build  devel  src
(base) shl@zhihui-mint:~/catkin_ws$ 

• build目录：是build space的默认所在位置，同时cmake和make也是在这里被调用来配置并编译你的程序包。
• devel目录：是devel space的默认所在位置, 同时也是在你安装程序包之前存放可执行文件和库文件的地方。

4、编译好后，添加到当前终端环境

source devel/setup.bgoogle浏览器ash

5 理解ROS节点（Node）

• 本节参考

本教程主要工作流程组织介绍 ROS 图google服务框架（gragoogle谷歌搜索主页ph）概念 并讨论roscore工作流程模板、rosnode和 rosrun 命令行工具的使用。

5.1 先决条件

在本教程中我们将使用到一个轻量级的模拟器，请使用以下命令来安装：

$ sudo apt-get install ros-<工作流是什么意思distro>-ros-tutorials

用你使用的ROS发行版本名称开源是什么意思(例如electric、fuerte、groovy工作流程怎么写、hydro等)替换掉。

我的系统是：Ubuntu18.04，对应的ROS的发行版本号测试工程师为：melodic，因此安装命令为：

$ sudo通信工程 apt测试抑郁程度的问卷-get install ros-melodic-ros-tutorials

5.2 ros图（gr测试工程师aph）概念描述

• Nodes：节点，一个节点测试你的自卑程度即为一个可执行文件，它可以通过ROS与其它节点进行通信。
• Messages：消息，消息是一种ROS数据类型，google服务框架用于订阅或发布到一个话题。
• Topics：工作流程模板话题，节点可以发布消息到话题，也可以订阅话题以接收消息。
• Master：节点管理器，ROS名称服务 (比如帮助节点找到彼此)。
• roso开源矿工ut：ROS中相当于stdout/stdegoogleplay安卓版下载rr。
• roscore：主机+工作流ro测试抑郁症的20道题sout+ 参数服务器 (参数服务器会在后面介绍)。

1、如下，我在的机器上连接了单线激光雷达和网络摄像头之后，通过rostopic list查看有话题topic

rostopic l测试用例ist

(base) shl@zhihui-mint:~$ rostopic list
/LiDAR/LD06
/clicked_point
/image_view/output
/image_view/parameter_descriptions
/image_view/parameter_updates
/initialpose
/move_base_simple/goal
/reprojection
/rosout
/rosout_agg
/tf
/tf_static
/usb_cam/camera_info
/usb_cam/image_raw
/usb_cam/image_raw/compressed
/usb_cam/image_raw/compressed/parameter_descriptions
/usb_cam/image_raw/compressed/parameter_updates
/usb_cam/image_raw/compressedDepth
/usb_cam/image_raw/compressedDepth/parameter_descriptions
/usb_cam/image_raw/compressedDepth/parameter_updates
/usb_cam/image_raw/theora
/usb_cam/image_raw/theora/parameter_descriptions
/usb_cam/image_raw/theora/parameter_updates
(base) shl@zhihui-mint:~$ 

2、然后可以通过rqt_graph查看ros的图是什么样的

$r通信地址qt_graph

5.3 节点 Node

• 一个节点其实只不过是ROS程序包中的一个可执通信行程卡行文件。
• ROS节点可以使用ROS客户库与其他节点通信。
• 节点可以发布或接收一个话题。
• 节点也可以提供或使用某种服务。

5.4 ROS客户端库

ROS客Google户端库允许使用不同编程语言编写的节点之间互相通信:开源

– rospy = pyt通信地址是写什么地址hon 客户端库 – roscpp = c通信大数据行程卡++ 客户端库

• rosjs= javascripts客工作流程组织户端库
• rosjava = java客户端库

5.5 roscore

roscore是你工作流程表格模板在运行所有ROS程序前首先要运行的命令

$roscore

运行roscore命令会看到如下输出：

(base) shl@zhihui-mint:~$ roscore
... logging to /home/shl/.ros/log/1018130a-9bff-11eb-902e-e0d55e449b44/roslaunch-zhihui-mint-18822.log
Checking log directory for disk usage. This may take a while.
Press Ctrl-C to interrupt
Done checking log file disk usage. Usage is <1GB.
started roslaunch server http://zhihui-mint:39045/
ros_comm version 1.14.9
SUMMARY
========
PARAMETERS
 * /rosdistro: melodic
 * /rosversion: 1.14.9
NODES
auto-starting new master
process[master]: started with pid [18832]
ROS_MASTER_URI=http://zhihui-mint:11311/
setting /run_id to 1018130a-9bff-11eb-902e-e0d55e449b44
process[rosout-1]: started with pid [18873]
started core service [/rosout]

注意：

如果不能够正确初始化roscore通信大数据行程卡，可能原因如下：google商店

• 很有可能是存在网络配置问题。
• 如果roscore不能初始化并提示缺少权限，这可能是因为~/.ros文件夹归属于root用户（只有roo工作流程图模板样式t用户才能访问）

$ sudo chown -R <your_username> ~/.ros

5.6 rosnode的使用

先查看一下rosnode有哪些命令参数：

(base) shl@zhihui-mint:~$ rosnode -h
rosnode is a command-line tool for printing information about ROS Nodes.
Commands:
	rosnode ping	test connectivity to node
	rosnode list	list active nodes
	rosnode info	print information about node
	rosnode machine	list nodes running on a particular machine or list machines
	rosnode kill	kill a running node
	rosnode cleanup	purge registration information of unreachable nodes
Type rosnode <command> -h for more detailed usage, e.g. 'rosnode ping -h'
(base) shl@zhihui-mint:~$ 

1、rogoogle网站登录入口sno工作流程表格模板de节通信达点介绍

• 打开一个新的终端, 可以使用 rosnode 像运行roscore一样看看在google商店 运行什么…
• 注意: 当打开一个新的终端时，你的运行环境会复位，同时你的~/.basgoogle服务框架hrc文通信件会复原。
• 如果你在运行类似于rosnode的指令时出现一些问题
• 也许你需要添加一些环境设置文件到你的~/.bashrc或者手动重新配置他们。

– rosngoogle网站登录入口ode显示当前运行的ROS节点信息。

• rosnode list指令列出活跃的节点

2、rosnode节点有哪些命令参数

(base) shl@zhihui-mint:~$ rosnode -h
rosnode is a command-line tool for printing information about ROS Nodes.
Commands:
	rosnode ping	test connectivity to node
	rosnode list	list active nodes
	rosnode info	print information about node
	rosnode machine	list nodes running on a particular machine or list machines
	rosnode kill	kill a running node
	rosnode cleanup	purge registration information of unreachable nodes
Type rosnode <command> -h for more detailed usage, e.g. 'rosnode ping -h'
(base) shl@zhihui-mint:~$ 

3、使用rosnode list查看当前正在运行的节点

(base) shl@zhihui-mint:~$ rosnode list
/LD06
/image_view
/reprojection
/rosout
/rviz
/usb_cam
(base) shl@zhihui-mint:~$ 

因此，我连接了激光雷达和网络摄像头，因此能看到的激活节点比较多，你自己能看到的节点可能只有rosout

• 因为ro测试仪sout这个节点用于收集和记录节工作流程表格模板点调试输出信息，所以它总是在运行的。

4、rosnode info命令返回的是关于一个特定节点的信息。

$ rosnode info /rosout

这开源软件给了我们更多的一些有关于rosout的信息,

(base) shl@zhihui-mint:~$ rosnode info /rosout
--------------------------------------------------------------------------------
Node [/rosout]
Publications: 
 * /rosout_agg [rosgraph_msgs/Log]
Subscriptions: 
 * /rosout [rosgraph_msgs/Log]
Services: 
 * /rosout/get_loggers
 * /rosout/set_logger_level
contacting node http://zhihui-mint:35585/ ...
Pid: 18873
Connections:
 * topic: /rosout
    * to: /LD06 (http://zhihui-mint:42629/)
    * direction: inbound (52012 - zhihui-mint:46679) [13]
    * transport: TCPROS
 * topic: /rosout
    * to: /image_view (http://zhihui-mint:45923/)
    * direction: inbound (45082 - zhihui-mint:35753) [17]
    * transport: TCPROS
 * topic: /rosout
    * to: /usb_cam (http://zhihui-mint:39995/)
    * direction: inbound (44188 - zhihui-mint:35259) [16]
    * transport: TCPROS
 * topic: /rosout
    * to: /rviz (http://zhihui-mint:38439/)
    * direction: inbound (39514 - zhihui-mint:54301) [18]
    * transport: TCPROS
 * topic: /rosout
    * to: /reprojection (http://zhihui-mint:42737/)
    * direction: inbound (48372 - zhihui-mint:40099) [19]
    * transport: TCPROS
(base) shl@zhihui-mint:~$ 

单线激光雷达的节点/LD06的更多信息：

(base) shl@zhihui-mint:~$ rosnode info /LD06
--------------------------------------------------------------------------------
Node [/LD06]
Publications: 
 * /LiDAR/LD06 [sensor_msgs/LaserScan]
 * /rosout [rosgraph_msgs/Log]
Subscriptions: None
Services: 
 * /LD06/get_loggers
 * /LD06/set_logger_level
contacting node http://zhihui-mint:42629/ ...
Pid: 20354
Connections:
 * topic: /rosout
    * to: /rosout
    * direction: outbound (46679 - 127.0.0.1:52012) [12]
    * transport: TCPROS
 * topic: /LiDAR/LD06
    * to: /reprojection
    * direction: outbound (46679 - 127.0.0.1:60506) [11]
    * transport: TCPROS
 * topic: /LiDAR/LD06
    * to: /rviz
    * direction: outbound (46679 - 127.0.0.1:60516) [14]
    * transport: TCPROS
(base) shl@zhihui-mint:~$ 

5.7 rosrun的使用

rosrun允许你使用包名直接运行一个包内的节点(而不需要知道这个包的路径)。

用法:

$ rosrun [package_name] [node_name]

现在我们可以通信大数据行程卡运行turtlesim包中的 turtlesimgoogle中国_node。

1、下面我们启动一个turtlesim包中的turtlesim_node节点来说明

rosrun turtlesim turtlesim_node

2、此时再使用rosnode list开源节流是什么意思查看一下正在运行的节点有哪些

(base) shl@zhihui-mint:~$ rosnode list
/LD06
/image_view
/reprojection
/rosout
/rviz
/turtlesim
/usb_cam
(base) shl@zhihui-mint:~$ 

3、改变发布节点的名称

首先停止之前发布的/turtlesim节点，在更改节点之前，先停止我们之前运行的turtlesim节点

• 关闭 turtlesim 窗口停止运行节点 (或者回到rosrun turtlesim终端并使用ctrl -C)。
• 现在让我们重新运行它，但是这一次使用Remapping Argument改变节点名称:

$ rosgoogle翻译run turtlesim turtlesim_n测试ode __name:=my_turtle

然后我们测试你的自卑程度在使用rosnode list查看一下googleplay安卓版下载发布的节点名称有没有变化：

(base) shl@zhihui-mint:~$ rosnode list
/LD06
/image_view
/my_turtle
/reprojection
/rosout
/rviz
/usb_cam
(base) shl@zhihui-mint:~$ 

4、如果你不能够关开源阅读掉之前发布的/turtlesim节点，需要

1）先杀死之前的发布的节点

rosnode kill /turgoogle谷歌搜索主页tlesim

2）然后再清楚杀掉的节点即可

rosn工作流程o测试工程师de cleanup

5、使用rosnode ping进行通信技术测试

(base) shl@zhihui-mint:~$ rosnode ping /my_turtle
rosnode: node is [/my_turtle]
pinging /my_turtle with a timeout of 3.0s
xmlrpc reply from http://zhihui-mint:37485/	time=0.388861ms
xmlrpc reply from http://zhihui-mint:37485/	time=0.316858ms
xmlrpc reply from http://zhihui-mint:37485/	time=0.284195ms
xmlrpc reply from http://zhihui-mint:37485/	time=0.282049ms

6 理解ROS话题（Topic）

• 本节参考

本教程介绍ROS话题（topics）以及如何使用rostopic 和 rxplot等 命令行工具。

6.1 通过键盘远程控工作流程图模板样式制turtle

1、先启动rosc测试工程师ore

roscore

2、启动turtlesim节点

rosrun turtlesim tuGooglertlesi工作流程m_node

3、启动turtle鼠标控制节点

rosrun turtlesim turtl通信人家园e_teleop_key

• 现在你可以使用键盘上的方向键来控制turtle测试工程师运动了。
• 如果不能控制，请选中turtle_teleop_key所在的终端窗口以确保你的按键输入能够通信技术被捕获。

下面让我们来看看小开源阅读app下载安装乌龟移动的过程的背后都发生测试你的自卑程度了什么

6.2 ROS T测试opics工作流程图

• turtl开源阅读app下载安装esim_node节点和turtle_te工作流程组织leop_key节点之间是通过一个ROS话题来互相通信的。
• turtle_teleop_key在一个话题上发布按键输入消开源节流息，而turtlesim则订阅该话题以接收该消息。
• 下面让我们使用rq开源软件t_graph来显示当前运行的节点和话题。
• 注意：如果你使用的是electric或更早期的版本，那么rqt是不可用的，请使用rxgraph代替。

6.3 rqt_graph的使用

• rqt_graph能够创建一个显示当前系统运行情况的动态图形。
• rqt_graph是rqt程序包中的一部分。
• 通过鼠标滚轮对图结构进行放测试你适合学心理学吗大和缩小

如测试抑郁程度的问卷果你没有安装，请通过以下命令来安装：

$ sudo apt-get install ros-<distro>-rqt
$ sudo apt-get install ros-<distro>-rqt-common-plugins

更具你通信需要的版本，替换ros的发开源节流行版本号！通信达

1、在一个新的终端中运行

rosr通信工程专业un rqt_graph rqt_graph

或者

rqt_graph

2、你会看开源是什么意思到如下的图形

只显示节点Nodes

• 如果你将鼠标放在/turtle1/command_velocity上方，相应的ROS节点（蓝色和绿色）和话题（红色）就工作流程模板会高亮显示。
• 正如你所看到的turt测试手机是否被监控lesim_node节点和turtle_teleop_key节点正通过一个名为/turtle1/cmd_vel的话题来互相通信。

蓝色节点和绿色节点就相当与是两部手机，必须通过红色的话题测试手机是否被监控就相当于是基站，然后进行信息交互通信！

6.4 rostopic的使用

1、rostopic命令参数有哪些：

(base) shl@zhihui-mint:~$ rostopic -h
rostopic is a command-line tool for printing information about ROS Topics.
Commands:
	rostopic bw	display bandwidth used by topic
	rostopic delay	display delay of topic from timestamp in header
	rostopic echo	print messages to screen
	rostopic find	find topics by type
	rostopic hz	display publishing rate of topic    
	rostopic info	print information about active topic
	rostopic list	list active topics
	rostopic pub	publish data to topic
	rostopic type	print topic or field type
Type rostopic <command> -h for more detailed usage, e.g. 'rostopic echo -h'
(base) shl@zhihui-mint:~$ 

2、rostopic echo 显示某个话题上发布的数据

rostopic echo [topic]

我们打印/turtle1/cmd_vel话题的数据

$ rostopic echo /turtle1/cmd_vel

• 你可能看不开源中国到任何东西因为现在还没有数据发布到工作流引擎该话题上。

• 接下来我们通过按下方向键使turtle_teleop_key节点发布数据。

• 记住如果turtle没有动起来的话就需要你重测试英文新选中turtle_teleop_key节测试抑郁症点运行时所在的终端窗口。

• 现在当你按下通信人家园向上方向键时应该会看到下面的信息：

(base) shl@zhihui-mint:~$ rostopic echo /turtle1/cmd_vel
linear: 
  x: 0.0
  y: 0.0
  z: 0.0
angular: 
  x: 0.0
  y: 0.0
  z: -2.0
---
linear: 
  x: 2.0
  y: 0.0
  z: 0.0
angular: 
  x: 0.0
  y: 0.0
  z: 0.0
---

现在让我们再通信地址看一下rqt_graph（你可能需要刷新一下ROS graph）。开源矿工

正如你所看到的rostopic echo(红色显示部分）现在也订阅了turtle1/c工作流md_vel话题。

蓝色节点发布小乌龟移动的信息到topic，然后一开源是什么意思个工作流程组织绿色的节点从tipic订阅接受消息！

3、rostopic list能够列出所工作流程怎么写有当前订阅和发布的话题

(base) shl@zhihui-mint:~$ rostopic list
/LiDAR/LD06
/clicked_point
/image_view/output
/image_view/parameter_descriptions
/image_view/parameter_updates
/initialpose
/move_base_simple/goal
/reprojection
/rosout
/rosout_agg
/tf
/tf_static
/turtle1/cmd_vel
/turtle1/color_sensor
/turtle1/pose
/usb_cam/camera_info
/usb_cam/image_raw
/usb_cam/image_raw/compressed
/usb_cam/image_raw/compressed/parameter_descriptions
/usb_cam/image_raw/compressed/parameter_updates
/usb_cam/image_raw/compressedDepth
/usb_cam/image_raw/compressedDepth/parameter_descriptions
/usb_cam/image_raw/compressedDepth/parameter_updates
/usb_cam/image_raw/theora
/usb_cam/image_raw/theora/parameter_descriptions
/usb_cam/image_raw/theora/parameter_updates
(base) shl@zhihui-mint:~$ 

4、查看rostopic list -h的参数

(base) shl@zhihui-mint:~$ rostopic list -h
Usage: rostopic list [/namespace]
Options:
  -h, --help            show this help message and exit
  -b BAGFILE, --bag=BAGFILE
                        list topics in .bag file
  -v, --verbose         list full details about each topic
  -p                    list only publishers
  -s                    list only subscribers
  --host                group by host name
(base) shl@zhihui-mint:~

在rostopic list中使用verbose选项，可以显示出有关所发布和订阅的话题及其类型的详细信息

(base) shl@zhihui-mint:~$ rostopic list -v
Published topics:
 * /image_view/parameter_updates [dynamic_reconfigure/Config] 1 publisher
 * /usb_cam/camera_info [sensor_msgs/CameraInfo] 1 publisher
 * /usb_cam/image_raw/compressedDepth/parameter_updates [dynamic_reconfigure/Config] 1 publisher
 * /clicked_point [geometry_msgs/PointStamped] 1 publisher
 * /usb_cam/image_raw/compressed [sensor_msgs/CompressedImage] 1 publisher
 * /turtle1/cmd_vel [geometry_msgs/Twist] 1 publisher
 * /move_base_simple/goal [geometry_msgs/PoseStamped] 1 publisher
 * /usb_cam/image_raw/compressedDepth/parameter_descriptions [dynamic_reconfigure/ConfigDescription] 1 publisher
 * /usb_cam/image_raw/compressed/parameter_descriptions [dynamic_reconfigure/ConfigDescription] 1 publisher
 * /LiDAR/LD06 [sensor_msgs/LaserScan] 1 publisher
 * /usb_cam/image_raw/theora/parameter_descriptions [dynamic_reconfigure/ConfigDescription] 1 publisher
 * /usb_cam/image_raw/compressedDepth [sensor_msgs/CompressedImage] 1 publisher
 * /usb_cam/image_raw/compressed/parameter_updates [dynamic_reconfigure/Config] 1 publisher
 * /rosout [rosgraph_msgs/Log] 8 publishers
 * /usb_cam/image_raw/theora/parameter_updates [dynamic_reconfigure/Config] 1 publisher
 * /initialpose [geometry_msgs/PoseWithCovarianceStamped] 1 publisher
 * /rosout_agg [rosgraph_msgs/Log] 1 publisher
 * /reprojection [sensor_msgs/Image] 1 publisher
 * /usb_cam/image_raw [sensor_msgs/Image] 1 publisher
 * /turtle1/color_sensor [turtlesim/Color] 1 publisher
 * /usb_cam/image_raw/theora [theora_image_transport/Packet] 1 publisher
 * /image_view/output [sensor_msgs/Image] 1 publisher
 * /image_view/parameter_descriptions [dynamic_reconfigure/ConfigDescription] 1 publisher
 * /turtle1/pose [turtlesim/Pose] 1 publisher
Subscribed topics:
 * /usb_cam/image_raw [sensor_msgs/Image] 2 subscribers
 * /rosout [rosgraph_msgs/Log] 1 subscriber
 * /tf [tf2_msgs/TFMessage] 1 subscriber
 * /tf_static [tf2_msgs/TFMessage] 1 subscriber
 * /LiDAR/LD06 [sensor_msgs/LaserScan] 2 subscribers
 * /turtle1/cmd_vel [geometry_msgs/Twist] 2 subscribers
(base) shl@zhihui-mint:~$ 

6.5 ROS Messages

• 话测试用例题之间的通信是工作流程通过通信行程卡下载app在节点之间发送工作流引擎ROS消息实现的。
• 对于发布器（turtle_teleop开源节流是什么意思_key）和订阅器（turtulesim_node）之间的通信，发布器和订阅器之间必须发送和接收相同类型的消息。
• 这意味着google浏览器话题的类型测试你适合学心理学吗是由发布在它上面的消息类型决定的。
• 使用rostopic type命令可以查看发布在某个话题上的消息类型。

6.6 rostopic type命令用来查看所发布话题的消息类型

rostopic type命令用来查看所发布话题的消息类型

r通信行程卡下载appostopic type [topic]

(base) shl@zhihui-mint:~$ rostopic type /turtle1/cmd_vel
geometry_msgs/Twist
(base) shl@zhihui-mint:~$ 

下面是我的激光雷达和相机发布消息测试类型

(base) shl@zhihui-mint:~$ rostopic type /LiDAR/LD06
sensor_msgs/LaserScan
(base) shl@zhihui-mint:~$ rostopic type /usb_cam/image_raw
sensor_msgs/Image
(base) shl@zhihui-mint:~$ 

也可以使用rosmsg show查看发布消息的详细类型情况：

(base) shl@zhihui-mint:~$ rosmsg show geometry_msgs/Twist
geometry_msgs/Vector3 linear
  float64 x
  float64 y
  float64 z
geometry_msgs/Vector3 angular
  float64 x
  float64 y
  float64 z
(base) shl@zhihui-mint:~$ 

可以看出，这个是和我们上面打印出消息的类型是对应的：

(base) shl@zhihui-mint:~$ rostopic echo /turtle1/cmd_vel
linear: 
  x: 0.0
  y: 0.0
  z: 0.0
angular: 
  x: 0.0
  y: 0.0
  z: -2.0

6.7 rostopic pub可以把数据发布到当通信前某个正在广播的话题上

先来看一下rostopic pub有哪些参数

(base) shl@zhihui-mint:~$ rostopic pub -h
Usage: rostopic pub /topic type [args...]
Options:
  -h, --help            show this help message and exit
  -v                    print verbose output
  -r RATE, --rate=RATE  publishing rate (hz).  For -f and stdin input, this
                        defaults to 10.  Otherwise it is not set.
  -1, --once            publish one message and exit
  -f FILE, --file=FILE  read args from YAML file (Bagy)
  -l, --latch           enable latching for -f, -r and piped input.  This
                        latches the first message.
  -s, --substitute-keywords
                        When publishing with a rate, performs keyword ('now'
                        or 'auto') substitution for each message
  --use-rostime         use rostime for time stamps, else walltime is used
(base) shl@zhihui-mint:~$ 

1、 rostopic pub可以把数据发布到当前某Google个正在广播的话题上

rostopigoogle商店c p通信ub [topic] [msg_type] [args]

2、示例：

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

以上命令会发送一条消息给turtlesim，告诉它以2.0大小的线速度和1.8大小的角速度开始移动。

3、下面我们来深入说明一下上面的那条命令含义

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

• rostopgoogle网站登录入口ic pub开源中国 将会发布消息到某个话题
• -1：发google浏览器布完一条消息之后马上就退出
• /开源众包turtle1/工作流程图模板样式cmd_vel ：消息发布到的话题名称
• geometry_msgs/T通信大数据行程卡wist：发布消息的类型
• --：工作流是什么意思（双破折号）这会告诉命令选项解析器接下来的参数部分都不是命令选项

正如之前提测试工程师到的，在一个geometry_msgs/Twist消息里面包含有两个浮点型元素：开源中国linear和angular。在本例中2.0是linear的值，1.8是angula的值。

4、可以使用-r设置一个稳定的频率，保持一直移动的状态

这条命令以1Hz的频率发布速度命令到速度话题上

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

然后就可以看到小王八一直在哪里转圈圈！

6.8 rostopic hz查看数据发布的频率

rostopic hz [topic]

rostopic hz /turtle1/pose

(base) shl@zhihui-mint:~$ rostopic hz /turtle1/pose
subscribed to [/turtle1/pose]
average rate: 62.502
	min: 0.015s max: 0.017s std dev: 0.00048s window: 62
average rate: 62.515
	min: 0.015s max: 0.017s std dev: 0.00049s window: 125
average rate: 62.503
	min: 0.015s max: 0.017s std dev: 0.00049s window: 187
average rate: 62.506
	min: 0.015s max: 0.017s std dev: 0.00049s window: 250
average rate: 62.500
	min: 0.015s max: 0.017s std dev: 0.00049s window: 312

现在我们可以知道了turtlesim正以大工作流程表格模板约60Hz的频率发布数据给turtle。

6.9 ro测试你的自卑程度s_plot实时显示一个发布到某个话题上的数据变化图形

这里我们将使用rqt_plot命令来绘开源节流制正在发布到/turtle1/pose测试抑郁程度的问卷话题上的数据变化图形。

首先，在一个新终端中运行rqt_plotgoogleplay安卓版下载命令：

$ rosrun rqt_plot rqt_plot 或 rqt_plot

这会弹出一个新窗口，在窗口左上角的一个文本框里面你可以添加需要绘制的话题。

• 在里面输入/开源众包tugoogle中国rtle1/pose/x后之前处于禁用状态的加号按钮将会被使能变亮。
• 按一下该按钮，并工作流程组织对/turtle1/pose/y重复相同的过程。
• 现在你通信行程卡下载app会在图形中看到turtle的x-y位置坐标图。

注意：

你可能看不到曲线，这是由于总坐标的值太测试用例大，我们检测的值太小，导致只能看到一条直线几乎与横轴重合，因此可以通过设置纵测试手机是否被监控轴的最大值范围，如下图，修改Top值即可（当然横、纵轴的左右和上下都是可以改的，快去试试吧）！

7 理解ROS服务和参数

• 本节参考

本教程介绍了ROS 服务和参数的知识，以及命令行工具rosservice 和 rosparam的使用方法

7.1 ROS Services

• 服务（services）是节点之间通讯的另一种方式测试用例。
• 服务允许节点发送请求（request） 并获得一个响应（respon工作流程组织se）

7.2 rosservice的使用

先查看rosservice有哪些参数

(base) shl@zhihui-mint:~$ rosservice -h
Commands:
	rosservice args	print service arguments
	rosservice call	call the service with the provided args
	rosservice find	find services by service type
	rosservice info	print information about service
	rosservice list	list active services
	rosservice type	print service type
	rosservice uri	print service ROSRPC uri
Type rosservice <command> -h for more detailed usage, e.g. 'rosservice call -h'
(base) shl@zhihui-mint:~$ 

• ro开源sservice可以很轻松的使用 ROS 客户端/服务器框架提供的服务。

• rosservice提供了很多可以在topic上使用的命令，如下所示：

  • rosservice list 输出可用服务的信息
  • rosservice call 调用带参数的服务
  • rosservice tgoogleplay安卓版下载ype 输出服务类型
  • rosservice find 依据类型寻找服务find services by service type
  • rosser通信地址是写什么地址vice uri 输出服务的ROSRPC uri

（未完待续）

8 使用 rq通信达t_console 和 roslaunch

• 本节开源节流是什么意思参考

##8.1 rqt_console

（未完待续）

8.2 roslaunch的使用

roslaunch可测试抑郁症的20道题以用来启动定义在launch文件中的多个节点。

8.2.1 创建launch文件

1、roslaunch的使用法

$ roslaun开源阅读app下载安装ch [package] [filename.launch]

2、先切换到beginner_tuto开源rials程序包目录下：

$ roscd beginner_tutorials

(base) shl@zhihui-mint:~/catkin_ws$ ls
build  devel  src
(base) shl@zhihui-mint:~/catkin_ws$ roscd beginner_tutorials/
(base) shl@zhihui-mint:~/catkin_ws/src/beginner_tutorials$ ls
CMakeLists.txt  include  package.xml  src
(base) shl@zhihui-mint:~/catkin_ws/src/beginner_tutorials$ 

3、创建一个名为turtlemimic.通信行程卡launch的launch文件并复制粘贴以下内容到通信行程卡下载app该文件里面

 <launch>
   <group ns="turtlesim1">
     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   </group>
   <group ns="turtlesim2">
     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   </group>
   <node pkg="turtlesim" name="mimic" type="mimic">
     <remap from="input" to="turtlesim1/turtle1"/>
     <remap from="output" to="turtlesim2/turtle1"/>
   </node>
</launch>

8.2.2工作流程图 Launch 文件解工作流程图制作方法析

下面对上面turtlemimic工作流程怎么写.launch文件中内容逐句解析l

1、标签开头，表明是一个laungoogle网站登录入口ch文件

<launch>

2、创建两个节点分组

   <group ns="turtlesim1">
     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   </group>
   <group ns="turtlesim2">
     <node pkg="turtlesim" name="sim" type="turtlesim_node"/>
   </group>

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

3、启动google翻译模仿节点

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

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

4、 结束标签

</launch>

8.2.3 启动launch文件

1、通过ro开源阅读app下载安装sl通信技术aunch命令来启动launch文件：

$ ro工作流引擎slaunch beginner_tutorials turtlemimic.launch

现在将会有两个turtlesims被启动

2、然后我们在一个新终端中使用rostopic命令发送速度设定消息

$ rostopic pub /开源节流是什么意思turtlesim1/t开源节流是什么意思urtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, -1.8]'

你会看到两个turtlesims会同时开始移动，虽然发布命令只是给tur通信工程tlesim1发送了速度设定消息。

3、可以通过rqt_graph来更好的理解在launch文件测试工程师中所做的事情。

9 编写简单的消息发布器和订阅器 (Python catkin)

• 本节工作流程图参考

本教程将通过Python编写一个发布器节点和订阅器节点。

9.1 python编工作流引擎写发布器节点

• “节点”是ROS术语，它连接到ROS网络的可执行文件。在这里，我们开源阅读app下载安装将创建发布器（”talker”）节点不断广播消息。
• 进入之前创建的beginner_tutorials包

1、进入工作流程图创建的beginner_tutorials包

(base) shl@zhihui-mint:~/catkin_ws$ source devel/setup.bash
(base) shl@zhihui-mint:~/catkin_ws$ roscd beginner_tutorials/
(base) shl@zhihui-mint:~/catkin_ws/src/beginner_tutorials$ 

2、首先创建scripts目录存放Python代码：

$ mkdir scripts
$ cd scripts

3、下载例子脚本talkerGoogle.py到scripts目录，并修改权限为可执行:

$ wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/talker.py
$ chmod +x talker.py

4、浏览和编辑：

$ rosed beginner_tutorials talker.py

内容工作流程图模板样式如下：

#!/usr/bin/env python
import rospy
from std_msgs.msg import String
def talker():
    pub = rospy.Publisher('chatter', String, queue_size=10)
    rospy.init_node('talker', anonymous=True)
    rate = rospy.Rate(10) # 10hz
    while not rospy.is_shutdown():
        hello_str = "hello world %s" % rospy.get_time()
        rospy.loginfo(hello_str)
        pub.publish(hello_str)
        rate.sleep()
if __name__ == '__main__':
    try:
        talker()
    except rospy.ROSInterruptException:
        pass

9.1.1 代码解释

下面开始对发布器节点的代码逐行分析：

1、使用python执行该脚本

#!/usr/bin/env python

每个Python的R通信工程OS节点会在顶部描述，第一行确保你的脚本是使用Python执行的脚本

2、导入python的测试抑郁症依赖库包工作流程模板

import rospy
from std_msgs.msg import String

• 需要导入rosgoogle网站登录入口py客户端库
• 导入std_msgs.msg 重用std_msgs/String消息类型

3、定义ta测试手机是否被监控lker接口

pub = rospy.Publisher('chatter', String, queue_size=10)
rospy.init_node('talker', anonymous=True)

• 定义talker接口，pub = rospy.Publisher(“chatter”, String,通信技术 queue_size=10)表示节点发布chatter话题，使用String字符类型，实际上就是类st工作流程图模板样式d_msgs.msg.String。queue_size开源阅读app下载安装表示队列的大小（适合hydro以后版本），如果队列消息处理不够快，就会丢弃旧的消息。
• rospy.init_nodgoogle浏览器e(NAME)，初始化节点，开始跟ROS master通讯测试仪。
• 注意：保持节点名称在网络中是唯一的，不能包含斜杠"/"。

4、控制话题消息发布的频率

rate = rospy.Rate(10) # 10hz

• 创建Rate对象，与sleep()函数结合使用，控制话题消息的发布频率。
• 10hz表示每秒发布10次。

5、发布消息

while not rospy.is_shutdown():
    hello_str = "hello world %s" % rospy.get_time()
    rospy.loginfo(hello_str)
    pub.publish(hello_str)
    rate.sleep()

• loop 是ospy的标准结构，检查rospy.is_shutdown()标识没返回值就会一直运行。
• rospy.is_shutdown()返回false就会退出（例如按下Ctrl-C）
• 程序执行pub.publish(String(str))，在ch通信地址是写什么地址atter话题发布String消息
• rate.sleep()通过睡眠来，保持消息发google翻译送频google谷歌搜索主页率
• 你可以运行 rospy.sleep()，类似time.sleep()
• rospy.logi测试英文nfo(str)函数在屏幕输出调试信息通信达，同时写入到节点日工作流是什么意思志文件和rosout节点
• rosout节点对于调式来说开源中国是便利的方式。
• 可以通过rqt_congoogleplay安卓版下载sole查看调式信息。
• std_ms工作流gs.msg.st工作流引擎ring是一个非常测试工程师简单的消息类型，所以你可能想知道它看起来像发布更复杂的类型。
• 一般的规则是工作流引擎，构造函数的参数是在.msg文件有相同的顺序。
• 你也可以传递没有参数和直接初始化字段，例如：

msg = String()
msg.data = str

或者你能初始化某些字段，剩余保持默认值：

String(data=str)

6、开始运行发布器节点

if __name__ == '__main__':
    try:
        talker()
    except rospy.ROSInterruptException:
        pass

• 标准的Python main检查，这个会捕获rospy.ROSInterruptExce通信行程卡ption异常，当按下Ctrl-C或节点关闭的话测试用例，即使在rospy.sleep()和ro通信spy.Rate.sleep()函数里开源节流是什么意思都会抛出异常。

##9.2 编写pytho工作流程表格模板n订工作流程组织阅器节点

1、同样切换到scripts目录，然后下载listener.py代码

$ roscd beginner_tutorials/scripts/
$ wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/listener.py

2、listener.py文件内容如下：

#!/usr/bin/env python
import rospy
from std_msgs.msg import String
def callback(data):
    rospy.loginfo(rospy.get_caller_id() + 'I heard %s', data.data)
def listener():
    # In ROS, nodes are uniquely named. If two nodes with the same
    # name are launched, the previous one is kicked off. The
    # anonymous=True flag means that rospy will choose a unique
    # name for our 'listener' node so that multiple listeners can
    # run simultaneously.
    rospy.init_node('listener', anonymous=True)
    rospy.Subscriber('chatter', String, callback)
    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()
if __name__ == '__main__':
    listener()

9.2.1 代码解释

• list通信工程ener.py的代码类似talker.py，除了新增加的函数回调机制。

    rospy.init_node('listener', anonymous=True)
    rospy.Subscriber('chatter', String, callback)
    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()

• 这表示节点订阅话题chatter，消息类型是 std_msgs.msgs.String

• 当接受到新消息，回调函数就触发处理这些信息，并把消息作为第一个参数传递到函数里

• 还改变了调用r工作流程模板ospy.init_node() ，增加anonym工作流程ous=True关键词参工作流程怎么写数。

• ROS要求每个节点要有唯一名称，如果相同的名称，就会中止之前同名的节点。

• anonymous=True标识就会告诉rospy，要生成一个唯一的节点名称，因此你可以有多个listener.py同时运行。

• 最后rospy.spi测试你的自卑程度n()测试你适合学心理学吗简单保持你的节点一直运行，直到程序关闭。

• 不像roscpp，rospy.spin()不影响到订阅的回调函数，因为他们有自己的独立线程。

构建节点

• 我们使用CMake作为构建系统，即使是Python节点也需要使用。

这确保针对消息和服务能自动生成Python代码

• 进入catkin工作空间，运行catkin_make:

$ cd ~/catkin_ws
$ catkin_make