ROS编程实现

最新推荐文章于 2023-09-07 16:58:18 发布

VIP文章 ywwsnowboy

最新推荐文章于 2023-09-07 16:58:18 发布

阅读量167

点赞数

分类专栏： ROS 文章标签：学习开发语言

本文链接：https://blog.csdn.net/m0_66238629/article/details/131510065

版权

本文主要内容是ROS编程实现。

ROS编程实现

1. 创造工作空间和功能包

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

src：代码空间（Source Space），用来放置功能包的代码、配置文件、launch文件

build：编译空间（Build Space），编译过程中产生的中间文件，二进制文件，不用考虑

devel：开发空间（Development Space）放置开发中编译生成的可执行文件，一些库、脚本

install：安装空间（Install Space），安装指令/程序的位置，放置开发后生成的可执行文件，和devel文件夹类似

1.1 创建工作空间

创建工作空间

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   # 显示ROS功能包路径，只有前面source之后才能通过echo命令显示出来

如果想产生install文件夹，可以通过catkin_make install编译后即可产生install安装空间，存放最终编译的可执行文件

1.2 创建功能包

创建功能包

cd ~/catkin_ws/src
catkin_create_pkg test_pkg std_msgs rospy roscpp catkin_create_pkg <package_name> [depend 1][depend 2][depend 3]

test_pkg编译过程中用到哪些库，就需要跟哪些依赖，比如std_msgs、rospy、roscpp，这些库都放到src文件夹中。

编译功能包

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

同一个工作空间下，不允许存在同名功能包，不同工作空间下，允许存在同名功能包

编译过后，C++头文件可以放到include文件夹中，功能包中一定有CMakeLists.txt和package.xml，这两个文件说明该文件夹为功能包。

package.xml的作用：记录该功能包相关的信息、个人信息、开源许可证、功能包依赖信息等，如果需要增加相应的依赖，可以再进行拓展。

CMakeLists.txt的作用：描述功能包的编译规则，主要的语法是Cmake语法。

2. 发布者Publisher的编程实现

发布者编程实现原理图：

2.1 创建功能包

具体操作步骤：

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

2.2 配置发布者代码编译规则

如何配置CMakeLists.txt中的编译规则：

设置需要编译的代码和生成的可执行文件；
设置链接库；
CMakeLists.txt中主要描述了如何编译以及编译的规则。

在~/catkin_ws/src/learning_topic文件夹下的CMakeLists.txt文件中加入如下代码：

add_executable(velocity_publisher src/velocity_publisher.cpp) ##将src/velocity_publisher.cpp编译成名为velocity_publisher的可执行文件
target_link_libraries(velocity_publisher ${catkin_LIBRARIES}) ##将可执行文件velocity_publisher和ROS相关的库做一个链接，比如C++的接口#python不用做接口，python不需要编译

2.3 用C++/python实现发布者

在src文件夹中创建cpp文件

C++代码实现一个发布者：

初始化ROS节点；
向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
创建消息数据；
按照一定频率循环发布消息。

具体实现的C++代码：

/*
*该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs:Twist
*/

#include <ros/ros.h>    //包含ROS相关的头文件
#include <geometry_msgs/Twist.h>  //ROS中线速度和角速度相关消息的头文件，geometry_msgs库中已经定义好的头文件

