ROS 古月居21讲视频学习记录

ROS 古月居21讲视频学习记录

节点（Node）：执行单元

• 执行具体任务的进程、独立运行的可执行文件;
• 不同节点可使用不同的编程语言，可分布式运行在不同的主机;
• 节点在系统中的名称必须是唯一的。

节点管理器（ROS Master）：控制中心

• 为节点提供命名和注册服务;
• 跟踪和记录主题/服务通信，辅助节点相互查找、建立连接;
• 提供参数服务器，节点使用此服务器存储和检索运行时的参数。

主题（Topic）：异步通信机制

• 节点间用来传输数据的重要总线;
• 使用发布/订阅模型，数据由发布者传输到订阅者，同一个主题的订阅者或发布者可以不唯一。

消息（Message）：主题数据

• 具有一定的类型和数据结构，包括ROS提供的标准类型和用户自定义类型;
• 使用编程语言无关的.msg文件定义，编译过程中生成对应的代码文件。

服务（Service）：同步通信机制

• 使用客户端/服务器（C/S）模型，客户端发送请求数据，服务器完成处理后返回应答数据;
• 使用编程语言无关的.srv文件定义请求和应答数据结构，编译过程中生成对应的代码文件。

参数（Parameter）：全局共享字典

• 可通过网络访问的共享、多变量字典;
• 节点使用此服务器来存储和检索运行时的参数;
• 适合存储静态、非二进制的配置参数，不适合存储动态配置的数据。

文件系统

功能包（package）

ROS软件中的基本单元，包含节点源码、配置文件、数据定义等

功能包清单（package manifest）

记录功能包的基本信息，包含作者信息、许可信息、依赖选项、编译标志等

元功能包（meta packages）

组织多个用于同一目的功能包

命令行

• 显示系统计算图
  • rqt_graph
• 显示节点相关参数
  • rosnode
• 显示主题相关参数
  • rostopic
• 显示消息相关参数
  • rosmsg
• 显示服务相关参数
  • rosservice
• 显示主题列表
  • rosnode list
• 发布主题消息
  • rostopic pub -r 10 /turtle1/cmd_vel geometry_msgs/Twist "linear:
    x: 1.0
    y: 0.0
    z: 0.0
    angular:
    x: 0.0
    y: 0.0
    z: 1.0"
• 发布服务请求
  • rosservice call /spawn "x: 2.0
    y: 3.0
    theta: 0.0
    name: 'turtle2'"
• 主题记录
  • rosbag record -a -O cmd_record
• 主题复现
  • rosbag play cmd_record.bag

工作空间

• src：代码空间（source space）
• build：编译空间（build space）
• devel：开发空间（development space），catkin_make编译后的结果存放在devel/lib目录下
• install：安装空间（install space）

创建工作空间

• mkdir catkin_ws
• cd catkin_ws
• mkdir src
• cd src
• catkin_init_workspace

编译工作空间

• cd catkin_ws
• catkin_make
• catkin_make install

创建功能包

同一个工作空间下，不允许存在同名功能包，不同工作空间下，允许存在同名功能包。

• catkin_create_pkg <package_name> [depend1] [depend2] [depend3]
• 例：
  • cd catkin_ws/src
  • catkin_create_pkg test_pkg std_msgs rospy roscpp

设置环境变量

• cd catkin_ws
• source devel/setup.bash

检查环境变量

• echo $ROS_PACKAGE_PATH

发布者Publisher的编程

• cd catkin_ws/src
• catkin_create_pkg learning_topic std_msgs rospy roscpp geometry_msgs turtlesim
• cd learning_topic/src
• touch velocity_publisher.cpp

实现一个发布者

1. 初始化ROS节点
2. 向ROS Master注册节点信息，包括发布的主题名和主题中的消息类型
3. 创建消息数据
4. 按照一定频率循环发布消息

/*
 * 该例程将发布turtle1/cmd_vel主题，消息类型geometry_msgs::Twist
 */
 
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

int main(int argc, char **argv)
{
	// 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);

	int count = 0;
	while (ros::ok())
	{
	    // 初始化geometry_msgs::Twist类型的消息
	    geometry_msgs::Twist vel_msg;
	    vel_msg.linear.x = 0.5;
	    vel_msg.angular.z = 0.2;

	    // 发布消息
	    turtle_vel_pub.publish(vel_msg);
	     ROS_INFO("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]", 
				vel_msg.linear.x, vel_msg.angular.z);

	    // 按照循环频率延时
	    loop_rate.sleep();
	}

	return 0;
}

