<< TOC (4) >>

¿Qué compone un paquete catkin?

Para que un paquete se considere un paquete catkin, debe cumplir con algunos requisitos:

• El paquete debe contener un archivo package.xml compatible con catkin.

  • Ese archivo package.xml proporciona metainformación sobre el paquete.

• El paquete debe contener un CMakeLists.txt que usa catkin.

  • Si es un metapaquete catkin debe tener el archivo estándar CMakeLists.txt correspondiente.

• Cada paquete debe tener su propia carpeta
  • Esto significa que no hay paquetes anidados ni varios paquetes que compartan el mismo directorio.

El paquete más simple posible podría tener una estructura similar a la siguiente:

• my_package/
    CMakeLists.txt
    package.xml

Paquetes en un espacio de trabajo catkin

El método recomendado para trabajar con paquetes catkin es usar un espacio de trabajo catkin, pero también puede construir paquetes catkin de forma independiente. Un espacio de trabajo infimo podría verse así:

• workspace_folder/        -- WORKSPACE
    src/                   -- SOURCE SPACE
      CMakeLists.txt       -- 'Toplevel' CMake file, provided by catkin
      package_1/
        CMakeLists.txt     -- CMakeLists.txt file for package_1
        package.xml        -- Package manifest for package_1
      ...
      package_n/
        CMakeLists.txt     -- CMakeLists.txt file for package_n
        package.xml        -- Package manifest for package_n

Antes de continuar con este tutorial, cree un espacio de trabajo de catkin vacío siguiendo el tutorial Creación de un espacio de trabajo para catkin.

Creando un paquete catkin

Este tutorial muestra cómo usar el script catkin_create_pkg para crear un nuevo paquete catkin y lo que puede hacer con él una vez creado.

Primero cambie al directorio de origen del espacio de trabajo catkin que creó en el tutorial Creación de un espacio de trabajo para el tutorial catkin:

# Usted debería haber creado esto en exploracion del tutorial sobre creacion de espacios de trabajo
$ cd ~/catkin_ws/src

Ahora utilice la script catkin_create_pkg para crear un nuevo paquete llamado 'beginner_tutorials' dependiente de std_msgs, roscpp, and rospy:

$ catkin_create_pkg beginner_tutorials std_msgs rospy roscpp

Esto creara una carpeta llamada beginner_tutorials que contendrá un paquete package.xml y un archivo CMakeLists.txt, que ha sido parcialmente completado con información que usted proporcionó a catkin_create_pkg.

catkin_create_pkg requiere que se le asigne un package_name (nombre de paquete) y opcionalmente una lista de dependencias propia:

# This is an example, do not try to run this
# catkin_create_pkg <package_name> [depend1] [depend2] [depend3]

catkin_create_pkg también tiene funciones más avanzadas que se describen en catkin/commands/catkin_create_pkg.

Construyendo un espacio de trabajo catkin (catkin workspace) y compilando su archivo de configuración

Ahora es necesario crear los paquetes en el espacio de trabajo catkin:

$ cd ~/catkin_ws
$ catkin_make

Despues de que el espacio de trabajo ha sido creado, este creo una estructura similar a la que se encuentra en la sub carpeta devel y que se encuentra comúnmente en /opt/ros/$ROSDISTRO_NAME.

Para agregar el espacio de trabajo a tu espacio ROS debes compilar el archivo de configuración generado mediante:

$ . ~/catkin_ws/devel/setup.bash

dependencias de paquetes

dependencias prioritarias (first-order)

Anteriormente cuando usamos catkin_create_pkg, se asignaron pocas dependencias de paquetes. Estas dependencias prioritarias pueden ser revistadas por medio de la herramienta rospack.

$ rospack depends1 beginner_tutorials 

• roscpp
  rospy
  std_msgs

Como se puede ver, rospack lista las mismas dependencias que fueron usasdas como argumentos cuando corrimos catkin_create_pkg. Esas dependencias para un paquete están guardadas en el archivo package.xml:

$ roscd beginner_tutorials
$ cat package.xml

• <package format="2">
  ...
    <buildtool_depend>catkin</buildtool_depend>
    <build_depend>roscpp</build_depend>
    <build_depend>rospy</build_depend>
    <build_depend>std_msgs</build_depend>
  ...
  </package>

Dependencias indirectas

En algunos casos, una dependencia tendrá sus propias dependencias. Por ejemplo, rospy posee las siguientes.

$ rospack depends1 rospy

• genpy
  roscpp
  rosgraph
  rosgraph_msgs
  roslib
  std_msgs

Un paquete puede tener bastantes dependencias indirectas. Afortunadamente rospack puede determinar de forma recursiva todas las dependencias anidadas.

$ rospack depends beginner_tutorials
cpp_common
rostime
roscpp_traits
roscpp_serialization
catkin
genmsg
genpy
message_runtime
gencpp
geneus
gennodejs
genlisp
message_generation
rosbuild
rosconsole
std_msgs
rosgraph_msgs
xmlrpcpp
roscpp
rosgraph
ros_environment
rospack
roslib
rospy

Personalizando tu paquete

Esta parte del tutorial examinará cada archivo generado por catkin_create_pkg y describe, linea por linea, cada componente de esos archivos y como los puedes personalizar para tu paquete.

Personalizando package.xml