int main(int argc, char **argv)
{
    // ROS节点初始化，
    ros::init(argc, argv, "velocity_publisher"); //velocity_publisher为节点的名字，在ROS中节点名不能重复。                             //argc和argv为输入的参数来设置初始化的属性，默认情况下属性不作配置，只有velocity_publisher这个名字
    
    // 创建节点句柄，主要用来管理ROS相关API的资源，比如发布者创建API调用需要节点句柄的调用，用来管理节点资源。
    ros::NodeHandle n;
    
    /*创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10。Publisher里面有一个缓存（队列），先把数据放入缓存中，再根据实际传输能力传输数据，当缓存空间不够或者传输速度太慢，会将最老的数据删除，只保留缓存长度的数据，再进行数据传输，出现这种情况时，会出现掉帧掉数据的情况*/
    ros==Publisher turtle_vel_pub = n.advertise<geometry_msgs==Twist>("/turtle1/cmd_vel",10);
    
    // 设置循环的频率，后续有一个while循环，loop_rate用来设置频率的
    ros::Rate loop_rate(10);
    
    int count = 0;
    while (ros::ok()) //封装数据，发不出去，延时满足频率，进行下一次循环
    {
        // 初始化geometry_msgs::Twist类型的消息，
        geometry_msgs::Twist vel_msg; //设置Twist消息的内容，首先创建Twist消息，Twist是一个类，首先创建类的对象，对象中包括线速度角速度
        vel_msg.linear.x = 0.5;  //设置线速度
        vel_msg.angular.z = 0.2;  //设置角速度
        
        // 发布消息
        turtle_vel_pub.publish(vel_msg); //调用发布者turtle_vel_pub，使用publish这个方法，publisher的输入是vel_msg
        ROS_INFO("Publish turtlesim velocity command[%0.2f m/s, %0.2f rad/s]",vel_msg.linear.x, vel_msg.angular.z);
        //ROS_INFO相当于printf，用来输出信息
        
        // 按照循环频率演示
        loop_rate.sleep();//延时10Hz
    }
    
    return 0;
}

python代码实现一个发布者：

初始化ROS节点；
向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
创建消息数据；
按照一定频率循环发布消息。

具体实现的python代码：

# 该例程将发布turtle1/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.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

	# 设置循环的频率
    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

		# 发布消息
        turtle_vel_pub.publish(vel_msg)
    	rospy.loginfo("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]", 
				vel_msg.linear.x, vel_msg.angular.z)

		# 按照循环频率延时
        rate.sleep()

if __name__ == '__main__':
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass

2.4 编译并运行发布者

编译具体操作如下：

cd ~/catkin_ws
catkin_make   # 用该指令进行编译
source devel/setup.bash   # 设置环境变量，可以将该句程序放入.bashrc文件的最后一行
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisher # 运行learning_topic文件中的velocity_publisher节点

python文件放在scripts文件夹中，同时注意要设置python文件具有可执行文件。

3. 订阅者Subscriber的编程实现

订阅者编程实现原理图：

3.1 配置发布者代码编译规则

如何配置CMakeLists.txt中的编译规则：

设置需要编译的代码和生成的可执行文件；
设置链接库

在~/catkin_ws/src/learning_topic文件夹下的CMakeLists.txt文件中加入如下代码：

add_executable(pose_subscriber src/pose_subscriber.cpp) # 将src/pose_subscriber.cpp编译成名为pose_subscriber的可执行文件
target_link_libraries(pose_subscriber ${catkin_LIBRARIES}) # 将可执行文件pose_subscriber和ROS相关的库做一个链接，比如C++的接口

3.2 用C++/python实现订阅者

C++代码实现一个订阅者：

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

具体实现的C++代码：

/**
 * 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose，这是小海龟仿真器自己定义的信息
 */
 
#include <ros/ros.h>
#include "turtlesim/Pose.h"

// 接收到订阅的消息后，会进入消息回调函数，turtlesim::Pose是消息的结构，后面的ConstPtr调用的是长指针
//当msg数据传输过来的时候，就以长指针的形式指向turtlesim::Pose这个姿态信息的数据内容
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这个类，创建一个pose_sub这个对象，订阅名为/turtle1/pose的topic，需要和turtlesim相对应，注册回调函数poseCallback
    //其中10为订阅话题的队列长度，poseCallback为回调函数，因为数据不知道什么时候发送过来，因此有回调函数，当有数据进来，就调用回调函数进行处理
    ros::Subscriber pose_sub = n.subscribe("/turtle1/pose", 10, poseCallback);

    // 循环等待回调函数，死循环，不断查看队列中是否有数据过来，如果有则进入poseCallback进行处理，如果没有则不断地死循环
    ros::spin();

    return 0;
}

python代码实现一个订阅者：

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

