ROS入门21讲 | ROS机器人入门教程 【简明笔记】

古月·ROS入门21讲 | 一学就会的ROS机器人入门教程

文章目录

    • ROS核心概念
    • ROS命令行
    • 工作空间与功能包
    • 订阅与发布
      • 发布者 Publisher
      • 订阅者 Subscriber
      • 话题消息的自定义与使用
    • 服务与客户端
      • 客户端 Client
      • 服务端 Server
      • 服务数据的自定义
    • 参数的使用与编程
    • ROS中的坐标管理系统 TF
      • TF坐标系广播与监听
    • launch启动文件的使用方法
    • 可视化工具

ROS核心概念

  1. ROS = 通信机制+开发工具+应用功能+生态系统

  2. 通信机制

    • Node:完成具体功能的进程、独立运行的可执行文件。可用多种语言py、c++。节点在系统中的名称唯一。

    • ROS Master:为节点提供命名注册服务;跟踪和记录话题、服务通信,节点之间建立连接;提供参数服务器,记录全局变量值。(管理Node)

    • Topic:节点间用来传输数据的重要总线;使用publisher/subscriber模型,单向数据传输有发布者传输到订阅者,同一个话题的订阅者或者发布者不唯一。(异步通讯)

      ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第1张图片

      Message:具有一定的类型和数据结构,包括ROS提供的标准类型和用户自定义类型;使用编程语言无关的.msg文件定义。

    • Service:(同步通讯机制):使用Client/Server模型,客户端发送请求数据,服务器完成处理后返回应答数据;使用编程语言无关的.srv文件定义。请求一次应答一次,带反馈。一个server,多个client。

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第2张图片
ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第3张图片

  1. 参数Parameter:全局共享字典

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

    • 借点使用此服务器来存储和检索运行时的参数

    • 存储静态、非二进制配置参数

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第4张图片

  1. 功能包Package:ROS软件基本单元,包含节点源码、配置文件、数据定义

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第5张图片

ROS命令行

  1. roscore:启动ros master

    rosrun:启动节点 TAB键查看包含节点

    rqt_graph:显示系统计算图。

    rosnode list:显示系统中所有节点

    rosnode info:显示节点信息,正在发布/订阅的话题

    rostopic:查看话题

    rosmsg show:显示消息的数据结构

    rosservice list:服务列表

    rossrv show std_srvs/Trigger:查看数据结构

    rosrecord -a -O cmd_record :话题记录

    rosbag play cmd_record.bag:复现指令

    //发布指令让乌龟移动 -r 10:rate,发布话题数据内容的频率,10hz
    //rostopiv pub /话题名 消息结构(内容)数据
    //如Twist数据结构有linear线速度和angular角速度两个结构
    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: 0.0"
    

工作空间与功能包

  1. 工作空间 workspace _ws:一个存放工程开发相关文件的文件夹。

    • src:代码空间 Source Space。 功能包、launch文件
    • build:编译空间 Build Space。
    • devel:开发空间 Development Space。编译生成的可执行文件。
    • install:安装空间 Install Space
  2. 在系统中创建工作空间并进行编译:

    //创建工作空间
    mkdir -p ~/catkin_ws/src
    cd ~/catkin_ws/src
    catkin_init_workspace
    //编译工作空间
    cd ~/catkin_ws/
    catkin_make
    //设置环境变量
    source devel/setup.bash
    //检查环境变量
    echo $ROS_PACKAGE_PATH
    

tf::MessageFilter结构:
定义数据:TransformListener、message_filters::Subscriber、tf::MessageFilter,用消息的名称来初始化 message_filters::Subscriber。用 tf、message_filters::Subscriber、目标坐标系来初始化 tf::MessageFilter,给 tf::MessageFilter 注册 callback。编写 callback,并在回调中完成坐标转换。至此完成消息订阅+坐标转换。

订阅与发布

发布者 Publisher

  1. 话题模型

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第6张图片

//创建功能包
// _ws/src目录下 catkin_create_pkg 功能包名
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim
  1. 实现发布
    • 初始化ROS节点,创建节点句柄
    • 向ROS Master注册节点信息,包括发布的话题名和话题中的消息类型
    • 创建消息数据
    • 按频率发布消息
