ROS学习与实践：从基础到进阶-优快云博客

本文链接：https://blog.youkuaiyun.com/L_T_W/article/details/118419857

ROS学习笔记

笔记记录

笔记记录

摄像头操作

查看摄像头是否挂载及挂载的USB端口号

1、查看摄像头是否已经挂载的命令

方法一:

ls /dev/video*

方法二：

ls /dev | grep video

或

ls /dev | grep video*

2、如果有多个USB端口，则通过以下命令查看摄像头挂载的端口号

ls -l /sys/class/video4linux/video*

Ubuntu 打开摄像头

sudo apt-get install guvcview

guvcview -d /dev/video

ROS 安装问题

ubuntu rosdep update出错

https://ghproxy.com/支持github的资源代理，非常好用，我们将用此代理加速rosdep对Github Raw的访问，进而解决rosdep update超时问题。
方法取自博主：leitu_wt
1.定位rosdep资源下载函数：数名为download_rosdep_data，位于/usr/lib/python2.7/dist-packages/rosdep2/sources_list.py，添加

url="https://ghproxy.com/"+url

在这里插入图片描述

2.用同样的方法修改/usr/lib/python2.7/dist-packages/rosdistro/init.py里面的DEFAULT_INDEX_URL。
即将DEFAULT_INDEX_URL 进行如下替换：

DEFAULT_INDEX_URL = 'https://ghproxy.com/https://raw.githubusercontent.com/ros/rosdistro/master/index-v4.yaml'

除此处外，下述文件中也含有github地址，分别是：

/usr/lib/python2.7/dist-packages/rosdep2/gbpdistro_support.py 36行
/usr/lib/python2.7/dist-packages/rosdep2/sources_list.py 72行
/usr/lib/python2.7/dist-packages/rosdep2/rep3.py	39行
/usr/lib/python2.7/dist-packages/rosdistro/manifest_provider/github.py 68行 119行

github 下载加速

加速链接

https://shrill-pond-3e81.hunsh.workers.dev/

学习相关资料

ubuntu快速入门

终端操作

https://blog.youkuaiyun.com/hello_new_life/article/details/75099249

系统学习

https://www.bilibili.com/video/BV1na4y1773c

编程基础C++ and pythonROS

使用的编程语言主要有 C++和 python，所以也有针对这两种语言的功能支持包 roscpp 和 rospy。针对用户快速上手 ROS 和进一步提升编程能力的需求，我们给出两种语言的快速入门和系统学习的推荐参考教程以及相关资料。同时为了方便开发，推荐在 Linux 环境下分别使用 Clion 和 Pycharm 作为 C++和 Python 的 IDE，此处也附上安装教程链接。

C++

快速入门教程：
http://wiki.ros.org/roscpp/Tutorials

系统学习教程：

https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=7599566888210019373

推荐资料：《C++ Primer》

Clion 安装：

https://blog.youkuaiyun.com/wfei101/article/details/82193140

Python

快速入门教程：
http://wiki.ros.org/rospy_tutorials

系统学习教程：

https://www.bilibili.com/video/BV1c4411e77t?from=search&seid=11983732368546479265

推荐资料：《Python 编程，从入门到实践》

Pycharm 安装：

https://blog.youkuaiyun.com/xiaozaizi666/article/details/84137768

ros c++

工作空间准备

创建工作空间

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

install 安装空间产生

catkin_make install

创建功能包

创建

cd ~/catkin_ws/src
catkin_create_pkg test_pkg std_msgs roscpp rospy

编译

cd ~/catkin_ws
catkin_make
source devel/setup.bash

检查环境变量

echo $ROS_PACKAGE_PATH

结果：

/home/user/catkin_ws/src:/opt/ros/melodic/share

Publisher实现

实现话题发布控制海龟

创建功能包

catkin_create_pkg learning_topic std_msgs roscpp rospy geometry_msgs turtlesim

编写程序

#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

int main() {
    //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 vel_msg;
        vel_msg.linear.x = 0.5;
        vel_msg.angular.z = 0.2;
        //发布消息
        turtle_vel_pub.publish(vel_msg);
        ROS_INFO("Publish 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

在build最后加入以下两行

#将cpp文件编译成可执行文件
add_executable(velocity_publisher src/velocity_publisher.cpp)
#可执行文件与ROS库做链接
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})

编译

cd ~/catkin_ws
catkin_make
source devel/setup.bash

执行展示效果

roscore
rosrun turtlesim turtlesim_node
rosrun  learning_pkg velocity_publisher

subscriber实现

