ROS通信模式编程

目录

一、话题模式的ROS程序设计

​编辑

二、 服务模式的ROS程序设计

三、动作编程


一、话题模式的ROS程序设计

1、创建工作空间

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

2、编译工作空间

cd ~/catkin_ws
catkin_make

3、配置环境变量

source devel/setup.bash
echo $ROS_PACKAGE_PATH

 4、创建my_turtle_package包

cd ~/catkin_ws/src                            
catkin_create_pkg my_turtle_package rospy roscpp         

 5、在/catkin_ws/src/my_turtle_package/src中创建talker.cpp并添加代码

/*
该例程将发布chatter话题,消息类型String
*/

#include <sstream>
#include "ros/ros.h"
#include "std_msgs/String.h"

int main(int argc,char **argv)
{
  //1. ROS节点初始化,“talker“为节点名称,后期可更改
  ros::init(argc,argv,"talker");
  
  //2. 创建节点句柄
  ros::NodeHandle n;
  // 创建一个Publisher,发布名为chatter的topic,消息类型为std::msgs::String,1000是发布队列的大小,它的作用是缓冲
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

  //3. 设置循环的频率
  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;
}

 6、在同目录下创建listener.cpp,并添加代码

/*
该例程将订阅chatter话题,消息类型String
*/
#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;
}

7、打开/catkin_ws/src/my_turtle_package中的CMakeLists.txt并添加代码

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

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

8、在工作空间catkin_ws中生成可执行文件

catkin_make

9、打开新终端启动ROS Master

roscore

10、打开新终端添加环境变量,并运行talker.cpp

source ~/catkin_ws/devel
rosrun my_turtle_package talker

11、再打开一个终端添加环境变量,并运行listener.cpp

source ~/catkin_ws/devel
rosrun my_turtle_package listener

 

二、 服务模式的ROS程序设计

1、在/catkin_ws/src/my_turtle_package中创建srv文件并在srv文件中添加AddTwoInts.srv文件

int64 a
int64 b
---
int64 sum

 2、创建服务器/catkin_ws/src/my_turtle_package/src中创建server.cpp并添加代码

/*
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)
{
  //1,ROS节点初始化
  ros::init(argc, argv, "add_two_ints_server");
  
  //2. 创建节点句柄
  ros::NodeHandle n;

  //3. 创建一个名为add_two_ints的server,注册回调函数add()
  ros::ServiceServer service = n.advertiseService("add_two_ints", add);

  //4. 循环等待回调函数
  ROS_INFO("Ready to add two ints.");
  ros::spin();

  return 0;
}

3、创建客户端 

创建服务器/catkin_ws/src/my_turtle_package/src中创建client.cpp并添加代码

/*
AddTwoInts Client
*/

#include <cstdlib>
#include "ros/ros.h"
#include "learning_communication/AddTwoInts.h"

int main(int argc, char **argv)
{
  //1. Ros节点初始化
  ros::init(argc, argv, "add_two_ints_client");
  
  //从终端命令行获取两个加数
  if (argc != 3)
  {
    ROS_INFO("usage: add_two_ints_client X Y");
    return 1;
  }

  //2. 创建节点句柄
  ros::NodeHandle n;

  //创建一个client,请求add_two_int service,service消息类型是learning_communication::AddTwoInts
  ros::ServiceClient client = n.serviceClient<learning_communication::AddTwoInts>("add_two_ints");

  //3. 创建learning_communication::AddTwoInts类型的service消息
  learning_communication::AddTwoInts srv;
  srv.request.a = atoll(argv[1]);
  srv.request.b = atoll(argv[2]);

  //4. 发布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;
}

 4、打开/catkin_ws/src/my_turtle_package中的CMakeLists.txt并添加代码

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

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

 5、在工作空间catkin_ws中生成可执行文件

catkin_make

6、打开新终端启动ROS Master

roscore

7、打开新终端添加环境变量,并运行talker.cpp

source ~/catkin_ws/devel
rosrun my_turtle_package server

8、再打开一个终端添加环境变量,并运行listener.cpp

source ~/catkin_ws/devel
rosrun my_turtle_package client 3 4

三、动作编程

1、在/catkin_ws/src/my_turtle_package/src中创建turtleMove.cpp并添加代码

/*
该例程将发布chatter话题,消息类型String
*/

#include <sstream>
#include "ros/ros.h"
#include "std_msgs/String.h"

int main(int argc,char **argv)
{
  //1. ROS节点初始化,“talker“为节点名称,后期可更改
  ros::init(argc,argv,"talker");
  
  //2. 创建节点句柄
  ros::NodeHandle n;
  // 创建一个Publisher,发布名为chatter的topic,消息类型为std::msgs::String,1000是发布队列的大小,它的作用是缓冲
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

  //3. 设置循环的频率
  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;
}

 2、在/catkin_ws/src/my_turtle_package/src中创建turtleMoveClient.cpp并添加代码