具体实现的python代码：

# 该例程将订阅/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__':
    pose_subscriber()

python可以不用编译，直接可以运行。

3.3 编译并运行发布者

编译具体操作如下：

cd ~/catkin_ws
catkin_make   # 用该指令进行编译
source devel/setup.bash   # 设置环境变量，可以将该句程序放入.bashrc文件的最后一行
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_subscriber#运行learning_topic文件中的velocity_subscriber节点,如果小海龟不移动，则订阅的小海龟的位置不变。
rosrun turtlesim turtle_teleop_key # 运行键盘遥控节点，控制小海龟移动，可以看到订阅的小海龟位置发生改变

4. 话题消息的定义与使用

4.1 自定义消息文件的配置

步骤一：定义msg文件

在learning_topic文件夹中创建msg文件夹，跟消息相关定义都存放在msg文件夹中，方便管理，创建文件person.msg，打开文件，将下列文件放入person.msg文件中。

string name
uint8 sex
uint8 age

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

步骤二：在package.xml中添加功能包依赖

在learning_topic文件夹中打开package.xml文件，添加下面的语句

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

一个是编译依赖，编译依赖是一个动态产生message的功能包；一个是执行依赖，执行依赖是一个执行message的功能包。如下图：

步骤三：在CMakeLists.txt添加编译选项

find_package(…… message_generation)
add_message_files(FILES Person.msg) 将定义的Person.msg作为接口，针对其来进行编译

generate_messages(DEPENDENCIES std_msgs) 编译Person.msg需要ROS已有的库或者包，需要依赖std_msgs

catkin_package(…… message_runtime) 创建message运行依赖

分别对应CMakeLists.txt文件中的内容为：

步骤四：编译生成语言相关文件

在工作空间的根目录catkin_ws下通过catkin_make进行编译，生成Person.h头文件。

4.2 话题消息的使用

如何根据上面4.1生成的Person.h头文件，通过程序来使用它，具体操作步骤如下：

在src文件夹中创建cpp文件

4.2.1 C++代码实现发布者

初始化ROS节点；
向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
创建消息数据；
按照一定频率循环发布消息。

具体实现的C++代码：

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

4.2.2 C++代码实现订阅者

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

具体实现的C++代码：

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

4.2.3 编译配置文件

添加订阅者和发布者相关程序后，需要对CMakeList_List.txt文件进行配置

配置CMakeLists.txt中的编译规则：

设置需要编译的代码和生成的可执行文件；
设置链接库；
添加依赖项。

在catkin_ws/src/learning_topic文件夹下的CMakeList_List.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)

有一些代码是动态生成的，需要将可执行文件和动态生成的程序产生依赖关系，因此需要通过add_dependencies命令来做一些连接。要和自己自定义的消息进行连接必须要添加这样一行代码。如图所示：

在工作空间的根目录catkin_ws下，通过catkin_make进行编译。

ROS Master是帮助节点之间创建连接，一旦两者创建连接后，关闭roscore，publisher和subscriber依然发布消息和订阅消息，此时ROS Master不再起作用。

4.2.4 python代码实现

发布者python实现：

# 该例程将发布/person_info话题，自定义消息类型learning_topic::Person

import rospy
from learning_topic.msg import Person   # 对应的msg文件也生成了python文件，通过import形式引入进来

def velocity_publisher():
	# ROS节点初始化
    rospy.init_node('person_publisher', anonymous

最低0.47元/天解锁文章

ywwsnowboy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
ROS编程实现

步骤一：定义msg文件在文件夹中创建msg文件夹，跟消息相关定义都存放在msg文件夹中，方便管理，创建文件person.msg，打开文件，将下列文件放入person.msg文件中。uint8 sexuint8 age步骤二：在package.xml中添加功能包依赖在文件夹中打开文件，添加下面的语句</一个是编译依赖，编译依赖是一个动态产生message的功能包；一个是执行依赖，执行依赖是一个执行message的功能包。步骤三：在CMakeLists.txt添加编译选项。
复制链接

扫一扫