ros基础知识总结

超、凢脫俗 2023-02-23 10:59 20阅读 0赞

**目录**

ros基础总结

ros常用命令

创建工作空间

话题编程

服务编程

动作编程

ros分布式通信

--------------------

### ros基础总结 ###

1.
    创建工作空间并初始化
    创建功能包
    优先查找环境变量中的最前面的工作空间
    
    2.
    话题编程 和自定义msg并配置
    服务编程 和自定义srv并配置
    动作编程 和自定义action并配置
    
    分布式通信 
    3.
    launch文件
    tf坐标转换 和两个小乌龟跟随         
    
    rqt工具 rqt_console rqt_graph rqt_plot rqt_reconfigure
    rviz 数据可视化 插件机制 机器人模型 坐标 运动规划 导航 点云 图像 slam
    gazebo 三维物理仿真环境
    
    4.
    创建模型并控制
    将模型添加到gazebo中
    创建Gazebo仿真环境
     
    5.
    图像标定
    ros和opencv之间的转换
    视觉移动物体识别 二维码识别
    
    科大讯飞语音识别 合成和智能语音助手（交互）
    
    6.
    SLAM建图
    导航过程中同步SLAM构建地图
    moveit

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70][]

### ros常用命令 ###

catkin_create_pkg 创建包
     
    roscd 
    rosls 
    rospack find          
    rosnode list         列出所有正在运行的节点
    rosnode info package 显示某个节点信息
    rosrun package       运行某个包
     
    rostopic list 列出当前所有topic
    rostopic info 显示某个topic的属性信息
    rostopic type 显示某个topic的类型
    rostopic echo 显示某个topic的内容
    rostopic pub -r 10 [topic] [msg_type] --[args]  向某个topic发布内容
     
    rosservice list     输出可用服务的信息
    rosservice info     显示某个service的属性信息
    rosservice call     调用带参数的服务
    rosservice type     输出服务类型
    rosservice find     依据类型寻找服务find services by service type
    rosservice uri      输出服务的ROSRPC uri
     
    rosmsg list 列出所有msg
    rosmsg show 显示某个msg内容
    rossrv show 显示某个srv内容
     
    rosparam set  param_key param_name     设置参数
    rosparam get  param_key                获取参数
    rosparam load  file_name               从文件读取参数
    rosparam dump  file_name               向文件中写入参数
    rosparam delete  param_key             删除参数
    rosparam list                          列出参数名

### 创建工作空间 ###

创建工作空间
    mkdir -p ~/catkin_ws/src
    cd ~/catkin_ws
    
    编译工作空间
    catkin_make
    
    设置环境变量
    source devel/setup.bash
    
    检查环境变量
    echo $ROS_PACKAGE_PATH
    
    创建功能包
    catkin_create_pkg learning rospy roscpp std_msgs
    
    编译功能包
    cd ~/catkin_ws
    catkin_make
    source ~/catkin_ws/devel/setup.bash
    
    编译制定功能包
    catkin_make -DCATKIN_WHITELIST_PACKAGES="包名"

### 话题编程 ###

话题编程流程

1.  创建发布者
2.  创建订阅者
3.  添加编译选项
4.  运行可执行文件

如何实现一个发布者
    1.初始化ROS节点
    2.向ROS Master注册节点信息,包括发布的话题名和话题中的消息类型
    3.按一定频率循环发布消息

/**
     * 该例程将发布chatter话题，消息类型String
     * talker.cpp
     */
     
    #include <sstream>
    #include "ros/ros.h"
    #include "std_msgs/String.h"
    
    int main(int argc, char **argv)
    {
      // ROS节点初始化
      ros::init(argc, argv, "talker");
      
      // 创建节点句柄
      ros::NodeHandle n;
      
      // 创建一个Publisher，发布名为chatter的topic，消息类型为std_msgs::String
      ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
    
      // 设置循环的频率
      ros::Rate loop_rate(10);
    
      int count = 0;
      while (ros::ok())
      {
    	// 初始化std_msgs::String类型的消息
        std_msgs::String msg;
        std::stringstream ss;
        ss << "hello world " << count;
        msg.data = ss.str();
    
    	// 发布消息
        ROS_INFO("%s", msg.data.c_str());
        chatter_pub.publish(msg);
    
    	// 循环等待回调函数
        ros::spinOnce();
    	
    	// 按照循环频率延时
        loop_rate.sleep();
        ++count;
      }
    
      return 0;
    }

