CMakeList.txt 文件中的基本配置不再赘述

代码模板

c++ 模板

1
2
3
4
5
6
7
8
9
10
#include "ros/ros.h"

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"");
    ros::NodeHandle nh;

    return 0;
}

python 模板

1
2
3
4
5
6
7
#! /usr/bin/env python

import rospy

if __name__ == "__main__":
	rospy.init_node("")

ROS通信机制

先创建一个启动乌龟界面的launch文件

1
2
3
4
5
6
<launch>
    <!-- 乌龟GUI -->
    <node pkg="turtlesim" type="turtlesim_node" name="turtle1" output = "screen"/>
    <!-- 键盘控制 -->
    <node pkg="turtlesim" type="turtle_teleop_key" name="turtle_key" output = "screen" />
</launch>

实操1 话题发布

需求描述：编码实现乌龟运动控制，让小乌龟做圆周运动

实现分析：

  1. 乌龟运动控制实现，关键节点有两个，一个是乌龟运动显示节点 turtlesim_node，另一个是控制节点，二者是订阅发布模式实现通信的，乌龟运动显示节点直接调用即可，运动控制节点之前是使用的 turtle_teleop_key 通过键盘控制，现在需要自定义控制节点
  2. 控制节点自实现时，首先需要了解控制节点与显示节点通信使用的话题与消息，可以使用ros命令结合计算图来获取
  3. 了解了话题与消息之后，通过 C++ 或 Python 编写运动控制节点，通过指定的话题，按照一定的逻辑发布消息即可

实现流程：

  1. 通过计算图结合ros命令获取话题与消息信息
  2. 编码实现运动控制节点
  3. 启动 roscore、turtlesim_node 以及自定义的控制节点，查看运行结果

话题与消息获取

先启动键盘控制乌龟运动案例

  1. 话题获取

    通过 rostopic 列出话题

    1
    rostopic list

    或者通过计算图查看话题，启动计算图

    1
    rqt_graph
    image-20250523203511067

    -> /turtle1/cmd_vel 传递运动指令

  2. 消息获取

    获取消息类型：

    1
    2
    rostopic type /turtle1/cmd_vel
    // rostopic info /turtle1/cmd_vel

    info 命令下也显示type

    type: geometry_msgs/Twist

  3. 获取消息格式

    1
    rosmsg info geometry_msgs/Twist

    输出: 

    1
    2
    3
    4
    5
    6
    7
    8
    geometry_msgs/Vector3 linear
      float64 x
      float64 y
      float64 z
    geometry_msgs/Vector3 angular
      float64 x
      float64 y
      float64 z

    inear(线速度) ：xyz分别对应在x、y和z方向上的速度(单位是 m/s)

    angular(角速度)：xyz分别对应x轴上的翻滚roll、y轴上pitch和z轴上偏航yaw的速度(单位是rad/s)

    欧拉角1

    弧度：单位弧度定义为圆弧长度等于半径时的圆心角

    在ros中顺时针弧度为 - ，逆时针为 +，值的范围在[-π,π]

于是可以通过直接发布指令做到简单实现

1
rostopic pub -r 10 /turtle1/cmd_vel [TAB补齐]

实现发布节点

创建功能包需要依赖的功能包: roscpp rospy std_msgs geometry_msgs(封装坐标)

c++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
	topic(已知: /turtle1/cmd_vel)
    消息类型(已知: geometry_msgs/Twist)
    
    实现流程:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建节点句柄
        4.创建发布者对象
        5.发布逻辑
        6.spinOnce()
*/

#include "ros/ros.h"
#include "geometry_msgs/Twist.h"

int main(int argc, char *argv[])
{
    ros::init(argc,argv,"circle_control");
    ros::NodeHandle nh;
    ros::Publisher pub = nh.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",1000);
    geometry_msgs::Twist msg;

    msg.linear.x = 1.0;
    msg.linear.y = 1.0;
    msg.linear.z = 0.0;
    msg.angular.x = 0.0;
    msg.angular.y = 0.0;
    msg.angular.z = 1.0;

    ros::Rate rate(10);
    while(ros::ok())
    {
        pub.publish(msg);
        rate.sleep();
        ros::spinOnce();
    }
    return 0;

}

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#! /usr/bin/env python

import rospy
from geometry_msgs.msg import Twist

