·préface
·Le public cible de ce livre
· Entrée

Paramètres
1.
Terminal
1.1 Nécessité d'un terminal à écran partagé
1.2 Essai du terminal de base
1.3 Terminator
1.4 Tilix
2.
Éditeur
2.1 Installation de Sublime Text
2.2 Essai de Sublime Text
3. Installer ROS
3.1 Trouvez la page d'installation de la version ROS Galactic
3.2 Définir les paramètres régionaux
3.3 Sources de configuration
3.3 Installation des packages ROS2
3.4 Vérification de l'installation de ROS2
4.
finition

Se familiariser avec le terminal, le fichier bashrc et Linux
1.
Objectif de ce chapitre
2.
Commandes de base relatives aux dossiers sous Ubuntu
2.1 Créons un dossier - mkdir
2.2 Déplacez le dossier vers le dossier dans lequel vous souhaitez l'installer - cd
2.3 Commande Supprimer = rm
3.
bashrc
3.1 Coque
3.2 .bashrc
3.3 Saisir les commandes dans .bashrc
4.
Définition d'un alias dans .bashrc
4.1 Configuration des alias
4.2 Définir le contexte galactique comme un alias
4.3 Spécifiez également la source ~/.bashrc comme alias
5. Paramètres du domaine ROS2
6.
finition

Apprendre les commandes de base de ROS2
1.
Objectif de ce chapitre
2.
Installation et exécution de Turtlesim
3.
Réaffirmer l'importance de l'environnement setup.bash
4. Nœud ROS
5. Service ROS
5.1 Concept de service
Liste des services ROS2 5.2
5.3 type de service ros2
5.4 Définition du service
5.5 Introduction aux robots mobiles
5.6 Comment appeler un service d'assistance
5.7 espace de noms
5.8 apparition
6. Sujet ROS
6.1 Concept du sujet
Liste des sujets ROS2 6.2
6.3 type de sujet ros2
Informations sur le sujet 6.4 ros2
6.5 Vérification du type de message pour utiliser le sujet
6.6 S'abonner à un sujet dans le terminal
6.7 Essayez d'émettre un sujet de commande de conduite
6.8 rqt_graph montrant le flux des sujets
7. Action ROS
7.1 Exécuter le nœud turtle_teleop_key
Liste d'actions ROS2 7.2
7.3 ros2 action send_goal
8.
finition

Gestion des sujets ROS2 avec Python
1.
Objectif de ce chapitre
2.
Installation et préparation
3.
Utilisation simple de Jupyter et des bases de Python
3.1 Utilisation de base de Jupyter
3.2 Document Markdown
4.
S'abonner aux sujets avec Python
4.1 Préparation de l'abonnement à un sujet avec Jupyter
4.2 Un avertissement avant de se lancer dans la programmation
4.3 Importation des modules requis pour l'abonnement
4.4 Méthode d'importation Python
4.5 Initialisation de rclpy et création des nœuds
4.6 Écriture d'une fonction de rappel à exécuter dans l'abonnement
4.7 Création d'un abonné à un sujet
4.8 Éléments à prendre en compte lors de l'utilisation de Jupyter
4.9 Limitez le nombre de sujets que vous recevez
5.
Publier des sujets avec Python
5.1 Préparation de la publication de sujets avec Jupyter
5.2 Initialisation de rclpy et des messages pour la publication de sujets
5.3 Déclaration de Twist comme type de données du sujet cmd_vel
5.4 Publication simplifiée du sujet cmd_vel avec Python
5.5 Publication d'un sujet à l'aide d'un minuteur dans ROS
6.
Types de nœuds
7.
finition

Gestion des clients de service avec Python
1.
Objectif de ce chapitre
2.
Utilisation du client de service ROS avec Python
2.1 Préparation à l'apprentissage et création de nœuds pour le client de service
2.2 Création d'un client de service demandant un service
2.3 Préparation de la définition de service pour une utilisation en Python
2.4 Essayez un simple appel de service
2.5 Tentative d'attente du service
2.6 Vérification de l'état d'exécution du client de service
3.
finition