#include <actionlib/client/simple_action_client.h>
#include "my_turtle_package/turtleMoveAction.h"
#include <turtlesim/Pose.h>
#include <turtlesim/Spawn.h>
#include <geometry_msgs/Twist.h>
typedef actionlib::SimpleActionClient<my_turtle_package::turtleMoveAction>
Client;
struct Myturtle
{
float x;
float y;
float theta;
}turtle_present_pose;
// 当 action 完成后会调用该回调函数一次
void doneCb(const actionlib::SimpleClientGoalState& state,
const my_turtle_package::turtleMoveResultConstPtr& result)
{
ROS_INFO("Yay! The turtleMove is finished!");
ros::shutdown();
}
// 当 action 激活后会调用该回调函数一次
void activeCb()
{
ROS_INFO("Goal just went active");
}
// 收到 feedback 后调用该回调函数
void feedbackCb(const my_turtle_package::turtleMoveFeedbackConstPtr& feedback)
{
ROS_INFO(" present_pose : %f %f %f",
feedback->present_turtle_x,
feedback->present_turtle_y,feedback->present_turtle_theta);
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "turtleMoveClient");
// 定义一个客户端
Client client("turtleMove", true);
// 等待服务器端
ROS_INFO("Waiting for action server to start.");
client.waitForServer();
ROS_INFO("Action server started, sending goal.");
// 创建一个 action 的 goal
my_turtle_package::turtleMoveGoal goal;
goal.turtle_target_x = 1;
goal.turtle_target_y = 1;
goal.turtle_target_theta = 0;
// 发送 action 的 goal 给服务器端,并且设置回调函数
client.sendGoal(goal, &doneCb, &activeCb, &feedbackCb);
ros::spin();
return 0;
}

 3、在/catkin_ws/src/my_turtle_package中创建action文件夹

4、在action文件夹中创建turtleMove.action文件并添加代码

cd action
touch turtleMove.action
gedit turtleMove.action
# Define the goal
float64 turtle_target_x # Specify Turtle's target position
float64 turtle_target_y
float64 turtle_target_theta
---
# Define the result
float64 turtle_final_x
float64 turtle_final_y
float64 turtle_final_theta
---
# Define a feedback message
float64 present_turtle_x
float64 present_turtle_y
float64 present_turtle_theta

5、修改 CMakeLists.txt 文件内容

1)、在 CMakeLists.txt 文件末尾添加如下代码:
add_executable(turtleMoveClient src/turtleMoveClient.cpp)
target_link_libraries(turtleMoveClient ${catkin_LIBRARIES})
add_dependencies(turtleMoveClient ${PROJECT_NAME}_gencpp)
add_executable(turtleMove src/turtleMove.cpp)
target_link_libraries(turtleMove ${catkin_LIBRARIES})
add_dependencies(turtleMove ${PROJECT_NAME}_gencpp)
2) 、在该文件中找到 find_package 函数方法,修改为如下:
find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
actionlib_msgs
actionlib
)
3)、继续在该文件中找到 add_action_files 函数一项,默认是用#注释掉了的,这
里我们找到后修改为如下代码:
add_action_files(
FILES
turtleMove.action
)
4)、继续在该文件中找到 generate_messages 函数一项,默认也是#注释,这里修改
为如下代码:
generate_messages(
DEPENDENCIES
std_msgs
actionlib_msgs
)
5)、找到 catkin_package 函数一项,修改为如下代码:
# INCLUDE_DIRS include
# LIBRARIES comm
# CATKIN_DEPENDS roscpp rospy std_msgs
# DEPENDS system_lib
CATKIN_DEPENDS roscpp rospy std_msgs
message_runtime

6、修改 package.xml 文件内容

  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>actionlib</build_depend>
  <build_depend>message_generation</build_depend>
  <build_depend>actionlib_msgs</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend> geometry_msgs </build_export_depend>
  <build_export_depend> std_msgs </build_export_depend>
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>message_runtime</exec_depend>
  <exec_depend> geometry_msgs </exec_depend>
  <exec_depend> std_msgs </exec_depend>
  <exec_depend>actionlib</exec_depend>
  <exec_depend>actionlib_msgs</exec_depend>

7、在工作空间catkin_ws中生成可执行文件

catkin_make

8、打开新终端启动ROS Master

roscore

9、打开新终端启动小海龟

rosrun turtlesim turtlesim_node

10、打开新终端,进入运行终端,运行目标位置程序代码

source ~/catkin_ws/devel
rosrun my_turtle_package turtleMoveClient

 11、 打开新终端,运行turtleMove.cpp

source ~/catkin_ws/devel
rosrun my_turtle_package turtleMove

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值