Titre du cours

Nom de la filière

Année

©2025 Caplogy. All rights reserved.

Nom de la filière - Année Titre du cours

Table des matières

Installing and Configuring Your ROS Environment..................................................8

[Link] ROS........................................................................................................... 8
2. Gérer votre environnement................................................................................ 8
............................................................................................................................... 9
............................................................................................................................... 9
3. Créer un espace de travail ROS..........................................................................9
Catkin.................................................................................................................. 9
Créons et construisons un espace de travail Catkin :.............................................................9
............................................................................................................................... 9
Rosbuild 7......................................................................................................... 11
3.1 Créer un nouvel espace de travail...............................................................11
3.2 Création d'un répertoire sandbox pour les nouveaux packages.................11
3.3 Confirmation............................................................................................... 11
4. Démonstration vidéo........................................................................................ 12
Naviguer dans le système de fichiers ROS...........................................................12
[Link]érequis........................................................................................................... 13
2. Aperçu rapide des concepts du système de fichiers........................................13
3. Outils du système de fichiers...........................................................................13
3.1 Utilisation de rospack.................................................................................. 13
3.2 Utilisation de roscd...................................................................................... 14
3.2.1 Sous-répertoires....................................................................................... 14
3.3 journal roscd............................................................................................... 15
3.4 Utilisation de rosls....................................................................................... 15
3.5 Complétion des tabulations.........................................................................15
4 .Revoir............................................................................................................... 16
Création d'un package ROS............................................................................... 17
Avec Chaton......................................................................................................... 17
[Link]'est-ce qui constitue un paquet de chatons ?................................................17
[Link] dans un espace de travail catkin.........................................................17
[Link]éation d'un package catkin............................................................................18
[Link]éation d'un espace de travail Catkin et recherche du fichier d'installation....18
5 . dépendances du paquet.................................................................................. 19
5.1 Dépendances de premier ordre...................................................................19
5.2 Dépendances indirectes..............................................................................19

© 2025 Caplogy. All rights reserved.

2
Nom de la filière - Année Titre du cours

6. Personnalisation de votre forfait......................................................................21

6.1 Personnalisation du [Link]................................................................21
6.1.1 balise de description................................................................................ 21
6.1.2 balises de maintenance........................................................................... 21
6.1.3 étiquettes de licence................................................................................ 21
6.1.4 balises de dépendances...........................................................................22
6.1.5 Package [Link]..................................................................................... 23
6.2 Personnalisation du fichier [Link]..................................................23
Démonstration vidéo.............................................................................................. 23
[Link] de Roscreate.................................................................................... 24
2. Création d'un nouveau package ROS...............................................................24
3. Dépendances des packages de premier ordre.................................................26
4. Dépendances indirectes des packages............................................................26
5. Bibliothèques clientes ROS...............................................................................27
6 .Revoir............................................................................................................... 28
7 .Démonstration vidéo........................................................................................ 28
Créer un package ROS......................................................................................... 29
[Link] de construction.................................................................................... 29
1.1 Utilisation de catkin_make..........................................................................29
1.2 Construire votre package............................................................................ 30
[Link] de construction.................................................................................... 33
1.1 Utilisation de Rosmake................................................................................33
1.2 rosmake plusieurs packages.......................................................................35
2. Revoir.................................................................................................................. 35
Comprendre les nœuds ROS............................................................................. 36
[Link]érequis........................................................................................................... 36
2. Aperçu rapide des concepts graphiques..........................................................36
3. Nœuds.............................................................................................................. 36
[Link]èques clientes....................................................................................... 36
5. Roscore............................................................................................................ 36
[Link] de Rosnode....................................................................................... 38
7. Utilisation de rosrun......................................................................................... 39
8. Revoir............................................................................................................... 40
9.Démonstration vidéo......................................................................................... 41
Comprendre les sujets ROS............................................................................... 42
[Link]......................................................................................................... 42

© 2025 Caplogy. All rights reserved.

3
Nom de la filière - Année Titre du cours

1.1Roscore........................................................................................................ 42
1.2simulation de tortue..................................................................................... 42
1.3téléopération du clavier de la tortue............................................................42
[Link] ROS......................................................................................................... 43
2.1 Utilisation de rqt_graph............................................................................... 43
2.2 Présentation de Rostopic.............................................................................44
2.3 Utilisation de l'écho rostopique...................................................................45
2.4 Utilisation de la liste rostopique..................................................................47
[Link] ROS................................................................................................... 48
3.1 Utilisation du type rostopique.....................................................................48
4. rostopic suite..................................................................................................... 50
4.1 Utilisation de la pub rostopique...................................................................50
4.2 Utilisation du Hz rostopique........................................................................54
5. Utilisation de rqt_plot....................................................................................... 55
6. Tutoriel vidéo................................................................................................... 57
Comprendre les services et les paramètres ROS..............................................58
[Link] ROS..................................................................................................... 58
2. Utilisation de rosservice................................................................................... 58
2.1 liste rosservice............................................................................................ 58
2.2 type de service Ros..................................................................................... 59
2.3 appel rosservice.......................................................................................... 59
3. Utilisation du rosparam.................................................................................... 61
3.1 liste de rosparam........................................................................................ 62
3.2 Rosparam set et Rosparam get...................................................................62
3.3 décharge et chargement de Rosparam.......................................................64
4. Démonstration vidéo........................................................................................ 65
Utilisation de rqt_console et roslaunch..............................................................66
[Link]érequis rqt et package turtlesim....................................................................66
2. Utilisation de rqt_console et rqt_logger_level...................................................66
2.1 Note rapide sur les niveaux d'enregistrement............................................69
2.2 Utilisation de Roslaunch..............................................................................70
2.3 Le fichier de lancement............................................................................... 70
2.4 Le fichier de lancement expliqué................................................................71
2.5 roslaunching................................................................................................ 71
3. Démonstration vidéo........................................................................................ 73

© 2025 Caplogy. All rights reserved.

4
Nom de la filière - Année Titre du cours

© 2025 Caplogy. All rights reserved.

5
Nom de la filière - Année Titre du cours

Objectifs du cours

 Lorem ipsum dolor sit amet, consectetur adipiscing elit.

 Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 Lorem ipsum dolor sit amet, consectetur adipiscing elit.

© 2025 Caplogy. All rights reserved.

6
Nom de la filière - Année Titre du cours

Séquencement du cours

1. Introduction au … (X heurs de cours)

2. Section 1 (X heurs de cours)

a) Notion 1
b) Notion 2

3. Section 2 (X heurs de cours)

a) Notion 1

4. Section 3 (X heurs de cours)

© 2025 Caplogy. All rights reserved.

7
Nom de la filière - Année Titre du cours

Installing and Configuring Your ROS

Environment

[Link] ROS
Avant de commencer ces tutoriels, veuillez terminer l'installation comme décrit dans
les instructions d'installation de ROS .

Remarque : Si vous avez installé ROS depuis un gestionnaire de paquets comme apt , ces
paquets ne seront pas accessibles en écriture et ne pourront pas être modifiés par vous,
l'utilisateur. Lorsque vous travaillez avec des paquets ROS depuis les sources ou que vous en
créez un, vous devez toujours travailler dans un répertoire auquel vous avez accès, comme
votre dossier personnel.
2. Gérer votre environnement
Lors de l'installation de ROS, vous serez invité à sourcer l'un des nombreux fichiers
setup.*sh, voire à ajouter ce « sourcer » à votre script de démarrage. Ceci est nécessaire car
ROS repose sur la notion de combinaison d'espaces via l'environnement shell. Cela facilite le
développement avec différentes versions de ROS ou différents ensembles de paquets.
Si vous rencontrez des difficultés pour trouver ou utiliser vos paquets ROS, assurez-vous que
votre environnement est correctement configuré. Un bon moyen de le vérifier est de vérifier
que les variables d'environnement comme ROS_ROOT et ROS_PACKAGE_PATH sont
définies :

$ printenv | grep ROS

Si ce n'est pas le cas, vous devrez peut-être « sourcer » certains fichiers setup.*sh.
Les fichiers de configuration de l'environnement sont générés pour vous, mais peuvent
provenir de différents endroits :

 Les packages ROS installés avec les gestionnaires de packages fournissent des fichiers
setup.*sh
 Les espaces de travail rosbuild fournissent des fichiers setup.*sh à l'aide d'outils tels
que rosws
 Les fichiers Setup.*sh sont créés en tant que sous-produit de la construction ou de
l'installation de packages catkin

© 2025 Caplogy. All rights reserved.

8
Nom de la filière - Année Titre du cours

Remarque : Tout au long des tutoriels, vous verrez des références à rosbuild et catkin . Ce
sont les deux méthodes disponibles pour organiser et compiler votre code ROS. rosbuild
n'est plus recommandé ni maintenu, mais conservé pour l'héritage. catkin est la
méthode recommandée pour organiser votre code. Il utilise des conventions CMake plus
standard et offre plus de flexibilité, notamment pour les personnes souhaitant intégrer
des bases de code externes ou publier leur logiciel. Pour une description complète,
consultez catkin ou rosbuild .

Si vous venez d'installer ROS depuis apt sur Ubuntu, vous aurez des fichiers
setup.*sh dans ' /opt/ros/<distro>/ ', et vous pourrez les sourcer comme ceci :

$ source /opt/ros/<distribution>/[Link]

Utiliser le nom court de votre distribution ROS au lieu de <distro>

Si vous avez installé ROS Kinetic, ce serait :

$ source /opt/ros/kinetic/[Link]

Vous devrez exécuter cette commande à chaque nouveau shell ouvert pour accéder aux
commandes ROS, sauf si vous ajoutez cette ligne à votre fichier .bashrc. Ce processus vous
permet d'installer plusieurs distributions ROS (par exemple, Indigo et Kinetic) sur le même
ordinateur et de passer de l'une à l'autre.
Sur d'autres plateformes, vous trouverez ces fichiers setup.*sh partout où vous avez installé
ROS.
3. Créer un espace de travail ROS
Catkin

Ces instructions concernent ROS Groovy et versions ultérieures. Pour ROS

Fuerte et versions antérieures, sélectionnez rosbuild.

Créons et construisons un espace de travail Catkin :

$ mkdir -p ~/catkin_ws/src
$ cd ~/catkin_ws/
$ catkin_make

© 2025 Caplogy. All rights reserved.

9
Nom de la filière - Année Titre du cours

La commande catkin_make est un outil pratique pour travailler avec les espaces de travail
catkin . Sa première exécution dans votre espace de travail crée un lien [Link] dans
votre dossier « src ».

Utilisateurs de Python 3 dans ROS Melodic et versions antérieures : remarque, si vous compilez
ROS à partir des sources pour obtenir la compatibilité avec Python 3 et que vous avez configuré votre
système de manière appropriée (c'est-à-dire que vous avez installé les versions Python 3 de tous les
packages ROS Python requis, tels que catkin ), la première commande catkin_make dans un espace
de travail catkin propre doit être :

$ catkin_make -DPYTHON_EXECUTABLE=/usr/bin/python3

Cela configurera catkin_make avec Python 3. Vous pourrez ensuite utiliser

uniquement catkin_make pour les builds suivantes.

De plus, si vous consultez votre répertoire actuel, vous devriez maintenant

trouver un dossier « build » et un dossier « devel ». Dans ce dossier, vous pouvez
voir plusieurs fichiers setup.*sh. Le sourcer de l'un de ces fichiers superposera
cet espace de travail à votre environnement. Pour en savoir plus, consultez la
documentation générale de catkin : catkin . Avant de continuer, sourcez votre
nouveau fichier setup.*sh :

$ source devel/[Link]

Pour vous assurer que votre espace de travail est correctement superposé par le script d'installation,
Pour vous assurer que votre espace de travail est correctement superposé par le
script d'installation, assurez-vous que la variable
d'environnement ROS_PACKAGE_PATH inclut le répertoire dans lequel vous vous
trouvez.