#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::init(argc, argv, "pose_subscriber");
    ros::NodeHandle n;
    ros::Subscriber pose_sub = n.subscribe("/turtle1/pose",10,poseCallback);
    ros::spin();
    return 0;
}

键盘控制

rosrun turtlesim turtle_teleop_key

消息的定义和使用

自定义消息类型，并创建发布者和话题订阅

自定义话题消息

消息内容定义Person.msg

string name
uint8 sex
uint8 age

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

在package.xml添加功能包依赖

  <!--package.xml添加功能包依赖-->
  <build_depend>message_generation</build_depend>
  <exec_depend>message_runtime</exec_depend>

在pCMakeLists.txt添加编译选项

## 依赖功能包
find_package(catkin REQUIRED COMPONENTS
  geometry_msgs
  roscpp
  rospy
  std_msgs
  turtlesim
  message_generation
)

## Generate added messages and services with any dependencies listed here
# generate_messages(
#   DEPENDENCIES
#   geometry_msgs#   std_msgs
# )
## 编译成不同的文件 配置项
add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)


################################################
## Declare ROS dynamic reconfigure parameters ##
################################################

catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES learning_topic
  CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs turtlesim message_runtime
#  DEPENDS system_lib
)

编译

catkin_make
生成Person.h

Publisher实现

person_publisher.cpp

//
// Created by wlt on 2021/8/8.
//
#include <ros/ros.h>
#include "learning_topic/Person.h"

int main(int argc, char **argv) {
    //
    ros::init(argc, argv, "person_publisher");
    //
    ros::NodeHandle n;
    //
    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 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;

}

动态依赖关系

add_executable(person_publisher src/person_publisher.cpp)
target_link_libraries(person_publisher ${catkin_LIBRARIES})
add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)

Subscriber实现

person_subscriber.cpp

//
// Created by wlt on 2021/8/8.
//

#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::init(argc,argv,"person_subscriber");

    ros::NodeHandle n;

    ros::Subscriber person_info_sub =n.subscribe("/person_info",10,personInfoCallback);

    ros::spin();


    return 0;
}

动态依赖关系

add_executable(person_subscriber src/person_subscriber.cpp)
target_link_libraries(person_subscriber ${catkin_LIBRARIES})
add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messages_cpp)

client实现

创建learning_service功能包

catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim

编写程序turtle_spawn.cpp


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

int main(int argc, char **argv) {
    ros::init(argc,argv,"turtlr_spawn");
    ros::NodeHandle node;
    //等待服务开启
    ros::service::waitForService("spawn");
    //创建服务客户端,连接名为/spawn的service
    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());
    add_turtle.call(srv);
    //显示服务调用结果
    ROS_INFO("Spawn turtle successfully[name:%s]",srv.response.name.c_str());

    return 0;

}

运行海龟

rosrun turtlrsim turtlesim_node

server实现

编写程序turtle_command_server.cpp

#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <std_srvs/Trigger.h>

ros::Publisher turtle_vel_pub;
bool pubCommand = false;

//service
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::init(argc, argv, "turtle_command_server");
    ros::NodeHandle node;
    //创建/turtle_command 的server,注册回调函数
    ros::ServiceServer command_service = node.advertiseService("/turtle_cammand", commandCallback);
    //创建publisher,名为：/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist
    turtle_vel_pub = node.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;
}

发送请求

rosservice call /turtle_cammand "{}"

服务数据的定义和使用

定义srv文件Person.srv

string name
uint8 sex
uint8 age

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

package.xml文件添加功能包依赖

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

CMakeLists.txt文件添加编译选项

find_package(catkin REQUIRED COMPONENTS
  message_generation
)

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

catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES learning_service
  CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs turtlesim message_runtime
#  DEPENDS system_lib
)

编译生成Person文件，devel/include/learning_service

Person.h
PersonRequest.h
PersonResponse.h

编写程序person_server.cpp

#include <ros/ros.h>
#include "learning_service/Person.h"

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::init(argc,argv,"person_server");
    ros::NodeHandle node;

    ros::ServiceServer person_service = node.advertiseService("/show_person",personCallback);


    //循环等待回调函数
    ROS_INFO("Ready to show person information");
    ros::spin();

    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)

编写程序person_client.cpp

#include <ros/ros.h>
#include "learning_service/Person.h"

int main(int argc,char **argv){
    ros::init(argc,argv,"person_client");
    ros::NodeHandle node;
    ros::service::waitForService("/show_person");
    ros::ServiceClient person_client=node.serviceClient
            <learning_service::Person>("/show_person");
    //初始化请求数据
    learning_service::Person srv;
    srv.request.name="Tom";
    srv.request.age=18;
    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_client src/person_client.cpp)