//C++
//创建发布者代码 发布tuetle1/cmd_vel 话题,消息类型geometry_msgs::Twist
#include 
#include //消息数据类型头文件

int main (int argc, char **argv)
{
    //ROS节点初始化 节点名Velocity_publisher
    ros::init(argc,argv,"velocity_publisher");
    //创建节点句柄 管理ROS API资源,调用
    ros::Nodehandle n;
    //创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10 
    //  发布者名 = 句柄.advertise<消息类型>("话题名",队列长度)
    ros::Publisher turtle_vel_pub = n.advertise("/turtle1/cmd_vel",10);
    //设置循环频率 不断publish
    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); //由发布者发布消息,消息即vel_msg
        ROS_INFO("Publish turtle velocity command[%0.2f m/s, %0.2f rad/s]", vel_msg.linear.x,vel_msg.angular.z);//printf 输出
        //按照循环频率延时
        loop_rate.sleep();
    }
    return 0;
}

#Python 存放于scripts文件夹下,要设置为可执行文件即可用rosrun执行 
#!/usr/bin/python是告诉操作系统调用/usr/bin下的python解释器来执行这个脚本。例如,我们编写了hello.py脚本,执行时需要输入命令:python hello.py。因为有了这行声明,就可以直接用./hellp.py 来执行了,在这之前需要给脚本设置可执行权限chmod +x hello.py。
#!/usr/bin/env python是为了防止没有将python装在默认的/usr/bin路径里。当系统看到这一行的时候,首先会到env设置里查找python的安装路径,再调用对应路径下的解释器程序完成操作,推荐这种写法。
#2.x版本的py文件一般默认的是ASCII码,如果文件里有中文,运行时会出现乱码,注释是中文也不行。因此,需要把文件编码类型改为utf-8的类型,输入# -*- coding:utf-8 -*-之后会把文件编码强制转换为utf-8。
#3.x版本的py文件的默认编码为Unicode,也就是说不用进行编码声明,可以直接使用中文了。


#!/usr/bin/env python
# -*- coding:utf-8 -*-
#创建发布者代码 发布tuetle1?cmd_vel 话题,消息类型geometry_msgs::Twist
import rospy
from geometry_msgs.msg import Twist
def velocity_publisher():
    #ROS节点初始化
    rospy,init_node('velocity_publisher',anonymous=True)
    #创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10 
    turtle_vel_pub = rospy.Publsiehr('/turtle1/cmd_vel',Twist,queue_size = 10)
    #设置循环频率 不断publish
    rate = rospy.Rate(10)
    
    while not rospy.is_shutdown():
        # 初始化geometry_msgs::Twist类型消息
        vel_msg = Twist()
        vel_msg.linear.x = 0.5
        vel_msg.angular.z = 0.2
        #发布消息
        turltle_vel_pub.publish(vel_msg)
        rospy.loginfo("Publish turtle velocity command[%0.2f m/s, %0.2f rad/s]",vel_msg.linear.x, vel_msg.angualr.z)
        #按照循环频率延时
        rate.sleep()
        
        if __name__ == '__main__':# 当模块被直接运行时,if...以下代码块将被运行,当模块是被导入时,代码块不被运行
            try:
                velocity_publisher()
                except rospy.ROSInterruptException:
                    pass
  1. 编译
##在CMakeLists.txt中加入 生成可执行文件和路径
add_executable(velocity_publisher src/velocity_publisher.cpp) 
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
//工作空间根目录
cd _ws
catkin_make
source devel/setup.bash //设置环境变量或可以把此行代码写入~/.bashrc
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisher

订阅者 Subscriber

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第7张图片

  1. 实现订阅
    • 初始化ROS节点
    • 订阅需要的话题
    • 循环等待话题消息,接收到消息后进入回调函数
    • 在回调函数中完成消息处理
//C++
//订阅/turtle1/pose话题,消息类型turtlesim::Pose
#include 
#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
    //订阅者:pose_sub,订阅话题:/turtle1/pose
    ros::Subscriber pose_sub = n.subscriber("/turtle1/pose", 10, poseCallback);
    //循环等待回调函数
    ros::;spin();//循环等待 查看队列,若有消息则调用poseCallback,否则死循环;缺少了某个资源,等到资源就绪之后,转换到就绪态,再等待上cpu执行;spin = 等待某个命令 = 直到命令到达 = 等着上cpu执行下一步
    return 0;
}
#Python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#订阅/turtle1/pose话题,消息类型turtlesim::Pose