$ echo $ROS_PACKAGE_PATH
/home/votreutilisateur/catkin_ws/src:/opt/ros/kinetic/share

Maintenant que votre environnement est configuré, continuez avec le didacticiel

sur le système de fichiers ROS .

© 2025 Caplogy. All rights reserved.

10
Nom de la filière - Année Titre du cours

Rosbuild 7
Lorsque vous travaillez avec du code source ROS, il est souvent utile de disposer d'un espace
de travail. Pour les tutoriels ROS suivants, vous aurez besoin d'un espace dédié à la création
de piles et de packages ROS.
rosws est un outil qui fournit une interface uniforme avec différents systèmes de gestion de
versions tels que SVN, Git et Mercurial, et permet de gérer tous les paquets installés dans
une surcouche ROS. Un tutoriel complet sur rosws est disponible ici .
3.1 Créer un nouvel espace de travail
La commande suivante crée un nouvel espace de travail dans ~/fuerte_workspace qui étend
l'ensemble des packages installés dans /opt/ros/fuerte :

rosws init ~/fuerte_workspace /opt/ros/fuerte

Remarque : rosws fait partie du paquet rosinstall , qui n'est pas installé par défaut. La
commande suivante le télécharge via le gestionnaire de paquets Ubuntu :

sudo apt-get install python-rosinstall

3.2 Création d'un répertoire sandbox pour les nouveaux packages

Les nouveaux paquets doivent être placés dans un chemin d'accès spécifié dans la
variable ROS_PACKAGE_PATH . Tous les répertoires gérés par rosws, c'est-à-dire ajoutés via
rosws, sont automatiquement ajoutés à ROS_PACKAGE_PATH lors de la recherche du
fichier [Link] de l'espace de travail correspondant. Bien que les nouveaux paquets
doivent toujours être placés dans des dépôts installés via rosws, il peut être très pratique de
disposer d'un répertoire sandbox où, par exemple, les paquets créés lors des tutoriels
peuvent être stockés sans nécessiter de commandes rosws supplémentaires. Pour cela, nous
créons un nouveau répertoire sandbox et l'ajoutons au fichier caché .rosinstall avec rosws :

mkdir ~/fuerte_workspace/sandbox
rosws définit ~/fuerte_workspace/sandbox

Chaque fois que les entrées de l'espace de travail changent, il est nécessaire de
réapprovisionner ~/fuerte_workspace/[Link] pour s'assurer que
le ROS_PACKAGE_PATH mis à jour est utilisé.

source ~/fuerte_workspace/[Link]

Il est très courant de remplacer la ligne source /opt/ros/fuerte/[Link] par la source du

[Link] dans ~/fuerte_workspace ou dans l'espace de travail que vous utilisez le plus
souvent.
Un didacticiel ROS Workspace plus complet peut être trouvé ici .
3.3 Confirmation

© 2025 Caplogy. All rights reserved.

11
Nom de la filière - Année Titre du cours

Pour confirmer que le chemin de votre package a été défini, faites écho à la variable
ROS_PACKAGE_PATH.

$ echo $ROS_PACKAGE_PATH

Vous devriez voir quelque chose de similaire à :

/home/votre_nom_d'utilisateur/fuerte_workspace/sandbox:/opt/ros/fuerte/share:/opt/
ros/fuerte/stacks

Maintenant que votre environnement est configuré, continuez avec le didacticiel sur le
système de fichiers ROS .

4. Démonstration vidéo
Regardez la vidéo ci-dessous pour avoir plus d'explications sur l'espace de travail
personnalisé et la création de packages avec un guide étape par étape.
[Link]

Naviguer dans le système de fichiers ROS

© 2025 Caplogy. All rights reserved.
12
Nom de la filière - Année Titre du cours

[Link]érequis
Pour ce tutoriel, nous allons inspecter un package dans ros-tutorials, veuillez l'installer en
utilisant

$ sudo apt-get install ros-<distribution>-ros-tutorials

Remplacez '<distro>' (y compris le '<>') par le nom de votre distribution ROS (par exemple
indigo, kinetic, lunar, etc.)
2. Aperçu rapide des concepts du système de fichiers
 Paquets : Les paquets constituent l'unité d'organisation logicielle du code ROS.
Chaque paquet peut contenir des bibliothèques, des exécutables, des scripts ou
d'autres artefacts.
 Manifestes ( [Link] ) : Un manifeste est la description d'un paquet . Il sert à
définir les dépendances entre les paquets et à collecter des métadonnées sur
le paquet , comme la version, le mainteneur, la licence, etc.
Afficher la note sur les piles
3. Outils du système de fichiers
Le code est réparti sur de nombreux packages ROS. Naviguer avec des outils en ligne de
commande comme ls et cd peut s'avérer fastidieux, c'est pourquoi ROS fournit des outils
pour vous aider.
3.1 Utilisation de rospack
rospack vous permet d'obtenir des informations sur les paquets. Dans ce tutoriel, nous
aborderons uniquement l' option find , qui renvoie le chemin d'accès au paquet.
Usage:

$ rospack find [nom_paquet]

Exemple:

$ rospack trouver roscpp

reviendrait :

 VOTRE_CHEMIN_D'INSTALLATION/share/roscpp

Si vous avez installé ROS Kinetic depuis apt sur Ubuntu Linux, vous verrez exactement :

© 2025 Caplogy. All rights reserved.

13
Nom de la filière - Année Titre du cours

 /opt/ros/kinetic/share/roscpp

3.2 Utilisation de roscd

roscd fait partie de la suite rosbash . Il permet de changer de répertoire ( cd ) directement
vers un paquet ou une pile.
Usage:

$ roscd <paquet-ou-pile>[/subdir]

Pour vérifier que nous sommes passés au répertoire du package roscpp, exécutez cet
exemple :

$ roscd roscpp

Imprimons maintenant le répertoire de travail en utilisant la commande Unix pwd :

$ mot de passe

Vous devriez voir :

 VOTRE_CHEMIN_D'INSTALLATION/share/roscpp

Vous pouvez voir que YOUR_INSTALL_PATH/share/roscpp est le même chemin que celui
donné par rospack find dans l'exemple précédent.
Notez que roscd , comme les autres outils ROS, ne trouve que les paquets ROS présents dans
les répertoires listés dans votre ROS_PACKAGE_PATH . Pour afficher le contenu de
votre ROS_PACKAGE_PATH , saisissez :

$ echo $ROS_PACKAGE_PATH

Votre ROS_PACKAGE_PATH doit contenir la liste des répertoires contenant vos paquets ROS,
séparés par deux points. Un ROS_PACKAGE_PATH typique pourrait ressembler à ceci :

 /opt/ros/kinetic/base/install/share

De la même manière que pour les autres chemins d'environnement, vous pouvez ajouter des
répertoires supplémentaires à votre ROS_PACKAGE_PATH , chaque chemin étant séparé par
deux points : '.
3.2.1 Sous-répertoires

roscd peut également se déplacer vers un sous-répertoire d'un package ou d'une pile.
Essayer:

$ roscd roscpp/cmake

© 2025 Caplogy. All rights reserved.

14
Nom de la filière - Année Titre du cours

$ mot de passe

Vous devriez voir :

 VOTRE_CHEMIN_D'INSTALLATION/share/roscpp/cmake

3.3 journal roscd

roscd log vous mènera au dossier où ROS stocke les fichiers journaux. Notez que si vous
n'avez pas encore exécuté de programme ROS, une erreur s'affichera indiquant que le
dossier n'existe pas encore.
Si vous avez déjà exécuté un programme ROS, essayez :

journal $ roscd

3.4 Utilisation de rosls

rosls fait partie de la suite rosbash . Il permet d'exécuter directement ls dans un paquet par
son nom plutôt que par son chemin absolu.
Usage:

$ rosls <paquet-ou-pile>[/subdir]

Exemple:

$ rosls roscpp_tutoriels

reviendrait :

 package de lancement [Link] srv

3.5 Complétion des tabulations

Il peut être fastidieux de saisir le nom complet d'un paquet. Dans l'exemple
précédent, roscpp_tutorials est un nom assez long. Heureusement, certains outils ROS
prennent en charge la complétion par tabulation .
Commencez par taper :

$ roscd roscpp_tut<<< appuyez maintenant sur la touche TAB >>>

Après avoir appuyé sur la touche TAB , la ligne de commande devrait remplir le reste :

$ roscd roscpp_tutoriels/

Cela fonctionne car roscpp_tutorials est actuellement le seul package ROS qui commence
par roscpp_tut .

© 2025 Caplogy. All rights reserved.

15
Nom de la filière - Année Titre du cours

Essayez maintenant de taper :

$ roscd tur<<< appuyez maintenant sur la touche TAB >>>

Après avoir appuyé sur la touche TAB , la ligne de commande devrait se remplir autant que
possible :

$ roscd tortue

Cependant, dans ce cas, plusieurs paquets commencent par turtle . Essayez de taper TAB à
nouveau. Cela devrait afficher tous les paquets ROS commençant par turtle :

 turtle_actionlib/ turtlesim/ turtle_tf/

Sur la ligne de commande, vous devriez toujours avoir :

$ roscd tortue

Tapez maintenant un s après tortue puis appuyez sur TAB :

$ roscd turtles<<< appuyez maintenant sur la touche TAB >>>

Comme il n'y a qu'un seul paquet qui commence par turtles , vous devriez voir :

$ roscd turtlesim/

Si vous souhaitez voir une liste de tous les packages actuellement installés, vous pouvez
également utiliser la saisie semi-automatique par tabulation :

$ rosls <<< appuyez maintenant deux fois sur la touche TAB >>>

4 .Revoir
Vous avez peut-être remarqué un modèle dans la dénomination des outils ROS :

 rospack = ros + paquet(âge)

 roscd = ros + cd
 rosls = ros + ls

Ce modèle de dénomination s’applique à de nombreux outils ROS.

Maintenant que vous savez vous déplacer dans ROS, créons un package .

Création d'un package ROS

© 2025 Caplogy. All rights reserved.

16
Nom de la filière - Année Titre du cours

Avec Chaton
[Link]'est-ce qui constitue un paquet de chatons ?
Pour qu'un paquet soit considéré comme un paquet de chatons, il doit répondre à quelques
exigences :
 Le package doit contenir un fichier [Link] compatible catkin .
o Ce fichier [Link] fournit des méta-informations sur le package.
 Le package doit contenir un [Link] qui utilise catkin .
o S'il s'agit d'un métapaquet catkin, il doit contenir le fichier [Link]
standard approprié.
 Chaque package doit avoir son propre dossier
o Cela signifie qu'il n'y a pas de packages imbriqués ni de packages multiples
partageant le même répertoire.

Le package le plus simple possible pourrait avoir une structure qui ressemble à ceci :

 mon_paquet/
 [Link]
 [Link]

[Link] dans un espace de travail catkin

La méthode recommandée pour travailler avec les paquets Catkin est d'utiliser un espace de
travail Catkin , mais vous pouvez également créer des paquets Catkin de manière autonome.
Un espace de travail simple pourrait ressembler à ceci :

 workspace_folder/ -- ESPACE DE TRAVAIL

 src/ -- ESPACE SOURCE
 [Link] -- Fichier CMake « Toplevel », fourni par catkin
 paquet_1/
 [Link] -- Fichier [Link] pour le package_1
 [Link] -- Manifeste du package pour package_1
 ...
 paquet_n/
 [Link] -- Fichier [Link] pour package_n
 [Link] -- Manifeste du package pour package_n

© 2025 Caplogy. All rights reserved.

17
Nom de la filière - Année Titre du cours

