节点与节点管理器

图形化说明

ROS通信机制

1. 话题通信

这里的/image_data是话题，message是传递的话题内容

msg是消息中间件，数据载体，方便通信
适用于不断更新的数据传输相关的应用场景

ROS Master 负责保管 Talker 和 Listener 注册的信息，并匹配话题相同的 Talker 与 Listener，帮助 Talker 与 Listener 建立连接，连接建立后，Talker 可以发布消息，且发布的消息会被 Listener 订阅。

1.1 基本话题通信

1.1.1 C++实现

发布方 demo01_pub.cpp

#include"ros/ros.h"
#include"std_msgs/String.h"
#include<sstream>
/*发布方实现：1.包含头文件ROS中文本类型--->std_msgs/String.h2.初始化ROS节点3.创建节点句柄4.创建发布者对象5.编写发布逻辑并发布数据
*/int main(int argc,char *argv[])
{// 解决中文乱码问题setlocale(LC_ALL,"");// 2.初始化ROS节点ros::init(argc,argv,"erGouZi");//ergouzi是节点名称，相当于是相亲对象，这里的ergouzi就是talker// 3.创建节点句柄ros::NodeHandle nh;// 4.创建发布者对象ros::Publisher pub = nh.advertise<std_msgs::String>("fang",10);//缓存10条数据,话题名称是fang，队列长10，由于网络阻塞，没有发出去，则存储在这里，最大容量是10，超出阈值后先放进去的先销毁// 5.编写发布逻辑并发布数据// 5.1 创建被发布的消息std_msgs::String msg;// 5.2 要求以10HZ 的频率发布数据，并且文本后添加编号// 5.2.1 发布频率ros::Rate rate(1);//每秒发布10次// 5.2.2 设置编号int count = 0;// 订阅时，第一条数据丢失；原因: 发送第一条数据时， publisher 还未在 roscore 注册完毕ros::Duration(3).sleep();//延迟3秒// 5.3 编写循环，循环要发布的消息while(ros::ok())//如果节点还活着，循环成立{count++;//msg.data = "hello";//实现字符串的拼接std::stringstream ss;ss << "hello ---> " << count;msg.data = ss.str();pub.publish(msg);//添加日志：ROS_INFO("发布的数据是：%s",msg.data.c_str());rate.sleep();// 发布一次，睡0.1秒ros::spinOnce();//每次循环完都回头一次，spinOnce()只调用一次回调函数，之后会继续往下执行，官方建议，处理回调函数}return 0;
}

订阅方 demo01_sub.cpp

#include "ros/ros.h"
#include"std_msgs/String.h"
/*订阅方实现：1.包含头文件ROS中文本类型--->std_msgs/String.h2.初始化ROS节点3.创建节点句柄4.创建订阅者对象5.处理订阅到的数据6.spin()函数
*/void doMsq(const std_msgs::String::ConstPtr &msg)//std_msgs String类型常量指针的引用，保证传入的实参是常量
{//通过msg获取并且操作订阅到的数据ROS_INFO("翠花订阅的数据：%s",msg->data.c_str());//指针的引用// ROS_INFO("我听见:%s",(*msg_p).data.c_str());
}int main(int argc, char *argv[])
{//解决乱码问题setlocale(LC_ALL,"");// 2.初始化ROS节点ros::init(argc,argv,"cuiHua");//节点名称具有唯一性// 3.创建节点句柄ros::NodeHandle nh;// 4.创建订阅者对象ros::Subscriber sub = nh.subscribe("fang",10,doMsq);//fang是两者的共同话题,doMsq是回调函数// 5.处理订阅到的数据ros::spin();//spin意思是回头，main函数从上往下一次执行，回头调用doMsq函数，doMsq需要被频繁执行return 0;
}

1.1.2 Python

发布方 demo01_pub_p.py

