Connexion au programme ROS

Bonjour, chers lecteurs! Je continue de parler de diverses fonctionnalités intéressantes et utiles de la plate-forme robotique Robot Operation System (ROS). Dans ce court didacticiel, je vais parler des possibilités de journalisation à l'aide de ROS lors de la programmation en C ++. Je pense que beaucoup conviendront que la sortie des messages pendant l'exécution du programme est d'une grande importance lors du développement de programmes, en particulier lors du débogage. ROS fournit une API pratique pour la sortie de divers types de messages vers le terminal avec la possibilité de visualiser et de filtrer les messages dans des outils ROS spéciaux. Commençons!

Utilisation des méthodes de la bibliothèque console.h pour afficher des messages dans un nœud

Écrivons donc un nœud simple, que nous appellerons logging_tutorial:

catkin_create_pkg logging_tutorial roscpp std_msgs 

Ajoutez à CMakeLists.txt:

 add_executable(logging_node src/main.cpp) target_link_libraries(logging_node ${catkin_LIBRARIES} ) 

Commençons maintenant à écrire du code main.cpp. Nous importons dans l'en-tête du fichier un fichier d'en-tête spécial console.h avec la définition des fonctions de journalisation:

 #include <ros/console.h> 

Ajoutez un message simple à la méthode principale:

 int main(int argc, char** argv) { ros::init(argc, argv, "logging_node"); ros::NodeHandle n; ROS_INFO("logging_node start"); return 0; } 

Compilez le package et exécutez-le:

 cd ~/catkin_ws catkin_make source devel/setup.bash rosrun logging_tutorial logging_node 

La sortie sera comme ceci:

 [ INFO] [1492194213.009783103]: logging_node start 

Au début du message, un "niveau" ou type et horodatage en secondes et nanosecondes à partir du 1er janvier 1970 est ajouté. Dans ce cas, nous avons un message avec un niveau INFO.

Nous pouvons transmettre des paramètres au message de la même manière que la méthode printf:

 int val = 5; ROS_INFO("message with argument: %d", val); 

Vous pouvez créer un message sous forme de flux standard comme std :: cout:

 ROS_INFO_STREAM("message with argument: " << val); 

ROS prend en charge les «niveaux de détail» suivants (par ordre croissant de pertinence):

• DEBUG
• INFO
• AVERTISSEMENT
• Erreur
• Fatal

Pour afficher un message d'un certain niveau, la fonction correspondante est utilisée au format: ROS _ \ <LEVEL \>. Les messages de différents types sont affichés avec une certaine couleur: DEBUG - vert, INFO - blanc, WARN - jaune, ERROR - rouge, FATAL - violet. Le but de chaque type de message est facile à deviner par son nom. Par exemple, les messages DEBUG sont utiles pour le débogage.

Ajoutez quelques messages différents et exécutez le tout en boucle. J'ai obtenu le fichier suivant:

 #include <ros/ros.h> #include <ros/console.h> int main(int argc, char** argv) { ros::init(argc, argv, "logging_node"); ros::NodeHandle n; ros::Rate rate (1); while(ros::ok()) { ROS_DEBUG("debug message"); ROS_INFO("logging_node start"); int val = 5; ROS_INFO("message with argument: %d", val); ROS_INFO_STREAM("stream message with argument: " << val); ROS_WARN("My warning"); ROS_ERROR("Some error"); ROS_FATAL("Fatal error"); ros::spinOnce(); rate.sleep(); } return 0; } 

Par défaut, les messages de tous types sauf DEBUG sont affichés pendant l'exécution du programme. Ceci est déterminé par le niveau minimum, appelé «niveau d'importance», à l'aide du paramètre ROSCONSOLE_MIN_SEVERITY. Le paramètre ROSCONSOLE_MIN_SEVERITY limite la sortie des messages de telle sorte que tous les messages avec un niveau égal ou supérieur au minimum soient affichés. Par défaut, le niveau minimum est défini sur DEBUG. Vous pouvez modifier le niveau minimum en définissant ROSCONSOLE_MIN_SEVERITY sur l'un des niveaux de message (ROSCONSOLE_SEVERITY_DEBUG, ROSCONSOLE_SEVERITY_INFO, etc.) ou sur aucun d'entre eux (ROSCONSOLE_SEVERITY_NONE) à l'aide de la macro au début du fichier de noeud:

 #define ROSCONSOLE_MIN_SEVERITY ROSCONSOLE_SEVERITY_DEBUG 