配置CMakeLists.txt中的编译规则

1. 设置需要编译的代码和生成的可执行文件
2. 设置链接库

在CMakeLists.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   （环境变量可在主目录下的.bashrc文件添加source /home/xxx/.../setup.bash）
• roscore
• rosrun turtlesim turtlesim_node
• rosrun learning_topic velocity_publisher

订阅者Subscriber的编程 

• cd catkin_ws/src/learning_topic/src
• touch pose_subscriber.cpp

实现一个订阅者

1. 初始化ROS节点
2. 订阅需要的主题
3. 循环等待主题消息，接收到消息后进入回调函数
4. 在回调函数中完成消息处理

/*
 * 该例程将订阅/turtle1/pose主题，消息类型turtlesim::Pose
 */
 
#include <ros/ros.h>
#include "turtlesim/Pose.h"

// 接收到订阅的消息后，会进入消息回调函数
void poseCallback(const turtlesim::Pose::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Turtle pose: x:%0.6f, y:%0.6f", msg->x, msg->y);
}

int main(int argc, char **argv)
{
    // 初始化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);

    // 循环等待回调函数
    ros::spin();

    return 0;
}

配置CMakeLists.txt中的编译规则

1. 设置需要编译的代码和生成的可执行文件
2. 设置链接库

add_executable(pose_subscriber src/pose_subscriber.cpp)
target_link_libraries(pose_subscriber ${catkin_LIBRARIES})

编译并运行

• cd catkin_ws
• catkin_make
• roscore
• rosrun turtlesim turtlesim_node
• rosrun learning_topic pose_subscriber
• rosrun turtlesim turtle_teleop_key

主题消息的定义和使用

自定义主题消息

定义msg文件

• cd caatkin_ws/src/learning_topic
• mkdir msg
• cd msg
• touch Person.msg  （注意：msg文件首字母大写）

string name
uint8 sex
uint8 age
uint8 unknown = 0
uint8 male = 1
uint8 female = 2

在package.xml中添加功能包依赖

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

在CMakeLists.txt添加编译选项

在find_package中添加功能包(... message_generation) 

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

在catkin_package中添加功能包(…… message_runtime)，并取消第三行注释CATKIN_DEPENDS...这行 

编译生成语言相关文件

• cd catkin_ws
• catkin_make

发布者

/*
 * 该例程将发布/person_info主题，自定义消息类型learning_topic::Person
 */
 
#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 = "Tom";
	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;
}

订阅者

/*
 * 该例程将订阅/person_info主题，自定义消息类型learning_topic::Person
 */
 
#include <ros/ros.h>
#include "learning_topic/Person.h"

// 接收到订阅的消息后，会进入消息回调函数
void personInfoCallback(const learning_topic::Person::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Subcribe 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;
}

配置CMakeLists.txt中的编译规则

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)

编译并运行

• cd catkin_ws
• catkin_make
• roscore
• rosrun learning_topic person_subscriber
• rosrun learning_topic person_publisher
• 连接建立后，关闭roscore，发布者和订阅者仍然会继续通信连接

客户端Client编程

• cd catkin_ws/src
• catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim

实现一个客户端

1. 初始化ROS节点；
2. 创建一个Client实例；
3. 发布服务请求数据；
4. 等待Server处理之后的应答结果。

/*
 * 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn
 */

#include <ros/ros.h>
#include <turtlesim/Spawn.h>

int main(int argc, char** argv)
{
    // 初始化ROS节点
    ros::init(argc, argv, "turtle_spawn");

    // 创建节点句柄
    ros::NodeHandle node;

    // 发现/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 spwan turtle[x:%0.6f, y:%0.6f, name:%s]", 
		srv.request.x, srv.request.y, srv.request.name.c_str());

    add_turtle.call(srv);

    // 显示服务调用结果
    ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());

    return 0;
};

配置CMakeLists.txt中的编译规则

1. 设置需要编译的代码和生成的可执行文件；
2. 设置链接库；

add_executable(turtle_spawn src/turtle_spawn.cpp)
target_link_libraries(turtle_spawn ${catkin_LIBRARIES})

编译并运行

• cd catkin_ws
• catkin_make
• roscore
• rosrun turtlesim turtlesim_node
• rosrun learning_service turtle_spawn

服务端Server编程

实现一个服务器

