ros1 基础通信

为争。

已于 2024-06-27 14:06:22 修改

阅读量1.4k

点赞数 1

分类专栏： ROS 文章标签：学习

于 2023-01-24 21:33:39 首次发布

本文链接：https://blog.csdn.net/ohhjack/article/details/128756357

版权

ROS 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1 ROS核心概念

1.1 节点（Node）

（1）执行具体任务的进程、独立运行的可执行文件

（2）不同节点可以使用不同的语言，可分布式运行在不同的主机

（3）节点在系统中的名称必须是唯一的

1.2 节点管理器（ROS Master）

（1）为节点提供命名和注册服务

（2）跟踪和记录话题/服务通信，辅助节点相互查找、建立连接

（3）提供参数服务器，节点使用此服务器存储和检索运行时的参数

1.3话题（Topic）异步通信机制

（1）节点间用来传输数据的重要总线

（2）使用发布/订阅模型，数据由发布者传输到订阅者，同一个话题的订阅者或发布者可以不唯一

1.4消息（Message）话题数据

（1）具有一定的类型和数据结构，包括ROS提供的标准类型和用户自定义类型

（2）使用编程语言无关的.msg文件定义，编译过程中生成对应的代码文件

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

（1）使用客户端/服务器（C/S）模型，客户端发送请求数据，服务端完成处理后返回应答数据

（2）使用编程语言无关的.srv文件定义请求和应答数据结构，编译过程中生成对应的代码文件

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

（1）可通过网络访问的共享、多变量字典

（2）字节使用此服务器来存储和检索运行时的参数

（3）适合存储静态、非二进制的配置参数，不适合存储动态配置的数据

2 ROS命令行工具

2.1 小海龟

启动ROS Master

roscore

启动小海龟仿真器

rosrun turtlesim turtlesim_node

启动海归控制节点

rosrun turtlesim turtle_teleop_key

2.2 rqt基于qt的可视化工具

rqt_graph

回车之后出现以下窗口，是以图形显示节点和消息之间的相关关系的工具

2.3 rosnode

2.3.1查看某一个节点的ping值

rosnode ping /节点名称

2.3.2将系统中所有的节点都列出来

rosnode list

2.3.3查看某一个节点的具体信息

rosnode info /节点名称

2.3.4查看运行的机器名称

rosnode machine

2.3.5杀死ros节点

rosnode kill

2.4 rostopic

2.4.1打印系统中所有的话题列表

rostopic list

2.4.2发布数据给某一个topic

rostopic pub /话题名 /话题消息类型

例如小海龟

输入

rostopic pub /turtle1/cmd_vel 按下tab 按下tab

出现以下情况，即可设置小海龟的速度和角度

在速度x方向改为1之后，海归会前行一段距离即停下，因为执行后默认运行一次，此时需要在pub后加上-r +频率，例如加上-r 10 即以10Hz的频率执行，1s发布10次1m/s的指令

rostopic pub -r 10 /turtle1/cmd_vel 按下tab 按下tab

2.5 rosmsg

查看数据结构，例如查看上一个小海龟的数据结构，show后边的是上边按两次tab出来的

rosmsg show geometru_msgs/Twist

2.6 rosservice

2.6.1 查看所有service的内容

rosservice list

2.6.2产生新的内容

例如小海龟中产生新的海归

rosservice call /spawn Tab

然后更改x、y和名称

2.7 rosbag

记录ros中所有内容并保存下来

rosbag record -a -O cmd_record

话题复现

rosbag play cmd_record.bag

3 工作空间与功能包

3.1 工作空间

工作空间（workspace）是一个存放工程开发相关文件的文件夹

src：代码空间（Source Space）

build：编译空间（Build Space）

devel：开发空间（Development Space）

install：安装空间（Install Space）

3.2 建立过程

3.2.1创建工作空间

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace

3.2.2编译工作空间

cd ~/catkin_ws/
catkin_make

3.2.3产生install文件

catkin_make install

3.2.4设置环境变量

source devel/setup.bash

3.2.5检查环境变量

echo $ROS_PACKAGE_PATH