Avant de continuer avec ce tutoriel, créez un espace de travail chaton vide en suivant
le tutoriel Création d'un espace de travail pour chaton .
[Link]éation d'un package catkin
Ce tutoriel vous montrera comment utiliser le script catkin_create_pkg pour créer un
nouveau package catkin et ce que vous pouvez en faire après sa création.
Tout d'abord, modifiez le répertoire de l'espace source de l'espace de travail catkin que vous
avez créé dans le didacticiel Création d'un espace de travail pour catkin :

# Vous auriez dû créer ceci dans le didacticiel de création d'un espace de travail
$ cd ~/catkin_ws/src

Utilisez maintenant le script catkin_create_pkg pour créer un nouveau package appelé

« beginner_tutorials » qui dépend de std_msgs, roscpp et rospy :

$ catkin_create_pkg tutoriels_débutants std_msgs rospy roscpp

Cela créera un dossier beginner_tutorials qui contient un [Link] et un [Link] ,

qui ont été partiellement remplis avec les informations que vous avez fournies à
catkin_create_pkg .
catkin_create_pkg nécessite que vous lui donniez un package_name et éventuellement une
liste de dépendances dont dépend ce package :

# Ceci est un exemple, n'essayez pas de l'exécuter

# catkin_create_pkg <nom_du_paquet> [depend1] [depend2] [depend3]

catkin_create_pkg possède également des fonctionnalités plus avancées qui sont décrites
dans catkin/commands/catkin_create_pkg .
[Link]éation d'un espace de travail Catkin et recherche du
fichier d'installation
Vous devez maintenant créer les packages dans l'espace de travail catkin :

$ cd ~/catkin_ws
$ catkin_make

Une fois l'espace de travail construit, il a créé une structure similaire dans le sous-
dossier devel comme vous le trouvez habituellement sous /opt/ros/$ROSDISTRO_NAME .
Pour ajouter l'espace de travail à votre environnement ROS, vous devez générer le fichier
d'installation généré :

$ . ~/catkin_ws/devel/[Link]

© 2025 Caplogy. All rights reserved.

18
Nom de la filière - Année Titre du cours

5 . dépendances du paquet
5.1 Dépendances de premier ordre
Lors de l'utilisation de catkin_create_pkg précédemment, quelques dépendances de package
étaient fournies. Ces dépendances de premier ordre peuvent désormais être examinées
avec l' outil rospack .

$ rospack depends1 tutoriels_débutants

 roscpp
 rosé
 messages_std

Comme vous pouvez le voir, rospack répertorie les mêmes dépendances qui ont été utilisées
comme arguments lors de l'exécution de catkin_create_pkg . Ces dépendances pour un
package sont stockées dans le fichier [Link] :

$ roscd tutoriels pour débutants

$ package [Link]

 <package format="2">
 ...
 <buildtool_depend>chaton</buildtool_depend>
 <build_depend>roscpp</build_depend>
 <build_depend>rospy</build_depend>
 <build_depend>messages_std</build_depend>
 ...
 </package>

5.2 Dépendances indirectes

Dans de nombreux cas, une dépendance possède également ses propres dépendances. Par
exemple, rospy possède d'autres dépendances.

$ rospack dépend1 rospy

 genpy
 roscpp
 rosgraphe

© 2025 Caplogy. All rights reserved.

19
Nom de la filière - Année Titre du cours

 rosgraph_msgs
 roslib
 messages_std

Un paquet peut avoir de nombreuses dépendances indirectes. Heureusement, rospack peut

déterminer récursivement toutes les dépendances imbriquées.

$ rospack dépend de beginner_tutorials

cpp_common
Rostime
traits_roscpp
roscpp_sérialisation
chaton
genmsg
genpy
message_runtime
gencpp
gène
gennodejs
genlisp
génération_de_messages
rosbuild
Rosconsole
messages_std
rosgraph_msgs
xmlrpcpp
roscpp
rosgraphe
ros_environnement
rospack
roslib
rosé

© 2025 Caplogy. All rights reserved.

20
Nom de la filière - Année Titre du cours

6. Personnalisation de votre forfait

Cette partie du tutoriel examinera chaque fichier généré par catkin_create_pkg et décrira,
ligne par ligne, chaque composant de ces fichiers et comment vous pouvez les personnaliser
pour votre package.
6.1 Personnalisation du [Link]
Le fichier [Link] généré devrait se trouver dans votre nouveau paquet. Examinons
maintenant le nouveau [Link] et peaufinons les éléments qui nécessitent votre
attention.
6.1.1 balise de description

Commencez par mettre à jour la balise de description :

Afficher/masquer les numéros de lignes

5 <description>Le package de tutoriels pour débutants</description>

Modifiez la description comme vous le souhaitez, mais par convention, la première phrase
doit être courte tout en couvrant la portée du package. S'il est difficile de décrire le package
en une seule phrase, il peut être nécessaire de la scinder.
6.1.2 balises de maintenance

Vient ensuite la balise du mainteneur :

Afficher/masquer les numéros de lignes

7 <!-- Une balise de maintenance requise, plusieurs autorisées, une personne par balise --
>
8 <!-- Exemple : -->
9 <!-- <maintainer email="[Link]@[Link]">Jane Doe</maintainer> -->
10 <maintainer email="user@[Link]">utilisateur</maintainer>
Cette balise est obligatoire et importante pour le fichier [Link] , car elle permet de
savoir qui contacter au sujet du paquet. Au moins un mainteneur est requis, mais vous
pouvez en avoir plusieurs si vous le souhaitez. Le nom du mainteneur est indiqué dans le
corps de la balise, mais un attribut d'adresse e-mail doit également être renseigné :
Afficher/masquer les numéros de lignes

7 <maintainer email="you@[Link]">Votre nom</maintainer>

6.1.3 étiquettes de licence

Vient ensuite l'étiquette de licence, qui est également requise :

Afficher/masquer les numéros de lignes

12 <!-- Une balise de licence requise, plusieurs autorisées, une licence par balise -->
13 <!-- Chaînes de licence couramment utilisées : -->
14 <!-- BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1, LGPLv3 -->
15 <license>À FAIRE</license>

© 2025 Caplogy. All rights reserved.

21
Nom de la filière - Année Titre du cours

Choisissez une licence et indiquez-la ici. Parmi les licences open source courantes, on trouve
BSD, MIT, Boost Software License, GPLv2, GPLv3, LGPLv2.1 et LGPLv3. Vous trouverez des
informations sur plusieurs d'entre elles sur l' Open Source Initiative . Pour ce tutoriel, nous
utiliserons la licence BSD, car les autres composants principaux de ROS l'utilisent déjà :
Afficher/masquer les numéros de lignes

8 <licence>BSD</licence>
6.1.4 balises de dépendances

L'ensemble de balises suivant décrit les dépendances de votre paquet. Ces dépendances
sont divisées en build_depend , buildtool_depend , exec_depend et test_depend . Pour une
explication plus détaillée de ces balises, consultez la documentation relative aux
dépendances Catkin . Puisque nous avons passé std_msgs , roscpp et rospy comme
arguments à catkin_create_pkg , les dépendances se présenteront comme suit :
Afficher/masquer les numéros de lignes

27 <!-- Les balises *_depend sont utilisées pour spécifier les dépendances -->
28 <!-- Les dépendances peuvent être des packages catkin ou des dépendances système --
>
29 <!-- Exemples : -->
30 <!-- Utilisez build_depend pour les packages dont vous avez besoin au moment de la
compilation : -->
31 <!-- <build_depend>genmsg</build_depend> -->
32 <!-- Utilisez buildtool_depend pour les packages d'outils de construction : -->
33 <!-- <buildtool_depend>chaton</buildtool_depend> -->
34 <!-- Utilisez exec_depend pour les packages dont vous avez besoin lors de l'exécution :
-->
35 <!-- <exec_depend>python-yaml</exec_depend> -->
36 <!-- Utilisez test_depend pour les packages dont vous avez besoin uniquement pour les
tests : -->
37 <!-- <test_depend>gtest</test_depend> -->
38 <buildtool_depend>chaton</buildtool_depend>
39 <build_depend>roscpp</build_depend>
40 <build_depend>rospy</build_depend>
41 <build_depend>messages_std</build_depend>
Toutes les dépendances listées ont été ajoutées comme dépendances de build , en plus de la
dépendance par défaut de buildtool_depend sur catkin. Dans ce cas, nous souhaitons que
toutes les dépendances spécifiées soient disponibles à la compilation et à l'exécution ; nous
allons donc ajouter une balise exec_depend pour chacune d'elles :
Afficher/masquer les numéros de lignes

12 <buildtool_depend>chaton</buildtool_depend>
13
14 <build_depend>roscpp</build_depend>
15 <build_depend>rospy</build_depend>
16 <build_depend>std_msgs</build_depend>

© 2025 Caplogy. All rights reserved.

22
Nom de la filière - Année Titre du cours

17
18 <exec_depend>roscpp</exec_depend>
19 <exec_depend>rospy</exec_depend>
20 <exec_depend>msgs_std</exec_depend>
6.1.5 Package [Link]

Comme vous pouvez le voir, le [Link] final , sans commentaires ni balises inutilisées,
est beaucoup plus concis :
Afficher/masquer les numéros de lignes

1 <?xml version="1.0"?>
2 <package format="2">
3 <name>tutoriels pour débutants</name>
4 <version>0.1.0</version>
5 <description>Le package de tutoriels pour débutants</description>
6
7 <maintainer email="you@[Link]">Votre nom</maintainer>
8 <licence>BSD</licence>
9 <url type="website">[Link]
10 <author email="you@[Link]">Jane Doe</author>
11
12 <buildtool_depend>chaton</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>
6.2 Personnalisation du fichier [Link]
Maintenant que le fichier [Link] , contenant les méta-informations, a été adapté à
votre package, vous êtes prêt à passer aux tutoriels. Le fichier [Link] créé
par catkin_create_pkg sera abordé dans les tutoriels ultérieurs sur la création de code ROS.
Maintenant que vous avez créé un nouveau package ROS, construisons notre package ROS .

Démonstration vidéo

Regardez la vidéo ci-dessous pour avoir plus d'explications sur l'espace de travail
personnalisé et la création de packages avec un guide étape par étape.
[Link]

© 2025 Caplogy. All rights reserved.

23
Nom de la filière - Année Titre du cours

Avec Rosbuild

[Link] de Roscreate
Avant de créer un paquet, voyons comment fonctionne l'outil en ligne de
commande roscreate-pkg . Celui-ci crée un nouveau paquet ROS . Tous les paquets ROS sont
constitués de nombreux fichiers similaires : manifests , [Link] , [Link] et
Makefiles. roscreate-pkg élimine de nombreuses tâches fastidieuses liées à la création
manuelle d'un nouveau paquet, ainsi que les erreurs courantes liées à la saisie manuelle des
fichiers de build et des manifestes.
Pour créer un nouveau package dans le répertoire actuel :

# roscreate-pkg [nom_du_paquet]

Vous pouvez également spécifier les dépendances de ce package :

# roscreate-pkg [nom_paquet] [depend1] [depend2] [depend3]

2. Création d'un nouveau package ROS

Nous allons maintenant accéder à votre répertoire personnel ou à celui de votre projet et
créer notre paquet beginner_tutorials . Nous allons le rendre dépendant
de std_msgs , roscpp et rospy , qui sont des paquets ROS courants.
Allez maintenant dans le répertoire ~/fuerte_workspace/sandbox :

$ cd ~/fuerte_workspace/sandbox

Alternativement, si vous utilisez Fuerte ou une version ultérieure, vous pouvez simplement
faire :

$ roscd
$ cd bac à sable

Créez ensuite votre package :

$ roscreate-pkg tutoriels_débutants std_msgs rospy roscpp

Vous verrez quelque chose de similaire à :

 Création du répertoire de packages ~/fuerte_workspace/sandbox/beginner_tutorials

 Création du répertoire d'inclusion
~/fuerte_workspace/sandbox/beginner_tutorials/include/beginner_tutorials

