Conceptos Fundamentales de Espacios de Trabajo y Paquetes

ROS 2 opera bajo una arquitectura de middleware modular y distribuido. Las funcionalidades del sistema se dividen en paquetes individuales, gestionados en repositorios separados, donde las dependencias se declaran medinate archivos XML. Herramientas como CMake se encargan de automatizar pruebas, resolver dependencias, ejecutar scripts y configurar variables de entorno y macros.

En este ecosistema, un proceso puede alojar múltiples nodos, y cada nodo expone diversas capacidades. La comunicación entre nodos se realiza a través de los paradigmas de ROS 2, permitiendo el uso de espacios de nombres o dominios DDS para aislar recursos y flujos de información.

Los espacios de trabajo (workspaces) admiten superposición (overlay). Los paquetes en un espacio de trabajo superior anularán (override) a aquellos con el mismo nombre en un espacio de trabajo base (underlay). Aunque un espacio de trabajo puede contener múltiples paquetes, estos no pueden anidarse entre sí.

Generación de Paquetes

La herramienta ros2 pkg create facilita la inicialización de la estructura de directorios. A continuación, se crea un espacio de trabajo con un paquete en C++ y otro en Python:

mkdir -p robot_ws/src && cd robot_ws/src
ros2 pkg create robot_core_cpp --license 'MIT'
ros2 pkg create robot_logic_py --build-type ament_python --license 'MIT'

La estructura resultante para el paquete en C++ será:

robot_core_cpp/
  include/
    robot_core_cpp/
  src/
  CMakeLists.txt
  package.xml

Configuración de Archivos y Dependencias

Para dotar de funcionalidad a los paquetes, se deben crear los archivos fuente. Para C++, se añaden robot_core_cpp/include/robot_core_cpp/kinematics.hpp, robot_core_cpp/src/kinematics.cpp y robot_core_cpp/src/main_node.cpp. Para Python, se crea robot_logic_py/robot_logic_py/logic_node.py.

Declaración de Dependencias en Python

En el archivo robot_logic_py/package.xml, se establece la dependencia del paquete C++:

<depend>robot_core_cpp</depend>

Esto garantiza que robot_logic_py se compile únicamente después de que robot_core_cpp haya sido procesado.

Puntos de Entrada en Python

El archivo robot_logic_py/setup.py debe registrar los scripts ejecutables:

setup(
    # ... otros parámetros ...
    entry_points={
        'console_scripts': [
            'logic_executor = robot_logic_py.logic_node:main'
        ],
    },
)

Configuración de CMake para C++

El archivo robot_core_cpp/CMakeLists.txt requiere ajustes para compilar librerías y binarios:

1. Definición de variables para los objetivos:

set(EXECUTABLE_NAME motion_node)
set(LIBRARY_NAME ${EXECUTABLE_NAME}_lib)

include_directories(include)

2. Creación de la biblioteca compartida y el ejecutable:

add_library(${LIBRARY_NAME} SHARED
    src/kinematics.cpp
)

add_executable(${EXECUTABLE_NAME}
    src/main_node.cpp
)

target_link_libraries(${EXECUTABLE_NAME}
    ${LIBRARY_NAME}
)

3. Reglas de instalación para bibliotecas, binarios y cabeceras:

install(TARGETS ${LIBRARY_NAME}
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
    RUNTIME DESTINATION bin
)

install(TARGETS ${EXECUTABLE_NAME}
    RUNTIME DESTINATION lib/${PROJECT_NAME}
)

install(DIRECTORY include/
    DESTINATION include/
)

4. Configuración de pruebas (dentro de if(BUILD_TESTING)):

find_package(ament_lint_auto REQUIRED)
ament_lint_auto_find_test_dependencies()
# Se asume el uso de ament_cmake_gtest para pruebas unitarias

5. Exportación de metadatos mediante macros de ament:

ament_export_include_directories(include)
ament_export_libraries(${LIBRARY_NAME})
ament_package()

Estas instrucciones generan los archivos de configuración necesarios en el directorio share para que otros paquetes puedan enlazar correctamente.

Compilación y Pruebas

La compilación se realiza desde la raíz del espacio de trabajo mediante colcon:

colcon build

Por defecto, colcon utiliza enlaces simbólicos o copias (merge) y analiza los archivos package.xml para resolver el orden de compilación.

Ejecución de Pruebas y Formateo

Para ejecutar las pruebas unitarias y estáticas:

colcon test --packages-select robot_core_cpp

Para mantener la consistencia del código C/C++, se emplea ament_uncrustify:

ament_uncrustify --reformat

Las extensiones de archivo válidas para estas herramientas incluyen .c, .cpp, .hpp, .h, entre otras, siguiendo las normativas de cpplint.

Ejecución de Nodos y Entorno

Antes de ejecutar cualquier nodo, es obligatorio cargar las variables de entorno generadas:

source install/setup.bash

Este script actualiza variables del sistema como PATH y LD_LIBRARY_PATH, además de variables específicas de ROS 2 como AMENT_PREFIX_PATH, la cual indica la ruta base de instalación.

Para lanzar un nodo específico:

ros2 run robot_core_cpp motion_node

El comando ros2 run actúa como un lanzador genérico. Admite el parámetro --prefix para integrar herramientas de depuración o análisis de rendimiento, como gdb o valgrind:

ros2 run --prefix 'gdb -ex run --args' robot_core_cpp motion_node

Resolución de Rutas y Directorios

El sistema de paquetes de ROS 2 busca los ejecutables dentro del directorio lib/<nombre_del_paquete> y no en bin. Durante la compilación, el código C/C++ se transforma en binarios, mientras que los scripts de Python simplemente se copian y organizan. Cualquier binario ubicado fuera de la estructura lib correspondiente no será reconocido por las API de ros2pkg como parte del paquete.