Acta de reunión

Ubicación Bloque 19, 19-213
Fecha 2022-09-13
Hora 10:00 a.m
Asistentes Davinson Castaño, Joan Beltran, Joan Francisco Alvarado, Juan Pedro Cano, Maria Camila Maldonado, Maria Paula Balaguera, Miguel Castaño, Pablo Soto, Stefania Valencia

Puntos de la agenda

  1. Miguel se presento.
  2. Davinson reviso los incovenientes que cada persona tenia con su instalación de Ubuntu y ROS.
  3. Davinson presento la página www.theconstructsim.com como alternativa para usar ROS2 sin USB.
  4. Davinson hizo una breve introducción a ROS y sus componentes básicos los nodos y los temas.
  5. Davinson presento como crear un paquete y hacer un programa, se explicará esto más adelante.

Acciones a seguir

  • Los estudiantes harán el programa para el rebote de la tortuga en XY (2 dimensiones).

Adicionalmente

Se llevaron a cabo diversas tareas importantes en el desarrollo de robótica con ROS:

Creando el paquete para nuestro nodo

Para crear el paquete para ROS2, debemos generar una estructura de carpetas para soportar el desarrollo correcto de paquetes y nodos en ROS. Por esto vamos a crear los directorios usando los siguientes comandos.

cd ~
mkdir ares_ws   # creamos el directorio "ws" working space o la carpeta base del desarrollo
ls 
cd ares_ws/
mkdir src       # creamos el directorio para todos los programas que vamos a desarrollar
ls
cd src

La información de cada comando se puede consultar usando el comando seguido por --help en el terminal de Linux. e.g. cd --help

Para la creación del paquete en cuestión usaremos el siguiente comando en la carpeta src (para llegar a esta carpeta usaremos cd ~/ares_ws/src/)

ros2 pkg create sep13 --build-type ament_python --license GPL-3.0-only 

Creando el código para nuestro nodo

Para crear nuestro nodo vamos a analizar cuales son los mensajes que debemos produccir y recibir, para esto:

ros2 run turtlesim turtlesim_node  # Ejecutaremos el turtlesim_node
ros2 topic list                    # Revisaremos la lista de temas

para revisar los comandos de ROS2 hacer clic aquí. Revisaremos la información de cada tema con los siguiente comandos:

ros2 topic info /turtle1/pose
ros2 topic info /turtle1/cmd_vel

Cada tema tiene una estructura mensaje especifico, el cual puede ser consultado con los comandos a continuación:

ros2 interface show turtlesim/msg/Pose 
ros2 interface show geometry_msgs/msg/Twist

En el mensaje /turtle1/pose tenemos una estructura turtlesim/msg/Pose la cual nos entregará la siguiente información:

float32 x
float32 y
float32 theta

float32 linear_velocity
float32 angular_velocity

En el mensaje /turtle1/cmd_vel tenemos una estructura geometry_msgs/msg/Twist la cual nos entregará la siguiente información:

# This expresses velocity in free space broken into its linear and angular parts.

Vector3  linear
  float64 x
  float64 y
  float64 z
Vector3  angular
  float64 x
  float64 y
  float64 z

Para enviar la información de la velocidad en x necesitaremos enviarla en el objeto Twist con la estructura msg.linear.x =

El código usado para hacer rebotar la tortuga en la dirección x fue el siguiente:

import random
import rclpy
from rclpy.node import Node

from turtlesim.msg import Pose
from geometry_msgs.msg import Twist

class Nodo(Node):

    def __init__(self):
        super().__init__('rebote')
        self.get_logger().info('Iniciamos Rebote X')

        # TOPIC PUBLISHERS

        self.publisher_ = self.create_publisher(Twist, 'turtle1/cmd_vel', 1)

        # TOPIC SUBSCRIBERS

        self.pose_sub = self.create_subscription(Pose,'turtle1/pose',self.pose_callback,10)
        self.pose_sub  # prevent unused variable warning

        self.velx = 1+4*random.random()

    # SUBSCRIBER CALLBACK

    def pose_callback(self, msg):
        posx = msg.x
        if posx > 10: 
            self.get_logger().info('Golpeamos x=10')
            self.velx = - abs(self.velx)
        elif posx < 1:
            self.get_logger().info('Golpeamos x=1')
            self.velx = abs(self.velx)

        newmsg = Twist()
        newmsg.linear.x = self.velx

        self.publisher_.publish(newmsg)

####################################################################
# No es necesario modificar lo que se presenta a continuación:
####################################################################

def main(args=None):          # Función main
    rclpy.init(args=args)     # Iniciamos la comunicacion con ROS2
    node = Nodo()             # Creamos el objeto nodo
    rclpy.spin(node)          # Ejectutamos el nodo en un loop
    node.destroy_node()       # Cuando salimos del nodo lo destruimos
    rclpy.shutdown()          # Cerrramos la comunicacion con ROS2

if __name__ == '__main__':    # Si ejecutamos el archivo de python
    main()                    # Ejecutamos la funcion main()

Este código fue guardado con el nombre rebote_x.py en la carpeta ~/ares_ws/src/sep13/sep13/.

Volviendo el archivo de Python ejecutable

Para configurar este archivo de Python como ejecutable necesitamos modificar el archivo setup.py creado en la carpeta ~/ares_ws/src/sep13/

Debemos entonces agregar la siguiente linea:

'console_scripts': [
    'rebote_x = sep13.rebote_x:main',
],

Corriendo nuestro nodo

Para correr nuestro nodo, debemos compilar el espacio de trabajo (working space). Luego nos ubicamos en la carpeta ~/ares_ws/ y corremos los siguientes commandos:

colcon build                # compilamos
source install/setup.bash   # informamos a ROS de nuestro paquete

Ahora solo nos queda ejecutar el simulador de turtlesim y nuestro nodo en dos terminales diferentes:

ros2 run sep13 rebote_x
ros2 run turtlesim turtlesim_node --ros-args -p background_r:=0 -p background_g:=0  -p background_b:=0