7.1.3 Arquitectura de ROS

Sistema de archivos de ROS

La estructura del sistema de archivos de ROS en el disco duro está organizada de la siguiente manera:

J3010

Code
WorkSpace --- Espacio de trabajo personalizado

    |--- build: Espacio de compilación para almacenar la caché de CMake y catkin, configuración y otros archivos intermedios.
    |--- devel: Espacio de desarrollo para almacenar archivos objeto compilados, incluyendo cabeceras, bibliotecas dinámicas y estáticas, ejecutables, etc.
    |--- src: Código fuente

        |-- package: Paquete ROS (unidad básica de ROS) que contiene varios nodos, bibliotecas y archivos de configuración. Los nombres de los paquetes deben estar en minúsculas y constar de letras, números y guiones bajos.
            |-- CMakeLists.txt: Configuración de las reglas de compilación, incluyendo archivos fuente, dependencias y archivos objetivo.
            |-- package.xml: Información del paquete, como nombre, versión, autor y dependencias.
            |-- scripts: Directorio para archivos Python.
            |-- src: Directorio para archivos fuente C++.
            |-- include: Archivos de cabecera.
            |-- msg: Archivos de formato de comunicación de mensajes.
            |-- srv: Archivos de formato de comunicación de servicios.
            |-- action: Archivos de formato de acciones.
            |-- launch: Archivos launch para ejecutar varios nodos a la vez.
            |-- config: Archivos de configuración.

        |-- CMakeLists.txt: Configuración básica para la compilación.

Algunos de estos directorios y archivos ya se han comentado, como la creación de paquetes, la escritura de archivos C++ y Python en los directorios src y scripts, y la creación de archivos launch en el directorio launch. Los archivos package.xml y CMakeLists.txt también ya se han configurado. Los demás directorios se presentarán en tutoriales posteriores.

package.xml

El archivo package.xml define las propiedades del paquete, tales como nombre, versión, autor, mantenedor y dependencias. El formato es el siguiente:

xml
<?xml version="1.0"?>
<package format="2">
  <name>hello_world</name>
  <version>0.0.0</version>
  <description>The hello_world package</description>
  <maintainer email="xuzuo@todo.todo">xuzuo</maintainer>
  <license>TODO</license>
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  <export>
  </export>
</package>

CMakeLists.txt

El archivo CMakeLists.txt es la entrada al sistema de construcción CMake y se utiliza para construir el paquete. Incluye la configuración para compilar archivos C++ y Python, así como la definición de dependencias.

cmake
cmake_minimum_required(VERSION 3.0.2)
project(demo01_hello_vscode)

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
)

catkin_package(
)

include_directories(
  ${catkin_INCLUDE_DIRS}
)

add_executable(hellow src/hello.cpp)

add_dependencies(hellow ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

target_link_libraries(hellow
  ${catkin_LIBRARIES}
)

catkin_install_python(PROGRAMS
  scripts/hello.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

Comandos del sistema de archivos de ROS

Comandos comunes para interactuar con el sistema de archivos de ROS:

  • Crear paquete: catkin_create_pkg <package_name> <dependency_1> <dependency_2> ...
  • Instalar paquete: sudo apt install <package_name>
  • Eliminar paquete: sudo apt purge <package_name>
  • Listar paquetes: rospack list
  • Buscar paquete: rospack find <package_name>
  • Navegar al paquete: roscd <package_name>
  • Listar archivos del paquete: rosls <package_name>
  • Buscar paquete: apt search <package_name>
  • Editar archivo del paquete: rosed <package_name> <file_name>

Ejecución de comandos ROS

  • Iniciar ROS Core: roscore
  • Ejecutar nodo ROS: rosrun <package_name> <executable_file_name>
  • Lanzar archivo ROS: roslaunch <package_name> <launch_file_name>

Grafo computacional de ROS

El grafo computacional en ROS representa la estructura en tiempo de ejecución de un sistema ROS, mostrando el flujo de datos entre los distintos nodos. Se puede visualizar con rqt_graph:

bash
rosrun rqt_graph rqt_graph

Si no está instalado:

bash
sudo apt install ros-<distro>-rqt
sudo apt install ros-<distro>-rqt-common-plugins

Reemplace <distro> por su versión de ROS (p. ej., kinetic, melodic, noetic).

Demostración del grafo computacional

A continuación, demostraremos el grafo computacional utilizando la simulación de tortuga integrada en ROS.

  1. Ejecutar el ejemplo: Siga las instrucciones anteriores para ejecutar la simulación de la tortuga.

  2. Ver el grafo computacional: Abra una nueva terminal e introduzca:

    bash
    rqt_graph

    o

    bash
    rosrun rqt_graph rqt_graph

Verá un grafo de topología de red que muestra las relaciones entre los distintos nodos, similar a la imagen siguiente.

![Ejemplo de grafo computacional](https://files.seeedstudio.com/wiki/reComputer-Jetson/beginner_images/7-Robotics/7.1-Introduction to ROS/7.1.3-ROS Architecture/images/computatioinal.png)