**如何实现一个订阅者**

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

/**
     * 该例程将订阅chatter话题，消息类型String
     * listener.cpp
     */
     
    #include "ros/ros.h"
    #include "std_msgs/String.h"
    
    // 接收到订阅的消息后，会进入消息回调函数
    void chatterCallback(const std_msgs::String::ConstPtr& msg)
    {
      // 将接收到的消息打印出来
      ROS_INFO("I heard: [%s]", msg->data.c_str());
    }
    
    int main(int argc, char **argv)
    {
      // 初始化ROS节点
      ros::init(argc, argv, "listener");
    
      // 创建节点句柄
      ros::NodeHandle n;
    
      // 创建一个Subscriber，订阅名为chatter的topic，注册回调函数chatterCallback
      ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
    
      // 循环等待回调函数
      ros::spin();
    
      return 0;
    }

**如何编译代码**

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

在CMakeLists.txt中加入
    
    add_executable(talker src/talker.cpp)
    target_link_libraries(talker ${catkin_LIBRARIES})
    # add_dependencies(talker ${PROJECT_NAME}_generate_messages_cpp)
    
    add_executable(listener src/listener.cpp)
    target_link_libraries(listener ${catkin_LIBRARIES})
    # add_dependencies(talker ${PROJECT_NAME}_generate_messages_cpp)

**运行代码**

1.启动roscore
    
    2.设置环境变量
    source ~/catkin_ws/devel/setup.bash
    
    3.运行发布者
    rosrun learning talker
    
    4.运行订阅者
    rosrun learning listener

**自定义msg话题消息**

话题person.msg数据定义
    
    string name
    uint8 sex
    uint8 age
    
    uint8 unknown=0
    uint8 male=1
    uint8 female=2

1.定义msg文件
    
    2.在package.xml中添加功能包依赖
     <build_depend>message_generation</build_depend>
     <exec_depend>message_runtime</exec_depend>
    
    3.在CMakeLists.txt中添加编译选项
      find_package( …… message_generation)
    
      catkin_package(CATKIN_DEPENDS geometry_msgs roscpp
      rospy std_msgs message_runtime)
    
      add_message_files(FILES Person.msg)
      generate_messages(DEPENDENCIES std_msgs)
    
    
    注：部分ros版本中的exec_depend需要改成run_depend

### 服务编程 ###

**服务编程流程**

1.  创建服务器
2.  创建客户端
3.  添加编译选项
4.  运行可执行程序

AddTwoInts.srv 数据格式
    
    int64 a
    int64 b
    ---
    int64 sum

1.定义srv文件
    
    2.在package.xml中添加功能包依赖
      <build_depend>message_generation</build_depend>
      <exec_depend>message_runtime</exec_depend>
    
    3.在CMakeLists.xml中添加编译选项
      find_package( …… message_generation)
    
      catkin_package(CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime)
    
      add_service_files(FILES AddTwoInts.srv)
    
      generate_messages(DEPENDENCIES std_msgs)

**如何实现一个服务器**

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

/**
     * AddTwoInts Server
     */
     
    #include "ros/ros.h"
    #include "learning_communication/AddTwoInts.h"
    
    // service回调函数，输入参数req，输出参数res
    bool add(learning_communication::AddTwoInts::Request  &req,
             learning_communication::AddTwoInts::Response &res)
    {
      // 将输入参数中的请求数据相加，结果放到应答变量中
      res.sum = req.a + req.b;
      ROS_INFO("request: x=%ld, y=%ld", (long int)req.a, (long int)req.b);
      ROS_INFO("sending back response: [%ld]", (long int)res.sum);
      
      return true;
    }
    
    int main(int argc, char **argv)
    {
      // ROS节点初始化
      ros::init(argc, argv, "add_two_ints_server");
      
      // 创建节点句柄
      ros::NodeHandle n;
    
      // 创建一个名为add_two_ints的server，注册回调函数add()
      ros::ServiceServer service = n.advertiseService("add_two_ints", add);
      
      // 循环等待回调函数
      ROS_INFO("Ready to add two ints.");
      ros::spin();
    
      return 0;
    }