#! /usr/bin/env pythonimport rospy
from std_msgs.msg import String # 发布的消息类型
"""使用python实现消息发布：1.导包；2.初始化ros节点3.创建发布者对象4.编写发布逻辑并发布数据"""
if __name__ == "__main__":# 2.初始化ros节点rospy.init_node("sanDai") # 传入节点名称# 3.创建发布者对象pub = rospy.Publisher("che",String, queue_size = 10) # che是话题名称,类型是String,消息队列大小为10# 4.编写发布逻辑并发布数据# 4.1 创建数据类型msg = String()# 4.2 指定发布频率rate = rospy.Rate(1)# 4.3 设置计数器count = 0# 休眠3s，完成在master下面的注册rospy.sleep(3)# 4.4 循环发布数据while not rospy.is_shutdown(): # 判断当前节点是否已经关闭,没有关闭则发布数据count += 1 # 如果要将count追加到hello后面，则需要将其变为字符串msg.data = "hello" + str(count)# 4.5 发布数据pub.publish(msg)# 4.6 添加日志输出rospy.loginfo("发布的数据:%s",msg.data)rate.sleep()

订阅方 demo01_sub_p.py

#! /usr/bin/env pythonimport  rospy
from std_msgs.msg import String
"""订阅实现流程：1.导包2.初始化ROS节点3.创建订阅者对象4.回调函数处理数据5.spin()
"""def doMsg(msg): #将订阅到的数据传进来rospy.loginfo("订阅的数据：%s",msg.data) #data是数据if __name__ == "__main__":# 2.初始化ROS节点rospy.init_node("huaHua")# 3.创建订阅者对象sub = rospy.Subscriber("che",String,doMsg,queue_size = 10)# sub = rospy.Subscriber("fang",String,doMsg,queue_size = 10) 跨语言通信# 4.回调函数处理数据# 5.spin()rospy.spin()

1.2 自定义msg话题通信

1.2.1 C++实现

发布方 demo02_pub_person.cpp

#include"ros/ros.h"
#include"plumbing_pub_sub/Person.h"
/*发布方：发布人的消息1.包含头文件#include"plumbing_pub_sub/Person.h"2.初始化ROS节点3.创建节点句柄4.创建发布者对象5.编写发布逻辑，发布数据
*/int main(int argc, char  *argv[])
{// 解决中文乱码问题setlocale(LC_ALL,"");// 添加日志ROS_INFO("这是消息发布方");// 2.初始化ROS节点ros::init(argc, argv,"banZhuRen");// 3.创建节点句柄ros::NodeHandle nh;// 4.创建发布者对象ros::Publisher pub = nh.advertise<plumbing_pub_sub::Person>("liaoTian",10); // 消息类型是功能包plumbing_pub_sub下面的Person// 5.编写发布逻辑，发布数据// 5.1 创建被发布的数据plumbing_pub_sub::Person person;person.name = "张三";person.age = 1;person.height = 1.73;// 5.2 设置发布频率ros::Rate rate(1);// 5.3 循环发布数据while(ros::ok()){//修改数据person.age += 1;//核心：数据发布pub.publish(person);//打印消息ROS_INFO("发布的消息:%s,%d,%.2f",person.name.c_str(),person.age,person.height);//休眠rate.sleep();//建议:使用回调函数ros::spinOnce();}return 0;
}

订阅方 demo02_sub_person.cpp

#include"ros/ros.h"
#include"plumbing_pub_sub/Person.h"/*订阅方：订阅的消息1.包含头文件#include"plumbing_pub_sub/Person.h"2.初始化ROS节点3.创建节点句柄4.创建订阅者对象5.处理订阅的数据6.spin()
*/
void doPerson(const plumbing_pub_sub::Person::ConstPtr& person){ROS_INFO("订阅人的信息：%s,%d,%.2f",person->name.c_str(),person->age,person->height);
}int main(int argc, char *argv[])
{// 中文乱码问题setlocale(LC_ALL,"");//添加日志ROS_INFO("订阅方实现");// 2.初始化ROS节点ros::init(argc,argv,"jiaZhang");// 3.创建节点句柄ros::NodeHandle nh;// 4.创建订阅者对象ros::Subscriber sub = nh.subscribe("liaoTian",10,doPerson);// 5.处理订阅的数据// 6.spin()ros::spin();return 0;
}

1.2.2 Python实现

