A comunicação de serviço também é um modo de comunicação extremamente comum no ROS. A comunicação de serviço é baseada no modo de resposta de solicitação , que é um mecanismo de resposta. Ou seja: um nó A envia uma solicitação para outro nó B e B recebe a solicitação de processamento e gera um resultado de resposta de volta para A. Por exemplo, o seguinte cenário:
Durante a patrulha do robô, o sistema de controle analisa os dados do sensor e encontra objetos ou pessoas suspeitas ... Nesse momento, é preciso tirar fotos e guardá-las.
No cenário acima, a comunicação de serviço é usada.
-
Um nó precisa enviar uma solicitação de foto para o nó da câmera, o nó da câmera processa a solicitação e retorna o resultado do processamento
Semelhante aos aplicativos acima, a comunicação de serviço é mais adequada para cenários de aplicativos que exigem pontualidade e têm determinado processamento lógico.
conceito
O modo de comunicação de interação de dados entre diferentes nós é realizado em uma forma de solicitação-resposta.
efeito
Ele é usado para cenários ocasionais de transmissão de dados que requerem pontualidade e certos requisitos de processamento lógico.
1 Modelo teórico de comunicação de serviço
A comunicação de serviço é mais simples do que a comunicação de tópico. O modelo teórico é mostrado na figura abaixo. Três funções estão envolvidas no modelo:
-
Mestre ROS (gerente)
-
Servidor (servidor)
-
Cliente
ROS Master é responsável por manter as informações cadastradas por Servidor e Cliente, e por combinar Servidor e Cliente com o mesmo tópico, auxiliando Servidor e Cliente a estabelecer uma conexão.Após a conexão ser estabelecida, o Cliente envia informações de solicitação e Servidor retorna informações de resposta.
Todo o processo é realizado pelas seguintes etapas:
(0). Registro do servidor
Após a inicialização do servidor, ele registrará suas próprias informações no ROS Master através do RPC, que contém o nome do serviço prestado. O ROS Master adicionará as informações de registro do nó ao registro.
(1) Registro de cliente
Após a inicialização do Cliente, ele também registrará suas próprias informações no ROS Master através do RPC, incluindo o nome do serviço que deve ser solicitado. O ROS Master adicionará as informações de registro do nó ao registro.
(2). ROS Master percebe correspondência de informações
O ROS Master fará a correspondência entre o Servidor e o Cliente de acordo com as informações do registro e enviará as informações do endereço TCP do Servidor ao Cliente via RPC .
(3) O cliente envia uma solicitação
O Cliente usa o TCP para estabelecer uma conexão de rede com o Servidor de acordo com as informações de resposta na etapa 2 e envia os dados solicitados.
(4) O servidor envia uma resposta
O servidor recebe e analisa os dados solicitados, gera um resultado de resposta e o retorna ao cliente.
Nota:
1. Quando a solicitação do cliente é processada, é necessário garantir que o servidor foi iniciado;
2. Pode haver vários servidores e clientes.
2 Serviço srv personalizado de comunicação
exigem:
Na comunicação de serviço, o cliente envia dois números inteiros para o servidor, e o servidor soma e responde com o resultado ao cliente. Crie uma portadora de dados para a comunicação entre o servidor e o cliente.
srv = pedido + resposta
Processar:
Os tipos de dados disponíveis no arquivo srv são iguais aos do arquivo msg e o processo de definição do srv é semelhante ao de msg personalizado:
-
Crie um arquivo srv em um formato fixo
-
Editar arquivo de configuração
-
Compilar e gerar arquivos intermediários
(1) Defina o arquivo srv
Na comunicação de serviço, os dados são divididos em duas partes, solicitação e resposta. A solicitação e a resposta são ---
divididas no arquivo srv . A implementação específica é a seguinte:
Crie um novo diretório srv no pacote de funções, adicione o arquivo xxx.srv e o conteúdo:
# 客户端请求时发送的两个数字
int32 num1
int32 num2
---
# 服务器响应发送的数据
int32 sum
(2) Edite o arquivo de configuração
Adicione dependência de compilação e dependência de execução em package.xml
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>
<!--
exce_depend 以前对应的是 run_depend 现在非法
添加构建依赖 和 执行依赖
-->
Copy
CMakeLists.txt editar configuração relacionada ao srv
find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
)
# 需要加入 message_generation,必须有 std_msgs
add_service_files(
FILES
Addints.srv
)
generate_messages(
DEPENDENCIES
std_msgs
)
Nota: O site oficial não configura message_runtime em catkin_package, ele pode ser configurado após o teste
(3) Compilar
Veja o arquivo intermediário compilado:
Arquivos intermediários que C ++ precisa chamar (... / workspace / devel / include / package name / xxx.h)
Arquivos intermediários que o Python precisa chamar (... / workspace / devel / lib / python2.7 / dist-packages / nome do pacote / srv)
Quando o srv relacionado é subseqüentemente chamado, ele é chamado a partir desses arquivos intermediários.
3 Chamada srv personalizada de comunicação de serviço A (C ++)
exigem:
Para escrever a comunicação de serviço, o cliente envia dois inteiros ao servidor, e o servidor soma e responde com o resultado ao cliente.
análise:
Na implementação do modelo, o mestre ROS não precisa ser implementado e o estabelecimento da conexão foi encapsulado. Existem três pontos principais que devem ser considerados:
-
Servidor
-
Cliente
-
dados
Processar:
-
Escreva a implementação do lado do servidor;
-
Escreva a implementação do cliente;
-
Edite o arquivo de configuração;
-
Compile e execute.
(0) configuração vscode
O arquivo c_cpp_properies.json precisa ser configurado como a implementação de msg personalizada anterior. Se ele foi configurado antes e o espaço de trabalho não foi alterado, você pode ignorá-lo. Se precisar configurá-lo, o método de configuração é o mesmo de antes :
{
"configurations": [
{
"browse": {
"databaseFilename": "",
"limitSymbolsToIncludedHeaders": true
},
"includePath": [
"/home/winter/catkin_wp/devel/include/**",
"/opt/ros/melodic/include/**",
"/home/winter/catkin_wp/src/learning_parameter/include/**",
"/home/winter/catkin_wp/src/learning_service/include/**",
"/home/winter/catkin_wp/src/learning_tf/include/**",
"/home/winter/catkin_wp/src/learning_topic/include/**",
"/usr/include/**",
"/home/winter/demo03_ws/devel/include/**"
],
"name": "ROS",
"intelliSenseMode": "gcc-x64",
"compilerPath": "/usr/bin/gcc",
"cStandard": "gnu17",
"cppStandard":"c++17"
}
],
"version": 4
}
(1) Servidor
#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)
{
//处理请求
int num1 = request.num1;
int num2 = request.num2;
ROS_INFO("服务器收到的请求数据是:num1 = %d,num2 = %d",num1,num2);
//响应请求
int num = num1 + num2;
response.sum = num;
ROS_INFO("求和结果是:sum = %d",num);
return true;
}
int main(int argc, char *argv[])
{
//设置中文
setlocale(LC_ALL,"");
//2 初始化ros结点
ros::init(argc,argv,"Server"); //名称保证唯一
//3 创建结点句柄
ros::NodeHandle nh;
//4 创建服务对象
ros::ServiceServer server = nh.advertiseService("Addints",doNums);
ROS_INFO("服务端启动了");
//5 回调函数
//6 spin函数
ros::spin();
return 0;
}
Arquivo de configuração
add_dependencies(demo01_server ${PROJECT_NAME}_generate_messages_cpp)
teste
roscore
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server
source ./devel/setup.bash
rosservice call Addints "num1: 20
num2: 10"
sum: 30
(2) Cliente
#include "ros/ros.h"
#include "plumbing_server_client/Addints.h"
/*
客户端:提交两个整数,处理响应的结果
1 包含头文件
2 初始化ros结点
3 创建结点句柄
4 创建客户对象
5 提交请求并处理响应
*/
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
// 2 初始化ros结点
ros::init(argc,argv,"Client");
// 3 创建结点句柄
ros::NodeHandle nh;
// 4 创建客户对象
ros::ServiceClient client = nh.serviceClient<plumbing_server_client::Addints>("Addints");
// 5 提交请求并处理响应
plumbing_server_client::Addints ai;
//组织请求
ai.request.num1 = 100;
ai.request.num2 = 200;
//处理响应 客户端访问服务器
bool flag = client.call(ai);
if(flag==true)
{
ROS_INFO("响应成功");
//获取结果
ROS_INFO("响应结果是:%d",ai.response.sum);
}
else
{
ROS_INFO("处理失败");
}
return 0;
}
Arquivo de configuração
roscore
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server
rosrun plumbing_server_client demo02_client
(3) Otimização do cliente
Fornece dados dinamicamente
#include "ros/ros.h"
#include "plumbing_server_client/Addints.h"
/*
客户端:提交两个整数,处理响应的结果
1 包含头文件
2 初始化ros结点
3 创建结点句柄
4 创建客户对象
5 提交请求并处理响应
实现参数的动态提交:
1 格式 rosrun 包名 结点名 参数1 参数2
2 节点执行时要获取命令中的参数,并组织进request 使用argc argv
*/
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
//优化实现,获取命令中的参数
/*
iargc = 3
argv[0] 是文件名
argv[1] 是参数1
argv[2] 是参数2
*/
if(argc !=3)
{
ROS_INFO("提交的参数个数不对");
return 1;
}
// 2 初始化ros结点
ros::init(argc,argv,"Client");
// 3 创建结点句柄
ros::NodeHandle nh;
// 4 创建客户对象
ros::ServiceClient client = nh.serviceClient<plumbing_server_client::Addints>("Addints");
// 5 提交请求并处理响应
plumbing_server_client::Addints ai;
//组织请求
ai.request.num1 =atoi( argv[1]);
ai.request.num2 = atoi(argv[2]);
//处理响应 客户端访问服务器
bool flag = client.call(ai);
if(flag==true)
{
ROS_INFO("响应成功");
//获取结果
ROS_INFO("响应结果是:%d",ai.response.sum);
}
else
{
ROS_INFO("处理失败");
}
return 0;
}
Se você iniciar o cliente primeiro, inicie o servidor
otimização:
Adicione antes que o cliente envie a solicitação:
client.waitForExistence();
或:ros::service::waitForService("AddInts");
Esta é uma função de bloqueio e só continuará a execução depois que o serviço for iniciado com sucesso