1. 初始化ROS节点；
2. 创建Server实例；
3. 循环等待服务请求，进入回调函数；
4. 在回调函数中完成服务功能的处理，并反馈应答数据。

/*
 * 该例程将执行/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.advertiseService("/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_msg;
	    vel_msg.linear.x = 0.5;
	    vel_msg.angular.z = 0.2;
	    turtle_vel_pub.publish(vel_msg);
	}

	//按照循环频率延时
	loop_rate.sleep();
    }

    return 0;
}

配置CMakeLists.txt中的编译规则

1. 设置需要编译的代码和生成的可执行文件；
2. 设置链接库；

add_executable(turtle_command_server src/turtle_command_server.cpp)
target_link_libraries(turtle_command_server ${catkin_LIBRARIES})

编译并运行

• cd catkin_ws
• catkin_make
• roscore
• rosrun turtlesim turtlesim_node
• rosrun learning_service turtle_command_server
• rosservice call /turtle_command "{}"   运行一次开始运动，再运行一次停止运动

服务数据的定义与使用

自定义服务数据

定义srv文件

• cd catkin_ws/src/learning_service
• mkdir srv
• cd srv
• touch Person.srv
• vi Person.srv
• string name
  uint8 age
  uint8 sex
  uint8 unknown = 0
  uint8 male = 1
  uint8 female = 2
  ---     （注意：此处三个横线，横线上方是客户端，横线下方是服务端）
  string result

在package.xml中添加功能包依赖

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

在CMakeLists.txt添加编译选项

find_package(……  message_generation)
add_service_files(FILES Person.srv)
generate_messages(DEPENDENCIES std_msgs)
catkin_package(…… message_runtime)

编译生成语言相关文件

• cd catkin_ws
• catkin_make

服务器

/*
 * 该例程将执行/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 informtion.");
    ros::spin();

    return 0;
}

客户端

/*
 * 该例程将请求/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 node;

    // 发现/show_person服务后，创建一个服务客户端，连接名为/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 = "Tom";
	srv.request.age  = 20;
	srv.request.sex  = learning_service::Person::Request::male;

    // 请求服务调用
	ROS_INFO("Call service to show person[name:%s, age:%d, sex:%d]", 
			 srv.request.name.c_str(), srv.request.age, srv.request.sex);

	person_client.call(srv);

	// 显示服务调用结果
	ROS_INFO("Show person result : %s", srv.response.result.c_str());

	return 0;
};

配置CMakeLists.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
• roscore    不能关闭，要一直运行
• rosrun learning_service person_server   
• rosrun learning_service person_client    

参数的使用与编程方法

• cd catkin/src
• catkin_create_pkg learning_parameter roscpp rospy std_srvs

参数命令行使用——YAML参数文件——rosparam

列出当前多有参数

• rosparam list

显示某个参数值

• rosparam get param_key

设置某个参数值

• rosparam set param_key param_value

保存参数到文件

• rosparam dump file_name

从文件读取参数

• rosparam load file_name

删除参数

• rosparam delete param_key

获取/设置参数

1. 初始化ROS节点；
2. get函数获取参数；
3. set函数设置参数；

/*
 * 该例程设置/读取海龟例程中的参数
 */
#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 node;

    // 读取背景颜色参数
	ros::param::get("/turtlesim/background_r", red);
	ros::param::get("/turtlesim/background_g", green);
	ros::param::get("/turtlesim/background_b", blue);

	ROS_INFO("Get Backgroud Color[%d, %d, %d]", red, green, blue);

	// 设置背景颜色参数
	ros::param::set("/turtlesim/background_r", 255);
	ros::param::set("/turtlesim/background_g", 255);
	ros::param::set("/turtlesim/background_b", 255);

	ROS_INFO("Set Backgroud Color[255, 255, 255]");

    // 读取背景颜色参数
	ros::param::get("/turtlesim/background_r", red);
	ros::param::get("/turtlesim/background_g", green);
	ros::param::get("/turtlesim/background_b", blue);

	ROS_INFO("Re-get Backgroud 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;
}

配置CMakeLists.txt中的编译规则

add_executable(parameter_config src/parameter_config.cpp)
target_link_libraries(parameter_config ${catkin_LIBRARIES})

编译并运行

• cd catkin_ws
• catkin_make
• roscore  
• rosrun turtlesim turtlesim_node
• rosrun learning_parameter parameter_config

ROS中的坐标系管理系统

TF功能包——默认保存10秒内的数据