发布方 demo02_pub_person_p.py

#! /usr/bin/env python
"""发布方：发布人的消息1.导包2.初始化ROS节点3.创建发布者对象4.组织发布逻辑并发布数据"""
import rospy
from plumbing_pub_sub.msg import Personif __name__ == "__main__":# 2.初始化ROS节点rospy.init_node("daMa")# 3.创建发布者对象pub = rospy.Publisher("jiaoSheTou",Person,queue_size=10)# 4.组织发布逻辑并发布数据# 4.1 创建Personp = Person()p.name = "奥特曼"p.age = 8p.height = 1.85# 4.2 创建Rate对象rate = rospy.Rate(1)# 4.3 循环发布数据while not rospy.is_shutdown():pub.publish(p)rospy.loginfo("发布的消息：%s,%d,%.2f",p.name,p.age,p.height)rate.sleep()

订阅方 demo02_sub_person_p.py

#! /usr/bin/env python
"""订阅方：订阅人的消息1.导包2.初始化ROS节点3.创建订阅者对象4.处理订阅的数据5.spin()"""import rospy
from plumbing_pub_sub.msg import Persondef doPerson(p):rospy.loginfo("小伙子的数据:%s,%d,%.2f",p.name,p.age,p.height)if __name__ == "__main__":# 2.初始化ROS节点rospy.init_node("daYe")# 3.创建订阅者对象sub = rospy.Subscriber("jiaoSheTou",Person,doPerson,queue_size=10)# 4.处理订阅的数据# 5.spin()rospy.spin()

2. 服务通信

服务通信模型

适用于对时时性有要求、具有一定逻辑处理的应用场景。基于请求响应模式的，是一种应答机制。一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A。

ROS Master 负责保管 Server 和 Client 注册的信息，并匹配话题相同的 Server 与 Client ，帮助 Server 与 Client 建立连接，连接建立后，Client 发送请求信息，Server 返回响应信息。

和话题通信相比，服务通信必须是服务端先启动，然后客户端启动。就是说客户端发起请求时，服务端已经启动。

srv包括请求+响应

srv目录下的AddInts里面进行设置时除了32后面其他地方不能加空格

2.1 服务通信实现

2.1.1 C++实现

服务端 demo01_server.cpp

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
/*服务端实现：解析客户端提交的数据，并运算再产生响应1.包含头文件2.初始化ROS节点3.创建节点句柄4.创建一个服务端对象5.处理请求并产生响应6.spin()
*/bool doNums(plumbing_server_client::AddInts::Request &request,plumbing_server_client::AddInts::Response &response){//1.处理请求int num1 = request.num1;int num2 = request.num2;ROS_INFO("收到的请求数据:num1 = %d,num2 = %d",num1,num2);//2.组织响应int sum = num1 + num2;response.sum = sum;ROS_INFO("求和的结果:sum = %d",sum);return true;
}
int main(int argc, char *argv[])
{//解决乱码问题setlocale(LC_ALL,"");// 2.初始化ROS节点ros::init(argc,argv,"heiShui");//节点名称// 3.创建节点句柄ros::NodeHandle nh;// 4.创建一个服务对象ros::ServiceServer server = nh.advertiseService("addInts",doNums);//addInts是话题名称，用于连接二者ROS_INFO("服务器端启动");// 5.处理请求并产生响应// 6.spin()ros::spin();return 0;
}