3.3 创建功能包

3.3.1创建功能包

catkin_create_pkg <package name> [depend1] [depend2] [depend3]

cd ~/catkin_ws/src
catkin_create_pkg test_pkg std_msgs rospy roscpp

3.3.2编译功能包

cd ~/catkin_ws
catkin_make
source ~/catkin_ws/devel/setup.bash

4 发布者Publisher编程实现

通过编程使海龟动起来

4.1创建一个功能包并编译

cd ~/catkin_ws/src
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim.
cd ..
catkin_make

4.2 如何实现一个发布者

（1）初始化ROS节点

（2）向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型

（3）创建消息数据

（4）按照一定的频率循环发布信息

4.3代码实现

在创建的功能包learning_topic功能包中的src中创建一个cpp文件velocity_publisher.cpp

/**
 * 该例程将发布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中编译规则

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

add_executable：将第二个位置的文件编译成第一个可执行文件

target_link_libraries：将ROS的可执行文件与ROS的库进行链接

编译并运行发布者

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

rosrun turtlesim turtlesim_node

source devel/setup.bash
rosrun learning_topic velocity_publisher

5 订阅者Subscriber编程实现

使用订阅者定位海龟的位置信息

5.1 如何实现一个订阅者

（1）初始化ROS节点

（2）订阅需要的话题

（3）循环等待话题消息，接收到消息后进入回调函数

（4）在回调函数中完成消息处理

5.2 代码实现

/**
 * 该例程将订阅/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中编译规则

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

add_executable：将第二个位置的文件编译成第一个可执行文件

target_link_libraries：将ROS的可执行文件与ROS的库进行链接

编译并运行发布者

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

rosrun turtlesim turtlesim_node

source devel/setup.bash
rosrun learning_topic pose_subscriber

6 话题消息的订阅和使用

传输一个名称、年龄等个人信息

6.1 如何自定义话题消息

（1）定义msg文件，即定义

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

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

(3)在CMakeLists.txt中增加编译选项

find_package(...... message_generation)

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

catkin_package(...... message_runtime)

（4）编译生成语言相关文件

6.2 代码编写

（1）Person.msg文件

string name
uint8 sex
uint8 age

uint8 unknown
uint8 male=1
uint8 female=2

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

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

(3)在CMakeLists.txt中增加编译选项

find_package(...... message_generation)

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

catkin_package(...... message_runtime)

（4）代码

Person_publisher.cpp

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将发布/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_subscriber.cpp

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将订阅/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
source devel/setup.bash
roscore

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_topic person_subscriber

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_topic person_publisher

7 客户端Client的编程实现

7.1 如何实现一个客户端

（1）初始化ROS节点

（2）创建一个Client实例

（3）发布服务请求数据

（4）等待Server处理之后的应答结果

7.2 代码实现

（1）创建功能包

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

（2）turtle_spawn.cpp

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

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

（3）CMakeLists.txt增加代码

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

(4)编译

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

cd ~/catkin_ws
source devel/setup.bash
rosrun turtlesim turtlesim_node

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_service turtle_spawn

8 服务端Server的编程实现

8.1 如何实现一个服务器

（1）初始化ROS节点

（2）创建Server实例

（3）循环等待服务请求，进入回调函数

（4）在回调函数中完成服务功能的处理，并反馈应答数据

8.2 代码实现

（1）在CMakeLists.txt中增加代码

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

（2）编译并运行服务器

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

cd ~/catkin_ws
source devel/setup.bash
rosrun turtlesim turtlesim_node

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_service turtle_command_server

cd ~/catkin_ws
source devel/setup.bash
rosservice call/turtle_command "{}"

9 服务数据的定义与使用

9.1 如何创建一个服务数据

（1）定时srv

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

（3）在CMakeLists.txt添加编译选项

（4）编译生成语言相关文件

9.2 代码实现

（1）Person.srv

string name
uint8 age
uint8 sex

uint8 unknown=0
uint8 male=1
uint8 female=2

---
string result

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

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

（3）在CMakeLists.txt中添加编译选项

find_package(...... message_generation)

add_service_files(FILES Person.srv)
generate_messages(DEPENDENCIES std_msgs)

catkin_package(...... message_runtime)

（4）编译生成语言相关文件

（5）代码

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

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

    // 发现/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 = "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;
};

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将执行/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;
}

（6）配置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)

（7）编译

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_service person_server

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_service person_client

10 参数的使用与编程方法

10.1 新建一个参数模型

（1）新建pkg

cd ~/catkin_ws/src
catkin_create_pkg learning_parameter roscpp rospy std_srvs

(2)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：删除参数

若更改颜色保存：rosservice call /clear "{}"

（3）代码

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程设置/读取海龟例程中的参数
 */