import rospy
from turtlesim.msg import Pose
def poseCallback(msg):
    rospy.loginfo("Turtle pose: x:%0.6f, y:%0.6f", msg.x, msg.y)
def pose_subscriber():
        # 初始化ROS节点
        rospy.init_node('pose_subscriber', anonymous=True)
        # 创建一个Subscriber, 订阅名为/turtle1/pose的topic,注册回调函数poseCallback
        rospy.Subscriber("/turtle1/pose", Pose, poseCallback)
        # 循环等待回调函数
        rospy.spin()
if __name__ == '__main__': # 当模块被直接运行时,if...以下代码块将被运行,当模块是被导入时,代码块不被运行
    pose_subscriber()
       
  1. 编译

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

话题消息的自定义与使用

  1. 消息数据类型的自定义

    • 创建msg文件并定义

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

      编译依赖 功能包message_generation动态产生message
      <build_depend>message_generationbuild_depend>
      执行依赖
      <exec_depend>message_runtimeexec_depend>
      
    • CMakeLists.txt添加编译选项

      find_package( ...... message_generation)
      add_message_files(FILES Person.msg) //定义接口
      generate_messages(DEPENDENCIES std_msgs) //接口依赖库
      catkin_package( ...... message_runtime) //运行依赖
      
    • 编译生成可执行文件,将在devel中生成.h头文件。使用时需引用头文件自己定义并编译的.h

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第8张图片

//定义一个人的类型的消息Person.msg
//一般在msg文件夹下
string name 
uint8 sex
uint8 age
//宏定义    
uint8 unknown = 0
uint8 male = 1
uint8 female = 2

依赖添加多一项add_dependcies

add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)
add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messsages_cpp)
  1. 关闭roscore不影响已经建立联系的Publisher和Subscriber

服务与客户端

客户端 Client

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第9张图片

  1. 话题模型:Client端 请求节点,发布产生乌龟的request,server收到后产生response。

    • 创建功能包

      //在工作空间的src目录下
      cd ~/catkin_ws/src
      catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim
      
  2. 实现一个客户端

    • 初始化ROS节点
    • 创建Client实例
    • 发布服务请求数据
    • 等待Server处理之后的应答结果
 /**
  * 该例程将请求/spawn服务,服务数据类型turtlesim::Spawn
  */
 #include 
 #include  //数据类型头文件
 
 int main(int argc, char** argv)
 {
     // 初始化ROS节点
 	ros::init(argc, argv, "turtle_spawn");
     // 创建节点句柄
 	ros::NodeHandle node;
     // 发现/spawn服务后,创建一个服务客户端,连接名为/spawn的service
 	ros::service::waitForService("/spawn"); //查询系统里是否有/spawn服务,存在才能请求
     //创建名为add_turtle的客户端,请求名为/spawn、数据类型为turtle::Spawn的服务
 	ros::ServiceClient add_turtle = node.serviceClient("/spawn");
     // 初始化turtlesim::Spawn的请求数据
 	turtlesim::Spawn srv;//定义请求数据结构为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());//c_str()返回当前字符串的首字符地址
 	return 0;
 };
 
#python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将请求/spawn服务,服务数据类型turtlesim::Spawn
import sys
import rospy
from turtlesim.srv import Spawn

def turtle_spawn():
	# ROS节点初始化
    rospy.init_node('turtle_spawn')
	# 发现/spawn服务后,创建一个服务客户端,连接名为/spawn的service
    rospy.wait_for_service('/spawn')
    try:
        add_turtle = rospy.ServiceProxy('/spawn', Spawn)
		# 请求服务调用,输入请求数据
        response = add_turtle(2.0, 2.0, 0.0, "turtle2")#x,y,theta,name
        return response.name
    except rospy.ServiceException, e:
        print "Service call failed: %s"%e