客户端 demo02_client.cpp

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
/*客户端：提交两个整数，并处理响应的结果1.包含头文件2.初始化ROS节点3.创建节点句柄4.创建一个客户端对象5.提交请求并产生响应实现参数的动态提交:1.格式：rosrun xxxx xxxxx 12 34 后面两个是需要相加的参数2.节点执行时，需要获取命令中的参数 并组织进request问题：如果先启动客户端，那么会请求异常需求：如果先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求。解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动client.waitForExistence();ros::service::waitForService("话题名称")
*///  char* argv[]：是一个数组，每个元素存储的一个指针，就是穿进去的参数的地址。
int main(int argc, char  *argv[])//字符串数组,数组中存放的是数据的地址，读取时是读取数组里存储的地址对应的数据
{//解决乱码问题setlocale(LC_ALL,"");//优化实现，获取命令中参数，实现动态 // 有1个参数argc为2，函数本身1+参数1=argc2if(argc != 3){ROS_INFO("提交的参数个数不对。");return true;}// 2.初始化ROS节点ros::init(argc,argv,"daBao");// 3.创建节点句柄ros::NodeHandle nh;// 4.创建一个客户端对象ros::ServiceClient client = nh.serviceClient<plumbing_server_client::AddInts>("addInts");//话题是addInts// 5.提交请求并产生响应plumbing_server_client::AddInts ai;// 5.1 组织请求ai.request.num1 = atoi(argv[1]);//argv[1]表示的是12，atoi将字符串变成整型ai.request.num2 = atoi(argv[2]);//argv[2]表示的是34// 5.2 处理响应//判断服务器状态的函数//函数1//client.waitForExistence();//客户端等待，实现挂起功能//函数2ros::service::waitForService("addInts");bool flag = client.call(ai);// true表示正常处理，否则为失败if(flag){ROS_INFO("响应成功");//获取结果ROS_INFO("响应结果：%d",ai.response.sum);}else{ROS_INFO("处理失败");}return 0;
}

2.1.2 Python实现

服务端 demo01_server_p.py

#! /usr/bin/env python # 指定编译器
"""服务端：解析客户端请求，产生响应。1.导包2.初始化ROS节点3.创建服务端对象4.处理逻辑5.spin()
"""import rospy
from plumbing_server_client.srv import AddInts,AddIntsRequest,AddIntsResponse
# import plumbing_server_client import *# 回调函数
# 参数：封装了请求数据 返回值：响应数据
def doNum(request):# 1. 解析提交的两个整数num1 = request.num1num2 = request.num2# 2. 求和sum = num1 + num2# 3. 将结果封装进响应response = AddIntsResponse()response.sum = sum # 将sum赋值给响应对象的sum,即可完成封装rospy.loginfo("服务器解析的数据：num1 = %d, num2 = %d,响应的结果：sum = %d",num1,num2,sum)return responseif __name__ == "__main__":# 2.初始化ROS节点rospy.init_node("heiShui")# 3.创建服务端对象server = rospy.Service("addInts",AddInts,doNum)# Addints表示消息对应类型,addInts表示话题名称rospy.loginfo("服务器已经启动了")# 4.处理逻辑# 5.spin()rospy.spin()

• 问题：如果先启动客户端，那么会请求异常
• 需求：如果先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求
• 解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
• client.waitForExistence()
• ros::service::waitForService(“话题名称”)

客户端 demo02_client_p.py

#! /usr/bin/env python # 指定编译器
"""客户端：组织并提交请求，处理服务端响应1.导包2.初始化ROS节点3.创建客户端对象4.组织请求数据，并且发送请求5.处理来自服务端的响应优化实现:可以在执行节点时，动态传入参数，使用sys问题：客户端先于服务端启动，那么会抛出异常需求：如果客户端先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求。解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
"""import rospy
from plumbing_server_client.srv import AddInts,AddIntsRequest,AddIntsResponse
import sysif __name__ == "__main__":# 判断参数长度if len(sys.argv) != 3:rospy.loginfo("传入的参数个数不对")sys.exit(1)# 2.初始化ROS节点rospy.init_node("erHei")# 3.创建客户端对象client = rospy.ServiceProxy("addInts",AddInts)# 4.组织请求数据，并且发送请求,call函数就是发请求的# 解析传入的参数 argv[0]表示程序名num1 = int(sys.argv[1])num2 = int(sys.argv[2]) # 将字符串转化为整型# 在客户端之后，发送请求之前调用。等待服务器启动# client.wait_for_service()rospy.wait_for_service("addInts")response = client.call(num1,num2)# 5.处理来自服务端的响应rospy.loginfo("相应的数据：%d",response.sum)

• 问题：客户端先于服务端启动，那么会抛出异常
• 需求：如果客户端先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求
• 解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
• 法1：client.wait_for_service()
• 法2：rospy.wait_for_service(“addInts”)