#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("/background_r", red);
	ros::param::get("/background_g", green);
	ros::param::get("/background_b", blue);

	ROS_INFO("Get Backgroud 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 Backgroud Color[255, 255, 255]");

    // 读取背景颜色参数
	ros::param::get("/background_r", red);
	ros::param::get("/background_g", green);
	ros::param::get("/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;
}

（4）CMakeLists.txt中增加编译规则

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

（5）运行程序后海龟背景变成白色

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore

cd ~/catkin_ws
source devel/setup.bash
rosrun turtlesim turtlesim_node

cd ~/catkin_ws
source devel/setup.bash
rosrun learning_parameter parameter_config

11 ROS中的坐标系管理

sudo apt-fet install ros-melodic-turtle-tf
roslaunch turtle_tf turtle_tf_demo.launch
rosrun turtlesim turtle_teleop_key

查看坐标关系

rosrun tf view_frames

rosrun tf tf_echo turtle1 turtle2

rosrun rviz rviz -d ·rospack find turtle_tf· /rviz/turtle_rviz.rviz

12 tf坐标系广播与监听

12.1 如何实现一个tf广播器

（1）定义TF广播器

（2）创建坐标变换值

（3）发布坐标变换

12.2 代码实现

（1）创建功能包

cd ~/catkin_ws/src
catkin_create_pkg learning_tf roscpp rospy tf turtlesim

(2)创建tf广播器

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程产生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, "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;
};

12.3 如何实现一个TF监听器

（1）定义TF监听器

（2）查找坐标变换

12.4 代码实现

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程监听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;
};

12.5 编译

（1）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})

（2）运行

cd ~/catkin_ws
catkin_make
source devel/setup.bash
roscore 

source devel/setup.bash
rosrun turtlesim turtlesim_node

source devel/setup.bash
rosrun learning_tf tule_tf_broadcaster __name:=turtle1_tf_broadcaster /turtle1

source devel/setup.bash
rosrun learning_tf turtle_tf_broadcaster __name:=turtle2_tf_broadcaster /turtle2

cd ~/catkin_ws/devel/lib/learning_tf
rosrun learning_tf turtle_tf_listener

cd ~/catkin_ws
source devel/setup.bash
rosrun turtlesim turtle_teleop_key

13 launch文件使用

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

13.1 语法

<launch>

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

<launch>开头

</launch>结尾

<node>启动节点

<node pkg="package-name" type="exectable-name" name="node-name"/>

pkg：节点所在的功能包名称

type：节点的可执行文件名称

name：节点运行时的名称

output、respawn、required、ns、args

<param/rosparam>设置ROS系统中运行的参数，存储在参数服务器中

<param neme="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_val"/>
form：原命名
to：映射之后的命名

<include>包含其他launch文件，类似C语言中的头文件包含

<include file="$(dirname)/other.launch"/>
file：包含的其他launch文件路径

13.2 启动方式

roslaunch 功能包名 launch文件名

14 可视化工具

rqt工具

rqt：综合工具

rqt_console：日志输出工具

rqt_graph：计算可视化工具

rqt_plot：数据绘图工具

rqt_image_view：图像渲染工具

Rviz工具

启动方式：

roscore

rosrun rviz rviz

Gazebo

很强大的三维物理仿真平台

roslaunch gezebo_ros

为争。

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
ros1 基础通信

ros
复制链接

扫一扫

专栏目录