if __name__ == "__main__":

    rospy.init_node("circle_control_p")
    pub = rospy.Publisher("/turtle1/cmd_vel",Twist,queue_size=1000)
    rate = rospy.Rate(10)
    msg = Twist()  // 注意这里要()

    msg.linear.x = 1.0
    msg.linear.y = 0.0
    msg.linear.z = 0.0

    msg.angular.x = 0.0
    msg.angular.y = 0.0
    msg.angular.z = 1.0

    while not rospy.is_shutdown():
        pub.publish(msg)
        rate.sleep

实操2 话题订阅

需求描述：turtlesim中的乌龟显示节点，会发布当前乌龟的位姿(窗体中乌龟的坐标以及朝向)，要求控制乌龟运动，并时时打印当前乌龟的位姿

实现分析：

  1. 首先，需要启动乌龟显示以及运动控制节点并控制乌龟运动
  2. 要通过ROS命令，来获取乌龟位姿发布的话题以及消息
  3. 编写订阅节点，订阅并打印乌龟的位姿

实现流程:

  1. 通过ros命令获取话题与消息信息
  2. 编码实现位姿获取节点
  3. 启动 roscore、turtlesim_node 、控制节点以及位姿订阅节点，控制乌龟运动并输出乌龟的位姿

话题与消息获取

先启动键盘控制乌龟运动案例

  1. 话题获取

    1
    rostopic list

    -> /turtle1/pose 存储乌龟位置

  2. 获取消息类型

    1
    rostopic info  /turtle1/pose

    -> type: turtlesim/Pose

  3. 获取消息格式

    1
    rosmsg info turtlesim/Pose

    响应结果：

    1
    2
    3
    4
    5
    float32 x
    float32 y
    float32 theta
    float32 linear_velocity
    float32 angular_velocity

实现订阅节点

需要增添功能包turtlesim

在package.xml中增添

1
2
<build_depend>turtlesim</build_depend>
<exec_depend>sturtlesim</exec_depend>

在CMakeLsit.txt中增添

1
2
3
4
5
6
7
find_package(catkin REQUIRED COMPONENTS
  geometry_msgs
  roscpp
  rospy
  std_msgs
  turtlesim //增添包
)

c++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
    话题名称 /turtle1/pose
    消息类型 turtlesim/Pose
    
    实现流程:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建订阅者对象
        5.回调函数处理订阅的数据
        6.spin
*/

#include "ros/ros.h"
#include "turtlesim/Pose.h"

void doPose(const turtlesim::Pose::ConstPtr &pose){
    ROS_INFO("乌龟的位姿信息: \n坐标(%.2f,%.2f)\n朝向(%.2f)\n线速度:%.2f\n角速度:%.2f",
    pose->x,pose->y,pose->theta,pose->linear_velocity,pose->angular_velocity);
}


int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"sub_pose");
    ros::NodeHandle nh;
    ros::Subscriber sub = nh.subscribe("/turtle1/pose",1000,doPose);
    ros::spin();
    return 0;
}

python

1
2
3
4
5
6
7
8
9
10
11
12
13
#! /usr/bin/env python

import rospy
from turtlesim.msg import Pose

def doPose(pose):
    rospy.loginfo("乌龟的位姿信息: \n坐标(%.2f,%.2f)\n朝向(%.2f)\n线速度:%.2f\n角速度:%.2f",
                pose.x,pose.y,pose.theta,pose.linear_velocity,pose.angular_velocity)

if __name__ == "__main__":
    rospy.init_node("sub_pose_p")
    sub = rospy.Subscriber("/turtle1/pose",Pose,doPose,queue_size=1000)
    rospy.spin()

代码中容易错误的地方：话题名是/turtle1/pose ，注意这个1

实操3 服务调用

需求描述：编码实现向 turtlesim 发送请求，在乌龟显示节点的窗体指定位置生成一乌龟，这是一个服务请求操作

实现分析:

  1. 首先，需要启动乌龟显示节点
  2. 要通过ROS命令，来获取乌龟生成服务的服务名称以及服务消息类型
  3. 编写服务请求节点，生成新的乌龟

实现流程:

  1. 通过ros命令获取服务与服务消息信息
  2. 编码实现服务请求节点
  3. 启动 roscore、turtlesim_node 、乌龟生成节点，生成新的乌龟