3. 参数服务器

实现不同节点之间的数据共享

参数服务器相当于是独立于所有节点的一个公共容器，可以将数据存储在该容器中，被不同的节点调用，不同的节点也可以往其中存储数据。

• rosparam list：可以列出参数服务器里的参数
• rosparam get /type：得到类型参数的具体值
• rosparam get /type_param

3.1 增改

3.1.1 C++实现 demo01_param_set.cpp

#include"ros/ros.h"
/*需要实现参数的新增和修改需求：属县设置机器人的共享参数，类型，半径（0.15m）再修改半径（0.2m）实现：ros::NodeHandlesetParam("键"，值)ros::paramset("键",值)修改，只需要继续调研 setParam 或者 set函数，保证键是已经存在的，那么值会覆盖
*/int main(int argc, char *argv[])
{// 初始化ROS节点ros::init(argc,argv,"set_param_c");// 创建ROS节点句柄ros::NodeHandle nh;// 参数增-------------------------// 方案1:nhnh.setParam("type","xiaoHuang");// 类型nh.setParam("radius",0.15);// 半径// 方案2:ros::paramros::param::set("type_param","xiaoBai");ros::param::set("radius_param",0.15);// 参数改-------------------------// 方案1:nhnh.setParam("radius",0.2);//参数的覆盖// 方案2:ros::paramros::param::set("radius_param",0.25);return 0;
}

3.1.2 Python实现 demo01_param_set_p.py

#! /usr/bin/env pythonimport rospy
"""演示参数的新增与修改需求：子阿参数服务器中设置机器人属性：型号，半径"""if __name__ == "__main__":# 初始化ros节点rospy.init_node("param_set_p")# 新增参数rospy.set_param("type_p","xiaoHuangChe") # 设置 键，值rospy.set_param("radius_p",0.5)# 修改参数rospy.set_param("radius_p",0.2) # 后面的语句会覆盖前面的值

3.2 查

3.2.1 C++实现 demo02_param_get.cpp

#include "ros/ros.h"
/*演示参数查询实现：ros::NodeHandle--------------------param(键,默认值) 存在，返回对应结果，否则返回默认值getParam(键,存储结果的变量)存在,返回 true,且将值赋值给参数2若果键不存在，那么返回值为 false，且不为参数2赋值getParamCached键,存储结果的变量)--提高变量获取效率存在,返回 true,且将值赋值给参数2若果键不存在，那么返回值为 false，且不为参数2赋值getParamNames(std::vector<std::string>)获取所有的键,并存储在参数 vector 中 hasParam(键)是否包含某个键，存在返回 true，否则返回 falsesearchParam(参数1，参数2)搜索键，参数1是被搜索的键，参数2存储搜索结果的变量ros::param-------------------------set("键",值)
*/int main(int argc, char *argv[])
{// 设置编码setlocale(LC_ALL,"");// 初始化ROS节点ros::init(argc,argv,"get_param_c");// 创建节点句柄ros::NodeHandle nh;// ros::NodeHandle--------------------// 1.paramdouble radius = nh.param("radius",0.5);//查询键为radius的值，没有的话返回0.5ROS_INFO("radius = %.2f",radius);// 2.getParamdouble radius2 = 0.0;bool result = nh.getParam("radius",radius2);// 第1个是键，第2个是存储结果的变量if(result){ROS_INFO("获取的半径是:%.2f",radius2);}else{ROS_INFO("被查询的变量不存在");}// 3.getParamCached 与getParam类似，底层性能有提升，一般测试下，看不出来// double radius3 = 1.0;// bool result = nh.getParamCached("radius",radius3);// if(result)// {//     ROS_INFO("获取的半径是:%.2f",radius3);// }else{//     ROS_INFO("被查询的变量不存在");// }// 4.getParamNamesstd::vector<std::string> names;nh.getParamNames(names);// 遍历names,获取每个键的名称for(auto &&name : names){ROS_INFO("遍历的元素:%s",name.c_str());//转化成c风格的字符串}// 5.hasParam 判断元素是否存在bool flag1 = nh.hasParam("radius");bool flag2 = nh.hasParam("radiusxxx");ROS_INFO("radius 存在吗？ %d",flag1);ROS_INFO("radiusxxx 存在吗？ %d",flag2);// 6.searchParam 搜索键std::string key;nh.searchParam("radius",key);ROS_INFO("搜索结果：%s",key.c_str());// ros::param-------------------------double radius_param = ros::param::param("radius",10);// 如果查询不到，就用默认值ROS_INFO("radius_param = %.2f",radius_param);std::vector<std::string> names_param;ros::param::getParamNames(names_param);for(auto &&name : names_param){ROS_INFO("键：%s",name.c_str());// 转成c风格}return 0;
}