• 五秒钟之前，机器人头部坐标系相对于全局坐标系的关系
• 机器人夹取的物体相对于机器人中心坐标系的位置
• 机器人中心坐标系相对于全局坐标系的位置

TF坐标变换的实现

• 广播TF变换
• 监听TF变换

机器人中的坐标变换

• roslaunch turtle_tf turtle_tf_demo.launch
• rosrun turtlesim turtle_teleop_key
• rosrun tf view_frames    可视化，记录5秒内所有关系，保存为pdf文件
• rosrun tf tf_echo turtle1 turtle2   显示两者坐标关系
• rosrun rviz rviz -d `rospack find turtle_tf`/rviz/turtle_rviz.rviz  三维可视化

TF坐标系广播与监听的编程

• cd catkin_ws/src
• catkin_create_pkg learing_tf roscpp rospy tf turtlesim

实现一个TF广播器

1. 定义TF广播器（TransformBroadcaster）
2. 创建坐标变换值；
3. 发布坐标变换（sendTransform）

/*
 * 该例程产生tf数据，并计算、发布turtle2的速度指令
 */

#include <ros/ros.h>
#include <tf/transform_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, "turtle_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;
};

实现一个TF监听器

1. 定义TF监听器；（TransformListener）
2. 查找坐标变换；（waitForTransform、 lookupTransform）

/*
 * 该例程监听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::Duration(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.publish(vel_msg);

		rate.sleep();
	}
	return 0;
};

配置CMakeLists.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
• rosrun turtlesim turtlesim_node
•  rosrun learning_tf turtle_tf_broadcaster __name:=turtle1_tf_broadcaster /turtle1
•  rosrun learning_tf turtle_tf_broadcaster __name:=turtle2_tf_broadcaster /turtle2
• rosrun learning_tf turtle_tf_listener
• rosrun turtlesim turtle_teleop_key

launch启动文件

通过XML文件实现多节点的配置和启动（可自动启动ROS Master）

Launch文件语法

<launch>

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

<node>

启动节点

• • <node pkg="package-name" type="executable-name" name="node-
    name" />
  • pkg：节点所在的功能包名称
  • type：节点的可执行文件名称
  • name：节点运行时的名
  • output 、respawn 、required 、ns 、args

<param> /
<rosparam>

设置ROS系统运行中的参数，存储在参数服务器中。

• • <param name="output_frame" value="odom"/>
  • name：参数名
  • value：参数值

加载参数文件中的多个参数：

• • <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文件路径

举例：xxx.launch

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

<launch>

	<include file="$(find learning_launch)/launch/simple.launch" />

    <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node">
		<remap from="/turtle1/cmd_vel" to="/cmd_vel"/>
	</node>

</launch>

 <launch>

    <!-- Turtlesim Node-->
    <node pkg="turtlesim" type="turtlesim_node" name="sim"/>
    <node pkg="turtlesim" type="turtle_teleop_key" name="teleop" output="screen"/>

    <node pkg="learning_tf" type="turtle_tf_broadcaster" args="/turtle1" name="turtle1_tf_broadcaster" />
    <node pkg="learning_tf" type="turtle_tf_broadcaster" args="/turtle2" name="turtle2_tf_broadcaster" />

    <node pkg="learning_tf" type="turtle_tf_listener" name="listener" />

  </launch>

常用可视化工具

Qt工具箱

日志输出工具

• rqt_console

计算图可视化工具

• rqt_graph

数据绘图工具

• rqt_plot

图像渲染工具

• rqt_image_view

Rviz三维可视化工具

可以使用可扩展标记语言XML对机器人、周围物体等任何实物进行尺寸、质量、位置、材质、关节等属性的描述，并且在界面中呈现出来。

可以通过图形化的方式，实时显示机器人传感器的信息、机器人的运动状态、周围环境的变化等信息。

通过机器人模型参数、机器人发布的传感信息等数据，为用户进行所有可监测信息的图形化显示。用户和开发者也可以在rviz的控制界面下，通过按钮、滑动条、数值等方式，控制机器人的行为。

启动界面

• rosrun rviz rviz

Gazebo三维物理仿真平台

应用场景包括

• 测试机器人算法
• 机器人的设计
  • 现实情景下的回溯测试

启动界面——有一系列仿真环境（虚拟机运行效果不好，可能运行不了）

• roslaunch gazebo_ros +Tab键选择环境
• roslaunch gazebo_ros willowgarage_world.launch