**如何实现一个客户端**

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

/**
     * AddTwoInts Client
     */
     
    #include <cstdlib>
    #include "ros/ros.h"
    #include "learning_communication/AddTwoInts.h"
    
    int main(int argc, char **argv)
    {
      // ROS节点初始化
      ros::init(argc, argv, "add_two_ints_client");
      
      // 从终端命令行获取两个加数
      if (argc != 3)
      {
        ROS_INFO("usage: add_two_ints_client X Y");
        return 1;
      }
    
      // 创建节点句柄
      ros::NodeHandle n;
      
      // 创建一个client，请求add_two_int service，service消息类型是learning_communication::AddTwoInts
      ros::ServiceClient client = n.serviceClient<learning_communication::AddTwoInts>("add_two_ints");
      
      // 创建learning_communication::AddTwoInts类型的service消息
      learning_communication::AddTwoInts srv;
      srv.request.a = atoll(argv[1]);
      srv.request.b = atoll(argv[2]);
      
      // 发布service请求，等待加法运算的应答结果
      if (client.call(srv))
      {
        ROS_INFO("Sum: %ld", (long int)srv.response.sum);
      }
      else
      {
        ROS_ERROR("Failed to call service add_two_ints");
        return 1;
      }
    
      return 0;
    }

**编译代码**

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

add_executable(server src/server.cpp)
    target_link_libraries(server ${catkin_LIBRARIES})
    add_dependencies(server ${PROJECT_NAME}_gencpp)
    
    add_executable(client src/client.cpp)
    target_link_libraries(client ${catkin_LIBRARIES})
    add_dependencies(client ${PROJECT_NAME}_gencpp)

**运行可执行文件**

1.启动roscore
    
    2.设置环境变量
    source ~/catkin_ws/devel/setup.bash
    
    3.运行服务端
    rosrun learning server
    
    4.运行客户端
    rosrun learning client 3 5

### 动作编程 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70 1][]

**自定义动作消息**

DoDishes.action文件格式信息
    
    # 定义目标信息
    uint32 dishwasher_id  # Specify which dishwasher we want to use
    ---
    # 定义结果信息
    uint32 total_dishes_cleaned
    ---
    # 定义周期反馈的信息
    float32 percent_complete

1.定义action文件
    
    2.在package.xml中添加功能包依赖
      <build_depend>actionlib</build_depend>
      <build_depend>actionlib_msgs</build_depend>
      <exec_depend>actionlib</exec_depend>
      <exec_depend>actionlib_msgs</exec_depend>
    
    3.在CMakeLists.txt中添加编译选项
      find_package(catkin REQUIRED actionlib_msgs actionlib)
    
      add_action_files(DIRECTORY action FILES DoDishes.action)
    
      generate_messages(DEPENDENCIES std_msgs actionlib_msgs)

**实现一个动作服务器**

1.  初始化ROS节点
2.  创建动作服务器实例
3.  启动服务器，等待动作请求
4.  在回调函数中完成动作服务功能的处理，并反馈进度信息
5.  动作完成，发送结束信息

#include <ros/ros.h>
    #include <actionlib/server/simple_action_server.h>
    #include "learning_communication/DoDishesAction.h"
    
    typedef actionlib::SimpleActionServer<learning_communication::DoDishesAction> Server;
    
    // 收到action的goal后调用该回调函数
    void execute(const learning_communication::DoDishesGoalConstPtr& goal, Server* as)
    {
        ros::Rate r(1);
        learning_communication::DoDishesFeedback feedback;
    
        ROS_INFO("Dishwasher %d is working.", goal->dishwasher_id);
    
        // 假设洗盘子的进度，并且按照1hz的频率发布进度feedback
        for(int i=1; i<=10; i++)
        {
            feedback.percent_complete = i * 10;
            as->publishFeedback(feedback);
            r.sleep();
        }
    
        // 当action完成后，向客户端返回结果
        ROS_INFO("Dishwasher %d finish working.", goal->dishwasher_id);
        as->setSucceeded();
    }
    
    int main(int argc, char** argv)
    {
        ros::init(argc, argv, "do_dishes_server");
        ros::NodeHandle n;
    
        // 定义一个服务器
        Server server(n, "do_dishes", boost::bind(&execute, _1, &server), false);
        
        // 服务器开始运行
        server.start();
    
        ros::spin();
    
        return 0;
    }