target_link_libraries(person_client ${catkin_LIBRARIES})
add_dependencies(person_client ${PROJECT_NAME}_gencpp)

参数的使用与编程方法

创建功能包

cd ~/catkin_ws/src
catkin_create_pkg learning_parameter roscpp rospy std_srvs

参数命令行使用

列出当前多有参数

rosparam list

显示某个参数值

rosparam get /turtlesim/background_b

设置某个参数值

rosparam set /turtlesim/background_b 0

发送服务更改

rosservice call /clear "{}"

保存参数到文件

rosparam dump param.yaml

保存到当前终端路径下

rosdistro: 'melodic

  '
roslaunch:
  uris: {host_wlt_gs65_stealth_9se__44773: 'http://wlt-GS65-Stealth-9SE:44773/'}
rosversion: '1.14.11

  '
run_id: 5e59e70e-0352-11ec-868f-7cb27df507bc
turtlesim: {background_b: 255, background_g: 86, background_r: 255}

从文件读取参数

rosparam load param.yaml

删除参数

rosparam delete param_key

程序操作

parammeter_config.cpp


#include <ros/ros.h>
#include <string>
#include <std_srvs/Empty.h>

int main(int argc, char **argv){
    int red, green, blue;

    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 Background 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 Background 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 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;


}

CMakefile 配置

## Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node
#   ${catkin_LIBRARIES}
# )

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

#############
## Install ##
#############

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

创建功能包

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

编写turtle_tf_broadcaster.cpp

#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::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与海龟坐标系之间的数据
    br.sendTransform(tf::StampedTransform(transform, ros::Time::now(), "world", turtle_name));
}

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

#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::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 loop_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);

        loop_rate.sleep();
    }
    return 0;
}

添加编译规则

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
roscore
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 turtlesim_teleop_key

坐标树查看

rosrun rqt_tf_tree rqt_tf_tree

launch启动文件的使用方法

Launch文件通过XML文件实现多节点启动，自动启动roscore

simple.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>

运行代码

roslaunch learning_launch simple.launch

simple.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>

turtlesim_parameter_config.launch

start_tf_demo_c++.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>

turtlesim_remap.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>

模拟话题发布者

rostopic pub /cmd_vel geometry_msgs/Twist "linear:
  x: 2.0
  y: 0.0
  z: 0.0
angular:
  x: 0.0
  y: 0.0
  z: 0.0"

常用可视化工具的使用方法

ROS_rqt 介绍

rqt_console 日志输出工具

roscore
rosrun turtlesim turtlesim_node 
rqt_console

2021-07-02

ROS学习笔记

笔记记录

摄像头操作

查看摄像头是否挂载及挂载的USB端口号

Ubuntu 打开摄像头

ROS 安装问题

ubuntu rosdep update出错

github 下载加速

加速链接

学习相关资料

ubuntu快速入门

终端操作

系统学习

编程基础C++ and pythonROS

C++

Python

ros c++

工作空间准备

创建工作空间

install 安装空间产生

创建功能包

检查环境变量

Publisher实现

创建功能包

编写程序

修改CMakeLists.txt

编译

执行展示效果

subscriber实现

键盘控制

消息的定义和使用

自定义话题消息

消息内容 定义Person.msg

在package.xml添加功能包依赖

在pCMakeLists.txt添加编译选项

编译

Publisher实现

person_publisher.cpp

动态依赖关系

Subscriber实现

person_subscriber.cpp

动态依赖关系

client实现

创建learning_service功能包

编写程序turtle_spawn.cpp

运行海龟

server实现

编写程序turtle_command_server.cpp

服务数据的定义和使用

定义srv文件Person.srv

package.xml文件添加功能包依赖

CMakeLists.txt文件添加编译选项

编译生成Person文件，devel/include/learning_service

编写程序person_server.cpp

CMakeLists.txt文件添加编译选项

编写程序person_client.cpp

CMakeLists.txt文件添加编译选项

参数的使用与编程方法

创建功能包

参数命令行使用

程序操作

parammeter_config.cpp

CMakefile 配置

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

创建功能包

编写turtle_tf_broadcaster.cpp

编写turtle_tf_listener.cpp

添加编译规则

编译并运行

坐标树查看

launch启动文件的使用方法

simple.launch

simple.launch

turtlesim_parameter_config.launch

start_tf_demo_c++.launch

turtlesim_remap.launch

模拟话题发布者

常用可视化工具的使用方法

rqt_console 日志输出工具

消息内容定义Person.msg