if __name__ == "__main__":
	#服务调用并显示调用结果
    print "Spwan turtle successfully [name:%s]" %(turtle_spawn())
  1. 编译

    add_executable(turtle_spawn src/turtle_spawn.cpp)
    target_link_libraries(turtle_spawn ${catkin_LIBRARIES})
    ##工作空间根目录下
    catkin_make
    source devel/setup.bash
    roscore
    rosrun turtlesim turtlesim_node
    rosrun learning_service turtle_spawn
    

服务端 Server

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第10张图片

  1. 服务端server:给海龟发指令,接受request决定是不是要给海龟发指令。包含server和topic发布。

    触发信号Trigger 可用rossrv show std_srvs/Trigger查看数据结构

    • 初始化ROS节点
    • 创建Server实例
    • 循环等待服务请求,进入回调函数(已注册)
    • 在回调函数中完成服务功能的处理,并反馈应答数据
    /**
     * 该例程将执行/turtle_command服务,服务数据类型std_srvs/Trigger
     */
    #include 
    #include  //topic头文件
    #include  //server头文件
    
    ros::Publisher turtle_vel_pub; //全局publisher
    bool pubCommand = false; //标志位默认停止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");
    	// 设置反馈数据 数据结构来自于内置库的Trigger
    	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。收到request后,立刻进入回调函数
        ros::ServiceServer command_service = n.advertiseService("/turtle_command", commandCallback);
    	// 创建一个Publisher,发布名为/turtle1/cmd_vel的topic,消息类型为geometry_msgs::Twist,队列长度10。发送速度指令
    	turtle_vel_pub = n.advertise("/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;
    }
    
    #Python
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # 该例程将执行/turtle_command服务,服务数据类型std_srvs/Trigger
    import rospy
    import thread,time
    from geometry_msgs.msg import Twist
    from std_srvs.srv import Trigger, TriggerResponse
    
    pubCommand = False;
    turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
    def command_thread():	#线程,判断标志位;python只有spin没有spinonce
    	while True:
    		if pubCommand:
    			vel_msg = Twist()
    			vel_msg.linear.x = 0.5
    			vel_msg.angular.z = 0.2
    			turtle_vel_pub.publish(vel_msg)
    		time.sleep(0.1)
    
    def commandCallback(req):
    	global pubCommand
    	pubCommand = bool(1-pubCommand)
    	# 显示请求数据
    	rospy.loginfo("Publish turtle velocity command![%d]", pubCommand)
    	# 反馈数据
    	return TriggerResponse(1, "Change turtle command state!")
    def turtle_command_server():
    	# ROS节点初始化
        rospy.init_node('turtle_command_server')
    	# 创建一个名为/turtle_command的server,注册回调函数commandCallback
        s = rospy.Service('/turtle_command', Trigger, commandCallback)
    	# 循环等待回调函数
        print "Ready to receive turtle command."
        thread.start_new_thread(command_thread, ())
        rospy.spin()#循环直到收到数据,进入回调函数 
    if __name__ == "__main__":
        turtle_command_server()
    
  2. 编译

    add_executable(turtle_command_server src/turtle_command_server.cpp)
    target_link_libraries(turtle_command_server ${catkin_LIBRARIES})
    
    cd ~/..._ws
    catkin_make
    source devel/setup.bash
    roscore
    rosrun turtlesim turtlesim_node
    rosrun learning_service turtle_command_server
    rosservice call /turtle_command "{}"
    

服务数据的自定义

  1. 服务模型

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第11张图片

  • 自定义服务数据 创建新文件srv下,创建Person.srv文件并写入
string name 
uint8 age
uint8 sex