© 2025 Caplogy. All rights reserved.

24
Nom de la filière - Année Titre du cours

 Création du répertoire source cpp ~/ros/ros_tutorials/beginner_tutorials/src

 Création du répertoire source Python
~/fuerte_workspace/sandbox/beginner_tutorials/src/beginner_tutorials
 Création du fichier de package
~/fuerte_workspace/sandbox/beginner_tutorials/Makefile
 Création du fichier de package
~/fuerte_workspace/sandbox/beginner_tutorials/[Link]
 Création du fichier de package
~/fuerte_workspace/sandbox/beginner_tutorials/[Link]
 Création du fichier de package
~/fuerte_workspace/sandbox/beginner_tutorials/[Link]


 Veuillez modifier beginner_tutorials/[Link] et [Link] pour terminer la

création de votre package

Vous allez vouloir passer un peu de temps à regarder beginner_tutorials/[Link] . Les

manifestes jouent un rôle important dans ROS car ils définissent la manière dont les
packages sont créés, exécutés et documentés.
Vérifions maintenant que ROS peut trouver votre nouveau paquet. Il est souvent utile
d'appeler le profil rospack après avoir modifié votre chemin afin que les nouveaux
répertoires soient trouvés :

profil $ rospack
$ rospack trouver des tutoriels pour débutants

 VOTRE_CHEMIN_DE_PAQUET/tutoriels_débutants

Si cela échoue, cela signifie que ROS ne trouve pas votre nouveau paquet, ce qui pourrait
être dû à votre ROS_PACKAGE_PATH . Veuillez consulter les instructions d'installation pour
une configuration depuis SVN ou depuis les binaires, selon la méthode d'installation de ROS.
Si vous avez créé ou ajouté un paquet hors des chemins de paquets existants, vous devrez
modifier votre variable d'environnement ROS_PACKAGE_PATH pour inclure ce nouvel
emplacement. Essayez de réapprovisionner votre fichier [Link] dans votre
fuerte_workspace.
Essayez de vous déplacer vers le répertoire du package.

$ roscd tutoriels pour débutants

$ mot de passe

 VOTRE_CHEMIN_DE_PAQUET/tutoriels_débutants

© 2025 Caplogy. All rights reserved.

25
Nom de la filière - Année Titre du cours

3. Dépendances des packages de premier ordre

Lors de l'utilisation de roscreate-pkg auparavant, quelques dépendances de package étaient
fournies. Ces dépendances de premier ordre peuvent désormais être examinées avec l'
outil rospack .
(9 janvier 2013) Un bug a été signalé et corrigé dans rospack sous Groovy ; il peut mettre un
certain temps à apparaître dans les paquets. Si vous rencontrez un problème similaire avec
la commande suivante, vous pouvez passer à la commande suivante.

$ rospack depends1 tutoriels_débutants

 messages_std
 rosé
 roscpp

Comme vous pouvez le voir, rospack répertorie les mêmes dépendances qui ont été utilisées
comme arguments lors de l'exécution de roscreate-pkg . Ces dépendances d'un package sont
stockées dans le fichier manifeste . Consultez-le.

$ roscd tutoriels pour débutants

$ cat [Link]

 <paquet>


 ...


 <depend package="std_msgs"/>
 <dépend du package="rospy"/>
 <depend package="roscpp"/>


 </package>

4. Dépendances indirectes des packages

Dans de nombreux cas, une dépendance possède également ses propres dépendances. Par
exemple, rospy possède d'autres dépendances.
(9 janvier 2013) Un bug a été signalé et corrigé dans rospack sous Groovy ; il peut mettre un
certain temps à apparaître dans les paquets. Si vous rencontrez un problème similaire avec
la commande suivante, vous pouvez passer à la commande suivante.

© 2025 Caplogy. All rights reserved.

26
Nom de la filière - Année Titre du cours

$ rospack dépend1 rospy

 roslib
 roslang

Un paquet peut avoir de nombreuses dépendances indirectes. Heureusement, rospack peut

déterminer récursivement toutes les dépendances imbriquées.

$ rospack dépend de beginner_tutorials

 rospack
 roslib
 messages_std
 rosgraph_msgs
 rosbuild
 roslang
 rosé
 cpp_common
 traits_roscpp
 Rostime
 roscpp_sérialisation
 xmlrpcpp
 Rosconsole
 roscpp

Remarque : à Fuerte, la liste est beaucoup plus courte :

 messages_std
 roslang
 rosé
 roscpp

5. Bibliothèques clientes ROS

Vous vous demandez peut-être quelles sont les dépendances de rospy et roscpp , d'après les
exemples précédents. rospy et roscpp sont des bibliothèques clientes . Ces bibliothèques

© 2025 Caplogy. All rights reserved.

27
Nom de la filière - Année Titre du cours

permettent à différents langages de programmation de communiquer via ROS. rospy est la

bibliothèque cliente pour Python. roscpp est la bibliothèque cliente pour C++.
6 .Revoir
Listons simplement certaines des commandes que nous avons utilisées jusqu'à présent :

 roscreate-pkg = ros+create-pkg : génère tous les fichiers nécessaires à la création d'un

package ROS
 rospack = ros+pack(age) : fournit des informations relatives aux packages ROS
 rosstack = ros+stack : fournit des informations relatives aux piles ROS

Maintenant que vous avez créé un nouveau package ROS, construisons notre package ROS .
7 .Démonstration vidéo
Regardez la vidéo ci-dessous pour avoir plus d'explications sur l'espace de travail
personnalisé et la création de packages avec un guide étape par étape.
[Link]

Créer un package ROS

© 2025 Caplogy. All rights reserved.

28
Nom de la filière - Année Titre du cours

Avec chaton

[Link] de construction
Tant que toutes les dépendances système de votre package sont installées, nous pouvons
maintenant créer votre nouveau package.
Remarque : si vous avez installé ROS à l’aide d’apt ou d’un autre gestionnaire de paquets,
vous devriez déjà disposer de toutes vos dépendances.
Avant de continuer, n'oubliez pas de télécharger les sources de votre fichier de configuration
d'environnement si ce n'est pas déjà fait. Sous Ubuntu, cela ressemblerait à ceci :

# source /opt/ros/%VOTRE_DISTRO_ROS%/[Link]
$ source /opt/ros/kinetic/[Link] # Pour Kinetic par exemple

1.1 Utilisation de catkin_make

catkin_make est un outil en ligne de commande qui simplifie le workflow standard de catkin.
Comme vous pouvez l'imaginer, catkin_make combine les appels à cmake et make dans le
workflow standard de CMake.
Usage:

# Dans un espace de travail de chaton

$ catkin_make [créer_cibles] [-DCMAKE_VARIABLES=...]

Pour les personnes qui ne connaissent pas le flux de travail standard de CMake, celui-ci se
décompose comme suit :
Remarque : si vous exécutez les commandes ci-dessous, cela ne fonctionnera pas, car ce
n’est qu’un exemple du fonctionnement général de CMake.

# Dans un projet CMake

$ mkdir build
$ cd construire
$ cmake ..
$ faire
$ make install # (facultatif)

Ce processus est exécuté pour chaque projet CMake. En revanche, les projets catkin peuvent
être construits ensemble dans des espaces de travail. La construction de zéro à plusieurs
paquets catkin dans un espace de travail suit le flux de travail suivant :

© 2025 Caplogy. All rights reserved.

29
Nom de la filière - Année Titre du cours

# Dans un espace de travail de chaton

$ catkin_make
$ catkin_make install # (facultatif)

Les commandes ci-dessus compileront tous les projets catkin présents dans le dossier src .
Ceci suit les recommandations de REP128 . Si votre code source se trouve ailleurs, par
exemple dans my_src , vous appellerez catkin_make comme suit :
Remarque : si vous exécutez les commandes ci-dessous, cela ne fonctionnera pas, car le
répertoire my_src n'existe pas.

# Dans un espace de travail de chaton

$ catkin_make --source ma_source
$ catkin_make install --source my_src # (facultatif)

Pour des utilisations plus avancées de catkin_make , consultez la

documentation : catkin/commands/catkin_make
1.2 Construire votre package
Si vous utilisez cette page pour créer votre propre code, veuillez également consulter les
tutoriels ultérieurs (C++) / (Python) car vous devrez peut-être modifier [Link] .
Vous devriez déjà disposer d'un espace de travail catkin et d'un nouveau paquet catkin
nommé beginner_tutorials , issu du tutoriel précédent, « Créer un paquet » . Accédez à
l'espace de travail catkin si ce n'est pas déjà fait et consultez le dossier src :

$ cd ~/catkin_ws/
$ ls src

 tutoriels_débutants/ [Link]@

Vous devriez voir un dossier nommé « beginner_tutorials » , créé

avec catkin_create_pkg dans le tutoriel précédent. Nous pouvons maintenant construire ce
paquet avec catkin_make :

$ catkin_make

Vous devriez voir beaucoup de résultats de cmake , puis de make , qui devraient ressembler
à ceci :

 Chemin de base : /home/user/catkin_ws

 Espace source : /home/user/catkin_ws/src
 Espace de construction : /home/user/catkin_ws/build

© 2025 Caplogy. All rights reserved.

30
Nom de la filière - Année Titre du cours

 Espace de développement : /home/user/catkin_ws/devel

 Espace d'installation : /home/user/catkin_ws/install
 ####
 #### Exécution de la commande : « cmake /home/user/catkin_ws/src
 -DCATKIN_DEVEL_PREFIX=/home/utilisateur/catkin_ws/devel
 -DCMAKE_INSTALL_PREFIX=/home/utilisateur/catkin_ws/install" dans
"/home/utilisateur/catkin_ws/build"
 ####
 -- L'identification du compilateur C est GNU 4.2.1
 -- L'identification du compilateur CXX est Clang 4.0.0
 -- Vérifier si le compilateur C a -isysroot
 -- Vérification si le compilateur C a -isysroot - oui
 -- Vérification si le compilateur C prend en charge l'indicateur de cible de
déploiement OSX
 -- Vérification si le compilateur C prend en charge l'indicateur de cible de
déploiement OSX - oui
 -- Vérifiez que le compilateur C fonctionne : /usr/bin/gcc
 -- Vérifiez que le compilateur C fonctionne : /usr/bin/gcc -- fonctionne
 -- Détection des informations ABI du compilateur C
 -- Détection des informations ABI du compilateur C - terminé
 -- Vérifiez que le compilateur CXX fonctionne : /usr/bin/c++
 -- Vérifiez que le compilateur CXX fonctionne : /usr/bin/c++ -- fonctionne
 -- Détection des informations ABI du compilateur CXX
 -- Détection des informations ABI du compilateur CXX - terminé
 -- Utilisation de CATKIN_DEVEL_PREFIX : /tmp/catkin_ws/devel
 -- Utilisation de CMAKE_PREFIX_PATH : /opt/ros/kinetic
 -- Cet espace de travail se superpose à : /opt/ros/kinetic
 -- PythonInterp trouvé : /usr/bin/python (version trouvée « 2.7.1 »)
 -- PY_em trouvé : /usr/lib/python2.7/dist-packages/[Link]
 -- Gtest trouvé : les gtests seront construits
 -- chaton 0.5.51

© 2025 Caplogy. All rights reserved.

31
Nom de la filière - Année Titre du cours

 -- BUILD_SHARED_LIBS est activé

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- ~~ parcourir les paquets dans l'ordre topologique :
 -- ~~ - tutoriels pour débutants
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- +++ add_subdirectory(tutoriels_débutants)
 -- Configuration terminée
 -- Génération terminée
 -- Les fichiers de build ont été écrits dans : /home/user/catkin_ws/build
 ####
 #### Exécution de la commande : « make -j4 » dans « /home/user/catkin_ws/build »
 ####

