Note: This tutorial assumes that you have completed the previous tutorials: créer un package ROS.
(!) Please ask about problems and questions regarding this tutorial on answers.ros.org. Don't forget to include in your question the link to this page, the versions of your OS & ROS, and also add appropriate tags.

Construire un package ROS

Description: Ce tutoriel détaille la création d'un package ROS à l'aide d'un ensemble d'outils ROS.

Tutorial Level: BEGINNER

Next Tutorial: Comprendre les nodes ROS

Building Packages

Once all the system dependencies are installed, we can build our package that we just created.

Using rosmake

rosmake is just like the make command, but it does some special ROS magic. When you type rosmake beginner_tutorials, it builds the beginner_tutorials package, plus every package that it depends on, in the correct order. Since we listed rospy, roscpp, and std_msgs as dependencies when creating our ROS package, these packages (and their dependiencies, and so on) will be built by rosmake as well.

Usage:

rosmake [package]

Try:

$ rosmake beginner_tutorials

This previous command may take a while to finish. As it is running you should see some output like:

  • [ rosmake ] No package specified.  Building ['beginner_tutorials']
    [ rosmake ] Logging to directory
    [ rosmake ] /home/dbking/.ros/rosmake_output-2009-09-22-03-17-14
    [ rosmake ] [ 0 of 18  Completed ]
    [rosmake-0] >>> genmsg_cpp >>> [ make ]
    [rosmake-0] <<< genmsg_cpp <<< [PASS] [ 0.39 seconds ]
    [ rosmake ] [ 1 of 18  Completed ]
    ...
    ...
    ...
    [ rosmake ] [ 17 of 18  Completed ]
    [rosmake-0] >>> beginner_tutorials >>> [ make ]
    [rosmake-0] <<< beginner_tutorials <<< [PASS] [ 0.79 seconds ]

On Fuerte, since dependencies are greatly reduced, this takes almost no time and produces:

  • [ rosmake ] rosmake starting...                                                                     
    [ rosmake ] Packages requested are: ['beginner_tutorials']                                          
    [ rosmake ] Logging to directory /home/alex/.ros/rosmake/rosmake_output-20120603-082414             
    [ rosmake ] Expanded args ['beginner_tutorials'] to:
    ['beginner_tutorials']                         
    [rosmake-0] Starting >>> std_msgs [ make ]                                                          
    [rosmake-1] Starting >>> roslang [ make ]                                                           
    [rosmake-0] Finished <<< std_msgs ROS_NOBUILD in package std_msgs
     No Makefile in package std_msgs  
    [rosmake-1] Finished <<< roslang ROS_NOBUILD in package roslang
     No Makefile in package roslang     
    [rosmake-1] Starting >>> rospy [ make ]                                                             
    [rosmake-2] Starting >>> roscpp [ make ]                                                            
    [rosmake-1] Finished <<< rospy ROS_NOBUILD in package rospy
     No Makefile in package rospy           
    [rosmake-2] Finished <<< roscpp ROS_NOBUILD in package roscpp
     No Makefile in package roscpp        
    [rosmake-2] Starting >>> beginner_tutorials [ make ]                                                
    [rosmake-2] Finished <<< beginner_tutorials [PASS] [ 1.14 seconds ]                                 
    [ rosmake ] Results:                                                                                
    [ rosmake ] Built 5 packages with 0 failures.                                                       
    [ rosmake ] Summary output to directory                                                             
    [ rosmake ] /home/alex/.ros/rosmake/rosmake_output-20120603-082414  

rosmake multiple packages

We can also use rosmake to build multiple packages at once.

Usage:

rosmake [package1] [package2] [package3]

Review

Lets just list some of the commands we've used so far:

  • rosdep = ros+dep(endencies) : a tool to install package dependencies
  • rosmake = ros+make : makes (compiles) a ROS package

Construire des Packages

Une fois que le système de dépendances de votre package est installé, vous pouvez maintenant construire votre nouveau package.

Note: Si vous avez installé ROS en utilisant apt ou un manager de paquets, vous devriez avoir toutes vos dépendances.

Avant de continuer pensez à "sourcer" votre environnement si ce n'est pas déjà fait. Sur Ubuntu se serait quelque chose comme ça :

$ source /opt/ros/groovy/setup.bash

Utiliser catkin_make

catkin_make c'est un outil en ligne de commande qui ajoute un certain confort à la procédure standard catkin. Vous pouvez imaginer ça : catkin_make combine l'appel à cmake et make à la norme CMake.

Utilisation :

# In a catkin workspace
$ catkin_make [make_targets] [-DCMAKE_VARIABLES=...]

Pour ceux qui ne sont pas familier avec la procédure standard CMake, elle se décompose comme suit :

Note: Si vous exécutez les commandes ci-dessous elles ne marcheront pas, c'est juste à titre d'exemple pour montrer comment fonctionne Cmake de manière générale.