Comprendre les classes Python pour l'apprentissage de ROS2
1.
Objectif de ce chapitre
2.
Préparation et simple tracé de la fonction sinus
2.1 Préparation d'un document vierge
2.2 Préparation à l'utilisation et à l'importation de matplotlib
2.3 Préparation du domaine
2.4 Détermination de la fonction sinus
2.5 Tracer un graphique
2.6 Implémentation avec la fonction def
3.
Représenter la fonction sinus comme une classe
3.1 Tout d'abord, enregistrons une variable dans la classe.
3.2 Complétez le cours sur le tracé des fonctions trigonométriques
4.
Héritage de classe
5.
Remplacement de méthode
6.
Utiliser super() dans une classe
7.
finition

Création de forfaits et couverture des sujets
1.
Objectif de ce chapitre
2.
Installation et préparation
3.
Création d'un paquet pour la première fois
3.1 Créons simplement un paquet.
3.2 Création d'un package et configuration d'un espace de travail
4.
Ajouter un nœud d'abonné au sujet
4.1 Ajout d'un nouveau fichier d'abonné
4.2 Description du fichier my_subscriber.py
4.3 Exécution du nœud nouvellement ajouté
5.
Ajouter un nœud d'éditeur de sujet
5.1 Description du fichier my_publisher.py
5.2 Si vous souhaitez effacer les informations de compilation de l'espace de travail
5.3 Exécution de my_publisher
6.
finition

Créez des définitions de messages et gérez-les dans des sujets et des services.
1.
Objectif de ce chapitre
2.
Définition du message
2.1 Création d'un package distinct pour les définitions de messages
2.2 Création d'une définition de message
2.3 Création d'un paquet avec le message nouvellement défini
3.
Abonnez-vous à deux sujets et publiez sur un seul.
3.1 Commençons par la partie sur le thème de la pose publiée par turtlesim.
3.2 Utilisons la nouvelle fonction CmdAndPoseVel.
3.3 S'abonner au sujet cmd_vel
3.4 Publions les résultats de l'abonnement à deux sujets.
4.
Permettez-moi de créer une définition de service.
4.1 Création et élaboration d'une définition de service
4.2 Créons un serveur de services
4.3 Créons du code client à l'intérieur du code du serveur de service.
4.4 Le problème de disposer plusieurs tortues en cercle
4.5 Mise en œuvre d'un serveur de services déployant plusieurs tortues
4.6 Présentons plusieurs tortues.
5.
finition

S'habituer à l'action
1.
Objectif de ce chapitre
2.
Création d'une définition d'action
2.1 Préparation de la définition d'une action
2.2 Création d'une définition d'action
2.3 Élaboration d'une définition d'action
3.
Un bref aperçu du concept avec un serveur d'actions simple.
3.1 Serveur d'actions qui affiche simplement les résultats
3.2 Ajout de commentaires au serveur d'actions
4. Principes de base du multithreading avec ROS2
5.
Créez un serveur d'actions qui se déplace d'une distance spécifiée.
5.1 Code complet
5.2 principal : Application du multithreading
5.3 TurtleSub_Action : S’abonner au sujet de la pose
5.4 DistTurtleServer : Se déplacer d’une distance spécifiée par l’utilisateur
6.
Un aperçu rapide du serveur d'action
7.
finition

Paramètres de gestion
1.
Objectif de ce chapitre
2.
Essayez d'utiliser des paramètres avec les commandes du terminal.
2.1 Environnement de pratique
2.2 liste des paramètres ros2
2.3 ros2 param get
2.4 ros2 param set
2.5 ros2 param dump
2.6 chargement des paramètres ros2
3.
Paramètres accessibles par le biais du code
3.1 Tout d'abord, déclarons les paramètres.
3.2 Comment utiliser les paramètres dans le code
3.3 Notez que les paramètres changent
4.
finition

Plusieurs outils de débogage et d'observation
1.
Le rôle du chef de village
2.
enregistrer
2.1 Consultation des journaux à l'aide de rqt_console
2.2 Création de vos propres messages de journalisation
3.rqt
3.1 rqt_graph
3.2 rqt_plot
3.3 Moniteur de sujets
3.4 Éditeur de sujet
4.
rosbag
5. LANCEMENT DE ROS
5.1 Principes de base de roslaunch
5.2 Spécification des paramètres
6.
finition

En conclusion