服务名称与服务消息获取

  1. 获取话题

    1
    rosservice list

    -> /spawn

  2. 获取服务消息类型

    1
    rosservice info /spawn

    type: turtlesim/Spawn

    Args: x y theta name

  3. 获取服务消息格式

    1
    rossrv info turtlesim/Spawn

    响应结果:

    1
    2
    3
    4
    5
    6
    float32 x
    float32 y
    float32 theta
    string name
    ---
    string name

也可以简单实现增添乌龟

1
rosservice call /spawn [TAB补齐]

c++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
    服务话题 /spawn
    服务消息类型 turtlesim/Spawn

    实现流程:
        1.包含头文件
          需要包含 turtlesim 包下资源，注意在 package.xml 配置
        2.初始化 ros 节点
        3.创建 ros 句柄
        4.创建 service 客户端
        5.等待服务启动
        6.发送请求
        7.处理响应
*/

#include "ros/ros.h"
#include "turtlesim/Spawn.h"


int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"service_call");
    ros::NodeHandle nh;
    ros::ServiceClient client = nh.serviceClient<turtlesim::Spawn>("/spawn");
    turtlesim::Spawn spawn;
    spawn.request.x = 1.0;
    spawn.request.y = 4.0;
    spawn.request.theta = 1.57;
    spawn.request.name = "turtlec";

    // ros::service::waitForService("/spawn");
    client.waitForExistence();
    bool flag = client.call(spawn);
    // 7.处理响应结果
    if (flag)
    {
        ROS_INFO("新的乌龟生成,名字:%s",spawn.response.name.c_str());
    } else {
        ROS_INFO("乌龟生成失败！！！");
    }
    return 0;
}

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#! /usr/bin/env python

import rospy
from turtlesim.srv import Spawn,SpawnRequest,SpawnResponse 

if __name__ == "__main__":
	
    rospy.init_node("service_call_p")
    client = rospy.ServiceProxy("/spawn",Spawn)
    request = SpawnRequest()
    request.x = 4.0
    request.y = 1.0
    request.theta = 1.57
    request.name = "turtlep"
    client.wait_for_service()
    try:
        response = client.call(request)
        rospy.loginfo("乌龟创建成功!，叫:%s",response.name)
    except:
        rospy.loginfo("服务调用失败")

可能会出现因为重复命名的异常

实操4 参数设置

需求描述: 修改turtlesim乌龟显示节点窗体的背景色，已知背景色是通过参数服务器的方式以 rgb 方式设置的

实现分析:

  1. 首先，需要启动乌龟显示节点[注意这里不启动launch文件]
  2. 要通过ROS命令，来获取参数服务器中设置背景色的参数
  3. 编写参数设置节点，修改参数服务器中的参数值

实现流程:

  1. 通过ros命令获取参数
  2. 编码实现服参数设置节点
  3. 启动 roscore、turtlesim_node 与参数设置节点，查看运行结果

参数名获取

获取参数列表：

1
rosparam list

响应结果：

1
2
3
4
5
6
/turtle1/background_b
/turtle1/background_g
/turtle1/background_r
/turtlesim/background_b
/turtlesim/background_g
/turtlesim/background_r

方式1：命令行实现

1
2
3
rosparam set /turtlesim/background_r 自定义数值
rosparam set /turtlesim/background_g 自定义数值
rosparam set /turtlesim/background_b 自定义数值

修改相关参数后，重启 turtlesim_node 节点，背景色就会发生改变了

方式2：代码

c++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "ros/ros.h"

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"color");
    ros::NodeHandle nh;
    nh.setParam("/turtlesim/background_r",0);
    nh.setParam("/turtlesim/background_g",0);
    nh.setParam("/turtlesim/background_b",0);
    
    // ros::NodeHandle nh("turtlesim"); //加上命名空间
	// nh.setParam("background_r",0);
    // nh.setParam("background_g",0);
    // nh.setParam("background_b",0);
    return 0;
}

python

1
2
3
4
5
6
7
8
9
#! /usr/bin/env python

import rospy

if __name__ == "__main__":
    rospy.init_node("color_p")
    rospy.set_param("/turtlesim/background_r",255)
    rospy.set_param("/turtlesim/background_g",255)
    rospy.set_param("/turtlesim/background_b",255)

TF坐标变换

需求描述：程序启动之初产生两只乌龟，中间的乌龟(A) 和 左下乌龟(B)，B 会自动运行至A的位置，并且键盘控制时，只是控制 A 的运动，但是 B 可以跟随 A 运行

