[Ros] ROS architecture

From different perspectives, the description of the ROS architecture is also different. Generally, we can describe the ROS structure from four perspectives: designer, maintainer, system structure, and own structure:

1. The designer

ROS designers express ROS as "ROS = Plumbing + Tools + Capabilities + Ecosystem"

• Plumbing: communication mechanism (realize the interaction between different nodes of ROS)

• Tools: Tool package (development and debugging tools in ROS)

• Capabilities: Robot high-level skills (a collection of certain functions in ROS, such as navigation)

• Ecosystem: Robot ecosystem (cross-region, cross-software and hardware ROS alliance)

 

2. Maintainer

Based on the maintainer 's perspective: ROS architecture can be divided into two parts

• main: The core part, mainly designed, provided and maintained by Willow Garage and some developers. It provides some basic tools for distributed computing, as well as the programming of the core part of the entire ROS.

• universe: Code on a global scale, developed and maintained by ROS community organizations in different countries. One is the library code, such as OpenCV, PCL, etc.; the upper layer of the library is the code provided from a functional perspective, such as face recognition, they call the lower library; the uppermost code is the application-level code, let the robot complete A certain function.

 

3. System architecture

Based on the system architecture: ROS can be divided into three layers

• OS layer, the operating system in the classic sense

  ROS is just a meta operating system, which needs to rely on a real operating system. Currently, the most compatible is Ubuntu on Linux. Mac and Windows also support newer versions of ROS.

• middle layer

  It is the middleware about robot development encapsulated by ROS, such as:

  • TCPROS/UDPROS communication system based on TCP/UDP continuous encapsulation

  • Used for inter-process communication Nodelet to provide support for real-time data transmission

  • In addition, a large number of robot development and implementation libraries are also provided, such as: data type definition, coordinate transformation, motion control...

• Application layer

  Function package, and nodes in the function package, such as: master, turtlesim control and motion nodes...

 

4. Own structure

In terms of ROS's own implementation: it can also be divided into three layers

• File system

  The ROS file system level refers to the organization of the ROS source code viewed on the hard disk

• Calculation graph

  Different processes in the ROS distributed system need to exchange data. The calculation graph can express the data interaction process in the form of a point-to-point network. The important concepts in the calculation graph: node (Node), message (message), communication mechanism topic (topic), communication Mechanism Service (service)

• Open source community

  The community-level concept of ROS is a manifestation of code release on the ROS network

  • Distribution (Distribution) ROS distribution is a series of comprehensive function packages that can be installed independently and have version numbers. ROS distributions play a similar role as Linux distributions. This makes the installation of ROS software easier, and can maintain a consistent version through a software collection.

  • Repository ROS relies on websites or hosting services that share open source code and software libraries, where different organizations can publish and share their robot software and programs.

  • ROS Wiki ROS Wiki is the main forum for recording information about the ROS system. Anyone can register for an account, contribute their own files, provide corrections or updates, write tutorials, and other actions. The website is http://wiki.ros.org/ .

  • Bug Ticket System (Bug Ticket System) If you find a problem or want to propose a new feature, ROS provides this resource to do it.

  • Mailing list (Mailing list) The ROS user mailing list is the main communication channel for ROS. It can exchange all kinds of questions or information from ROS software update to ROS software use like a forum. The website is http://lists.ros.org/ .

  • ROS Answer users can use this resource to ask questions. The URL is https://answers.ros.org/questions/ .

  • Blog (Blog) You can see regular updates, photos and news. The website is https://www.ros.org/news/ , but the blog system has been retired and replaced by the ROS community. The website is https://discourse.ros.org/ .

Now in the initial stage of learning, I just ran the built-in case of ROS and wrote a simple ROS implementation. Therefore, due to the current progress, we will not introduce all the modules in all design architectures in detail. Currently, only the file system and calculation diagrams are introduced. , The next chapter will introduce the communication mechanism of ROS, which is also one of the core implementations of ROS.

 

1 ROS file system

The ROS file system level refers to the organization of the ROS source code on the hard disk, and its structure can be roughly as shown in the following figure:

WorkSpace --- 自定义的工作空间

    |--- build:编译空间，用于存放CMake和catkin的缓存信息、配置信息和其他中间文件。

    |--- devel:开发空间，用于存放编译后生成的目标文件，包括头文件、动态&静态链接库、可执行文件等。

    |--- src: 源码

        |-- package：功能包(ROS基本单元)包含多个节点、库与配置文件，包名所有字母小写，只能由字母、数字与下划线组成

            |-- CMakeLists.txt 配置编译规则，比如源文件、依赖项、目标文件

            |-- package.xml 包信息，比如:包名、版本、作者、依赖项...(以前版本是 manifest.xml)

            |-- scripts 存储python文件

            |-- src 存储C++源文件

            |-- include 头文件

            |-- msg 消息通信格式文件

            |-- srv 服务通信格式文件

            |-- action 动作格式文件

            |-- launch 可一次性运行多个节点 

            |-- config 配置信息

        |-- CMakeLists.txt: 编译的基本配置

Some directories and files in the ROS file system have been involved in the previous programming, such as the creation of function packages, the writing of cpp files in the src directory, the writing of python files in the scripts directory, the writing of launch files in the launch directory, and the configuration package.xml and CMakeLists.txt files. The contents of other directories will be introduced later in the tutorial. At present, we mainly introduce: package.xml and CMakeLists.txt these two configuration files.

