ROS es la abreviatura de Robot Operating System Este artículo presenta el desarrollo de aplicaciones ROS y la programación del cliente. La función del programa es crear una tortuga simulada con código. Primero el código C ++, luego el código Python, también puede elegir ver solo uno con el que esté familiarizado.
Creación de paquetes de funciones
El espacio de trabajo de ROS se establece en el artículo Desarrollo de ROS y preparación de aplicaciones: crear un espacio de trabajo . Ahora, cree un paquete funcional:
cd ~ / catkin_ws / src
catkin_create_pkg servicio_de_aprendizaje std_msgs roscpp rospy geometry_msgs turtlesim
La primera línea es para volver al directorio src del espacio de trabajo La creación del paquete de funciones debe ejecutarse en este directorio.
La segunda línea es el comando para crear el paquete de funciones, el primer parámetro es el nombre del paquete de funciones, aquí está learning_service y la siguiente es la biblioteca de dependencias del paquete de funciones, aquí está std_msgs roscpp rospy geometry_msgs turtlesim Hay 5 dependencias Bibliotecas.
Después de ejecutar el comando anterior, puede ver un directorio llamado learning_service en el directorio src, que tiene el siguiente contenido:
CMakeLists.txt incluye scripts package.xml src
Entre ellos, los scripts se crearon manualmente más tarde para almacenar el código Python.
código fuente c ++
En el directorio src, que también es el directorio ~ / catkin_ws / src / learning_service / src, cree un archivo turtle_spawn.cpp,
cd ~ // catkin_ws / src / servicio_aprendizaje / src
nano turtle_spawn.cpp
El contenido es:
/**
* 该例程将请求/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 tiene comentarios claros. Este es un proceso básico para implementar el cliente:
Inicializar el nodo ROS
Crear identificador de nodo
Cree un cliente de servicio y conéctese al servicio llamado / spawn
Inicializar la solicitud de datos de turtlesim :: Spawn
Solicitar llamada de servicio
Mostrar resultados de llamadas de servicio
Configurar el archivo cmake
En el directorio ~ / catkin_ws / src / learning_service /, hay un archivo CMakeLists.txt, necesitamos modificar este archivo
cd ~ / catkin_ws / src / learning_service
nano CMakeLists.txt
Agregue las siguientes 2 líneas a este archivo,
add_executable(turtle_spawn src/turtle_spawn.cpp)
target_link_libraries(turtle_spawn ${catkin_LIBRARIES})La ubicación agregada es la última parte de Build. Consulte la siguiente ubicación, que es ## install ## al 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 ##
#############
Guardar la salida
Esto completa la compilación y configuración.
Compila y ejecuta la prueba
La compilación debe volver al directorio ~ / catkin_ws
cd ~ / catkin_ws
catkin_make
Debe obtenerse una vez después de la compilación:
fuente devel / setup.bash
Si hay un error en la compilación, debe eliminar el error y luego ejecutar la prueba.
Abra una terminal, inicie ros, ejecute
roscore
Abre otra terminal y ejecuta la tortuga.
rosrun turtlesim turtlesim_node
Lo anterior es para iniciar el entorno de prueba.Si hay un problema, puede consultar: La tortuga de simulación en ROS , pero el control del teclado no se inicia.
Finalmente ejecutamos en nuestra terminal:
rosrun learning_service turtle_spawn
Después de ejecutar el comando anterior, vemos una tortuga más, ahora hay dos.
Esto completa el desarrollo de c ++.
código python
Para no mezclar con C ++, cree un directorio de scripts en el directorio ~ / catkin_ws / src / learning_service /, y luego vaya a este directorio y cree un archivo turtle_spawn.py
cd ~ / catkin_ws / src / learning_service / scripts
nano turtle_spawn.py
El contenido del archivo es:
#!/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())Hay instrucciones claras en el código y el proceso es:
Inicialización del nodo ROS
Después de descubrir el servicio / spawn, cree un cliente de servicio y conéctese al servicio llamado / spawn
Solicitar llamada de servicio, ingresar datos de solicitud
prueba de ejecución de python
Python se puede ejecutar directamente sin compilación,
Cambie turtle_spawn.py para tener atributos de ejecución
chmod + x * .py
Esto se puede verificar con ls -l:
Al mismo tiempo, debe obtenerse una vez:
fuente ~ / catkin_ws / devel / setup.bash
Primero, necesita iniciar el entorno de prueba. Una terminal inicia roscore y otra terminal inicia la tortuga rosrun turtlesim turtlesim_node. Si hay un problema, puede consultar: La tortuga de simulación bajo ROS , pero el control del teclado no está activado.
Luego ejecute el siguiente comando:
rosrun learning_service turtle_spawn.py
El resultado de la ejecución es que hay más tortugas.
El código fuente también se puede descargar en https://github.com/huchunxu/ros_21_tutorials
Eso es todo para la introducción.