Notez que catkin_make affiche d'abord les chemins utilisés pour chaque « espace ». Ces
espaces sont décrits dans la REP128 et dans la documentation relative aux espaces de travail
catkin sur le wiki : catkin/workspaces . Il est important de noter qu'en raison de ces valeurs
par défaut, plusieurs dossiers ont été créés dans votre espace de travail catkin. Examinez-les
avec ls :

$ ls

 construire
 développer
 source

Le dossier build est l'emplacement par défaut de l' espace de compilation et c'est là
que cmake et make sont appelés pour configurer et compiler vos paquets. Le
dossier devel est l'emplacement par défaut de l' espace de compilation , où se trouvent vos
exécutables et bibliothèques avant l'installation des paquets.
Maintenant que vous avez créé votre package ROS, parlons davantage des nœuds ROS .

Avec rosbuild

© 2025 Caplogy. All rights reserved.

32
Nom de la filière - Année Titre du cours

[Link] de construction
Une fois toutes les dépendances système installées, nous pouvons construire notre package
que nous venons de créer.
1.1 Utilisation de Rosmake
rosmake est similaire à la commande make , mais avec des fonctionnalités ROS spécifiques.
Lorsque vous saisissez rosmake beginner_tutorials , le paquet beginner_tutorials est
construit , ainsi que tous les paquets dont il dépend, dans l'ordre correct. Puisque nous
avons listé rospy, roscpp et std_msgs comme dépendances lors de la création de notre
paquet ROS, ces paquets (et leurs dépendances, etc.) seront également construits
par rosmake .
Usage:

rosmake [paquet]

Essayer:

$ rosmake tutoriels_débutants

L'exécution de la commande précédente peut prendre un certain temps. Pendant son

exécution, vous devriez obtenir un résultat similaire à celui-ci :

 [ rosmake ] Aucun paquet spécifié. Construction de ['beginner_tutorials']

 [ rosmake ] Connexion au répertoire
 [ rosmake ] /home/dbking/.ros/rosmake_output-2009-09-22-03-17-14
 [ rosmake ] [ 0 sur 18 terminé ]
 [rosmake-0] >>> genmsg_cpp >>> [ créer ]
 [rosmake-0] <<< genmsg_cpp <<< [PASS] [ 0,39 seconde ]
 [ rosmake ] [ 1 sur 18 terminé ]
 ...
 ...
 ...
 [ rosmake ] [ 17 sur 18 terminé ]
 [rosmake-0] >>> tutoriels pour débutants >>> [ make ]

© 2025 Caplogy. All rights reserved.

33
Nom de la filière - Année Titre du cours

 [rosmake-0] <<< tutoriels_débutants <<< [PASS] [ 0,79 seconde ]

Sur Fuerte, comme les dépendances sont grandement réduites, cela ne prend presque pas
de temps et produit :

 [ rosmake ] rosmake démarre...

 [ rosmake ] Les packages demandés sont : ['beginner_tutorials']
 [ rosmake ] Journalisation dans le répertoire
/home/alex/.ros/rosmake/rosmake_output-20120603-082414
 [ rosmake ] Arguments étendus ['beginner_tutorials'] à :
 ['tutoriels_débutants']
 [rosmake-0] Démarrage >>> std_msgs [ make ]
 [rosmake-1] Démarrage >>> roslang [ make ]
 [rosmake-0] Terminé <<< std_msgs ROS_NOBUILD dans le paquet std_msgs
 Aucun Makefile dans le paquet std_msgs
 [rosmake-1] Terminé <<< roslang ROS_NOBUILD dans le package roslang
 Pas de Makefile dans le paquet roslang
 [rosmake-1] Démarrage >>> rospy [ make ]
 [rosmake-2] Démarrage >>> roscpp [ make ]
 [rosmake-1] Terminé <<< rospy ROS_NOBUILD dans le paquet rospy
 Pas de Makefile dans le paquet rospy
 [rosmake-2] Terminé <<< roscpp ROS_NOBUILD dans le paquet roscpp
 Pas de Makefile dans le paquet roscpp
 [rosmake-2] Démarrage >>> tutoriels pour débutants [ make ]
 [rosmake-2] Terminé <<< beginner_tutorials [PASS] [ 1,14 seconde ]
 [ rosmake ] Résultats :
 [ rosmake ] 5 paquets créés avec 0 échec.
 [ rosmake ] Sortie récapitulative dans le répertoire
 [ rosmake ] /home/alex/.ros/rosmake/rosmake_output-20120603-082414

1.2 rosmake plusieurs packages

Nous pouvons également utiliser rosmake pour créer plusieurs packages à la fois.
Usage:

© 2025 Caplogy. All rights reserved.

34
Nom de la filière - Année Titre du cours

rosmake [paquet1] [paquet2] [paquet3]

2. Revoir

Listons simplement certaines des commandes que nous avons utilisées jusqu'à présent :

 rosdep = ros+dep(endencies) : un outil pour installer les dépendances des packages

 rosmake = ros+make : crée (compile) un package ROS

Maintenant que vous avez créé votre package ROS, parlons davantage des nœuds ROS .

© 2025 Caplogy. All rights reserved.

35
Nom de la filière - Année Titre du cours

Comprendre les nœuds ROS

[Link]érequis
Pour ce tutoriel, nous utiliserons un simulateur léger, pour l'installer, exécutez la commande
suivante :

$ sudo apt-get install ros-<distribution>-ros-tutorials

Remplacez '<distro>' par le nom de votre distribution ROS (par exemple indigo, jade, kinetic,
noetic)
2. Aperçu rapide des concepts graphiques
 Nœuds : Un nœud est un exécutable qui utilise ROS pour communiquer avec d'autres
nœuds.
 Messages : type de données ROS utilisé lors de l'abonnement ou de la publication sur
une rubrique.
 Sujets : les nœuds peuvent publier des messages sur un sujet ainsi que s'abonner à un
sujet pour recevoir des messages.
 Maître : Service de noms pour ROS (c'est-à-dire qu'il aide les nœuds à se trouver)
 rosout : équivalent ROS de stdout/stderr
 roscore : Master + rosout + serveur de paramètres (le serveur de paramètres sera
introduit plus tard)
3. Nœuds
Un nœud n'est en réalité qu'un fichier exécutable au sein d'un package ROS. Les nœuds ROS
utilisent une bibliothèque cliente ROS pour communiquer avec d'autres nœuds. Ils peuvent
publier ou s'abonner à un sujet. Ils peuvent également fournir ou utiliser un service.
[Link]èques clientes
Les bibliothèques clientes ROS permettent aux nœuds écrits dans différents langages de
programmation de communiquer :

 rospy = bibliothèque cliente Python

 roscpp = bibliothèque cliente c++

5. Roscore
roscore est la première chose que vous devez exécuter lorsque vous utilisez ROS.
Veuillez exécuter :

$ roscore

Vous verrez quelque chose de similaire à :

© 2025 Caplogy. All rights reserved.

36
Nom de la filière - Année Titre du cours

 ... journalisation dans ~/.ros/log/9cf88ce4-b14d-11df-8a75-00251148e8cf/roslaunch-

machine_name-[Link]
 Vérification de l'utilisation du disque dans le répertoire des journaux. Cette opération
peut prendre un certain temps.
 Appuyez sur Ctrl-C pour interrompre
 Vérification de l'utilisation du disque du fichier journal terminée. L'utilisation est
inférieure à 1 Go.


 démarrage du serveur roslaunch [Link]

 version 1.4.7 de ros_comm


 RÉSUMÉ
 ======


 PARAMÈTRES
 * /rosversion
 * /rosdistro


 NŒUDS


 démarrage automatique du nouveau maître

 processus[master] : démarré avec le pid [13054]
 ROS_MASTER_URI=[Link]


 définition de /run_id sur 9cf88ce4-b14d-11df-8a75-00251148e8cf

 processus[rosout-1] : démarré avec le pid [13067]
 démarrage du service principal [/rosout]

Si Roscore ne s'initialise pas, vous avez probablement un problème de configuration réseau.

Voir Configuration réseau - Configuration d'une seule machine.
Si roscore ne s'initialise pas et envoie un message concernant le manque d'autorisations, le
dossier ~/.ros appartient probablement à root , changez récursivement la propriété de ce
dossier avec :

© 2025 Caplogy. All rights reserved.

37
Nom de la filière - Année Titre du cours

$ sudo chown -R <votre_nom_d'utilisateur> ~/.ros

[Link] de Rosnode
Ouvrez un nouveau terminal et utilisons rosnode pour voir ce que l'exécution de roscore a
fait...N'oubliez pas de garder le terminal précédent ouvert soit en ouvrant un nouvel onglet,
soit simplement en le réduisant.
Remarque : À l'ouverture d'un nouveau terminal, votre environnement est réinitialisé et
votre fichier ~/.bashrc est sourcer. Si vous rencontrez des difficultés pour exécuter des
commandes comme rosnode , vous devrez peut-être ajouter des fichiers de configuration
d'environnement à votre fichier ~/.bashrc ou les sourcer manuellement.
Rosnode affiche des informations sur les nœuds ROS en cours d'exécution. La
commande rosnode list répertorie ces nœuds actifs :

liste $ rosnode

 Vous verrez :
 /rosout

Cela nous a montré qu'un seul nœud est en cours d'exécution : rosout . Ce nœud est
toujours en cours d'exécution, car il collecte et enregistre les résultats de débogage des
nœuds.
La commande rosnode info renvoie des informations sur un nœud spécifique.

$ rosnode info /rosout

Cela nous a donné quelques informations supplémentaires sur rosout , comme le fait qu'il
publie /rosout_agg .

 ------------------------------------------------------------------------
 Nœud [/rosout]
 Publications:
 * /rosout_agg [rosgraph_msgs/Log]


 Abonnements :
 * /rosout [type inconnu]


 Services:
 * /rosout/get_loggers

© 2025 Caplogy. All rights reserved.

38
Nom de la filière - Année Titre du cours

 * /rosout/set_logger_level


 contacter le nœud [Link] ...

 Pid: 5092

Voyons maintenant d'autres nœuds. Pour cela, nous allons utiliser rosrun pour créer un
autre nœud.
7. Utilisation de rosrun
rosrun vous permet d'utiliser le nom du package pour exécuter directement un nœud dans
un package (sans avoir à connaître le chemin du package).
Usage:

$ rosrun [nom_paquet] [nom_nœud]

Nous pouvons donc maintenant exécuter le turtlesim_node dans le package turtlesim.

Ensuite, dans un nouveau terminal :

$ rosrun turtlesim turtlesim_node

Vous verrez la fenêtre turtlesim :


REMARQUE : La tortue peut avoir un aspect différent dans votre simulation de tortues. Pas
d'inquiétude : il existe de nombreuses espèces de tortues et la vôtre est une surprise !
Dans un nouveau terminal :

liste $ rosnode

Vous verrez quelque chose de similaire à :

 /rosout
 /turtlesim

L’une des fonctionnalités puissantes de ROS est que vous pouvez réaffecter des noms à
partir de la ligne de commande.
Fermez la fenêtre turtlesim pour arrêter le nœud (ou revenez au terminal rosrun turtlesim et
utilisez Ctrl-C ). Relançons-le, mais cette fois, en utilisant un argument de remappage pour
modifier le nom du nœud :

$ rosrun turtlesim turtlesim_node __name:=ma_tortue

© 2025 Caplogy. All rights reserved.

39
Nom de la filière - Année Titre du cours

Maintenant, si nous revenons en arrière et utilisons la liste rosnode :

liste $ rosnode

 Vous verrez quelque chose de similaire à :

 /ma_tortue
 /rosout

