[Documentation] [TitleIndex] [WordIndex

Do que é feito um pacote catkin?

Para que um pacote seja considerado um pacote catkin, ele deve responder à alguns requerimentos:

O pacote mais simples possível poderia ser assim:

Pacotes em um espaço de trabalho catkin

O método recomendado para trabalhar com pacotes catkin é usando um espaço de trabalho catkin, mas você também pode criar pacotes catkin por fora. Um espaço de trabalho trivial poderia ser algo do tipo:

Antes de continuar com este tutorial, crie um espaço catkin vazio seguindo o tutorial sobre criar um espaço de trabalho catkin.

Criando um pacote catkin

Este tutorial vai mostrar como usar o script catkin_create_pkg para criar um novo pacote catkin, e o que você pode fazer com ele depois de ter sido criado.

Primeiro vá para o diretório de código fonte que você criou no tutorial Criando um espaço de trabalho catkin:

# Você já deveria ter criado este diretório no tutorial anterior
$ cd ~/catkin_ws/src

Agora use o script catkin_create_pkg para criar um novo pacote chamado beginner_tutorials, que depende de std_msgs, roscpp, e rospy:

$ catkin_create_pkg beginner_tutorials std_msgs rospy roscpp

Isso vai criar uma pasta beginner_tutorials que contém os arquivos package.xml e CMakeLists.txt, que já foram parcialmente preenchidos com informações que você deu ao script catkin_create_pkg.

catkin_create_pkg pede que você dê um `nome_do_pacote' e opcionalmente uma lista de dependências para o pacote:

# Isso é um exemplo, não rode
# catkin_create_pkg <nome_do_pacote> [depende1] [depende2] [depende3]

catkin_create_pkg também tem funcionalidades mais avançadas que são descritas em catkin/commands/catkin_create_pkg.

Compilando o espaço catkin e usando o arquivo de setup

Agora você precisa compilar os pacotes no espaço de trabalho catkin:

$ cd ~/catkin_ws
$ catkin_make

Depois do espaço ter sido compilado, ele criou uma estrutura similar na subpasta devel, como geralmente encontrado em /opt/ros/$ROSDISTRO_NAME.

Para adicionar o espaço ao seu ambiente ROS você precisa "source" o arquivo setup gerado com o seguinte comando:

$ . ~/catkin_ws/devel/setup.bash

Dependências do pacote

Dependências de primeira ordem

Quando usamos catkin_create_pkg antes, algumas dependências foram fornecidas. Essas dependências de primeira ordem agora podem ser revisadas com a ferramenta rospack.

$ rospack depends1 beginner_tutorials 

Você pode ver que rospack lista as mesmas dependências que foram usadas como argumentos quando rodamos catkin_create_pkg. Essas dependências de pacote são guardadas no arquivo package.xml:

$ roscd beginner_tutorials
$ cat package.xml

Dependências indiretas

Em muitos casos, uma dependência também vai ter suas próprias dependências. Por exemplo, rospy tem outras dependências.

$ rospack depends1 rospy

Um pacote pode ter várias dependências. Felizmente, rospack pode determinar recursivamente todas as dependências herdadas.

$ 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

Customizando seu pacote

Esta parte do tutorial vai examinar cada arquivo gerado por catkin_create_pkg e descrever, linha por linha, cada componente desses arquivos e como customizá-los para seu pacote.

Customizando package.xml

O arquivo package.xml gerado deveria estar no seu pacote. Now lets go through the new package.xml and touch up any elements that need your attention.

description tag

First update the description tag:

   5   <description>The beginner_tutorials package</description>

Change the description to anything you like, but by convention the first sentence should be short while covering the scope of the package. If it is hard to describe the package in a single sentence then it might need to be broken up.

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>

This is a required and important tag for the package.xml because it lets others know who to contact about the package. At least one maintainer is required, but you can have many if you like. The name of the maintainer goes into the body of the tag, but there is also an email attribute that should be filled out:

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

license tags

Next is the license tag, which is also required:

  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>

You should choose a license and fill it in here. Some common open source licenses are BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, and LGPLv3. You can read about several of these at the Open Source Initiative. For this tutorial we'll use the BSD license because the rest of the core ROS components use it already:

   8   <license>BSD</license>

dependencies tags

The next set of tags describe the dependencies of your package. The dependencies are split into build_depend, buildtool_depend, exec_depend, test_depend. For a more detailed explanation of these tags see the documentation about Catkin Dependencies. Since we passed std_msgs, roscpp, and rospy as arguments to catkin_create_pkg, the dependencies will look like this:

  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>

All of our listed dependencies have been added as a build_depend for us, in addition to the default buildtool_depend on catkin. In this case we want all of our specified dependencies to be available at build and run time, so we'll add a exec_depend tag for each of them as well:

  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>

Final package.xml

As you can see the final package.xml, without comments and unused tags, is much more concise:

   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>

Customizing the CMakeLists.txt

Now that the package.xml, which contains meta information, has been tailored to your package, you are ready to move on in the tutorials. The CMakeLists.txt file created by catkin_create_pkg will be covered in the later tutorials about building ROS code.


2019-10-19 13:03