uint8 unknown = 0
uint8 male = 1
uint8 female = 2
---   //以上是request数据,以下是response数据
string result
  • 在package.xml中添加功能包依赖

    message_generation
    message_runtime
    
  • 在CMakeLists.txt文件中添加编译选项

    find_package( .... message_generation)#加功能包
    add_service_files(FILES Person.srv)#根据哪一个srv文件创建头文件
    generate_messages(DEPENDENCIES std_msgs)#根据文件定义产生头文件
    catkin_package( .... message_runtime)#添加编译依赖
    #工作空间根目录下
    catkin_make#成功后在include下会找到对应的头文件 
    
  1. 客户端

    /**
     * 该例程将请求/show_person服务,服务数据类型learning_service::Person
     */
    #include 
    #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("/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;
    };
    
    1. 服务端

      /**
       * 该例程将执行/show_person服务,服务数据类型learning_service::Person
       */
      #include 
      #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;
      }
      
    2. 编译

      add_executable(person_server src/person_server.cpp)
      target_link_libraries(person_servr ${catkin_LIBRARIES})
      add_dependencies(person_server ${PROJECT_NAME}_gencpp) #动态生成的cpp文件
      
      add_executable(person_client src/person_client.cpp)
      target_link-libraries(person_client ${catkin_LIBRARIES})
      add_dependencies(person_client ${PROJECT_NAME}_gencpp)
      
      # 工作空间根目录下
      catkin_make
      source devel/setup.bash #可写入系统环境变量bashrc,否则每次都要输入
      roscore 
      rosrun learning_service person_server
      rosrun learning_service person_client
      

参数的使用与编程

  1. 参数模型:各个节点可以全局访问参数服务器。参数文件.yaml

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第12张图片

  • 创建功能包

    cd ~/catkin_ws/src
    catkin_create_pkg learning_parameter roscpp rospy std_srvs
    
  • 参数命令行 修改参数后请求服务才能生效

    //显示参数列表
    rosparam list
    //获取参数
    rosparam get 
    //修改参数值
    rosparam set 变量名 变量值
    //保存参数到文件于当前路径下
    rosparam dump 文件名.yaml 
    //从文件读取参数
    rosparam load 文件名.yaml
    //删除参数
    rosparam delete 参数名
    
  1. 程序实现参数操作

    • 初始化ROS节点
    • get函数获取参数
    • set函数设置参数
    /**
     * 该例程设置/读取海龟例程中的参数
     */
    #include 
    #include 
    #include 
    
    int main(int argc, char **argv)
    {
    	int red, green, blue;
        // ROS节点初始化
        ros::init(argc, argv, "parameter_config");
        // 创建节点句柄
        ros::NodeHandle node;
        // 读取背景颜色参数 get("变量名",参数值存储到哪个变量中)
    	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("/clear");
    	std_srvs::Empty srv;
    	clear_background.call(srv);
    	sleep(1);
        return 0;
    }
    
    • 编译

      add_executable(parameter_config src/parameter_config.cpp)
      target_link_libraries(parameter_config ${catkin_LIBRARIES})
      #工作空间下
      catkin_make
      source devel/setup.absh
      roscore
      rosrun turtlesim turtlesim_node
      rosrun learning_parameter parameter_config
      

ROS中的坐标管理系统 TF

  1. 坐标变换工具TF:查询两坐标系之间的变换关系。通过广播监听实现。

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第13张图片

sudo apt-get install ros-melodic-turtlle-tf //ros-版本-功能包
roslaunch turtle_tf turtle_tf_demo.launch //.launch启动脚本文件中的诸多节点
rosrun turtlesim turtle_teleop_key
rosrun tf view_frames //tf功能包提供的查看系统中所有tf关系

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第14张图片

World坐标系:全局坐标系,不动。

rosrun tf tf_echo 坐标系1 坐标系2   //查询坐标关系
//Translation:平移,旋转:四元数/欧拉角RPY

TF基本的数据类型(Quaternion, Vector, Point, Pose, Transform)

ROS入门21讲 | ROS机器人入门教程 【简明笔记】_第15张图片