Remarque : Si /turtlesim apparaît toujours dans la liste, cela peut signifier que vous avez
arrêté le nœud dans le terminal avec Ctrl-C au lieu de fermer la fenêtre, ou que la variable
d'environnement $ROS_HOSTNAME n'est pas définie comme décrit dans Configuration
réseau - Configuration d'une seule machine . Vous pouvez essayer de nettoyer la liste
rosnode avec : $ nettoyage rosnode
Nous voyons notre nouveau nœud /my_turtle . Utilisons une
autre commande rosnode , ping , pour vérifier son bon fonctionnement :

$ rosnode ping ma_tortue

 rosnode : le nœud est [/my_turtle]

 ping de /my_turtle avec un délai d'attente de 3,0 s
 Réponse xmlrpc de [Link] time=1.152992ms
 Réponse xmlrpc de [Link] time=1.120090ms
 Réponse xmlrpc de [Link] time=1.700878ms
 Réponse xmlrpc de [Link] time=1.127958ms

8. Revoir
Ce qui a été couvert :

 roscore = ros+core : master (fournit un service de noms pour ROS) + rosout

(stdout/stderr) + serveur de paramètres (le serveur de paramètres sera introduit plus
tard)
 rosnode = ros+node : outil ROS pour obtenir des informations sur un nœud.
 rosrun = ros+run : exécute un nœud à partir d'un package donné.

Maintenant que vous comprenez le fonctionnement des nœuds ROS, examinons le

fonctionnement des rubriques ROS . N'hésitez pas à appuyer sur Ctrl-C pour arrêter
turtlesim_node.

9.Démonstration vidéo

© 2025 Caplogy. All rights reserved.

40
Nom de la filière - Année Titre du cours

Regardez la vidéo ci-dessous pour avoir plus d'explications sur la communication des nœuds
Python et un guide étape par étape.
[Link]

© 2025 Caplogy. All rights reserved.

41
Nom de la filière - Année Titre du cours

Comprendre les sujets ROS

[Link]
1.1Roscore
Commençons par nous assurer que Roscore est en cours d'exécution, dans un nouveau
terminal :

$ roscore

Si vous avez laissé Roscore fonctionner depuis le dernier tutoriel, vous pouvez obtenir le
message d'erreur :

 roscore ne peut pas s'exécuter car un autre roscore/master est déjà en cours
d'exécution.
 Veuillez tuer les autres processus roscore/master avant de relancer

C'est correct. Un seul Roscore doit être exécuté.

1.2simulation de tortue
Pour ce tutoriel, nous utiliserons également turtlesim. Veuillez exécuter la commande dans
un nouveau terminal :

$ rosrun turtlesim turtlesim_node

1.3téléopération du clavier de la tortue

Nous aurons également besoin d'un outil pour piloter la tortue. Veuillez exécuter la
commande dans un nouveau terminal :

$ rosrun turtlesim clé_téléphonique_tortue

 [ INFO] 1254264546.878445000 : Nœud démarré [/teleop_turtle], PID [5528], lié à

[aqy], port xmlrpc [43918], port tcpros [55936], journalisation dans
[~/ros/ros/log/teleop_turtle_5528.log], en temps [réel]
 Lecture à partir du clavier
 ---------------------------
 Utilisez les touches fléchées pour déplacer la tortue.

© 2025 Caplogy. All rights reserved.

42
Nom de la filière - Année Titre du cours

Vous pouvez maintenant utiliser les touches fléchées du clavier pour piloter la tortue. Si vous
ne pouvez pas piloter la tortue, sélectionnez la fenêtre de terminal de la commande
turtle_teleop_key pour vous assurer que les touches que vous saisissez sont enregistrées.

Maintenant que vous pouvez conduire votre tortue, regardons ce qui se passe dans les
coulisses.
[Link] ROS
Les nœuds turtlesim_node et turtle_teleop_key communiquent entre eux via
un sujet ROS . turtle_teleop_key publie les frappes clavier sur un sujet, tandis que turtlesim
s'abonne au même sujet pour les recevoir. Utilisons rqt_graph pour afficher les nœuds et les
sujets en cours d'exécution.
Remarque : Si vous utilisez une version électrique ou antérieure, rqt n'est pas disponible.
Utilisez plutôt rxgraph .
2.1 Utilisation de rqt_graph

© 2025 Caplogy. All rights reserved.

43
Nom de la filière - Année Titre du cours

rqt_graph crée un graphique dynamique de l'activité du système. rqt_graph fait partie du

paquet rqt . Sauf s'il est déjà installé, exécutez :

 $ sudo apt-get install ros-<distribution>-rqt

 $ sudo apt-get install ros-<distribution>-rqt-common-plugins

en remplaçant <distro> par le nom de votre distribution ROS (par exemple indigo, jade,
kinetic, lunar...)
Dans un nouveau terminal :

$ rosrun rqt_graph rqt_graph

Vous verrez quelque chose de similaire à :

En plaçant la souris sur /turtle1/command_velocity , les nœuds ROS (ici en bleu et vert) et
les sujets (ici en rouge) seront mis en surbrillance. Comme vous pouvez le constater, les
nœuds turtlesim_node et turtle_teleop_key communiquent sur le sujet
nommé /turtle1/command_velocity .

2.2 Présentation de Rostopic

L' outil rostopic vous permet d'obtenir des informations sur les sujets ROS .
Vous pouvez utiliser l'option d'aide pour obtenir les sous-commandes disponibles
pour rostopic

$ rostopique -h

 bande passante d'affichage rostopic bw utilisée par sujet

© 2025 Caplogy. All rights reserved.

44
Nom de la filière - Année Titre du cours

 rostopic echo imprimer les messages à l'écran

 taux de publication du sujet à l'écran rostopic hz
 liste rostopique imprimer des informations sur les sujets actifs
 le pub rostopic publie des données sur le sujet
 type de sujet d'impression de type rostopique

Ou en appuyant sur la touche Tab après que Rostopic imprime les sous-commandes
possibles :

$ rostopique
bw echo find hz info liste type pub

Utilisons certaines de ces sous-commandes de sujet pour examiner turtlesim.

2.3 Utilisation de l'écho rostopique
L'écho rostopique montre les données publiées sur un sujet.
Usage:

écho rostopique [sujet]

Regardons les données de vitesse de commande publiées par le nœud turtle_teleop_key .

Pour ROS Hydro et versions ultérieures, ces données sont publiées dans la
rubrique /turtle1/cmd_vel . Dans un nouveau terminal, exécutez :

$ écho rostopique /tortue1/cmd_vel

Pour ROS Groovy et versions antérieures, ces données sont publiées dans la
rubrique /turtle1/command_velocity . Dans un nouveau terminal, exécutez :

$ rostopic echo /turtle1/command_velocity

Vous ne verrez probablement rien se produire, car aucune donnée n'est publiée sur le sujet.
Demandons à turtle_teleop_key de publier des données en appuyant sur les touches
fléchées. Si la tortue ne bouge pas, vous devez sélectionner à nouveau le
terminal turtle_teleop_key .
Pour ROS Hydro et versions ultérieures, vous devriez maintenant voir ce qui suit lorsque vous
appuyez sur la touche haut :

linéaire:
x: 2.0
y: 0,0

© 2025 Caplogy. All rights reserved.

45
Nom de la filière - Année Titre du cours

z: 0,0
angulaire:
x: 0,0
y: 0,0
z: 0,0
---
linéaire:
x: 2.0
y: 0,0
z: 0,0
angulaire:
x: 0,0
y: 0,0
z: 0,0
---

Pour ROS Groovy et les versions antérieures, vous devriez maintenant voir ce qui suit lorsque
vous appuyez sur la touche haut :

---
linéaire : 2,0
angulaire : 0,0
---
linéaire : 2,0
angulaire : 0,0
---
linéaire : 2,0
angulaire : 0,0
---
linéaire : 2,0
angulaire : 0,0
---

© 2025 Caplogy. All rights reserved.

46
Nom de la filière - Année Titre du cours

linéaire : 2,0
angulaire : 0,0

Regardons à nouveau rqt_graph . Appuyez sur le bouton d'actualisation en haut à gauche

pour afficher le nouveau nœud. Comme vous pouvez le constater, rostopic echo , affiché ici
en rouge, est désormais également abonné au sujet turtle1/command_velocity .

2.4 Utilisation de la liste rostopique

rostopic list renvoie une liste de tous les sujets actuellement abonnés et publiés.
Déterminons les arguments nécessaires à la sous-commande list . Dans un nouveau
terminal , exécutez :

$ liste rostopique -h

 Utilisation : liste rostopique [/topic]



 Options:
 -h, --help affiche ce message d'aide et quitte
 -b FICHIER DE SAC, --bag=FICHIER DE SAC
 lister les sujets dans le fichier .bag
 -v, --verbose répertorie tous les détails sur chaque sujet
 -p liste uniquement les éditeurs
 -s liste uniquement les abonnés

Pour la liste rostopique, utilisez l' option verbeuse :

$ liste rostopique -v

Cela affiche une liste détaillée des sujets sur lesquels publier et auxquels s'abonner ainsi que
leur type.
Pour ROS Hydro et versions ultérieures,

© 2025 Caplogy. All rights reserved.

47
Nom de la filière - Année Titre du cours

 Sujets publiés :
 * /turtle1/color_sensor [turtlesim/Color] 1 éditeur
 * /turtle1/cmd_vel [geometry_msgs/Twist] 1 éditeur
 * /rosout [rosgraph_msgs/Log] 2 éditeurs
 * /rosout_agg [rosgraph_msgs/Log] 1 éditeur
 * /turtle1/pose [turtlesim/Pose] 1 éditeur


 Sujets abonnés :
 * /turtle1/cmd_vel [geometry_msgs/Twist] 1 abonné
 * /rosout [rosgraph_msgs/Log] 1 abonné

Pour ROS Groovy et versions antérieures,

 Sujets publiés :
 * /turtle1/color_sensor [turtlesim/Color] 1 éditeur
 * /turtle1/command_velocity [turtlesim/Velocity] 1 éditeur
 * /rosout [roslib/Log] 2 éditeurs
 * /rosout_agg [roslib/Log] 1 éditeur
 * /turtle1/pose [turtlesim/Pose] 1 éditeur


 Sujets abonnés :
 * /turtle1/command_velocity [turtlesim/Velocity] 1 abonné
 * /rosout [roslib/Log] 1 abonné

[Link] ROS
La communication sur les sujets s'effectue par l'envoi de messages ROS entre les nœuds.
Pour que l'éditeur ( turtle_teleop_key ) et l'abonné ( turtlesim_node ) puissent
communiquer, ils doivent envoyer et recevoir le même type de message. Cela signifie
qu'un type de sujet est défini par le type de message publié sur celui-ci. Le type de message
envoyé sur un sujet peut être déterminé grâce au type rostopic .
3.1 Utilisation du type rostopique
Le type rostopic renvoie le type de message de tout sujet en cours de publication.
Usage:

© 2025 Caplogy. All rights reserved.

48
Nom de la filière - Année Titre du cours

type rostopique [sujet]

Pour ROS Hydro et versions ultérieures,

 Essayer:

$ type rostopique /tortue1/cmd_vel

o Vous devriez obtenir :

géométrie_msgs/Twist

Nous pouvons regarder les détails du message en utilisant rosmsg :

$ rosmsg afficher geometry_msgs/Twist

o geometry_msgs/Vector3 linéaire
o float64 x
o float64 y
o float64 z
o geometry_msgs/Vector3 angulaire
o float64 x
o float64 y
o float64 z

Pour ROS Groovy et versions antérieures,

 Essayer:

$ rostopic type /turtle1/command_velocity

o Vous devriez obtenir :

tortuesim/Vitesse

Nous pouvons regarder les détails du message en utilisant rosmsg :

$ rosmsg afficher turtlesim/Velocity

o float32 linéaire

© 2025 Caplogy. All rights reserved.

49
Nom de la filière - Année Titre du cours

o float32 angulaire

Maintenant que nous savons quel type de message turtlesim attend, nous pouvons publier
des commandes sur notre tortue.