J'étudie et développe des robots depuis très longtemps.
J'ai commencé comme étudiant et j'ai travaillé sur tout, des petits robots éducatifs au développement de robots chirurgicaux laparoscopiques qui coûtent des centaines de millions de wons.
Il y a beaucoup de domaines qui m'intéressent, mais il n'a pas été facile de m'impliquer concrètement dans leur développement.
Mais d'une manière ou d'une autre, je me suis retrouvé à me lancer des défis avec divers projets, dont un robot éducatif utilisant la programmation par blocs, un robot de déminage, un robot skate (un type de robot d'équilibre qui aide les gens à se déplacer en maintenant leur équilibre), une imprimante 3D et même un projet basé sur l'apprentissage profond.
Que je développe ou utilise un robot, l'ami qui m'aide toujours à implémenter des fonctions facilement est ROS (Robot Operating System).
Bien sûr, je n'ai pas utilisé ROS dès le début.
J'ai découvert ROS vers 2012, mais ce n'est que quelques années plus tard que j'ai commencé à l'étudier et à l'utiliser, et encore plusieurs années plus tard que j'ai développé un logiciel de robotique avec ROS. Après avoir utilisé ROS, je me suis dit : « Waouh ! Si seulement j'avais utilisé cet outil formidable plus tôt ! Ça aurait été tellement plus simple. »

Récemment, j'ai participé à divers programmes éducatifs pour faire connaître la robotique et l'apprentissage profond.
Nous nous efforçons également de fournir d'excellents livres et du matériel pédagogique aux étudiants situés dans différentes régions.
Ensuite, j'ai pensé que j'aimerais apprendre le fonctionnement des robots et apporter mon aide à ceux qui souhaitent apprendre ROS pour le développement de robots.
Plutôt que de parler de la grande histoire de ROS, de sa philosophie ou de son architecture, je voulais parler de la façon d'utiliser ROS de manière optimale.

Je pensais qu'il était de mon devoir d'enseigner tout ce que je pouvais sur le développement de robots, notamment ROS, la programmation par blocs, la théorie du contrôle, la robotique, les filtres numériques et l'apprentissage profond.
Je ne sais pas encore s'il y aura un livre par domaine ou un format différent, mais je compte raconter les histoires une par une.

Le premier livre par lequel je vais commencer est ROS2 Galactic.
Je ne pense pas que la version de ROS (1 ou 2) ait une importance.
Je pense qu'il est plus important de trouver rapidement les fonctions dont on a besoin et comment les appliquer que de choisir l'outil que l'on utilise.
Des expressions comme « organisation parfaite » ou « ce livre est tout ce dont vous avez besoin » ne correspondent pas à mon livre.
Je ne pense pas être capable d'organiser plus de contenu de manière plus approfondie que ce qui est disponible sur Internet.
Comme je l'ai mentionné précédemment, je tiens à souligner que je réfléchis à des moyens de permettre aux lecteurs d'apprendre rapidement à utiliser les outils.

Ce livre abordera d'abord les bases de l'utilisation de ROS, mais nous évoquerons brièvement son utilisation sous Linux. ROS fonctionne parfaitement sous Ubuntu (un système d'exploitation basé sur Linux), il est donc essentiel de bien connaître Ubuntu.
Nous aborderons également dans les deux prochains volumes la manière de décrire les robots avec URDF, de les simuler dans Gazebo et d'utiliser Arduino avec ROS.
Actuellement, un outil utile appelé ROS est en phase de transition de ROS1 à ROS2, la version ROS2 étant sortie il y a quelques années.
Il existe de nombreux débats au sein de la communauté internet concernant ROS1 et ROS2, mais je pense que c'est un débat inutile.
Parce qu'il faut savoir tout gérer.
Je vais ici parler de ROS basé sur Ubuntu 20.04.
La raison est simple.
Car la dernière version d'Ubuntu qui prend en charge à la fois ROS1 et ROS2 est la 20.04.

Au moment de la publication de ce livre, Ubuntu aura probablement été mis à jour vers la version 22.04.
Mais cela n'a pas d'importance non plus.
Parce que de nombreuses personnes développent encore avec la version ROS1 Kinetic sur Ubuntu 16.04.
Ce qui compte, ce n'est pas la version, mais la compréhension de son utilisation.
Une nouvelle version de ROS2 pour Ubuntu 22.04 sortira certainement, mais les bases resteront les mêmes, vous n'avez donc pas trop à vous en soucier.