Editores de ROS que usan Python

A menudo se considera que escribir un editor en Robot Operating Systems (ROS) es mucho más fácil que trabajar con el suscriptor. En la mayoría de las cuentas, esto es cierto, dado que la publicación es una tarea minimalista: solo alimentamos valores al robot o robot en simulación. Para ser sincero, esa es la medida en que trabajan los editores en ROS. De hecho, algunos profesionales incluso dirían que es similar a una función de impresión ( ) o visualización.

Editores de ROS 

Dado que los robots pretenden principalmente automatizar lo que los humanos harían de otro modo, estableceremos paralelismos entre la parafernalia simple hecha por el hombre y la construcción del robot para generar perspectiva. Por lo tanto, es crucial que el lector comprenda qué son los Nodes ROS y los temas ROS. Aquí hay un resumen rápido de Nodes y temas en ROS.

Un Node ROS es un proceso computacional que se ejecuta como un programa en un paquete. Dado que podemos tener varios Nodes ejecutándose simultáneamente, los Nodes son análogos a los órganos humanos, en los que cada órgano (Node) realiza una tarea dedicada para que todo el ser humano (robot) funcione de la manera deseada.

Si desea establecer qué Nodes están actualmente activos en su paquete, simplemente ejecute los siguientes comandos.

# only if the master node is not running
$ roscore
# to list all active nodes
$ rosnode list
# to obtain info on a specific node
$ rosnode info /<node_name>

Otra alternativa sería usar gráficos rqt para mostrar el diagrama de árbol para comprender el flujo de datos entre Nodes.

Un tema ROS es esencialmente un bus con nombre sobre el cual los Nodes intercambian mensajes. Pueden considerarse como canales de radio en los que se envía y recibe información. Tenga en cuenta que cada tema tiene un formato único de datos que se intercambian.

La idea de Publicar información surge de la pregunta de cómo dirigir a un robot para que haga algo ya que lo estamos controlando. Tenga en cuenta que mantendremos la comunicación con los temas individualmente: escribimos editores para temas específicos y no todo el robot como tal . 

Publicamos datos al robot. Suscribirse a los datos funciona al revés. Ambos se realizan a través de temas. 

Ahora que se ha proporcionado algo de claridad sobre la noción de editores, veremos una plantilla simple para escribir editores en Python.

Modelo

# Do not skip line 2
#!/usr/bin/env python
  
import rospy
# the following line depends upon the
# type of message you are trying to publish
from std_msgs.msg import String
  
  
def publisher():
      
    # define the actions the publisher will make
    pub = rospy.Publisher('/<topic_name>',
                          String, queue_size=10)
    # initialize the publishing node
    rospy.init_node('<node_name>', anonymous=True)
      
    # define how many times per second
    # will the data be published
    # let's say 10 times/second or 10Hz
    rate = rospy.Rate(10)
    # to keep publishing as long as the core is running
    while not rospy.is_shutdown():
        data = "The data that you wish to publish."
          
        # you could simultaneously display the data
        # on the terminal and to the log file
        rospy.loginfo(data)
          
        # publish the data to the topic using publish()
        pub.publish(data)
          
        # keep a buffer based on the rate defined earlier
        rate.sleep()
  
  
if __name__ == '__main__':
    # it is good practice to maintain
    # a 'try'-'except' clause
    try:
        publisher()
    except rospy.ROSInterruptException:
        pass

Explicación 

• La ejecución del código comienza desde la cláusula try and except. La función de publicación se llama desde aquí.
• Defina la función de editor:
  • el primer campo indica el nombre del tema en el que desea publicar los datos. Por ejemplo, /odom o /rosout.
  • el segundo campo indica el tipo de datos que se están publicando. String, Float32 o Twist son algunos ejemplos.
  • el último campo declara el límite de la cantidad de mensajes que se pueden poner en cola para el tema.
• Seguimos esto con la inicialización del Node.
• El resto de la plantilla se explica por sí mismo (consulte los comentarios en el código).

Ejemplo

Este ejemplo implementa un código para publicar datos en el tema /rosout. Si bien hay una manera mucho más fácil de hacerlo (usando el eco rostópico), sirve como una demostración fácilmente comprensible.

El objetivo es publicar datos en el tema /cmd_vel (velocidad de comando) y, por lo tanto, aumentar la velocidad del bot. Como resultado del ciclo while como se muestra en la plantilla, notaremos una aceleración en el robot.

#!/usr/bin/env python3
import rospy
from geometry_msgs.msg import Twist
  
  
def increase(Twist):
  
    print('We are in the callback function!')
    velo_msg = Twist
      
    # l = Twist.linear.x
    # print(l)
    # define the rate at which
    # we will be publishing the velocity.
    rate = rospy.Rate(5)
  
    # prompt the user for the acceleration value
    speed = float(input('By how much would \
    you like to accelerate? '))
  
    while not rospy.is_shutdown():
        
        # increase the current velocity by the speed defined.
        velo_msg.linear.x = (Twist.linear.x) + speed
          
        # publish the increased velocity
        pub.publish(velo_msg)
        print('Publishing was successful!')
        rate.sleep()
  
  
def main():
    print("In main...")
      
    # initializing the publisher node
    rospy.init_node('Velocity_publisher', anonymous=True)
    sub = rospy.Subscriber('/cmd_vel', Twist, increase)
    rospy.spin()
  
  
if __name__ == '__main__':
    try:
        pub = rospy.Publisher('/cmd_vel', Twist, queue_size=10)
        main()
    except rospy.ROSInterruptException:
        pass

Código Explicación

• Comenzamos definiendo el Node de publicación ‘pub’. Aquí definimos el tema (/cmd_vel) al que se publicarán mensajes de tipo Twist. Luego nos movemos a main().
• Inicializar el Node es clave. Sin esto, nuestro Node maestro (roscore) no podrá definir el flujo de información entre todos los Nodes.
• Para aumentar la velocidad del robot, necesitamos conocer su velocidad actual. Por lo tanto, nos suscribimos al tema de la velocidad de comando.
• La función de devolución de llamada en el comando rospy.Subscriber() es aumentar().
• Dentro de la función de aumento():
  • Comience por obtener la velocidad en una variable: aquí es velo_msg. Observe cómo velo_msg es de tipo Twist.
  • Ahora defina la tasa a la que se publicarán los valores.
  • Ahora se le pide al usuario que elija el cambio de velocidad.
  • En el ciclo while:
    • Obtenemos la componente x de la velocidad lineal. También podemos usar el componente y dependiendo de la aplicación.
    • El componente x ahora se incrementa en la cantidad especificada por el usuario.
    • Ahora se publica la velocidad y se vuelve a ejecutar el bucle while.

Implementación de ROS

Entrada (Terminal):

$roscore
#open new terminal
$source devel/setup.bash
#launch turtlebot3 on gazebo
$roslaunch turtlebot3_gazebo turtlebot3_empty_world.launch
#open new terminal
#give turtlebot3 some starting velocity
$roslaunch turtlebot3_teleop turtlebot3_teleop_key.launch
#now press w
#open a new terminal
#run your python script from your package
$rosrun <pkg_name> publisher.py

Producción:

In main...
In the callback function.
0.01
By how much would you like to increase the speed? 
Publishing Successful!

Consulte el enlace de video a continuación para ver la ejecución completa.

Demostración de código