3.2.2 Python实现 demo02_param_get_p.py

#! /usr/bin/env pythonimport rospy
"""参数服务器操作之查询_Python实现:    get_param(键,默认值)当键存在时，返回对应的值，如果不存在返回默认值get_param_cached 和get_param 使用一致，效率高get_param_names获取所有参数键的集合has_param判断是否包含某个键search_param查找某个参数的键，并返回完整的键名"""if __name__ == "__main__":rospy.init_node("get_param_p")# 1.get_param 根据键获取参数的值radius1 = rospy.get_param("radius_p",0.5)radius2 = rospy.get_param("radius_pxxx",0.5)rospy.loginfo("radius1 = %.2f",radius1)rospy.loginfo("radius2 = %.2f",radius2)# 2.get_param_cached  效率比第1个高radius3 = rospy.get_param("radius_p",0.5)radius4 = rospy.get_param("radius_pxxx",0.5)rospy.loginfo("radius3 = %.2f",radius1)rospy.loginfo("radius4 = %.2f",radius2)# 3.get_param_names 遍历包names = rospy.get_param_names()for name in names:rospy.loginfo("name = %s",name)# 4.has_param 判断某个键是否存在flag1 = rospy.has_param("radius_p")if flag1:rospy.loginfo("radius_p 存在")else:rospy.loginfo("radius_p 不存在")flag2 = rospy.has_param("radius_pxxx")if flag2:rospy.loginfo("radius_pxxx 存在")else:rospy.loginfo("radius_pxxx 不存在")# 5.search_param 查询是否存在，存在则返回键名key = rospy.search_param("radius_p")rospy.loginfo("key = %s",key)

3.3 删

3.3.1 C++实现 demo03_param_del.cpp

#include"ros/ros.h"/*实现：ros::NodeHandledeleteParam()ros::paramdel()
*/int main(int argc, char *argv[])
{setlocale(LC_ALL,"");ros::init(argc,argv,"param_del_c");ros::NodeHandle nh;//删除：NodeHandlebool flag1 = nh.deleteParam("radius");if(flag1){ROS_INFO("删除成功");}else{ROS_INFO("删除失败");}//删除：ros::parambool flag2 = ros::param::del("radius_param");if(flag2){ROS_INFO("radius_param删除成功");}else{ROS_INFO("radius_param删除失败");}return 0;
}

3.3.2 Python实现 demo03_param_del_p.py

#! /usr/bin/env pythonimport rospy
"""演示参数删除：delete_param()
"""if __name__ == "__main__":rospy.init_node("del_param_p")# 使用try捕获异常，使它不显示错误(第2次删除会抛出异常)try:# 删除参数rospy.delete_param("radius_p")except Exception as e:rospy.loginfo("被删除的参数不存在")

ROS 通信机制(已整理)相关推荐

1. ROS自主导航学习———ROS通信机制

   前言 前面ROS很多都忘记了 ,现在来重新回顾一下内容 ROS 中的基本通信机制主要有如下三种实现策略: 话题通信(发布订阅模式) 服务通信(请求响应模式) 参数服务器(参数共享模式) Action通 ...

2. Chapter2 ROS通信机制----基础篇(Ⅰ)vs配置及通信基础

   目录 一.复习及launch 1.1 深入理解配置信息(非常重要) 1.2 launch文件演示 二.ROS通信机制-----基础 2.1 本节导论 2.2 话题通信 2.2.1 话题通信概述 2.2 ...

