ros 工作空间的覆盖、c++编程接口实现通信方式、自定义消息格式、分布式多机通信

最新推荐文章于 2022-05-09 15:47:23 发布
最新推荐文章于 2022-05-09 15:47:23 发布
阅读量2k 收藏 16
点赞数 1
分类专栏： ROS 文章标签： ros c 自定义消息服务 多机通讯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li528405176/article/details/82776710
版权

目录

工作空间的覆盖

通信方式的c++实现

话题

服务

动作

分布式通信

多机通讯

工作空间的覆盖

同一个工作空间下，不允许出现同名的功能包，否则无法编译。不同工作空间下，允许出现同名的功能包，但会出现工作空间覆盖的现象。

ros工作空间的路径记录在ROS_PACKAGE_PATH环境变量中，可以通过env命令查看计算机中的环境变量，再利用管道过滤出有关ros的环境变量。

env | grep ros

新添加的工作空间路径会自动放置在ROS_PACKAGE_PATH环境变量最前端。ros运行时，会按照顺序从前往后查找工作空间中是否存在指定的功能包。一旦找到指定的功能包就不再查找后面的工作空间。因此，如果我们的系统当中存在名称相同的功能包，就会出现工作空间向后覆盖的问题。当我们使用rospack find命令查找功能包的时候，只能查找到最新路径下的同名功能包，而一旦有第三方功能包依赖于原来的同名功能包，就有可能会出现问题。

通信方式的c++实现

话题

发布者实现步骤大致如下：

1、初始化ROS节点

2、向ROS Master注册节点信息，包括发布的话题名，消息类型

3、设置一定的频率循环发布消息

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

int main(int argc,char **argv)
{
    ros::init(argc,argv,"talker"); //ROS节点的初始化，指定节点名称为talker
    ros::NodeHandle n; //创建节点句柄
    ros::Publisher pub=n.advertise<std_msgs::String>("greet",1000); 
    //创建一个发布者pub，指定消息类型为std_msgs::String，话题名称为greet，1000为缓存队列的长度
    ros::Rate loop_rate(10); //设置循环的频率
    int count=0;
    while(ros::ok())
    {
        std_msgs::String msg; //创建消息对象
        std::stringstream ss;
        ss<<"hello world"<<count;
        msg.data=ss.str(); //初始化消息
        ROS_INFO("%s",msg.data.c_str());
        pub.publish(msg); //发布消息
        ros::spinOnce(); //等待消息调用一次回调函数
        loop_rate.sleep(); //按照循环频率休眠
        ++count;
    }

    return 0;
}

订阅者实现步骤大致如下：

1、初始化ROS节点

2、向ROS Master注册节点信息，包括订阅的话题名，回调函数

3、循环等待话题消息，接收到消息后进入回调函数

4、在回调函数中处理消息

#include "ros/ros.h"
#include "std_msgs/String.h"

void greetCallback(const std_msgs::String::ConstPtr& msg)
// 接收到订阅的消息后，会进入消息回调函数
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());// 将接收到的消息打印出来
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "listener");// 初始化ROS节点
  ros::NodeHandle n;// 创建节点句柄
  ros::Subscriber sub = n.subscribe("greet", 1000, greetCallback);
  // 创建一个Subscriber，订阅名为greet的topic，注册回调函数greetCallback
  ros::spin();// 循环等待消息调用回调函数
  return 0;
}

修改CMakeLists文件

1）、设置要编译的文件

 add_executable(${PROJECT_NAME}_node src/a_node.cpp)

其中，${PROJECT_NAME}_node 代表节点名称，a_node.cpp 表示对应的c++文件，修改这两个参数即可。当然有时候一个节点可能对应着多个c++文件，这种情况需要把所有需要的文件名都列出来。

add_executable(talker src/talker.cpp)
add_executable(listener src/talker.cpp)

2）、设置链接库

 target_link_libraries(${PROJECT_NAME}_node
   ${catkin_LIBRARIES}
 )

其中，${PROJECT_NAME}_node 表示节点名称，这里只需要修改这一个参数即可，因为没有使用第三方的链接库。${catkin_LIBRARIES} 代表的是默认的ros catkin链接库，如果我们用到了第三方库的时候可以将第三方库的名称放到默认库后面即可。

target_link_libraries(talker    ${catkin_LIBRARIES}  )
target_link_libraries(listener    ${catkin_LIBRARIES}  )

