【ros学习笔记】

ros学习笔记：

提示：ros

1.适用对象

linux
开发工具：TF坐标变换、QT工具、Rviz、Gazebo
应用功能：Navigation、SLAM、Movelt

2.核心概念

ROS Master:节点管理器，控制中心，为节点提供命名和注册服务；跟踪和记录话题/服务通信，辅助节点相互查找、建立连接；提供参数服务器，节点使用此服务器存储和检索运行时的参数，一旦链接后，话题间的链接不受Master的影响。
Workspace:工作空间，开发进程的大本营；
Package:功能包，功能源码的聚集地；ROS软件中的基本单元，包括节点源码、配置文件、数据定义等；
Package manifest:功能包清单，记录功能包的基本信息，包括作者信息、许可信息、依赖选项、编译标志等。
Meta Packages:元功能包，组织多个用于同一目的功能包；
Node：节点，机器人的工具细胞，执行具体任务的进程、独立运行的可执行文件；不同节点可使用不同的编程语言，可分布式运行在不同的主机；节点在系统中的名称必须是唯一的。
Topic:话题，节点间传递数据的桥梁；节点间用来传输数据的重要总线；使用发布/订阅模型，数据由发布者传输到订阅者，同一话题的订阅者或者发布者可以不唯一。
Message:消息，话题数据，具有一定的类型和数据结构，包括ROS提供的标准类型和用户自定义类型；使用编程语言无关的.msg文件定义，编译过程中生成对应的代码文件。
Service:服务，节点间的你问我答；使用客户端/服务器（C/S)模型，客户端发送请求数据，服务器完成处理后返回应答数据；使用编程语言无关的.srv文件定义请求和应答数据结构，编译过程中生成对应的代码文件。
Interface:通信接口，数据传递的标准结构；
Parameter:参数，机器人系统的全局字典；可通过网络访问的共享、多变量、多类型字典；节点使用此服务器来存储和检索运行时的参数；适合存储静态、非二进制的配置参数，不适合存储动态配置的数据。
Action:动作，完整行为的流程管理；
Distributed Communication:分布式通信，多计算平台的任务分配；
DDS(Data Distribution Service):机器人的神经网络；
Tab键：终端自动补齐；
双击Tab键:补齐所有内容；
Ctr+C:停止终端，相对于停止程序；
Ctr+H:显示隐藏文件，便于设置setup.bash;
/spawn:rosservice list下的服务，用于产生和诞生新的海龟（示例）；
src:代码空间（suorce space)
buld:编译空间（build space),catkin编译下
devel:开发空间（Development space)
install:安装空间（install space)

常用命令：

rostopic
rosservice
rosnode
rosparam
rosmsg
rossrv

3.命令执行示例

rqt_gragh

启动ROS Master:
roscore
启动小海龟仿真器：
rosrun turtlesim turtlesim_node
启动海龟控制节点：
rosrun turtlesim turtle_teleop_key
显示系统计算图的工具，了解整个系统的全貌，可视化工具，流程图结构：
rqt_gragh

rosnode

把系统中所有节点都列出来：
rosnode list
查看某个节点的信息，如/turtlesim:
rosnode info /turtlesim

rostopic

打印出当前系统中所有的话题列表：
rostopic list
通过给话题发布指令，控制海龟运动：
rostopic pub /turtle/cmd_vel geometry_msgs/Twist +双击Tab键补齐
通过给话题发布指令，控制海龟运动，并且实现一秒钟发布10次的指令,10表示10HZ：
rostopic -r 10 /turtle/cmd_vel geometry_msgs/Twist +双击Tab键补齐
查看消息geometry_msgs/Twist的数据结构：
rosmsg show geometry_msgs/Twist

rosservice

查看服务内容：
rosservice list
产生新的海龟，可以指定海龟的初始位置和海龟名字：
rosservice call /spawn +Tab补齐

rosbag

话题记录工具，记录当前系统运行的所有数据，便于调试，可以复现数据,停止终端保存数据：
rosbag record -a -O cmd_record
复现指令内容，.bag默认存放于当前终端的主文件里：
rosbag play cmd_record.bag

创建工作空间：
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace
编译工作空间,结果存放于build 和 devel：
cd ~/catkin_ws/
catkin_make
设置环境变量：
source devel/setup.bash
检查环境变量：
echo $ROS_PACKAGE_PATH
生成install文件夹：
catkin_make install