TF坐标系广播与监听

  1. 创建功能包

    $ cd ~/catkin_ws/src
    $ catkin_create_pkg learning_tf roscpp rospy tf turtlesim
    
  2. TF广播器:广播坐标系之间的关系

    • 定义TF广播器(TransformBroadcaster)

    • 创建坐标变换值

    • 发布坐标变换(sendTransform)

      /**
       * 该例程产生tf数据,并计算、发布turtle2的速度指令
       */
      #include 
      #include 
      #include 
      std::string turtle_name;
      
      void poseCallback(const turtlesim::PoseConstPtr& msg)
      {
      	// 创建tf的广播器
      	static tf::TransformBroadcaster br;
      	// 初始化tf数据
      	tf::Transform transform; //4x4矩阵 T
      	transform.setOrigin( tf::Vector3(msg->x, msg->y, 0.0) ); //平移参数
      	tf::Quaternion q; //旋转
      	q.setRPY(0, 0, msg->theta); //姿态变化
      	transform.setRotation(q);
      	// 广播world与海龟坐标系之间的tf数据 StampedTransform(变换矩阵,时间戳,坐标系1,坐标系2)
      	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;
      };
      
  3. TF监听器:获取任意两个坐标系之间关系

    • 定义TF监听器 TransformListener

    • 查找坐标变换 waitForTransform、lookupTransform

      /**
       * 该例程监听tf数据,并计算、发布turtle2的速度指令
       */
      #include 
      #include 
      #include 
      #include 
      
      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("/spawn");
      	turtlesim::Spawn srv;
      	add_turtle.call(srv);
      	// 创建发布turtle2速度控制指令的发布者
      	ros::Publisher turtle_vel = node.advertise("/turtle2/cmd_vel", 10);
      	// 创建tf的监听器
      	tf::TransformListener listener;
      	ros::Rate rate(10.0);
      	while (node.ok())
      	{
      		// 获取turtle1与turtle2坐标系之间的tf数据
      		tf::StampedTransform transform;//保存平移旋转关系
      		try
      		{
                   // waitForTransform(坐标系1,坐坐标系2,查询(当前)时间,等待时间)如果存在关系则程序往下走
      			listener.waitForTransform("/turtle2", "/turtle1", ros::Time(0), ros::Duration(3.0));
                   // lookupTransform(坐标系1,坐标系2,查询时间,结果保存于)
      			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;
      };
      
  4. 编译

    • 编译成可执行文件 add_executable

    • 添加链接 target_link_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 turtle_teleop_key
      

launch启动文件的使用方法

  1. 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:namespace,避免命名冲突
             args:输入参数
        node>
    <param> 设置ROS运行中的一个参数,存储在参数服务器中
        <param name="output_frame" value="odom"/>
        name:参数名
        value:参数值
        param>
        
    <rosparam>加载参数文件中的多个参数
        <rosparam file="params.yaml" command="load" ns="params" />
        rosparam>
        
    <arg> launch文件内部的局部变量,仅限于launch文件使用
        <arg name="arg-name" default="arg-value" />
        name:参数名
        value:参数值
        arg>
        调用
        
    <remap>重映射ROS计算图资源的命名
        <remap from="/turtlebot/cmd_vel" to="/cmd_vel" />
        from :原命名
        to:映射之后的命名
            param>
        
    <include>包含其他launch文件,类似于C语言中的头文件包含
        <include flle="$(dirname)/other.launch" />
        file:包含的其他launch文件路径
        include>
    
  2. 示例:开启两个node节点

    <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

    $ roslaunch 功能包 .launch
    
  3. 示例:配置参数

    <launch>
    	<param name="/turtle_number"   value="2"/> 
        <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node">
    		<param name="turtle_name1"   value="Tom"/>
    		<param name="turtle_name2"   value="Jerry"/> 
    		<rosparam file="$(find learning_launch)/config/param.yaml" command="load"/>
    	node>
        <node pkg="turtlesim" type="turtle_teleop_key" name="turtle_teleop_key" output="screen"/>
    launch>
    $(find learning_launch)系统搜索功能包
    
  4. 示例:启动海龟跟随

     <launch>
        
        <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>
    
  5. 示例:重映射以及include

    <launch>
    	<include file="$(find learning_launch)/launch/simple.launch" /> 启动这个launch文件所有内容
        <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node">
    		<remap from="/turtle1/cmd_vel" to="/cmd_vel"/>
    	node>
    launch>
    

可视化工具

  1. Qt工具箱

    • rqt_console日志输出工具
    • rqt_graph计算图可视化工具
    • rqt_plot数据绘图工具
    • rqt_image_view图像渲染工具
    • rqt工具箱
  2. Rviz:数据显示平台

    rosrun rviz rviz
    
  3. Gazebo:三维仿真平台

你可能感兴趣的:(机器人,自动驾驶,人工智能,c++,python)