El package.xml generado debe de estar dentro de tu paquete. Ahora vayamos por el nuevo package.xml y retoquemos cualquier elemento que necesite de su atención.

Etiqueta descriptiva (description tag)

Primero actualicemos la etiqueta descriptiva:

   5   <description>The beginner_tutorials package</description>

Cambie la descripción por la que desee, pero por convención, la primera oración debe ser corta y cubrir el alcance del paquete. Si es difícil describir el paquete en una sola oración, es posible que deba dividirse.

Etiquetas de mantenedor (maintainer tags)

Next comes the maintainer tag:

   7   <!-- One maintainer tag required, multiple allowed, one person per tag --> 
   8   <!-- Example:  -->
   9   <!-- <maintainer email="jane.doe@example.com">Jane Doe</maintainer> -->
  10   <maintainer email="user@todo.todo">user</maintainer>

Esta es una etiqueta necesaria e importante para package.xml porque permite que otros sepan a quién contactar sobre el paquete. Se requiere al menos un mantenedor, pero puede tener muchos si lo desea. El nombre del mantenedor va en el cuerpo de la etiqueta, pero también hay un atributo de correo electrónico que debe completarse:

   7   <maintainer email="you@yourdomain.tld">Your Name</maintainer>

Etiquetas de licencia (license tags)

A continuación, se encuentra la etiqueta de licencia, que también es necesaria:

  12   <!-- One license tag required, multiple allowed, one license per tag -->
  13   <!-- Commonly used license strings: -->
  14   <!--   BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
  15   <license>TODO</license>

Debe elegir una licencia y completarla aquí. Algunas licencias de código abierto comunes son BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1 y LGPLv3. Puede leer sobre varios de estos en la Open Source Initiative. Para este tutorial usaremos la licencia BSD porque el resto de los componentes centrales de ROS ya la usan:

   8   <license>BSD</license>

Etiquetas de dependencias (dependencies tags)

El siguiente conjunto de etiquetas describe las dependencias de su paquete. Las dependencias se dividen en build_depend, buildtool_depend, exec_depend, test_depend. Para obtener una explicación más detallada de estas etiquetas, consulte la documentación sobre Catkin Dependencies. Dado que pasamos std_msgs, roscpp y rospy como argumentos a catkin_create_pkg, las dependencias se verán así:

  27   <!-- The *_depend tags are used to specify dependencies -->
  28   <!-- Dependencies can be catkin packages or system dependencies -->
  29   <!-- Examples: -->
  30   <!-- Use build_depend for packages you need at compile time: -->
  31   <!--   <build_depend>genmsg</build_depend> -->
  32   <!-- Use buildtool_depend for build tool packages: -->
  33   <!--   <buildtool_depend>catkin</buildtool_depend> -->
  34   <!-- Use exec_depend for packages you need at runtime: -->
  35   <!--   <exec_depend>python-yaml</exec_depend> -->
  36   <!-- Use test_depend for packages you need only for testing: -->
  37   <!--   <test_depend>gtest</test_depend> -->
  38   <buildtool_depend>catkin</buildtool_depend>
  39   <build_depend>roscpp</build_depend>
  40   <build_depend>rospy</build_depend>
  41   <build_depend>std_msgs</build_depend>

Todas nuestras dependencias enumeradas se han agregado como un build_depend para nosotros, además del buildtool_depend predeterminado en catkin. En este caso, queremos que todas nuestras dependencias especificadas estén disponibles en tiempo de compilación y ejecución, por lo que también agregaremos una etiqueta exec_depend para cada una de ellas:

  12   <buildtool_depend>catkin</buildtool_depend>
  13 
  14   <build_depend>roscpp</build_depend>
  15   <build_depend>rospy</build_depend>
  16   <build_depend>std_msgs</build_depend>
  17 
  18   <exec_depend>roscpp</exec_depend>
  19   <exec_depend>rospy</exec_depend>
  20   <exec_depend>std_msgs</exec_depend>

package.xml final

Como puede ver, el package.xml final, sin comentarios y etiquetas sin usar, es mucho más conciso:

   1 <?xml version="1.0"?>
   2 <package format="2">
   3   <name>beginner_tutorials</name>
   4   <version>0.1.0</version>
   5   <description>The beginner_tutorials package</description>
   6 
   7   <maintainer email="you@yourdomain.tld">Your Name</maintainer>
   8   <license>BSD</license>
   9   <url type="website">http://wiki.ros.org/beginner_tutorials</url>
  10   <author email="you@yourdomain.tld">Jane Doe</author>
  11 
  12   <buildtool_depend>catkin</buildtool_depend>
  13 
  14   <build_depend>roscpp</build_depend>
  15   <build_depend>rospy</build_depend>
  16   <build_depend>std_msgs</build_depend>
  17 
  18   <exec_depend>roscpp</exec_depend>
  19   <exec_depend>rospy</exec_depend>
  20   <exec_depend>std_msgs</exec_depend>
  21 
  22 </package>

Personalizando el archivo CMakeLists.txt

Ahora que el package.xml, que contiene metainformación, se ha adaptado a su paquete, está listo para continuar con los tutoriales. El archivo CMakeLists.txt creado por catkin_create_pkg se tratará en los tutoriales posteriores sobre la creación de código ROS.