创建功能包，其中std_msgs rospy roscpp为依赖库，包名为test_pkg：
cd ~/catkin_ws/src
catkin_create_pkg test_pkg std_msgs rospy roscpp
编译功能包：
cd ~/catkin_ws 
catkin_make
source ~/catkin_ws/devel/setup.bash

发布者Publisher的编程实现

创建功能包：
cd ~/catkin_ws/src
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim
创建.cpp文件：
velecity_pulisher.cpp
配置发布者代码编译规则，在CMakeList.txt加入以下内容：
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
编译并运行发布者：
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisher

ROS节点初始化：
ros::init(argc,argv,"velocity_publisher");
创建节点句柄：
ros::NodeHandle n;
 创建一个publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度为10：
 ros::Publisher turtle_vel_pub=n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);
 设置循环的频率：
 ros::Rate loop_rate(10);
 初始化geometry_msgs::Twist类型的消息：
 geometry_msgs::Twist vel_msg;
 vel_msg_linear.x=0.5;
 vel_msg_linear.y=0.2;
 发布消息：
 turtle_vel_pub.publisher(vel_msg);
 ROS_INFO("Publisher turtle velocity commond[%0.2f m/s,%0.2f rad/s]",vel_msg.linear.x,vel_msg.angular.z);
 按循环频率延时：
 loop_rate.sleep();

订阅者Subscriber的编程实现

创建.cpp文件：
cd ~/catkin_ws/src
pose_subscriber.cpp
配置订阅者代码编译规则，在CMakeList.txt中加入以下内容：
add_executable(pose_subscriber src/pose_subscriber.cpp)
target_link_libraries(pose_subscriber ${catkin_LIBRARIES})
编译并运行订阅者：
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisher

pose_subscriber.cpp文件
接收订阅的消息后，会进入消息回调函数：
void poseCallback(const turtlesim::Pose::ConstPtr& msg){};
将接收到的消息打印出来：
ROS-INFO("Turtle pose:x:%0.6f,y:%0.6f,msg->x,msg->y);
初始化ROS节点：
ros::init(argc,argv,"pose_subscriber");
创建节点句柄：
ros::NodeHandle n;
创建一个Subscriber,订阅名为/turtle1/pose的topic,注册回调函数poseCallback:
ros::Subscriber pose_sub=n.subscribe("/turtle1/pose",10,poseCallback);
循环等待回调函数,死循环，不会自动到达return 0：
ros::spin();

话题消息

定义msg文件；
在package.xml中添加功能包依赖：
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>
在CMakeList.txt添加编译选项,"..."表示改内容保持不变：
find_package(..... message_generation)

add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)

catkin_package(..... message_runtime)
编译生成语言相关文件
配置代码编译规则：
add_executable(person_publisher src/person_publisher.cpp)
target_link_libraries(person_publisher ${catkin_LIBRARIES})
//自定义文件链接必须添加
add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)

add_executable(person_subscriber src/person_subscriber.cpp)
target_link_libraries(person_subscriber${catkin_LIBRARIES})
//自定义文件链接必须添加
add_dependencies(person_subscriber${PROJECT_NAME}_generate_messages_cpp)

Person.msg文件

在catkin_ws/msg/下创建该文件
string name
uint8 age

uint8 unknown=0
uint8 male=1
uint8female=2

//该文件存放于 /catkin_ws/src/learning_topic/src下，文件名为person_publisher.cpp;
#include<ros/ros.h>
#include "learning_topic/Person.h"
int main(int argc,,char **argv)
{
//ROS节点初始化
ros::init(argc,argv,"person_publisher");
//创建节点句柄
ros::NodeHandle n;
//创建一个Publisher,发布名为/person_info的topic，消息类型为learning_topic::Person,队列长度10
ros::Publisher person_info_pub =n.advertise<learning_topic::Person>("/person_info",10);
//设置循环的频率
ros::Rate loop_rate(1);
int count=0;
while(ros::ok())
{
//初始化Learning_topic::Person类型的消息
learning_topic::Person person_msg;
person_msg.name="Yang";
person_msg.age=18;
person_msg.sex=learning_topic::Person::male;
//发布消息
person_info_pub.publish(person_msg);
ROS_INFO("Publish Person Info:name:%s age:%d sex:%d",person_msg.name.c_str(),person_msg.age,person_msg.sex);
//按照循环频率延时
loop_rate.sleep();
}
return 0;
}