**实现一个动作客户端**

1.  初始化ROS节点
2.  创建动作客户端实例
3.  连接动作服务端
4.  发送动作目标
5.  根据不同的服务端反馈处理回调函数

#include <actionlib/client/simple_action_client.h>
    #include "learning_communication/DoDishesAction.h"
    
    typedef actionlib::SimpleActionClient<learning_communication::DoDishesAction> Client;
    
    // 当action完成后会调用该回调函数一次
    void doneCb(const actionlib::SimpleClientGoalState& state,
            const learning_communication::DoDishesResultConstPtr& result)
    {
        ROS_INFO("Yay! The dishes are now clean");
        ros::shutdown();
    }
    
    // 当action激活后会调用该回调函数一次
    void activeCb()
    {
        ROS_INFO("Goal just went active");
    }
    
    // 收到feedback后调用该回调函数
    void feedbackCb(const learning_communication::DoDishesFeedbackConstPtr& feedback)
    {
        ROS_INFO(" percent_complete : %f ", feedback->percent_complete);
    }
    
    int main(int argc, char** argv)
    {
        ros::init(argc, argv, "do_dishes_client");
    
        // 定义一个客户端
        Client client("do_dishes", true);
    
        // 等待服务器端
        ROS_INFO("Waiting for action server to start.");
        client.waitForServer();
        ROS_INFO("Action server started, sending goal.");
    
        // 创建一个action的goal
        learning_communication::DoDishesGoal goal;
        goal.dishwasher_id = 1;
    
        // 发送action的goal给服务器端，并且设置回调函数
        client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);
    
        ros::spin();
    
        return 0;
    }

**编译代码**

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

add_executable(DoDishes_client src/DoDishes_client.cpp)
    target_link_libraries( DoDishes_client ${catkin_LIBRARIES})
    add_dependencies(DoDishes_client ${${PROJECT_NAME}_EXPORTED_TARGETS})
    
    add_executable(DoDishes_server src/DoDishes_server.cpp)
    target_link_libraries( DoDishes_server ${catkin_LIBRARIES})
    add_dependencies(DoDishes_server ${${PROJECT_NAME}_EXPORTED_TARGETS})

**运行可执行文件**

1.启动roscore
    
    2.设置环境变量
    source ~/catkin_ws/devel/setup.bash
    
    3.运行服务端
     rosrun learning_communication DoDishes_server
    
    4.运行客户端
     rosrun learning_communication DoDishes_client

### ros分布式通信 ###

首先需要确定ROS多机系统中的所有计算机处于同一网络，然后分别在计算机hcx-pc、raspi2上使用`ifconfig`命令查看计算机的局域网IP地址。  
分别在两台计算机系统的`/etc/hosts`文件中加入对方的IP地址和对应的计算机名：

# @hcx-pc，/etc/hosts
    192.168.31.14      raspi2
    
    # @raspi2，/etc/hosts
    192.168.31.198      hcx-pc

设置完毕后，分别在两台计算机上使用`ping`命令测试网络是否连通。

# @hcx-pc
    ping  raspi2
    
    # @raspi2
    ping  hcx-pc

如果双向网络都畅通，就说明底层网络的通信已经没有问题，接下来设置ROS相关的环境变量。

**设置ROS\_MASTER\_URI**

因为系统中只能存在一个Master，所以从机raspi2需要知道Master的位置。ROS Master的位置可以使用环境变量ROS\_MASTER\_URI进行定义，在从机raspi2上使用如下命令设置ROS\_MASTER\_URI：

export ROS_MASTER_URI=http://hcx-pc:11311
    
    但是以上设置只能在输入的终端中生效，为了让所有打开的终端都能识别，最好使用如下命令将环境变量的设置加入终端额配置文件中。
    echo ''export ROS_MASTER_URI=http://hcx-pc:11311'' >> ~/.bashrc

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200707101359231.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200710160044782.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4=,size_16,color_FFFFFF,t_70