4. rostopic suite

Maintenant que nous avons appris à connaître les messages ROS , utilisons rostopic avec les
messages.
4.1 Utilisation de la pub rostopique
Rostopic Pub publie des données sur un sujet actuellement annoncé.
Usage:

pub rostopique [sujet] [type_msg] [args]

Pour ROS Hydro et versions ultérieures, exemple :

$ rostopic pub -1 /turtle1/cmd_vel geometry_msgs/Twist -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'

Pour ROS Groovy et versions antérieures, exemple :

$ rostopic pub -1 /turtle1/command_velocity turtlesim/Velocity -- 2.0 1.8

La commande précédente enverra un seul message à turtlesim lui indiquant de se déplacer

avec une vitesse linéaire de 2,0 et une vitesse angulaire de 1,8.

© 2025 Caplogy. All rights reserved.

50
Nom de la filière - Année Titre du cours


Il s’agit d’un exemple assez compliqué, examinons donc chaque argument en détail.
Pour ROS Hydro et versions ultérieures,
 Cette commande publiera des messages sur un sujet donné :
pub rostopique

 Cette option (tiret-un) oblige Rostopic à publier un seul message puis à quitter :
-1

 C'est le nom du sujet sur lequel publier :

/tortue1/cmd_vel

 Il s'agit du type de message à utiliser lors de la publication sur le sujet :

géométrie_msgs/Twist

© 2025 Caplogy. All rights reserved.

51
Nom de la filière - Année Titre du cours

 Cette option (double tiret) indique à l'analyseur d'options qu'aucun des arguments
suivants n'est une option. Elle est obligatoire lorsque vos arguments sont précédés
d'un tiret - , comme les nombres négatifs.
--

 Comme indiqué précédemment, un message geometry_msgs/Twist comporte deux

vecteurs de trois éléments à virgule flottante chacun : linéaire et angulaire . Dans ce
cas, « [2.0, 0.0, 0.0] » devient la valeur linéaire avec x=2.0 , y=0.0 et z=0.0 , et « [0.0,
0.0, 1.8] » est la valeur angulaire avec x=0.0 , y=0.0 et z=1.8 . Ces arguments sont en
fait en syntaxe YAML, décrite plus en détail dans la documentation de la ligne de
commande YAML .
'[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'

Pour ROS Groovy et versions antérieures,

 Cette commande publiera des messages sur un sujet donné :
pub rostopique

 Cette option (tiret-un) oblige Rostopic à publier un seul message puis à quitter :
-1

 C'est le nom du sujet sur lequel publier :

/turtle1/command_velocity

 Il s'agit du type de message à utiliser lors de la publication sur le sujet :

tortuesim/Vitesse

 Cette option (double tiret) indique à l'analyseur d'options qu'aucun des arguments
suivants n'est une option. Elle est obligatoire lorsque vos arguments sont précédés
d'un tiret - , comme les nombres négatifs.
--

 Comme indiqué précédemment, un message turtlesim/Velocity comporte deux

éléments à virgule flottante : linéaire et angulaire . Dans ce cas, 2,0 devient la valeur
linéaire et 1,8 la valeur angulaire . Ces arguments sont en fait en syntaxe YAML,
décrite plus en détail dans la documentation de la ligne de commande YAML .
2.0 1.8

Vous avez peut-être remarqué que la tortue s'est immobilisée ; cela est dû au fait qu'elle a
besoin d'un flux constant de commandes à 1 Hz pour se déplacer. Nous pouvons publier un
flux constant de commandes avec la commande rostopic pub -r :
Pour ROS Hydro et versions ultérieures,

© 2025 Caplogy. All rights reserved.

52
Nom de la filière - Année Titre du cours

 $ rostopic pub /turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0, 0.0]' '[0.0, 0.0,

-1.8]'

Pour ROS Groovy et versions antérieures,

 $ rostopic pub /turtle1/command_velocity turtlesim/Velocity -r 1 -- 2.0 -1.8

Ceci publie les commandes de vitesse à une fréquence de 1 Hz sur le sujet de vitesse.

Nous pouvons également observer ce qui se passe dans rqt_graph . Cliquez sur le bouton
d'actualisation en haut à gauche. Le nœud rostopic pub (ici en rouge) communique avec le
nœud rostopic echo (ici en vert) :

© 2025 Caplogy. All rights reserved.

53
Nom de la filière - Année Titre du cours

Comme vous pouvez le constater, la tortue décrit un cercle continu. Dans un nouveau
terminal , nous pouvons utiliser l'écho rostopique pour visualiser les données publiées par
notre simulation de tortue :

écho rostopique /tortue1/pose

4.2 Utilisation du Hz rostopique

rostopic Hz indique la fréquence à laquelle les données sont publiées.
Usage:

Hz rostopique [sujet]

Voyons à quelle vitesse turtlesim_node publie /turtle1/pose :

$ rostopic hz /tortue1/pose

Vous verrez :

 abonné à [/turtle1/pose]
 taux moyen : 59,354
 min : 0,005 s max : 0,027 s écart type : 0,00284 s fenêtre : 58
 taux moyen : 59,459
 min : 0,005 s max : 0,027 s écart type : 0,00271 s fenêtre : 118
 taux moyen : 59.539
 min : 0,004 s max : 0,030 s écart type : 0,00339 s fenêtre : 177
 taux moyen : 59.492
 min : 0,004 s max : 0,030 s écart type : 0,00380 s fenêtre : 237
 taux moyen : 59.463
 min : 0,004 s max : 0,030 s écart type : 0,00380 s fenêtre : 290

© 2025 Caplogy. All rights reserved.

54
Nom de la filière - Année Titre du cours

Nous pouvons maintenant constater que la simulation de tortue publie des données sur
notre tortue à une fréquence de 60 Hz. Nous pouvons également utiliser le type rostopic en
conjonction avec rosmsg show pour obtenir des informations détaillées sur un sujet :
Pour ROS Hydro et versions ultérieures,

 $ rostopic type /turtle1/cmd_vel | rosmsg show

Pour ROS Groovy et versions antérieures,

 $ rostopic type /turtle1/command_velocity | rosmsg show

Maintenant que nous avons examiné les sujets à l'aide de Rostopic , utilisons un autre outil
pour examiner les données publiées par notre turtlesim :
5. Utilisation de rqt_plot
Remarque : Si vous utilisez Electric ou une version antérieure, rqt n'est pas disponible.
Utilisez plutôt rxplot .
rqt_plot affiche un graphique temporel défilant des données publiées sur les sujets. Nous
allons ici utiliser rqt_plot pour tracer les données publiées sur le sujet /turtle1/pose .
Commencez par lancer rqt_plot en saisissant

$ rosrun rqt_plot rqt_plot

Dans un nouveau terminal. Dans la nouvelle fenêtre qui devrait apparaître, une zone de
texte en haut à gauche vous permet d'ajouter n'importe quel sujet au graphique.
Tapez /turtle1/pose/x pour mettre en surbrillance le bouton « + », précédemment désactivé.
Appuyez dessus et répétez la même procédure avec le sujet /turtle1/pose/y . La position xy
de la tortue apparaît alors sur le graphique.

© 2025 Caplogy. All rights reserved.

55
Nom de la filière - Année Titre du cours

Appuyer sur le bouton « moins » affiche un menu permettant de masquer le sujet spécifié du
graphique. Masquer les sujets que vous venez d'ajouter et
ajouter /turtle1/pose/theta produira le graphique illustré dans la figure suivante.

C'est tout pour cette section, utilisez Ctrl-C pour tuer les terminaux rostopiques mais gardez
votre turtlesim en cours d'exécution.

© 2025 Caplogy. All rights reserved.

56
Nom de la filière - Année Titre du cours

Maintenant que vous comprenez comment fonctionnent les rubriques ROS, examinons
comment fonctionnent les services et les paramètres .
6. Tutoriel vidéo
La vidéo suivante présente un petit tutoriel utilisant turtlesim sur les nœuds ROS et les sujets
ROS
[Link]

© 2025 Caplogy. All rights reserved.

57
Nom de la filière - Année Titre du cours

Comprendre les services et les paramètres ROS

[Link] ROS
Les services constituent un autre moyen de communication entre les nœuds. Ils permettent
aux nœuds d'envoyer une requête et de recevoir une réponse .
2. Utilisation de rosservice
rosservice peut facilement se connecter au framework client/service de ROS avec des
services. rosservice dispose de nombreuses commandes qui peuvent être utilisées sur les
services, comme indiqué ci-dessous :
Usage:

liste rosservice imprimer des informations sur les services actifs

rosservice call appelle le service avec les arguments fournis
type de service d'impression de type rosservice
rosservice trouver des services par type de service
service d'impression URI rosservice ROSRPC URI

2.1 liste rosservice

liste $ rosservice

La commande list nous montre que le nœud turtlesim fournit neuf

services : reset , clear , spawn , kill , turtle1/set_pen , /turtle1/teleport_absolute , /turtle1/
teleport_relative , turtlesim/get_loggers et turtlesim/set_logger_level . Deux autres services
sont liés au nœud rosout : /rosout/get_loggers et /rosout/set_logger_level .

 /clair
 /tuer
 /réinitialiser
 /rosout/get_loggers
 /rosout/définir_le_niveau_du_journal
 /frayer
 /teleop_turtle/get_loggers
 /teleop_turtle/set_logger_level
 /tortue1/set_pen

© 2025 Caplogy. All rights reserved.

58
Nom de la filière - Année Titre du cours

 /turtle1/teleport_absolute
 /turtle1/teleport_relative
 /turtlesim/get_loggers
 /turtlesim/set_logger_level

Regardons de plus près le service clair utilisant le type rosservice :

2.2 type de service Ros
Usage:

type de service ros [service]

Découvrons quel type de service est clair :

$ rosservice type /effacer

 std_srvs/Vide

Ce service est vide, ce qui signifie qu'il ne prend aucun argument lors de l'appel (c'est-à-dire
qu'il n'envoie aucune donnée lors d'une requête et ne reçoit aucune donnée lors
d'une réponse ). Appelons ce service via rosservice call :
2.3 appel rosservice
Usage:

appel rosservice [service] [args]

Ici, nous appellerons sans arguments car le service est de type vide :

$ rosservice appel /effacer

Cela fait ce que nous attendons, cela efface l'arrière-plan du turtlesim_node .

© 2025 Caplogy. All rights reserved.

59
Nom de la filière - Année Titre du cours

Regardons le cas où le service a des arguments en regardant les informations pour le spawn
du service :

$ rosservice type /spawn | rossrv afficher

 float32 x
 float32 y
 float32 thêta
 nom de chaîne
 ---
 nom de chaîne

Ce service nous permet de faire apparaître une nouvelle tortue à un endroit et avec une
orientation donnés. Le champ « nom » est facultatif ; nous pouvons donc laisser turtlesim en
créer un pour nous.

© 2025 Caplogy. All rights reserved.

60
Nom de la filière - Année Titre du cours

$ rosservice appel /spawn 2 2 0.2 ""

L'appel de service revient avec le nom de la tortue nouvellement créée

 nom : tortue2

Maintenant, notre simulation de tortue devrait ressembler à ceci :

3. Utilisation du rosparam
rosparam vous permet de stocker et de manipuler des données sur le serveur de
paramètres ROS . Ce serveur peut stocker des entiers, des nombres à virgule flottante, des
booléens, des dictionnaires et des listes. rosparam utilise le langage de balisage YAML pour
la syntaxe. Dans les cas simples, YAML est très naturel : 1 est un entier, 1,0 est un nombre à
virgule flottante , 1 est une chaîne, true est un booléen, [1, 2, 3] est une liste d'entiers et {a:
b, c: d} est un dictionnaire. rosparam propose de nombreuses commandes utilisables sur les
paramètres, comme illustré ci-dessous :
Usage:

© 2025 Caplogy. All rights reserved.