//在指定的路径下：~/catkin_ws/src/learning_topic/src/,文件名为：person_subscriber.cpp;
#include<ros/ros.h>
#include "learning_topic/Person.h"
//接收订阅消息后，会进入消息回调函数
void personInfoCallback(const learning_topic::Person::ConstPtr& msg)
{
//接收到的消息打印出来
ROS_INFO("Subscribe Person Info:name:%s age:%d sex:%d,msg->name.c_str(),msg->age,msg->sex);
int main(int argc,char **argv)
{
//初始化ROS节点
ros::init(argc,argv,"person_subscriber");
//创建节点句柄
ros::NodeHandle n;
//创建一个Subscriber,订阅名为/person_info的topic,注册回调函数personInfoCallback
ros::Subscriber person_info_sub=n.subscribe("/person_info",10,personInfoCallback);
//循环等待回调函数
ros::spin():
return 0;
}

客户端Client的编程实现

创建功能包,依赖为： roscpp rospy std_msgs geometry_msgs turtlesim：
cd ~/catkin_ws/src
catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim
在 ~/catkin_ws/src/learning_service/src下创建turtle_spawn.cpp文件：
turtle_spawn.cpp
 配置客户端代码编译规则，在CMakeList.txt中添加以下内容：
 add_executable(turtle_spawn src/turtle_spawn.cpp)
 target_link_libraries(turtle_spawn $[catkin_LIBRARIES])
 编译并运行客户端：
 cd ~/catkin_ws
 catkin_make
 source devel/setup.bash
 roscore
 rosrun turtlesim turtlesim_node
 rosrun learning_service turtle_spawn

//turtle_spawn.cpp文件
初始化ROS节点：
ros::init(argc,argv,"turtle_spawn");
创建节点句柄：
ros::NodeHandle n;
发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service:
ros::service::waitForService("/spawn");
ros::ServiceClient add_turtle=node.serviceClient<turtlesim::Spawn>("/spawn");
初始化turtlesim::Spawn的请求数据：
turtlesim::Spawn srv;
srv.request.x=2.0;
srv.request.y=2.0;
srv.request.name="turtle2";
请求服务调用：
ROS_INFO("Call service to spawn turtle[x:%0.6f,y:%0.6f,name:%s]",srv.request.x,srv.request.y,srv.request.name.c_str());
显示服务调用 结果：
ROS_INFO("Spawn turtle successfully [name:%s]",srv.response.name.c_str());

服务端server的编程实现

在路径~/catkin_ws/src/learning_service/src下创建文件turtle_command_server.cpp:
turtle_command_server.cpp
编译并运行服务端：
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_command_server
rosservice call /turtle_command "{}"

查看srvs定义：
rossrv show std_srvs/Trigger

//turtle_command_service.cpp文件
//该程序将执行/turtle_command服务，服务数据类型std_srvs/Trigger
#include<ros/ros.h>
#include<geometry_msgs/Twist.h>
#include<std_srvs/Trigger.h>
ros::Publisher turtle_vel_pub;
bool pubCommand=false;
//service回调函数，输入参数req,输出参数res
bool commandCallback(std_srvs::Trigger::Request &req,std_srvs::Trigger::Response &res)
{
pubCommand=!pubCommand;
//显示请求数据
ROS_INFO("Publish turtle velocity command[%s]",pubCommand==true?"Yes":"No");
//设置反馈数据
res.success=true;
res.message="Change turtle command state!";
return true;
}
int main(int argc,char **argv)
{
//ROS节点初始化
ros::init(argc,argv,"turtle_command_server");
//创建节点句柄
ros::NodeHandle n;
//创建一个名为/turtle_command的server,注册回调函数commandCallback
ros::ServiceServer command_service=n.advertise("/turtle_command",commandCallback);
//创建一个Publisher,发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist,队列长度为10
turtle_vel_pub=n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);
//循环等待回调函数
ROS_INFO("Ready to receive turtle command.");
//设置循环的频率
ros::Rate loop_rate(10);
while(ros::ok))
{
//查看一次回调函数队列
ros::spinOnce();
//如果标志为true,则发布速度指令
if(pubCommand)
{
geometry_msgs::Twist vel_msgs;
vel_msgs.linear.x=0.5;
vel_msgs.linear.y=0.2;
turtle_vel_pub.publish(vel_msg);
}
//按照循环频率延时
loop_rate.sleep();
}
return 0;
}

服务数据的定义与使用