实现分析：

乌龟跟随实现的核心，是乌龟A和B都要发布相对世界坐标系的坐标信息，然后，订阅到该信息需要转换获取A相对于B坐标系的信息，最后，再生成速度信息，并控制B运动。

  1. 启动乌龟显示节点
  2. 在乌龟显示窗体中生成一只新的乌龟(需要使用服务)
  3. 编写两只乌龟发布坐标信息的节点
  4. 编写订阅节点订阅坐标信息并生成新的相对关系生成速度信息

实现流程：

  1. 新建功能包，添加依赖
  2. 编写服务客户端，用于生成一只新的乌龟
  3. 编写发布方，发布两只乌龟的坐标信息
  4. 编写订阅方，订阅两只乌龟信息，生成速度信息并发布
  5. 运行

创建第二只乌龟需要使用rosservice，话题使用的是 spawn

位置信息通过话题 /乌龟名称/pose 来获取的

创建功能包依赖于 tf2、tf2_ros、tf2_geometry_msgs、roscpp rospy std_msgs geometry_msgs、turtlesim

服务客户端(生成乌龟)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include "ros/ros.h"
#include "turtlesim/Spawn.h"

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"turtle_new");
    ros::NodeHandle nh;
    // 创建客户端
    ros::ServiceClient client = nh.serviceClient<turtlesim::Spawn>("/spawn");
    // 请求内容
    turtlesim::Spawn spawn;
    spawn.request.x = 1;
    spawn.request.y = 3;
    spawn.request.theta = 1.57;
    spawn.request.name = "turtle2";
    // 等待服务器启动
    client.waitForExistence();
    // call 发送请求,flag反应结果
    bool flag = client.call(spawn);
    if(flag)
    {
        ROS_INFO("新的乌龟生成,名称:%s",spawn.response.name.c_str());
    }else {
        ROS_INFO("乌龟生成失败！！！");
    }
    return 0;
}

发布方(发布两只乌龟的坐标信息)

  • 该节点需要启动两次
  • 每次启动时都需要传入乌龟节点名称(第一次是 turtle1 第二次是 turtle2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include "ros/ros.h"
#include "turtlesim/Pose.h"
#include "tf2_ros/transform_broadcaster.h"
#include "geometry_msgs/TransformStamped.h" 
#include "tf2/LinearMath/Quaternion.h" 
/* 
    发布方：需要订阅乌龟的位姿信息，转换成相对于窗体的坐标关系，并发布
    准 备
        话题：/turtle1/pose
        消息：/turtlesim/Pose
*/

// 声明传入的变量
std::string turtle_name;

void doPose(const turtlesim::Pose::ConstPtr& pose){
    // 获取位姿信息，转换成坐标系相对关系(核心),并发布
    // 创建发布对象
    // tf2_ros::TransformBroadcaster pub; 如果这么写每次处理都要创建一个新的发布对象
    static tf2_ros::TransformBroadcaster pub; // 静态发布对象
    // 处理发布数据
    geometry_msgs::TransformStamped tfs;
    tfs.header.frame_id = "world";
    tfs.header.stamp = ros::Time::now();
    // tfs.child_frame_id 动态传入
    tfs.child_frame_id = turtle_name;
    // 从乌龟位姿信息获取坐标
    tfs.transform.translation.x = pose->x;
    tfs.transform.translation.y = pose->y;
    tfs.transform.translation.z = 0;
    // 坐标系四元数
    // pose 信息中只有偏航yaw -> theta,二维没有翻滚roll,俯仰pitch
    // 欧拉角为 (0,0,theta)
    tf2::Quaternion qtn;
    qtn.setRPY(0,0,pose->theta);
    tfs.transform.rotation.x = qtn.getX();
    tfs.transform.rotation.y = qtn.getY();
    tfs.transform.rotation.z = qtn.getZ();
    tfs.transform.rotation.w = qtn.getW();
    // 发布
    pub.sendTransform(tfs);
}

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"dynamic_pub");
    // 解析argc传入的参数
    if(argc != 2)
    {
        ROS_ERROR("请传入一个参数");
        return 1;
    }else
    {
        turtle_name = argv[1];
        ROS_INFO("乌龟 %s 坐标发送启动",turtle_name.c_str());
    }

    ros::NodeHandle nh;
    // 创建订阅对象,订阅话题动态传入
    ros::Subscriber sub = nh.subscribe(turtle_name + "/pose",100,doPose);
    ros::spin();
    return 0;
}