# In a CMake project
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install  # (optionally)

Cette procédure est appliqué pour chaque projet Cmake. En comparaison des projets catkin qui peuvent être construits ensemble dans le workspace. Construire zéro ou plusieurs packages catkin dans un workspace suit la procédure suivante :

# In a catkin workspace
$ catkin_make
$ catkin_make install  # (optionally)

Les commandes ci-dessus construirons tous les projets présent dans le dossier src. Cela fait suite aux recommandations formulées par REP128. Si votre code source est à un endroit différent, appelé my_src alors vous pouvez appeler catkin_make comme ceci :

Note: Si vous exécutez les commandes suivantes elles ne marcheront pas, si le dossier my_src n'existe pas.

# In a catkin workspace
$ catkin_make --source my_src
$ catkin_make install --source my_src  # (optionally)

Pour une utilisation plus avancée de catkin_make voir la documentation : catkin/commands/catkin_make

Construire Son Package

Pour les lecteurs de cette page qui voudraient construire leur propre code, regardez aussi un des tutoriels suivants (C++)/(Python) puisque vous devrez peut-être modifier le fichier CMakeLists.txt.

Vous devriez déjà avoir un espace de travail catkin (catkin workspace) et un nouveau package catkin appelé beginner_tutorials de la leçon précédente, Créer un Package. Allez dans l'espace de travail catkin (catkin_ws) si vous n'y êtes pas déjà et regarder dans le dossier src :

$ cd ~/catkin_ws/
$ ls src
  • beginner_tutorials/  CMakeLists.txt@  

Vous devriez voir qu'il ya un dossier appelé beginner_tutorials que vous avez créé avec catkin_create_pkg dans le tutoriel précédent. Nous pouvons maintenant construire ce package en utilisant catkin_make :

$ catkin_make

Vous devriez voir sur votre console la sortie de cmake et aussi de make , qui devrait être similaire à ceci :

  • Base path: /home/user/catkin_ws
    Source space: /home/user/catkin_ws/src
    Build space: /home/user/catkin_ws/build
    Devel space: /home/user/catkin_ws/devel
    Install space: /home/user/catkin_ws/install
    ####
    #### Running command: "cmake /home/user/catkin_ws/src
    -DCATKIN_DEVEL_PREFIX=/home/user/catkin_ws/devel
    -DCMAKE_INSTALL_PREFIX=/home/user/catkin_ws/install" in "/home/user/catkin_ws/build"
    ####
    -- The C compiler identification is GNU 4.2.1
    -- The CXX compiler identification is Clang 4.0.0
    -- Checking whether C compiler has -isysroot
    -- Checking whether C compiler has -isysroot - yes
    -- Checking whether C compiler supports OSX deployment target flag
    -- Checking whether C compiler supports OSX deployment target flag - yes
    -- Check for working C compiler: /usr/bin/gcc
    -- Check for working C compiler: /usr/bin/gcc -- works
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Check for working CXX compiler: /usr/bin/c++
    -- Check for working CXX compiler: /usr/bin/c++ -- works
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Using CATKIN_DEVEL_PREFIX: /tmp/catkin_ws/devel
    -- Using CMAKE_PREFIX_PATH: /opt/ros/groovy
    -- This workspace overlays: /opt/ros/groovy
    -- Found PythonInterp: /usr/bin/python (found version "2.7.1") 
    -- Found PY_em: /usr/lib/python2.7/dist-packages/em.pyc
    -- Found gtest: gtests will be built
    -- catkin 0.5.51
    -- BUILD_SHARED_LIBS is on
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- ~~  traversing packages in topological order:
    -- ~~  - beginner_tutorials
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- +++ add_subdirectory(beginner_tutorials)
    -- Configuring done
    -- Generating done
    -- Build files have been written to: /home/user/catkin_ws/build
    ####
    #### Running command: "make -j4" in "/home/user/catkin_ws/build"
    ####

Notez que catkin_make affiche en premiers quels sont les chemins qu'il utilise pour chacun des 'espaces'. Les espaces sont décrits dans le REP128 et par la documentation de catkin/workspaces. La chose importante à noter est qu'en raison de ces valeur par défaut, plusieurs dossiers ont été créés dans votre espace de travail catkin. Regardez avec ls :

$ ls
  • build
    devel
    src

Le dossier build est l'emplacement par défaut de l'espace de construction build space et c'est là que cmake et make sont appelés à configurer et construire vos packages. Le dossier devel est l'emplacement par défaut de l'espace de développement devel space, qui est l'endroit où vos exécutables et les bibliothèques de vos packages vont être installés.

Maintenant que vous avez créez votre package ROS, parlons des Nodes ROS.

Wiki: fr/ROS/Tutorials/BuildingPackages (last edited 2015-03-22 23:12:59 by ArnaudMarot)