ROS es la abreviatura de Robot Operating System Este artículo presenta mi primer desarrollo de aplicaciones ROS, la programación de Publisher Publisher. El programa es muy simple, el código tiene solo unas pocas líneas, pero deje que la tortuga de simulación se mueva. 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 tema_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_topic, 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 debajo del directorio src, el nombre es learning_topic y el siguiente contenido está debajo:
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_topic / src, cree un archivo velocity_publisher.cpp,
cd ~ / catkin_ws / src / learning_topic / src
nano velocity_publisher.cpp
El contenido es:
/**
* 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist
*/
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
int main(int argc, char **argv)
{
// ROS节点初始化
ros::init(argc, argv, "velocity_publisher");
// 创建节点句柄
ros::NodeHandle n;
// 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);
// 设置循环的频率
ros::Rate loop_rate(10);
int count = 0;
while (ros::ok())
{
// 初始化geometry_msgs::Twist类型的消息
geometry_msgs::Twist vel_msg;
vel_msg.linear.x = 0.5;
vel_msg.angular.z = 0.2;
// 发布消息
turtle_vel_pub.publish(vel_msg);
ROS_INFO("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]",
vel_msg.linear.x, vel_msg.angular.z);
// 按照循环频率延时
loop_rate.sleep();
}
return 0;
}
Este código tiene comentarios claros. Este es un proceso básico para implementar editores:
Inicializar el nodo ROS
Crear identificador de nodo
Crear un editor, incluido el nombre del tema y el tipo de mensaje.
Establecer la frecuencia del ciclo
ciclo
Configurar el archivo cmake
En el directorio ~ / catkin_ws / src / learning_topic /, hay un archivo CMakeLists.txt, necesitamos modificar este archivo
cd ~ / catkin_ws / src / learning_topic /
nano CMakeLists.txt
Agregue las siguientes 2 líneas a este archivo,
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
La ubicación agregada se refiere a la siguiente ubicación, que está frente a ## install ##:
# target_link_libraries(${PROJECT_NAME}_node
# ${catkin_LIBRARIES}
# )
add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${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_topic velocity_publisher
Abro el administrador de archivos y hay un velocity_publisher en la siguiente ubicación
Después de ejecutar el comando anterior, vemos a la tortuguita girando en círculo.
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_topic /, luego vaya a este directorio y cree un nuevo archivo velocity_publisher.py
cd ~ / catkin_ws / src / learning_topic / scripts
nano velocity_publisher.py
El contenido del archivo es:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist
import rospy
from geometry_msgs.msg import Twist
def velocity_publisher():
# ROS节点初始化
rospy.init_node('velocity_publisher', anonymous=True)
# 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
#设置循环的频率
rate = rospy.Rate(10)
while not rospy.is_shutdown():
# 初始化geometry_msgs::Twist类型的消息
vel_msg = Twist()
vel_msg.linear.x = 0.5
vel_msg.angular.z = 0.2
# 发布消息
turtle_vel_pub.publish(vel_msg)
rospy.loginfo("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]",
vel_msg.linear.x, vel_msg.angular.z)
# 按照循环频率延时
rate.sleep()
if __name__ == '__main__':
try:
velocity_publisher()
except rospy.ROSInterruptException:
passHay instrucciones claras en el código y el proceso es:
Inicialización del nodo ROS
Cree un editor, publique un tema llamado / turtle1 / cmd_vel, el tipo de mensaje es geometry_msgs :: Twist y la longitud de la cola es 10
Establecer la frecuencia del bucle
ciclo
prueba de ejecución de python
Cambie velocity_publisher.py para tener atributos de ejecución
chmod + x * .py
Esto se puede verificar con ls -l:
leon@ubuntu:~/catkin_ws/src/learning_topic/scripts$ ls -l
total 8
-rwxrwxrwx 1 leon leon 824 May 8 2020 pose_subscriber.py
-rwxrwxrwx 1 leon leon 1275 May 8 2020 velocity_publisher.py
leon@ubuntu:~/catkin_ws/src/learning_topic/scripts$ Python no necesita compilarse,
Pero para abrir una terminal, inicie roscore y luego abra una terminal para iniciar la tortuga rosrun turtlesim turtlesim_node
También recuerde la fuente ~ / catkin_ws / devel / setup.bash
Finalmente, se puede ejecutar directamente,
El resultado de la ejecución de rosrun learning_topic velocity_publisher.py es que la pequeña tortuga se convierte en un círculo, que es lo mismo que la ejecución de c ++. Puedes consultar el diagrama de c ++ anterior.
Mostrar relación de flujo de información
Abra una nueva terminal e ingrese el comando:
rqt_graph
Puede ver el siguiente diagrama de relación de información:
La primera parte de la información es el tema / tortuga / cmd_vel, que es el flujo de información entre el editor y la tortuga simulada.
Estos 2 códigos fuente también se pueden descargar en https://github.com/huchunxu/ros_21_tutorials
Eso es todo para la introducción.