3）、设置依赖

add_dependencies(${PROJECT_NAME}_node
${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS}
)

其中，${PROJECT_NAME}_node  表示节点名称，${${PROJECT_NAME}_EXPORTED_TARGETS} 表示在本package中依赖的消息，${catkin_EXPORTED_TARGETS} 表示对其他package消息的依赖。

当使用自定义的message、service、action时注意添加。这里的例子当中并没有使用自定义的消息，所以不用添加依赖。

编译功能包

回到工作空间，运行catkin_make对功能包进行编译。编译完成后即可生成talker和listener两个可执行文件，设置好工作空间的环境变量之后就可以通过rosrun来运行了，效果如下：

ldz@MSI:~$ rosrun a talker
[ INFO] [1537440776.481837500]: hello world0
[ INFO] [1537440776.582547600]: hello world1
[ INFO] [1537440776.682226900]: hello world2
[ INFO] [1537440776.781844500]: hello world3
[ INFO] [1537440776.882372400]: hello world4
[ INFO] [1537440776.982076300]: hello world5
[ INFO] [1537440777.082023100]: hello world6
[ INFO] [1537440777.181946400]: hello world7
[ INFO] [1537440777.283714400]: hello world8
ldz@MSI:~$ rosrun a listener
[ INFO] [1537863017.967429700]: I heard: [hello world75]
[ INFO] [1537863018.067197800]: I heard: [hello world76]
[ INFO] [1537863018.166951500]: I heard: [hello world77]
[ INFO] [1537863018.267036300]: I heard: [hello world78]
[ INFO] [1537863018.367167600]: I heard: [hello world79]
[ INFO] [1537863018.467182300]: I heard: [hello world80]
[ INFO] [1537863018.567118800]: I heard: [hello world81]
[ INFO] [1537863018.666904400]: I heard: [hello world82]
[ INFO] [1537863018.767226700]: I heard: [hello world83]

自定义话题消息

1）、定义 .msg 文件

话题消息的定义格式：

定义一个变量列表即可，类似于c语言结构体。定义变量：数据类型+变量名 eg：我们自定义一个学生基本信息的消息stu.msg

 

如上图，自定义消息格式中还可以定义符号常量，类似于c语言中的define。即male代表1，female代表2，可以直接将这两个符号常量赋给sex。

2）、修改package.xml文件，添加功能包依赖

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

indigo之前的ros版本需要将exec_depend改成run_depend。

3）、修改CMakeLists.txt文件，添加编译选项

find_package(...... message_generation) #生成自定义的消息需要使用message_generation功能包

catkin_package(CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime) #添加编译依赖message_runtime

add_message_files(FILES Person.msg) #添加消息文件
generate_messages(DEPENDENCIES  std_msgs) #添加生成依赖