订阅方(解析坐标信息并生成速度信息)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include "ros/ros.h"
#include "tf2_ros/transform_listener.h"
#include "tf2_ros/buffer.h"
#include "geometry_msgs/PointStamped.h"
#include "tf2_geometry_msgs/tf2_geometry_msgs.h"
#include "geometry_msgs/TransformStamped.h" // buffer.lookupTransform 返回值类型
#include "geometry_msgs/Twist.h" //速度信息
/* 
    订阅方实现：
        1. 计算turtle1相对turtle2的关系
        2. 计算线速度和角速度发布
*/
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"control");
    ros::NodeHandle nh;
    tf2_ros::Buffer buffer;
    tf2_ros::TransformListener listener(buffer); // 不能删监听器
    // 创建发布对象
    ros::Publisher pub = nh.advertise<geometry_msgs::Twist>("/turtle2/cmd_vel",100);
    ros::Rate rate(1);
    while (ros::ok()){
        try
        {
            // 参数1父级坐标系,参数2子坐标系,参数3ros::Time(0) 取间隔最小的两个时间戳进行计算
            geometry_msgs::TransformStamped tfs = buffer.lookupTransform("turtle2","turtle1",ros::Time(0));
            // ROS_INFO("%s 相对 %s 的偏移量:(%.2f,%.2f,%.2f)",
            //         tfs.child_frame_id.c_str(),
            //         tfs.header.frame_id.c_str(),
            //         tfs.transform.translation.x,
            //         tfs.transform.translation.y,
            //         tfs.transform.translation.z
            //     );
            geometry_msgs::Twist twist;
            // 2D只需要配置角速度z和线速度x
            // x = 系数*\sqrt{(y^2+x^2)}
            // z = 系数*arctan(y/x)
            twist.linear.x = 0.5 * sqrt(pow(tfs.transform.translation.x,2)+pow(tfs.transform.translation.y,2));
            twist.angular.z = 0.5 * atan2(tfs.transform.translation.y,tfs.transform.translation.x);
            // 发布
            pub.publish(twist);
            
        }
        catch(const std::exception& e)
        {
            ROS_INFO("错误提示:%s",e.what());
        }
        rate.sleep();
        ros::spinOnce(); 
    }

    return 0;
}

运行

使用launch文件

1
2
3
4
5
6
7
8
9
10
11
12
13
<launch>
    <!-- 1. 启动乌龟GUI节点 -->
    <node pkg="turtlesim" type="turtlesim_node" name="turtle1" output="screen" />
    <node pkg="turtlesim" type="turtle_teleop_key" name="key" output="screen" />
    <!-- 2. 生成新乌龟节点 -->
    <node pkg="tf04_test" type="new_turtle" name="turtle2" output="screen"/>
    <!-- 3. 设置两个乌龟相对于世界坐标的发布 -->
    <node pkg="tf04_test" type="dynamic_pub" name="pub1" args="turtle1" output="screen"/>
    <node pkg="tf04_test" type="dynamic_pub" name="pub2" args="turtle2" output="screen"/>
    <!-- 4. 订阅两只乌龟相对于世界坐标系的信息,并转化为turtle1相对于turtle2的坐标关系
            再生成速度信息 -->
    <node pkg="tf04_test" type="control" name="control" output="screen"/>
</launch>

机器人系统仿真

Xacro

需求描述：在前面小车底盘基础之上，添加摄像头和雷达传感器

实现分析：

机器人模型由多部件组成，可以将不同组件设置进单独文件，最终通过文件包含实现组件的拼装。

实现流程：

  1. 首先编写摄像头和雷达的 xacro 文件
  2. 然后再编写一个组合文件，组合底盘、摄像头与雷达
  3. 最后，通过 launch 文件启动 Rviz 并显示模型

