ROS é a abreviatura de Robot Operating System. Este artigo apresenta o desenvolvimento de aplicativos ROS e a programação do cliente. A função do programa é criar uma tartaruga simulada com código. Primeiro o código C ++, depois o código python, você também pode optar por olhar apenas um com o qual esteja familiarizado.
Criação de pacote de funções
O espaço de trabalho ROS é estabelecido no artigo Desenvolvimento de ROS e preparação de aplicativos: Criar um espaço de trabalho . Agora, crie um pacote funcional:
cd ~ / catkin_ws / src
catkin_create_pkg learning_service std_msgs roscpp rospy geometry_msgs turtlesim
A primeira linha é para retornar ao diretório src da área de trabalho.A criação do pacote de funções deve ser executada neste diretório.
A segunda linha é o comando para criar o pacote de funções, o primeiro parâmetro é o nome do pacote de funções, aqui está learning_service, e a próxima é a biblioteca de dependências do pacote de funções, aqui está std_msgs roscpp rospy geometry_msgs turtlesim Existem 5 dependências bibliotecas.
Depois que o comando acima é executado, você pode ver um diretório chamado learning_service no diretório src, que tem o seguinte conteúdo:
CMakeLists.txt inclui scripts package.xml src
Entre eles, os scripts foram criados manualmente mais tarde para armazenar o código python.
código fonte c ++
No diretório src, que também é o diretório ~ / catkin_ws / src / learning_service / src, crie um arquivo turtle_spawn.cpp,
cd ~ // catkin_ws / src / learning_service / src
nano turtle_spawn.cpp
O conteúdo é:
/**
* 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn
*/
#include <ros/ros.h>
#include <turtlesim/Spawn.h>
int main(int argc, char** argv)
{
// 初始化ROS节点
ros::init(argc, argv, "turtle_spawn");
// 创建节点句柄
ros::NodeHandle node;
// 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
ros::service::waitForService("/spawn");
ros::ServiceClient add_turtle = node.serviceClient<turtlesim::Spawn>("/spawn");
// 初始化turtlesim::Spawn的请求数据
turtlesim::Spawn srv;
srv.request.x = 2.0;
srv.request.y = 2.0;
srv.request.name = "turtle2";
// 请求服务调用
ROS_INFO("Call service to spwan turtle[x:%0.6f, y:%0.6f, name:%s]",
srv.request.x, srv.request.y, srv.request.name.c_str());
add_turtle.call(srv);
// 显示服务调用结果
ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());
return 0;
};
Este código tem comentários claros. Este é um processo básico para implementar o cliente:
Inicialize o nó ROS
Criar nó identificador
Crie um cliente de serviço e conecte-se ao serviço chamado / spawn
Inicialize os dados de solicitação de turtlesim :: Spawn
Solicitar chamada de serviço
Exibir resultados de chamada de serviço
Configurar o arquivo cmake
No diretório ~ / catkin_ws / src / learning_service /, há um arquivo CMakeLists.txt, precisamos modificar este arquivo
cd ~ / catkin_ws / src / learning_service
nano CMakeLists.txt
Adicione as 2 linhas a seguir a este arquivo,
add_executable(turtle_spawn src/turtle_spawn.cpp)
target_link_libraries(turtle_spawn ${catkin_LIBRARIES})O local adicionado é a última parte do Build. Consulte o seguinte local, que é ## install ## na frente:
# target_link_libraries(${PROJECT_NAME}_node
# ${catkin_LIBRARIES}
# )
add_executable(turtle_spawn src/turtle_spawn.cpp)
target_link_libraries(turtle_spawn ${catkin_LIBRARIES})
#############
## Install ##
#############
Saída segura
Isso conclui a compilação e configuração.
Compile e execute o teste
A compilação deve voltar para o diretório ~ / catkin_ws
cd ~ / catkin_ws
catkin_make
Deve ser obtido uma vez após a compilação:
fonte devel / setup.bash
Se houver um erro na compilação, você deve eliminar o erro e, em seguida, executar o teste.
Abra um terminal, inicie ros, execute
roscore
Abra outro terminal e execute a tartaruga
rosrun turtlesim turtlesim_node
O procedimento acima é para iniciar o ambiente de teste.Se houver um problema, você pode consultar: A tartaruga de simulação em ROS , mas o controle do teclado não é iniciado.
Finalmente execute em nosso terminal:
rosrun learning_service turtle_spawn
Após executar o comando acima, vemos mais uma tartaruga, agora são duas.
Isso completa o desenvolvimento do c ++.
código python
Para não se misturar com C ++, crie um diretório de scripts no diretório ~ / catkin_ws / src / learning_service / e, em seguida, vá para este diretório e crie um arquivo turtle_spawn.py
cd ~ / catkin_ws / src / learning_service / scripts
nano turtle_spawn.py
O conteúdo do arquivo é:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn
import sys
import rospy
from turtlesim.srv import Spawn
def turtle_spawn():
# ROS节点初始化
rospy.init_node('turtle_spawn')
# 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
rospy.wait_for_service('/spawn')
try:
add_turtle = rospy.ServiceProxy('/spawn', Spawn)
# 请求服务调用，输入请求数据
response = add_turtle(3.0,3.0, 0.0, "turtle3")
return response.name
except rospy.ServiceException, e:
print "Service call failed: %s"%e
if __name__ == "__main__":
#服务调用并显示调用结果
print "Spwan turtle successfully [name:%s]" %(turtle_spawn())Existem instruções claras no código e o processo é:
Inicialização do nó ROS
Depois de descobrir o serviço / spawn, crie um cliente de serviço e conecte-se ao serviço chamado / spawn
Solicite chamada de serviço, insira os dados do pedido
teste de execução python
Python pode ser executado diretamente sem compilação,
Altere turtle_spawn.py para ter atributos de execução
chmod + x * .py
Isso pode ser verificado com ls -l:
Ao mesmo tempo, deve ser fornecido uma vez:
fonte ~ / catkin_ws / devel / setup.bash
Primeiro, você precisa iniciar o ambiente de teste. Um terminal inicia o roscore e outro terminal inicia o turtle rosrun turtlesim turtlesim_node. Se houver um problema, você pode consultar: A tartaruga de simulação em ROS , mas o controle do teclado não está ativado.
Em seguida, execute o seguinte comando:
rosrun learning_service turtle_spawn.py
O resultado da execução é que há mais tartarugas.
O código-fonte também pode ser baixado em https://github.com/huchunxu/ros_21_tutorials
É isso para a introdução.