61
Nom de la filière - Année Titre du cours

rosparam set définir le paramètre

rosparam obtenir obtenir le paramètre
rosparam charger les paramètres de chargement à partir du fichier
rosparam dump vide les paramètres dans un fichier
rosparam supprimer supprimer le paramètre
liste rosparam liste des noms de paramètres

Regardons quels paramètres sont actuellement sur le serveur de paramètres :

3.1 liste de rosparam

liste $ rosparam

Ici, nous pouvons voir que le nœud turtlesim a trois paramètres sur le serveur de paramètres
pour la couleur d'arrière-plan :

 /rosdistro
 /roslaunch/uris/host_nxt__43407
 /rosversion
 /run_id
 /turtlesim/background_b
 /turtlesim/background_g
 /turtlesim/background_r

Modifions l'une des valeurs des paramètres à l'aide de rosparam set :

3.2 Rosparam set et Rosparam get
Usage:

ensemble rosparam [param_name]

rosparam obtenir [param_name]

Ici, nous allons changer le canal rouge de la couleur d'arrière-plan :

$ rosparam définir /turtlesim/background_r 150

Cela modifie la valeur du paramètre, nous devons maintenant appeler le service clear pour
que le changement de paramètre prenne effet :

$ rosservice appel /effacer

© 2025 Caplogy. All rights reserved.

62
Nom de la filière - Année Titre du cours

Maintenant, notre simulation de tortue ressemble à ceci :


Examinons maintenant les valeurs des autres paramètres du serveur de paramètres.
Obtenons la valeur du canal d'arrière-plan vert :

$ rosparam obtenir /turtlesim/background_g

 86

Nous pouvons également utiliser rosparam get / pour nous montrer le contenu de
l'ensemble du serveur de paramètres.

$ rosparam obtenir /

 rosdistro : 'noétique


© 2025 Caplogy. All rights reserved.

63
Nom de la filière - Année Titre du cours

 '
 roslaunch:
 uris:
 hôte_nxt__43407 : [Link]
 rosversion : « 1.15.5 »


 '
 run_id : 7ef687d8-9ab7-11ea-b692-fcaa1494dbf9
 tortuesim:
 background_b: 255
 background_g: 86
 background_r: 69

Vous pouvez enregistrer ces informations dans un fichier afin de pouvoir les recharger
ultérieurement. C'est facile avec rosparam :
3.3 décharge et chargement de Rosparam
Usage:

rosparam dump [nom_fichier] [espace de noms]

rosparam load [nom_fichier] [espace_de_noms]

Ici, nous écrivons tous les paramètres dans le fichier [Link]

$ rosparam dump paramè[Link]

Vous pouvez même charger ces fichiers yaml dans de nouveaux espaces de noms, par
exemple copy_turtle :

$ rosparam charger [Link] copy_turtle

$ rosparam obtenir /copy_turtle/turtlesim/background_b

 255

Maintenant que vous comprenez comment fonctionnent les services et paramètres ROS,
essayons d'utiliser rqt_console et roslaunch

© 2025 Caplogy. All rights reserved.

64
Nom de la filière - Année Titre du cours

4. Démonstration vidéo
Regardez la vidéo ci-dessous pour comprendre comment utiliser les services de différentes
manières dans les projets ROS.
[Link]

© 2025 Caplogy. All rights reserved.

65
Nom de la filière - Année Titre du cours

Utilisation de rqt_console et roslaunch

[Link]érequis rqt et package turtlesim

Ce tutoriel utilise les paquets rqt et turtlesim . Pour ce faire, veuillez installer les deux
paquets, si ce n'est pas déjà fait.

$ sudo apt-get install ros-<distribution>-rqt ros-<distribution>-rqt-common-plugins ros-

<distribution>-turtlesim

Remplacez <distro> par le nom de votre distribution ROS (par exemple indigo, jade, kinetic,
lunar...).
REMARQUE : Vous avez peut-être déjà compilé rqt et turtlesim pour l'un des tutoriels
précédents. En cas de doute, les réinstaller ne posera aucun problème.
2. Utilisation de rqt_console et rqt_logger_level
rqt_console s'attache au framework de journalisation de ROS pour afficher la sortie des
nœuds. rqt_logger_level nous permet de modifier le niveau de verbosité (DEBUG, WARN,
INFO et ERROR) des nœuds pendant leur exécution.
Regardons maintenant la sortie de TurtleSim dans rqt_console et changeons les niveaux
d'enregistrement dans rqt_logger_level lors de l'utilisation de TurtleSim. Avant de démarrer
TurtleSim, démarrez rqt_console et rqt_logger_level dans deux nouveaux terminaux :

$ rosrun rqt_console rqt_console

$ rosrun rqt_logger_level rqt_logger_level

Vous verrez deux fenêtres apparaître :

© 2025 Caplogy. All rights reserved.

66
Nom de la filière - Année Titre du cours

Démarrons maintenant turtlesim dans un nouveau terminal :

$ rosrun turtlesim turtlesim_node

Étant donné que le niveau de journalisation par défaut est INFO, vous verrez toutes les
informations que Turtlesim publie au démarrage, ce qui devrait ressembler à :

© 2025 Caplogy. All rights reserved.

67
Nom de la filière - Année Titre du cours

Modifions maintenant le niveau du journal sur Avertir en actualisant les nœuds dans la
fenêtre rqt_logger_level et en sélectionnant Avertir comme indiqué ci-dessous :

Maintenant, dirigeons notre tortue vers le mur et voyons ce qui s'affiche dans notre
rqt_console :
Pour ROS Hydro et versions ultérieures,

 pub rostopic /turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '{linéaire : {x : 2,0, y : 0,0,

z : 0,0}, angulaire : {x : 0,0, y : 0,0, z : 0,0}}'

© 2025 Caplogy. All rights reserved.

68
Nom de la filière - Année Titre du cours

Pour ROS Groovy et versions antérieures,

 pub rostopique /turtle1/command_velocity turtlesim/Velocity -r 1 -- 2.0 0.0

2.1 Note rapide sur les niveaux d'enregistrement

Les niveaux de journalisation sont hiérarchisés dans l’ordre suivant :

Fatal
Erreur
Avertir
Informations
Déboguer

Fatal a la priorité la plus élevée et Debug la plus basse. En définissant le niveau de

journalisation, vous obtiendrez tous les messages de ce niveau de priorité ou supérieur. Par
exemple, en définissant le niveau sur Warn , vous obtiendrez tous les messages de
journalisation Warn , Error et Fatal .

© 2025 Caplogy. All rights reserved.

69
Nom de la filière - Année Titre du cours

Appuyons sur Ctrl-C sur notre simulation de tortue et utilisons roslaunch pour faire
apparaître plusieurs nœuds de simulation de tortue et un nœud d'imitation pour amener
une simulation de tortue à imiter une autre :
2.2 Utilisation de Roslaunch
roslaunch démarre les nœuds tels que définis dans un fichier de lancement.
Usage:

$ roslaunch [package] [nom de [Link]]

Accédez d’abord au package beginner_tutorials que nous avons

créé et construit précédemment :

$ roscd tutoriels pour débutants

Si roscd indique quelque chose de similaire à roscd: No such package/stack

'beginner_tutorials' , vous devrez sourcer le fichier de configuration de l'environnement
comme vous l'avez fait à la fin du didacticiel create_a_workspace :

$ cd ~/catkin_ws
$ source devel/[Link]
$ roscd tutoriels pour débutants

Créons alors un répertoire de lancement :

$ mkdir lancement
$ cd lancement

 REMARQUE : Le répertoire de stockage des fichiers de lancement ne doit pas

nécessairement s'appeler launch . En fait, il n'est même pas nécessaire de les stocker
dans un répertoire. La commande roslaunch examine automatiquement le paquet
transmis et détecte les fichiers de lancement disponibles. Cependant, cette pratique
est considérée comme une bonne pratique.
2.3 Le fichier de lancement
Créons maintenant un fichier de lancement appelé [Link] et collons ce qui suit :
Afficher/masquer les numéros de lignes

1 < lancement >

2
3 < groupe ns = " turtlesim1 " >
4 < nœud pkg = " turtlesim " nom = " sim " type = " turtlesim_node " />
5 </ groupe >
6
7 < groupe ns = " turtlesim2 " >

© 2025 Caplogy. All rights reserved.

70
Nom de la filière - Année Titre du cours

8 < nœud pkg = " turtlesim " nom = " sim " type = " turtlesim_node " />
9 </ groupe >
10
11 < node pkg = " turtlesim " name = " mimic " type = " mimic " >
12 < remapper de = " entrée " à = " turtlesim1/turtle1 " />
13 < remapper de = " sortie " vers = " turtlesim2/turtle1 " />
14 </ nœud >
15
16 </ lancement >
2.4 Le fichier de lancement expliqué
Maintenant, décomposons le XML de lancement.
Afficher/masquer les numéros de lignes

1 < lancement >

Ici, nous démarrons le fichier de lancement avec la balise de lancement, afin que le fichier
soit identifié comme un fichier de lancement.
Afficher/masquer les numéros de lignes

3 < groupe ns = " turtlesim1 " >

4 < nœud pkg = " turtlesim " nom = " sim " type = " turtlesim_node " />
5 </ groupe >
6
7 < groupe ns = " turtlesim2 " >
8 < nœud pkg = " turtlesim " nom = " sim " type = " turtlesim_node " />
9 </ groupe >
Ici, nous démarrons deux groupes avec l'espace de noms turtlesim1 et turtlesim2, et un
nœud turtlesim nommé sim. Cela nous permet de démarrer deux simulateurs sans conflit de
noms.
Afficher/masquer les numéros de lignes

11 < node pkg = " turtlesim " name = " mimic " type = " mimic " >
12 < remapper de = " entrée " à = " turtlesim1/turtle1 " />
13 < remapper de = " sortie " vers = " turtlesim2/turtle1 " />
14 </ nœud >
Nous démarrons ici le nœud mimique avec les sujets « input » et « output » renommés
« turtlesim1 » et « turtlesim2 ». Ce changement de nom permettra à turtlesim2 d'imiter
turtlesim1.
Afficher/masquer les numéros de lignes

16 </ lancement >

Cela ferme la balise XML pour le fichier de lancement.
2.5 roslaunching
Maintenant, lançons le fichier de lancement :

© 2025 Caplogy. All rights reserved.

71
Nom de la filière - Année Titre du cours

$ roslaunch tutoriels_débutants [Link]

Deux turtlesims démarreront et dans un nouveau terminal enverront la

commande rostopic :
Pour ROS Hydro et versions ultérieures,

 $ rostopic pub /turtlesim1/turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0,

0.0]' '[0.0, 0.0, -1.8]'

Pour ROS Groovy et versions antérieures,

 $ rostopic pub /turtlesim1/turtle1/command_velocity turtlesim/Velocity -r 1 -- 2.0 -

1.8

Vous verrez les deux turtlesims commencer à bouger même si la commande de publication
n'est envoyée qu'à turtlesim1.

Nous pouvons également utiliser rqt_graph pour mieux comprendre le fonctionnement de

notre fichier de lancement. Ouvrez la fenêtre principale de rqt et sélectionnez Extensions >
Introspection > Node Graph .

$ rqt

Ou simplement :

$ rqt_graph

© 2025 Caplogy. All rights reserved.

72
Nom de la filière - Année Titre du cours

Maintenant que vous avez utilisé rqt_console et roslaunch avec succès, découvrons les
options d'édition pour ROS . Vous pouvez utiliser Ctrl-C pour toutes vos simulations de
tortues, car vous n'en aurez pas besoin pour les prochains tutoriels.
3. Démonstration vidéo
Regardez la vidéo ci-dessous pour avoir une compréhension plus approfondie des fichiers de
lancement.
[Link]

© 2025 Caplogy. All rights reserved.

73