3. ROS通信机制——发布/订阅者模型

   目录 发布/订阅者模型 (一)发布者 (二)订阅者 (三)综合 参考资料 ROS (Robot Operating System),即机器人操作系统,是为了加快机器人的开发效率,提高机器人软件代码的复 ...

4. 【ROS理论与实践-赵虚左老师】Chap2 ROS通信机制

   第二章 ROS通信机制 通信是ROS中的核心 Core 机器人是一种高度复杂的系统性实现,在机器人上可能集成各种传感器(雷达.摄像头.GPS-)以及运动控制实现,为了解耦合,在ROS中每一个功能点都是 ...

5. ROS入门跟着我就够了（二）上 ROS通信机制

   由于这一章东西比较多,我分了上下两篇,下部分可以在< ROS 入门跟着我就够了>专辑中查看 ROS 中的基本通信机制主要有如下三种实现策略: 话题通信(发布订阅模式)服务通信(请求响应模式 ...

6. ROS通信机制一---话题通信

   文章目录 总述 1. 话题通信模型 2. 话题通信基本实现示例 2.1 发布者 2.1.1 创建发布者topic_pub.cpp文件 2.1.2 修改CMakeLists.txt文件 2.1.3 编译 ...

7. ROS通信机制--键盘控制乌龟运动线速度角速度XYZ值的解释

   目录 前言 案例实现 线速度角速度X.Y.Z值的取值和作用 (END) 前言 在学习ros之初,想必大家运行的第一个案例就是键盘控制乌龟运动.这是ros内置的小案例,采用的通信机制为话题通信.本文介绍 ...

8. 6th ROS通信机制概述

   ROS通信是ROS的核心之一. 一.基本概念 节点(Node) 一个节点就表示一个进程 多节点.端到端.分布式通信机制 消息(Message) 节点之间通过订阅和发布传递的数据 可以使用ROS提供的消 ...

9. ROS通信机制：话题、服务、参数

   目录 话题通信 理论模型 流程 通信样例 自定义消息的通信 服务通信 理论模型 服务通信自定义srv 参数服务器 理论模型 参数操作 话题通信 话题通信是ROS中使用频率最高的一种通信模式,话题通信是 ...

最新文章

1. sohu广告js代码调研
2. 互联网10年，激战如梦
3. python生成对象内部执行过程
4. Open×××的Linux内核版，鬼魅的残缺 part I:The PROTOCOL
5. 江西师范大学c语言程序考研,2018年江西师范大学程序设计（C语言）考研大纲
6. 新星云集！CVPR 论文分享会圆桌论坛：计算机视觉科研​之“路”
7. 洛谷 P4300 BZOJ 1266 [AHOI2006]上学路线route
8. *pdb时出错；请检查是否是磁盘空间不足、路径无效或权限不够
9. NET学习笔记-3：垃圾回收与内存管理
10. 如何成长为一名合格的web架构师？
11. oracle 游标取字段名称,Oracle使用游标查询指定数据表的所有字段名称组合而成的字符串...
12. 计算机专业黑板报迎新,开学迎新黑板报_迎新学期黑板报高三
13. 计算机专业认识实习目的,计算机专业实习目的与意义
14. Windows二进制文件合并工具
15. 使用安全浏览器将网页保存为pdf的方法步骤
16. 对象存储介绍（腾讯云cos）
17. hdmi接口线_HDMI高清线不能随便买，这五点要记住
18. 80端口被封 php跳转,80端口打不开网站问题
19. genymotion配置android模拟器
20. 数据库的三才阵——人

热门文章

1. NLP英文缩写词性含义
2. 【DS实践 | Coursera】Assignment3 | Introduction to Data Science in Python
3. 软技能-代码外的生存指南PDF下载
4. 使用WordPress插件搭建一个商城（一）（小白推荐）
5. 解决PotPlayer播放视频没有声音
6. STA静态时序分析——学习笔记
7. 0. Redis-Server（操作）
8. Science: 重新“野化“ 植物微生物组
9. (*visit)(TElemType e )函数指针理解
10. SAGA GIS使用教程