Vous pouvez également définir le niveau de gravité pour tous les nœuds du package dans le fichier CMakeLists.txt:

 add_definitions(-DROSCONSOLE_MIN_SEVERITY=ROSCONSOLE_SEVERITY_ERROR) 

Cette méthode a une limitation: seuls les messages d'un niveau supérieur à DEBUG seront affichés, même si nous spécifions directement ROSCONSOLE_SEVERITY_DEBUG. Ce problème peut être résolu à l'aide d'un fichier de configuration spécial. Créez un dossier de configuration et à l'intérieur un fichier custom_rosconsole.conf avec le contenu suivant:

 log4j.logger.ros.logging_tutorial=DEBUG 

Ensuite, créez le fichier de lancement logging.launch et spécifiez le chemin d'accès au fichier custom_rosconsole.conf dans la variable ROSCONSOLE_CONFIG_FILE:

 <launch> <env name="ROSCONSOLE_CONFIG_FILE" value="$(find logging_tutorial)/config/custom_rosconsole.conf"/> <node pkg="logging_tutorial" type="logging_node" name="logging_node" output="screen"/> </launch> 

Ici, nous avons ajouté le paramètre output = "screen", qui permet de sortir des messages de niveau commençant par INFO.

Compilez et exécutez notre lanceur:

 cd ~/catkin_ws catkin_make roslaunch logging_tutorial logging.launch 

Nous obtenons une conclusion similaire:



ROS a la capacité de nommer les messages. Par défaut, les messages obtiennent le nom d'hôte. Les utilisateurs peuvent donner des noms à divers messages via la fonction ROS _ \ <LEVEL \> [_ STREAM] _NAMED:

 ROS_INFO_STREAM_NAMED("named_msg", "named info stream message with argument: " << val); 

Les noms vous permettent d'attribuer différents niveaux minimum à chaque message nommé dans le fichier de configuration et de les modifier individuellement. Le nom du message est indiqué après le nom du package:

 log4j.logger.ros.logging_tutorial.named_msg = ERROR 

Les messages conditionnels exécutés sous une certaine condition peuvent également être utiles. Pour ce faire, utilisez la fonction ROS _ \ <LEVEL \> [_ STREAM] _COND [_NAMED]:

 ROS_INFO_STREAM_COND(val < 2, "conditional stream message shown when val (" << val << ") < 2"); 

Les messages peuvent être émis à une fréquence spécifique à l'aide de la fonction ROS _ \ <LEVEL \> [_ STREAM] _THROTTLE [_NAMED]. Le premier paramètre définit la fréquence en secondes:

 ROS_INFO_THROTTLE(3, "throttled message with period 3 seconds"); 

Utilisation de rqt_console pour afficher des messages

Exécutez l'utilitaire rqt_console:

 rosrun rqt_console rqt_console 

Et démarrez notre nœud en utilisant le lancement:

 roslaunch logging_tutorial logging.launch 

La fenêtre rqt_console ressemblera à ceci:



Ici, dans le tableau de chaque message, son niveau, le nom du nœud, le nom du fichier et la ligne de code où il est généré sont affichés.

En double-cliquant sur un message, vous pouvez obtenir des informations détaillées à son sujet:


Vous pouvez filtrer les messages en excluant tous les messages d'erreur. Pour ce faire, ajoutez un filtre en cliquant sur le signe plus à côté du tableau Exclure les messages et en sélectionnant l'option "... contenant":



Ou excluez les messages avec le niveau Info:



En outre, les messages d'un niveau donné peuvent être distingués parmi tous à l'aide des filtres de la section Messages en surbrillance:



Ainsi, rqt_console vous permet de configurer de manière flexible l'affichage des messages de différents nœuds et de simplifier les programmes de débogage dans ROS.

J'espère que ce guide s'avérera utile dans le travail et simplifiera la solution des problèmes qui surviennent lors de la programmation. Je vous souhaite beaucoup de succès dans votre travail avec ROS et à bientôt!