在learning_service文件夹下创建srv文件夹，并在其中创建Person.srv文件：
cd ~/catkin_wp/src/learning_service
mkdir srv
touch Person.srv
在package.xml中添加功能包依赖：
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>
在CMakeList.txt中添加编译选项：
find_package(... message_generation)
add_service_files(FILES Person.srv)
generate_messages(DEPENDENCIES std_msgs)
catkin_package(... message_runtime)
在下列路径中创建person_client.cpp和person_server.cpp：
cd ~/catkin_ws/src/learning_service/src
配置服务器/客户端代码编译规则，在CMakeList.txt中加入以下内容：
add_executable(person_server src/person_server.cpp)
target_link_libraries(person_server ${catkin_LIBRARIES})
add_dependencies(person_server ${PROJECT_NAME}_gencpp)

add_executable(person_client src/person_client.cpp)
target_link_libraries(person_client ${catkin_LIBRARIES}）
add_dependencies(person_client ${PROJECT_NAME}_gencpp)
编译并运行文件：
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun learning_service person_server
rosrun learning_service person_client

//Person.srv文件
string name
uint8 age
uint8 sex

uint8 unknown=0
uint8 male=1
uint8 female=2
---
string result

//person_client.cpp文件，将请求/show_person服务，服务数据类型learning_service::Person
#include<ros/ros.h>
#include "learning_service/Person.h"
int main(int argc,char** argv)
{
//初始化ROS节点
ros::init(argc,argv,"person_client");
//创建节点句柄
ros::NodeHandle n;
//发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
ros::service::waitForService("/show_person");
ros::ServiceClient person_client=node.serviceClient<learning_service::Person>("/show_person");
//初始化learning_service::Person的请求数据
learning_service::Person srv;
srv.request.name="Yang";
srv.request.age=18;
srv.request.sex=learning

//person_server.cpp文件
//该文件用于将执行/show_person服务，服务数据类型为learning_service::Person
#include<ros/ros.h>
#include "learning_service/Person.h"
//service回调函数，输入参数req,输出参数res
bool personCallback(learning_service::Person::Request &req,learning_service::Person::Response &res)
{
//显示请求数据
ROS_INFO("Person :name:%s age:%d sex:%d",req.name.c_str(),req.age,req.sex);
//设置反馈数据
res.result="OK";
return true;
}
int main(int argc,char **argv)
{
//ROS节点初始化
ros::init(argc,argv,"person_server");
//创建节点句柄
ros::NodeHandle n;
//创建一个名为/show_person的server,注册回调函数personCallback
ros::ServiceServer person_service=n.advertiseService("/show_person",personCallback);
//循环等待回调函数
ROS_INFO("Ready to show person information.");
ros::spin();
return 0;
}

参数的使用与编译方法

创建功能包,其中依赖为roscpp rospy std_srvs：
cd ~/catkin_ws/src
catkin_create_pkg learning_parameter roscpp rospy std_srvs
在以下路径中创建parameter_config.cpp文件：
cd ~/catkin_ws/src/learning_parameter/src
配置代码编译规则，在CMakeList.txt中添加以下内容：
add_executable(parameter_config src/parameter_config.cpp)
target_link_libraries(parameter_config ${catkin_LIBRARIES})
编译并运行发布者：
cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore
rosrun turtlesim turtlesim_node
rosrun learning_parameter parameter_config

rosparam

列出当前有多少参数：
rosparam list
显示某个参数的值：
rosparam get param_key
设置某个参数值：
rosparam set param_key param_value
保存参数到文件,主要保存为.YAML类型的文件：
rosparam dump file_name.yaml
从文件读取参数,通常加载.YAML类型的文件：
rosparam load file_name.yaml
删除参数：
rospara delete param_key
发送请求，更新参数,通常更改完参数后查看：
rosservice call /clear "{}"

YAML文件类型示例：

background_b:100
background_g:188
background_r:44
rosdistro:'melodic'
roslaunch:
uris:{host_hcx_cpc__4569:'http://hcx-vpc:343442/'}
rosversion:'1.16.0'
run_id:12334-34455-3303-3033dccmv

//parameter_config.cpp文件
//程序设置/读取海龟示例中的参数
#include<string>
#include<ros/ros.h>
#include<std_srvs/Empty.h>
int main(int argc,char** argv)
{
int red,green,blue;
//ROS节点初始化
ros::init(argc,argv,"parameter_config");
//创建节点句柄
ros::NodeHandle n;
//读取背景颜色参数
ros::param::get("/background_r",red);
ros::param::get("/background_g",green);
ros::param::get("/background_b",blue);
ROS_INFO("Get Background Color[%d,%d,%d]",red,green,blue);
//设置背景颜色参数
ros::param::set("/background_r",255);
ros::param::set("/background_g",255);
ros::param::set("/background_b",255);
ROS_INFO("Set Background Color[%d,%d,%d]",red,green,blue);
//读取背景颜色参数
ros::param::get("/background_r",red);
ros::param::get("/background_g",green);
ros::param::get("/background_b",blue);
ROS_INFO("Get Background Color[%d,%d,%d]",red,green,blue);
//调用服务，刷新背景颜色
ros::service::waitForService("/clear");
ros::ServiceClient clear_background=node.serviceClient<std_srvs::Empty>("/clear");
std_srvs::Empty srv;
clear_background.call(srv);
sleep(1);
return 0;
}

ROS中的坐标系管理系统

TF功能包：管理坐标系间的转换管理；

机器人中的坐标变换：
sudo apt install ros-melodic-turtle-tf
roslaunch turtle_tf turtle_tf_demo.launch
rosrun turtlesim turtle_teleop_key
//查看所有坐标系之间的关系,以及所有tf之间的关系
rosrun tf view_frames
查看两个坐标系之间的转换关系：
rosrun tf tf_echo turtle1 turtle2
三维视觉查看坐标系之间的变化关系：
rosrun rviz rviz -d 'rospack find turtle_tf' /rviz/turtle_rviz.rviz

tf坐标系广播与监听的编程实现

创建功能包,依赖包为roscpp rospy tf turtlesim：
cd ~/catkin_ws/src
catkin_create_pkg learning_tf roscpp rospy tf turtlesim
在下列路径中创建turtle_tf_broadcaster.cpp和turtle_tf_listener.cpp:
cd ~/catkin_ws/src/learning_tf/src
配置tf广播器与监听器代码编译规则,在CMakeList.txt中添加以下内容：
add_executable(turtle_tf_broadcaster src/turtle_tf_broadcaster.cpp)
target_link_libraries(turtle_tf_broadcaster ${catkin_LIBRARIES})

add_executable(turtle_tf_listener src/turtle_tf_listener.cpp)
target_link_libraries(turtle_tf_listener ${catkin_LIBRARIES})
编译并运行：
cd ~/catkin_ws/
catkin_make
source devel/setup.bash
rescore 
rosrun turtlesim turtlesim_node
//__name:=表示重映射机制，同一程序可以运行两次
rosrun learning_tf turtle_tf_broadcaster __name:=turtle1_tf_broadcaster /turtle1
rosrun learning_tf turtle_tf_broadcaster __name:=turetle2_tf_broadcaster /turtle2
rosrun learning_tf turtle_tf_listener
rosrun learning_tf turtle_teleop_key

//turtle_tf_broadcaster.cpp文件
//程序产生tf数据，并计算、发布turtur2的速度指令
#include<ros/ros.h>
#include<tf/transferm_broadcaster.h>
#include<turtlesim/Pose.h>
std::string turtle_name;
void poseCallback(const turtlesim::PoseConstPtr& msg)
{
//创建tf的广播器
static tf::TransformBroadcaster br;
//初始化tf数据
tf::Transform transform;
//平移参数的设置
transform.setOrigin(tf::Vector3(msg->x,msg-y,0.0));
//旋转参数的设置
tf::Quaternion q;
q.setRPY(0,0,msg->theta);
transform.setRotation(q);
//广播world与海龟 坐标系之间的tf数据
br.sendTransform(tf::StampedTransform(transform,ros::Time::now(),"world",turtle_name);
}
int main(int argc,char** argv)
{
//初始化ROS节点
ros::init(argc,argv,"my_tf_broadcaster");
//输入参数作为海龟的名字
if(argc!=2)
{
ROS_ERROR("need turtle name as argument");
return -1;
}
turtle_name=argv[1];
//订阅海龟的位置话题
ros::NodeHandle node;
ros::Subscriber sub=node.subscribe(turtle_name+"/pose",10,&poseCallback);
//循环等待回调函数
ros::spin();
return 0
};

//turtle_tf_listener.cpp文件
//程序监听tf数据，并计算、发布turtle2的速度指令
#include<ros/ros.h>
#include<tf/transform_listener.h>
#include<geometry_msgs/Twist.h>
#include<turtlesim/Spawn.h>
int main(int argc,char** argv)
{
//初始化ROS节点
ros::init(argc,argv,"my_tf_listener");
//创建节点句柄
ros::NodeHandle node;
//请求产生turtle2
ros::service::waitForService("/spawn");
ros::ServiceClient add_turtle=node.serviceClient<turtlesim::Spawn>("/spawn");
turtlesim::Spawn srv;
add_turtle.call(srv);
//创建发布turtle2速度控制指令的发布者
ros::Publisher turtle_vel=node.advertise<geometry_msgs::Twist>("turtle2/cmd_vel",10);
//创建tf的监听器
tf::TransformListener listener;
ros::Rate rate(10.0);
while(node.ok())
{
//获取turtle1与turtle2坐标系之间的tf数据
tf::StampedTransform transform;
try
{
//等待查看系统是否存在如下两个坐标系，如果存在，则执行
listener.waitForTransform("/turtle2","/turtle1",ros::Time(0),ros::Duration(3.0));
listener.lookupTransform("turtle2","turtle1",ros::Time(0),transform);
catch(tf::TransformException &ex)
{
ROS_ERROR("%S",ex.what());
ros::Duaration(1.0).sleep();
continue;
}
//根据turtle1与turtle2坐标系之间的位置关系，发布turtle2的速度控制指令
geometry_msgs::Twist vel_msg;
vel_msg.angular.z=4.0*atan2(transform.getOrigin().y(),transform.getOrigin().x());
vel_msg.linear.x=0.5*sqrt(pow(transform.getOrigin().x(),2)+pow(transform.getOrigin().y(),2));
turtle_vel.publisher(vel_msg);
rate.sleep();
}
return 0;
}

Launch启动文件的使用方法

launch文件：
通过XML文件实现多节点的配置和启动（可以自动启动ROS Master)
创建功能包：
cd ~/catkin_ws/src
catkin_create_pkg learning_launch 
在~/catkin_ws/src/learning_launch/创建launch文件夹：
mkdir launch
在~/catkin_ws/src/learning_launch/launch/创建simple.launch文件：
touch simple.launch
touch turtl  e_parameter_config.launch
编译并运行，让工作空间知道learning_launch功能包添加进来：
cd ~/catkin_ws/
catkin_make
//roslaunch+功能包名+.launch文件名
roslaunch learning_launch simple.launch

<launch>:launch文件中的根元素采用<launch>标签定义

<node>:启动节点
<node pkg="package-name" type="executable-name" name="node-name"/>:
pkg:节点所在的功能包名称
type:节点的可执行文件名称
name:节点运行时的名称，可用于重复运行同类型代码
output:控制信息是否打印终端
respawn:控制节点挂掉后是否重启
required:是否必须启动
ns:可以给每个节点设置命名空间
args:可以给每个节点输入参数使用的

<param>:设置ROS系统运行中的参数，存储在参数服务器中，用于保存某一个参数的值。
<param name="output_frame" value="node"/>:
name:参数名
value：参数值
<rosparam>:用于加载文件中的多个参数，并存到服务器中
<rosparam file="params.yaml" command="load" ns="params"/>

<arg>:launch文件内部的局部变量，仅限于launch文件使用
<arg name="arg-name" default="arg-value"/>:
name:参数名
value:参数值
调用：
<param name="foo" value="$(arg arg-name)"/>
<node name="node" pkg="package" type="type" args="$(arg arg-name)"/>

<remap>:重映射ROS计算图资源的命名，原来名字就没有了
<remap from="/turtlebot/cmd_vel" to="/cmd_vel"/>:
from：原命名
to:映射之后的命名

<include>:包含其他launch文件，类似C语言中的头文件包含。
<include file="$(dirname)/other.launch"/>:
file:包含的其他launch文件路径

<!--简单的Launch文件-->
<launch>
<node pkg="turtlesim" name="sim1" type="turtlesim_node"/>
<node pkg="turtlesim" name="sim2" type="turtlesim_node"/>
</launch>

<launch>
<node pkg="learning_topic" type="person_subscriber" name="talker" output="screen"/>
<node pkg="learning_topic" type="person_publisher" name="listener" output="sreen"/>
</launch>

常用可视化工具的使用

Qt工具箱：
终端输入rqt_+双击Tab键补齐
输入rqt
Rviz工具：

rosrun rviz rviz