**摄像头Xacro **

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="camera">
    <!-- 摄像头属性 -->
    <!-- 
        连杆属性：厚度、宽度、高度
        关节属性：x y z
    -->
    <xacro:property name="camera_length" value="0.02" /> <!-- 摄像头长度(x) -->
    <xacro:property name="camera_width" value="0.02" /> <!-- 摄像头宽度(y) -->
    <xacro:property name="camera_height" value="0.02" /> <!-- 摄像头高度(z) -->
    <xacro:property name="camera_x" value="0.08" /> <!-- 摄像头安装的x坐标 -->
    <xacro:property name="camera_y" value="0.0" /> <!-- 摄像头安装的y坐标 -->
    <xacro:property name="camera_z" value="${base_length / 2 + camera_height / 2}" /> <!-- 摄像头安装的z坐标:底盘高度 / 2 + 摄像头高度 / 2  -->
    <!-- 摄像头关节以及link -->
    <link name="camera">
        <visual>
            <geometry>
                <box size="${camera_length} ${camera_width} ${camera_height}" />
            </geometry>
            <origin xyz="0.0 0.0 0.0" rpy="0.0 0.0 0.0" />
            <material name="black" />
        </visual>
    </link>

    <joint name="camera2base_link" type="fixed">
        <parent link="base_link" />
        <child link="camera" />
        <origin xyz="${camera_x} ${camera_y} ${camera_z}" />
    </joint>
</robot>

雷达Xacro

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="laser">
    <!-- 雷达支架 -->
    <xacro:property name="support_length" value="0.15" /> <!-- 支架长度 -->
    <xacro:property name="support_radius" value="0.01" /> <!-- 支架半径 -->
    <xacro:property name="support_x" value="0.0" /> <!-- 支架安装的x坐标 -->
    <xacro:property name="support_y" value="0.0" /> <!-- 支架安装的y坐标 -->
    <xacro:property name="support_z" value="${base_length / 2 + support_length / 2}" /> <!-- 支架安装的z坐标:底盘高度 / 2 + 支架高度 / 2  -->
    <link name="support">
        <visual>
            <geometry>
                <cylinder radius="${support_radius}" length="${support_length}" />
            </geometry>
            <origin xyz="0.0 0.0 0.0" rpy="0.0 0.0 0.0" />
            <material name="red">
                <color rgba="0.8 0.2 0.0 0.8" />
            </material>
        </visual>
    </link>

    <joint name="support2base_link" type="fixed">
        <parent link="base_link" />
        <child link="support" />
        <origin xyz="${support_x} ${support_y} ${support_z}" />
    </joint>

    <!-- 雷达属性 -->
    <xacro:property name="laser_length" value="0.05" /> <!-- 雷达长度 -->
    <xacro:property name="laser_radius" value="0.03" /> <!-- 雷达半径 -->
    <xacro:property name="laser_x" value="0.0" /> <!-- 雷达安装的x坐标 -->
    <xacro:property name="laser_y" value="0.0" /> <!-- 雷达安装的y坐标 -->
    <xacro:property name="laser_z" value="${support_length / 2 + laser_length / 2}" /> <!-- 雷达安装的z坐标:支架高度 / 2 + 雷达高度 / 2  -->
    <!-- 雷达关节以及link -->
    <link name="laser">
        <visual>
            <geometry>
                <cylinder radius="${laser_radius}" length="${laser_length}" />
            </geometry>
            <origin xyz="0.0 0.0 0.0" rpy="0.0 0.0 0.0" />
            <material name="black" />
        </visual>
    </link>

    <joint name="laser2support" type="fixed">
        <parent link="support" />
        <child link="laser" />
        <origin xyz="${laser_x} ${laser_y} ${laser_z}" />
    </joint>
    
</robot>

组合底盘摄像头与雷达

1
2
3
4
5
6
<robot name="my_car_camera" xmlns:xacro="http://wiki.ros.org/xacro">
    <!-- 组合小车底盘与摄像头与雷达 -->
    <xacro:include filename="base.urdf.xacro"/>
    <xacro:include filename="camera.urdf.xacro"/>
    <xacro:include filename="laser.urdf.xacro"/>
</robot>

launch 文件

1
2
3
4
5
6
7
8
9
10
<launch>
    <param name="robot_description" command="$(find xacro)/xacro $(find urdf01_rviz)/urdf/xacro/combination.urdf.xacro"/>
    <node pkg = "rviz" type = "rviz" name = "rviz" args = "-d $(find urdf01_rviz)/config/show_car.rviz" />
    <!--  关节状态发布节点 -->
    <node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher"/>
    <!--  机器人状态发布节点 -->
    <node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher"/>
    <!-- 添加控制关节运动的节点 -->
    <node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" />
</launch>