1.package.xml

<?xml version="1.0"?>
<!-- 格式: 以前是 1，推荐使用格式 2 -->
<package format="2">
  <!-- 包名 -->
  <name>demo01_hello_vscode</name>
  <!-- 版本 -->
  <version>0.0.0</version>
  <!-- 描述信息 -->
  <description>The demo01_hello_vscode package</description>

  <!-- One maintainer tag required, multiple allowed, one person per tag -->
  <!-- Example:  -->
  <!-- <maintainer email="[email protected]">Jane Doe</maintainer> -->
  <!-- 维护人员 -->
  <maintainer email="[email protected]">winter</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 -->
  <!-- 许可证信息，ROS核心组件默认 BSD -->
  <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/demo01_hello_vscode</url> -->


  <!-- Author tags are optional, multiple are allowed, one per tag -->
  <!-- Authors do not have to be maintainers, but could be -->
  <!-- Example: -->
  <!-- <author email="[email protected]">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>

2.CMakelists.txt

The file CMakeLists.txt is the input of the CMake build system and is used to build the software package. Any CMake-compatible software package contains one or more CMakeLists.txt files, which describe how to build the code and where to install the code.

cmake_minimum_required(VERSION 3.0.2) #所需 cmake 版本
project(demo01_hello_vscode) #包名称，会被 ${PROJECT_NAME} 的方式调用

## 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
# 启动 python 模块支持
# catkin_python_setup()

################################################
## Declare ROS messages, services and actions ##
## 声明 ROS 消息、服务、动作... ##
################################################

## 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 ##
## 声明 ROS 动态参数配置 ##
################################################

## 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 ##
## catkin 特定配置##
###################################
## 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 demo01_hello_vscode
#  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
# 声明 C++ 库
# add_library(${PROJECT_NAME}
#   src/${PROJECT_NAME}/demo01_hello_vscode.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
# 添加库的 cmake 目标依赖
# 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
# 声明 C++ 可执行文件
add_executable(Hello_VSCode src/Hello_VSCode.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"
#重命名c++可执行文件
# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "")

## Add cmake target dependencies of the executable
## same as for the library above
#添加可执行文件的 cmake 目标依赖
add_dependencies(Hello_VSCode ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

## Specify libraries to link a library or executable target against
#指定库、可执行文件的链接库
target_link_libraries(Hello_VSCode
  ${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/Hi.py
  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_demo01_hello_vscode.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)

2 ROS file system related commands

The file system of ROS is essentially operating system files. We can use Linux commands to manipulate these files. However, for a better user experience in ROS, ROS specifically provides some commands similar to Linux. These commands are compared to Linux native commands are more brief and efficient. File operations are nothing more than operations such as adding, deleting, modifying, checking, and executing. Next, we will introduce some common commands of the ROS file system from these five dimensions.

1. Increase

 catkin_create_pkg 自定义包名 依赖包 === 创建新的ROS功能包
 sudo apt install xxx === 安装 ROS功能包

2. Delete

 sudo apt purge xxx ==== 删除某个功能包

3. Check

rospack list === 列出所有功能包

rospack find 包名 === 查找某个功能包是否存在，如果存在返回安装路径

roscd 包名 === 进入某个功能包

rosls 包名 === 列出某个包下的文件

apt search xxx === 搜索某个功能包

4. Change

rosed package name file name === modify function package file

Need to install vim

rosed turtlesim Color.msg

5. Execution

5.1roscore

roscore === is a collection of ROS system prerequisite nodes and programs, and roscore must be running to enable ROS nodes to communicate.

roscore will start:

• ros master

• ros parameter server

• rosout log node

usage:

roscore

Or (specify port number)

roscore -p xxxx

5.2rosrun

rosrun package name executable file name === run the specified ROS node

such as:

rosrun turtlesim turtlesim_node

5.3roslaunch

roslaunch 包名 launch文件名 === 执行某个包下的 launch 文件

3 ROS calculation diagram

1. Introduction to computational graphs

What I introduced earlier is the ROS file structure, which is the storage structure of the ROS program on the disk. It is static. After the ros program runs, different nodes are intricately complicated. ROS provides a practical tool: rqt_graph.

rqt_graph can create a dynamic graph that shows the current system operation. Different processes in the ROS distributed system need to exchange data, and the calculation graph can express the data exchange process in the form of a point-to-point network. rqt_graph is part of the rqt package.

2. Calculation diagram installation

If all the packages have been installed in the early stage, enter directly in the terminal window

rosrun rqt_graph rqt_graph

If it is not installed, enter it in the terminal

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

Please use your ROS version name (for example: kinetic, melodic, Noetic, etc.) to replace <distro>.

For example, the current version is Noetic, just enter in the terminal window

sudo apt install ros-noetic-rqt
sudo apt install ros-noetic-rqt-common-plugins

3. Demonstration of calculation graph

Next, use the built-in small turtle case in ROS to demonstrate the calculation graph

First, run the case as shown earlier

Then, start a new terminal and type: rqt_graph or rosrun rqt_graph rqt_graph, you can see a network topology diagram similar to the following figure, which can show the relationship between different nodes.