经过以上三个步骤，我们就可以使用catkin_make对自定义消息进行编译了。编译完成之后，会在工作空间的 devel/include/【功能包名】路径下生成自定义消息的头文件 stu.h 。编写节点时只要包含了这个头文件( #include<【功能包名】/ stu.h> )就可以使用这个消息进行通信了。使用该消息类型创建消息对象的方式为: 【功能包名】:: stu  对象名;  。

服务

自定义服务消息

1）、定义 .srv 文件

服务类型的定义格式：

变量的定义方式与话题消息一致，即：数据类型+变量名，但与消息不同的是，需要用三个短横线(---)把请求数据和应答数据分隔开。 eg：我们自定义一个加法的服务addition.srv

2）、修改package.xml文件，添加功能包依赖（同msg操作）

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

3）、修改CMakeLists.txt文件，添加编译选项（除添加的文件不同，其他与msg操作相同）

find_package(...... message_generation) #生成自定义的消息需要使用message_generation功能包

catkin_package(CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime) #添加编译依赖message_runtime

​add_service_files(FILES addition.srv) #添加服务类型文件addition.srv
generate_messages(DEPENDENCIES  std_msgs) #添加生成依赖

经过以上三个步骤，我们就可以使用catkin_make对自定义服务进行编译了。编译完成之后，会在工作空间的 devel/include/【功能包名】路径下生成自定义服务的头文件 addition.h、additionRequest.h、additionResponse.h 。编写节点时只要包含第一个头文件( #include<【功能包名】/ addition.h> )就可以使用这个服务进行通信了。使用该服务类型创建服务对象的方式为: 【功能包名】:: addition  对象名;  。

 

服务器实现步骤大致如下：

1、初始化ROS节点

2、创建server实例

3、循环等待服务请求，接收到请求后进入回调函数

4、在回调函数中处理服务请求，并反馈应答数据

#include "ros/ros.h"
#include "a/addition.h"
// service回调函数，输入参数req，输出参数res
bool add(a::addition::Request  &req, a::addition::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::init(argc, argv, "add_two_ints_server"); // ROS节点初始化
  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处理之后的应答结果

#include <cstdlib>
#include "ros/ros.h"
#include "a/addition.h"
int main(int argc, char **argv)
{
  ros::init(argc, argv, "add_two_ints_client");// ROS节点初始化
  // 从终端命令行获取两个数
  if (argc != 3)
  {
    ROS_INFO("usage: add_two_ints_client X Y");
    return 1;
  }
  ros::NodeHandle n;// 创建节点句柄
  // 创建一个client，请求add_two_int service，service消息类型是a::addition
  ros::ServiceClient client = n.serviceClient<a::addition>("add_two_ints");
  a::addition srv;// 创建a::addition类型的service消息
  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;
}

修改CMakeLists文件

1）、设置要编译的文件（同话题）

add_executable(server src/server.cpp)
add_executable(client src/client.cpp)

2）、设置链接库（同话题）

target_link_libraries(server    ${catkin_LIBRARIES}  )
target_link_libraries(client    ${catkin_LIBRARIES}  )

3）、设置依赖（同话题）

add_dependencies(server ${PROJECT_NAME}_gencpp)
add_dependencies(client ${PROJECT_NAME}_gencpp)

编译功能包

回到工作空间，运行catkin_make对功能包进行编译。编译完成后即可生成server和client两个可执行文件，然后就可以通过rosrun来运行了，效果如下：

ldz@MSI:~$ rosrun a client 1 2
[ INFO] [1537523575.202664700]: Sum: 3
ldz@MSI:~$ rosrun a server
[ INFO] [1537523561.898041700]: Ready to add two ints.
[ INFO] [1537523575.202092800]: request: x=1, y=2
[ INFO] [1537523575.202301100]: sending back response: [3]

动作

自定义动作消息

1）、定义 .action文件

服务类型的定义格式：

变量的定义方式与话题以及服务消息一致，即：数据类型+变量名，但与消息和服务不同的是，需要动作消息需要用两条由三个短横线(---)构成的虚线把目标信息、结果信息和反馈信息分隔开。 eg：我们自定义一个洗碗机的服务DoDishes.srv

第一部分定义的是目标数据，使用哪一台洗碗机；第二部分定义的是结果数据，任务成功完成与否；第三部分定义的是周期反馈的状态数据，任务完成的进度。

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文件，添加编译选项（除添加的文件不同，其他与msg操作相同）

find_package(......  actionlib_msgs actionlib) #生成自定义的消息需要使用 actionlib_msgs、actionlib功能包

​add_action_files(FILES DoDishes.action) #添加动作消息文件DoDishes.action
generate_messages(DEPENDENCIES  actionlib_msgs) #添加生成依赖

经过以上三个步骤，我们就可以使用catkin_make对自定义动作进行编译了。编译完成之后，会在工作空间的 devel/include/【功能包名】路径下生成自定义动作的头文件 DoDishesAction.h、DoDishesActionFeedback.h、DoDishesActionResult.h 、DoDishesResult.h、DoDishesActionGoal.h、DoDishesFeedback.h、DoDishesGoal.h。编写节点时只要包含第一个头文件( #include<【功能包名】/ DoDishesAction.h> )就可以使用这个动作进行通信了。

 

服务器实现步骤大致如下：

1、初始化ROS节点

2、创建action server实例

3、启动服务器，等待动作请求

4、接收到请求后进入回调函数处理动作请求，并反馈进度信息

5、动作完成，发送结束信息

#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include "a/DoDishesAction.h"
typedef actionlib::SimpleActionServer<a::DoDishesAction> Server;

// 收到action的goal后调用该回调函数
void execute(const a::DoDishesGoalConstPtr& goal, Server* as)
{
    ros::Rate r(1);
    a::DoDishesFeedback feedback;
    ROS_INFO("Dishwasher %d is working.", goal->dishwasher_id);
    // 假设洗盘子的进度平均为10%，并且按照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、创建action client实例

3、连接动作服务器

4、发送动作目标

5、根据服务器的不同反馈信息，处理回调函数

#include <actionlib/client/simple_action_client.h>
#include "a/DoDishesAction.h"
typedef actionlib::SimpleActionClient<a::DoDishesAction> Client;

// 当action完成后会调用该回调函数一次
void doneCb(const actionlib::SimpleClientGoalState& state,
        const a::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 a::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.");
    a::DoDishesGoal goal;  // 创建一个action的goal
    goal.dishwasher_id = 1;
    // 发送action的goal给服务器端，并且设置回调函数
    client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);
    ros::spin();
    return 0;
}

修改CMakeLists文件

1）、设置要编译的文件（同话题）

add_executable(DoDishes_client src/DoDishes_client.cpp) 
add_executable(DoDishes_server src/DoDishes_server.cpp)

2）、设置链接库（同话题）

target_link_libraries(DoDishes_client    ${catkin_LIBRARIES}  )
target_link_libraries(DoDishes_server    ${catkin_LIBRARIES}  )

3）、设置依赖（同话题）

add_dependencies(DoDishes_client ${${PROJECT_NAME}_EXPORTED_TARGETS})
add_dependencies(DoDishes_server ${${PROJECT_NAME}_EXPORTED_TARGETS})

编译功能包

回到工作空间，运行catkin_make对功能包进行编译。编译完成后即可生成DoDishes_client和DoDishes_server两个可执行文件，然后就可以通过rosrun来运行了，效果如下：

ldz@MSI:~$ rosrun b DoDishes_client
[ INFO] [1537541980.774761400]: Waiting for action server to start.
[ INFO] [1537541981.204468700]: Action server started, sending goal.
[ INFO] [1537541981.205188000]: Goal just went active
[ INFO] [1537541981.206087300]:  percent_complete : 10.000000
[ INFO] [1537541982.205776000]:  percent_complete : 20.000000
[ INFO] [1537541983.205963000]:  percent_complete : 30.000000
[ INFO] [1537541984.205360000]:  percent_complete : 40.000000
[ INFO] [1537541985.205488100]:  percent_complete : 50.000000
[ INFO] [1537541986.205560800]:  percent_complete : 60.000000
[ INFO] [1537541987.205739900]:  percent_complete : 70.000000
[ INFO] [1537541988.205424100]:  percent_complete : 80.000000
[ INFO] [1537541989.205597000]:  percent_complete : 90.000000
[ INFO] [1537541990.205898500]:  percent_complete : 100.000000
[ INFO] [1537541991.208537400]: Yay! The dishes are now clean
ldz@MSI:~$ rosrun b DoDishes_server
[ INFO] [1537541981.205257600]: Dishwasher 1 is working.
[ INFO] [1537541991.207887100]: Dishwasher 1 finish working.

分布式通信

前面我们介绍ros的时候提到，它是一种分布式的软件框架，节点之间通过松耦合的方式进行组合。

多机通讯

设置IP地址，确认网络连通性

首先需要将 对方主机的ip地址和主机名 添加到 本机的 /etc/hosts 文件 中：

sudo vi /etc/hosts

然后在终端中使用 ping 命令测试网络连通性。

ldz@MSI:~$ ping ldz-dell
PING ldz-dell (192.168.43.144) 56(84) bytes of data.
64 bytes from ldz-dell (192.168.43.144): icmp_seq=1 ttl=64 time=1415 ms
64 bytes from ldz-dell (192.168.43.144): icmp_seq=2 ttl=64 time=1587 ms
64 bytes from ldz-dell (192.168.43.144): icmp_seq=3 ttl=64 time=1450 ms
ldz@ldz-dell:~$ ping MSI
PING MSI (192.168.43.64) 56(84) bytes of data.
64 bytes from MSI (192.168.43.64): icmp_seq=1 ttl=64 time=1351 ms
64 bytes from MSI (192.168.43.64): icmp_seq=2 ttl=64 time=1597 ms
64 bytes from MSI (192.168.43.64): icmp_seq=3 ttl=64 time=1692 ms

在从机中设置节点管理器所在的地址(ROS_MASTER_URI)

在 .bashrc文件中追加一句，设置节点管理器的地址在主控机的11311端口，11311为节点管理器的默认端口，这里的MSI是我的主控机主机名。

echo "export ROS_MASTER_URI=http://MSI:11311" >> ~/.bashrc
source ~/.bashrc

OK，经过以上配置，我们的多机通讯环境就搭建好了。只要我们就在主控机上运行节点管理器，所有从机上就都可以运行节点了，而不必在每个机器上都运行节点管理器。

 

 

 

 

 

 

 

 

 

 

 

 

Jack LDZ
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
兼容ros1 ros2自定义消息的cmakelists.txt文件与package.xml文件
04-14
兼容ros1 ros2自定义消息的cmakelists.txt文件与package.xml文件
自定义通信协议（实用）
ArthurBruin‘s Blogs
03-08 5517
自定义通信协议（实用） 现在大部分的仪器设备都要求能过通过上位机软件来操作，这样方便调试，利于操作。其中就涉及到通信的过程。在实际制作的几个设备中，笔者总结出了通信程序的通用写法，包括上位机端和下位机端等。 1．自定义数据通信协议   这里所说的数据协议是建立在物理层之上的通信数据包格式。所谓通信的物理层就是指我们通常所用到的RS232、RS485、红外、光纤、无线等等通信方式。在这个层面上
ROS分布式多机通信
wpthad的博客
05-09 514
ROS作为一种分布式软件框架，允许节点之间以松耦合的方式组合，但是ROS中只允许存在一个Master，其他机器要通过ssh的方式和Master取得联系，以下为多机系统的配置步骤。 设置IP地址 配置多机系统首先要求所有的计算机处于同一局域网内，然后分别在两台机器上使用ifconfig命令查看IP地址，结果如下： 之后在两台计算机的/etc/hosts文件中加入对方的IP和计算机名 # @enp2s0 192.168.0.18 niubot # @eth0 192.168.0.18 sil
ROS与C++
acxm45824的博客
01-11 492
构建工作空间 catkin_make构建Catkin包 catkin_create_pkg# This is an example, do not try to run this # catkin_create_pkg <package_name> [depend1] [depend2] [depend3]搭建开发环境 catkin_makeros_qtc_plugin 官网...
【ros学习】10.ros服务通讯之Server与Client的c++实现
ArtemisKhryso的博客
10-01 420
1.Server #include <ros/ros.h> #include <service_demo/Greeting.h> bool handle_function(service::demo::Greeting::Request &req, service::demo::Greeting::Response &res){ //显示请求信息 ROS_INFO("Request from %s with age %d", req.name.c_s
自定义通讯协议
Orson的博客
03-04 1265
摘要： 1、为了降低程序的复杂度，尽量采取单向查询方式； 2、为了确认通讯正常，每隔一段时间应有心跳查询命令从主控端发送到从机端； 3、主控端每次发送一条消息之后，应检查是否有回应；从机端每次收到一条消息后，应返回消息作为响应； 4、消息发送之后如果没有回复，或回复的消息表明出现错误了，应有重发机制；重发机制的时间间隔和重发次数应仔细考虑； 5、为了向后兼容，通讯协议中应包含版本号；
ROS服务通信C++实现服务端客户端程序
04-17
ROS服务通信C++实现服务端客户端程序
ROS笔记 – 自定义消息格式
01-06
CMakeList.txt修改（按内容在CMakeList.txt中的顺序） ...添加自定义msg的文件名，如下 add_message_files( FILES mymsg.msg ) 79行左右，添加如下内容以生成头文件 generate_messages( DEPENDENCI
ros+rviz+自定义消息+自定义插件
最新发布
08-17
1.包含自定义消息 2.包含Panel类型的自定义插件 3.包含Display类型的自定义插件
ROS学习自定义msg C++ Python实现代码
04-17
ROS学习自定义msg C++ Python实现代码
2.5 自定义通讯数据包协议
oDuanYanGuHong的博客
03-02 577
文章目录前言一、通讯协议二、各个命令1--升级命令 U2-- 读取设备缓冲状态3—发送数据4—确认总结 前言 不知道你们定义通讯数据包格式是什么样的？我刚开始“包头+数据+包尾“，这样就算好了。虽然能用，但是过于粗糙，因为不够严谨所以可能回丢包，也导致比较难添加新命令。 提示：以下是本篇文章正文内容，下面案例可供参考 一、通讯协议 一．数据以命令包的形式发送 二．通讯方式：半双工 三．设备： 包头 {| 两个字节 ASCII 0X7B,0X7C + 包长度2 BYTE(每字节值0-99) 共计
多人在线斗地主游戏开发——自定义TCP网络通信协议包格式
木可的博客
07-16 1722
什么叫做通信协议？为什么制定通信协议？ 怎么制定通信协议？ 不知道大家有没有迷茫过这个问题，反正我是有的，，， 想我在刚接触网络编程的时候，是linux下用socket懵懵懂懂地按照pdf书籍上的代码敲了个非常简单的C/S架构的 聊天程序， Client端发一个字符串，服务器接收到打印后，再返回一个字符串，敲完了后，自己运行着这个‘很牛 很高大上’的程序，玩得不亦乐乎，同时脑子...
ROS学习（二）——服务通信的C++实现
lurenjia1256的博客
02-17 1055
ROS学习（二）——服务通信的C++实现. 引言：本文分为三个部分，分别为服务通信的理论模型、自定义srv文件的导入以及服务端和响应端对应的C++实现。 一、服务通信理论模型 服务通信的理论模型与单片机的中断模式类似，我们先将服务端程序挂起，然后只有当客户端发出请求的时候，服务端才会响应，调用对应的回调函数。在这里我们也举一个比较简单的例子：服务端进行加和运算，把客户端发来的两个数字求和并输出。 二、自定义srv文件的导入 在本例子中，我们需要3个变量：即客户端要输入的2个数字num1，num2，以及服务端
ROS报错处理(持续更新)
热门推荐
德prince
08-22 2万+
1、运行节点时报错： [rospack] Error: package 'test' not found 没有找到ros功能包，原因是没有为功能包配置系统环境，可以利用source运行工作空间中devel目录下的setup.bash配置文件并使配置立即生效。setup.bash脚本的作用是让一些ros* 开头的命令可以使用，同时还能够创建一些ROS开头的环境变量eg：ROS_PACKAGE_P...
ros入门 工程目录结构、节点通信方式、基本操作命令
德prince
03-27 1万+
目录 ROS(Robot Operating System) ros的特点 ros的系统实现 ROS(Robot Operating System) ros的基本框架是斯坦福大学人工智能实验室在STAIR项目与机器人技术公司Willow Garage的个人机器人项目（Personal Robots Program）之间的合作中为了提高机器人研发中的软件复用率，由吴恩达教授指导的Morga...
ros 机器人系统设计、urdf机器人建模
德prince
10-30 5810
目录 机器人的定义 机器人的组成 移动机器人系统构建 传感器的使用 urdf 机器人建模 建模实践 机器人的定义 自动执行工作的机器装置。可以根据预先编写的程序或者接受人类指挥来行动，最终目标是使其能够脱离人的干预，根据以人工智能技术制定的原则和策略自主行动，以协助或取代人类工作。 机器人的组成 从控制的角度来看，机器人可以划分为四个部分：执行机构、传感系统、驱动系统、控制系统...
在仿真环境下基于数据包和RGB-D相机运行ORB_SLAM2功能包
德prince
07-23 5576
目录 1、仿真环境 2、安装功能包及其依赖 3、功能演示 ORB_SLAM是基于特征点的实时单目slam功能包,发布于2015年。翌年，作者又发布了支持Monocular（单目）、RGB-D（深度）、Stereo（双目）摄像头的ORB_SLAM2功能包。接下来演示功能包中的mono和rgbd两个算法的运行过程和效果，其中mono算法采用基于官方数据包的方式来运行，rgbd算法采用基于机器人...
ROS部署到机器人小车并实现底层电机控制过程中遇到的问题
德prince
09-20 2574
任务：在实验室原有的基于can总线控制的移动机器人平台上应用ROS步骤：1.ROS推荐系统为ubuntu，首先需要重装机器人的操作系统。            2.下载并安装ROS。            3.原can卡不支持linux系统，须更换机器人的usbcan设备。            4.利用所购产品附带的测试代码(c语言)测试硬件连接以及驱动和共享库的安装是否正常（即usbcan设备...
详细介绍ROS机器人的分布式计算和多机通信
03-11
ROS机器人的分布式计算和多机通信是指在ROS系统中，多个机器人或者多个计算机之间进行数据交换和任务分配的过程。...通过ROS的分布式计算和多机通信，可以实现机器人的协同工作，提高机器人的工作效率和灵活性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值