La Système d'exploitation du robot (ROS) n'est pas un système d'exploitation réel, mais un cadre et un ensemble d'outils qui fournissent les fonctionnalités d'un système d'exploitation sur un cluster d'ordinateurs hétérogène. Son utilité ne se limite pas aux robots, mais la majorité des outils fournis sont axés sur le travail avec du matériel périphérique.

ROS est divisé en plus de 2000 packages, chaque package fournissant des fonctionnalités spécialisées. Le nombre d'outils connectés au framework est probablement sa plus grande puissance.

Pourquoi devrais-je utiliser Robot OS?

ROS fournit des fonctionnalités pour l'abstraction matérielle, les pilotes de périphériques, la communication entre les processus sur plusieurs machines, des outils de test et de visualisation, et bien plus encore.

La principale caractéristique de ROS est la façon dont le logiciel est exécuté et la façon dont il communique, vous permettant de concevoir des logiciels complexes sans savoir comment certains matériels fonctionnent. ROS fournit un moyen de connecter un réseau de processus (nœuds) à un hub central. Les nœuds peuvent être exécutés sur plusieurs appareils et ils se connectent à ce hub de différentes manières.

quels sont les principes de conception?

Les principales façons de créer le réseau consistent à fournir des services demandables ou à définir des connexions éditeur / abonné avec d'autres nœuds. Les deux méthodes communiquent via des types de messages spécifiés. Certains types sont fournis par les packages principaux, mais les types de messages peuvent être définis par des packages individuels.

Les développeurs peuvent assembler un système complexe en connectant des solutions existantes pour de petits problèmes. La manière dont le système est implémenté, nous permet de:

• Remplacez les composants par des interfaces similaires à la volée, éliminant ainsi le besoin d'arrêter le système pour divers changements

• Multiplexage des sorties de plusieurs composants en une entrée pour un autre composant, permettant la résolution parallèle de divers problèmes

  
  
  

• Connectez des composants créés dans divers langages de programmation en implémentant simplement les connecteurs appropriés au système de messagerie, ce qui facilite le développement de logiciels en connectant des modules existants de divers développeurs

• Créez des nœuds sur un réseau d'appareils, sans vous soucier de l'endroit où le code est exécuté et en mettant en œuvre des systèmes de communication interprocessus (IPC) et d'appel de procédure à distance (RPC)

  
  
  

• Connectez-vous directement aux flux à la demande à partir de matériel distant sans écrire de code supplémentaire, en utilisant les deux points précédents

Nous prévoyons de démontrer à quel point cela est utile en développant de manière itérative une solution simple. Il existe plusieurs avantages clés par rapport aux autres approches. ROS prend en charge plusieurs plates-formes et permet les connexions entre les processus sur plusieurs périphériques via des connexions peer-to-peer qui sont gérées en arrière-plan. La conception permet la prise en charge de n'importe quel langage en encapsulant les classes de communication C ++ ou en développant manuellement des classes pour l'interface du langage.

ROS est fait par sa propre communauté, destinée à sa communauté. Après plusieurs années, cela a abouti à une grande quantité de packages réutilisables et simples à intégrer, grâce à l'architecture du système.

Approches alternatives comme MRPT , CARMEN , LCM , Joueur , Microsoft RDS et d'autres fournissent certaines de ces fonctionnalités, mais pas toutes. La plupart du temps, les problèmes de conception sont les limitations de la prise en charge du langage, la communication non optimisée entre les processus ou le manque de prise en charge de divers périphériques, ce qui est sans doute le problème le plus difficile à résoudre.

Qu'allons-nous construire?

Puisque notre objectif est le cadre et non les algorithmes réels pour des problèmes particuliers, le problème donné sera assez simple. Notre objectif est de créer un logiciel pour un ordinateur de bord qui nous permet de contrôler et de surveiller à distance un robot, connecté à nous via Wi-Fi, en utilisant une manette de jeu sur notre ordinateur et une alimentation de la caméra montée sur le robot.

Tout d'abord, nous allons créer un lien entre un programme simple et une simulation simple, juste pour démontrer les principes de base de ROS. Nous allons attacher une manette de jeu à un ordinateur et essayer de concevoir un bon schéma de contrôle pour transformer l'entrée de la manette de jeu en signaux de commande pour un robot.

Les principaux langages d'écriture de code ROS sont C ++ et Python, C ++ étant préféré en raison de meilleures performances. Nous expliquerons nos exemples dans Python en raison de moins de passe-partout dans le code et aucun besoin de construction explicite.

Installation et configuration

Les versions ROS sont désignées par leur nom. À partir de cette date, la dernière version est Tortue de jade , et la dernière version LTS Igloo indigo . Opter pour la version LTS est préférable, et la compatibilité avec les versions antérieures n’est pas garantie dans ROS, donc tous les exemples seront écrits pour Indigo .

ROS est disponible sur diverses plates-formes * NIX. La version officiellement prise en charge est sur Ubuntu. Les versions OS X, Arch Linux, Debian, Raspbian et Android sont prises en charge par la communauté.

Nous allons passer par le processus d'installation d'Ubuntu 14.04 sur le bureau. Les processus pour toutes les versions et plates-formes prises en charge sont disponibles sur le site officiel site Internet . Des machines virtuelles sur lesquelles ROS est installé sont également disponibles.

L'installation dépend de la plate-forme (et la plupart des plates-formes ont des packages fournis), mais la configuration de l'espace de travail est la même pour toutes les plates-formes.

Installation sur Ubuntu

ROS fournit ses propres référentiels. La première étape consiste à les ajouter.

sudo sh -c 'echo 'deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main' > /etc/apt/sources.list.d/ros-latest.list' sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net --recv-key 0xB01FA116 sudo apt-get update

Après cela, vous aurez tous les packages hébergés pour toutes les versions de ROS disponibles pour votre version d'Ubuntu. Par exemple, Ubuntu 14.04 prend en charge indigo et jade.

L'installation des packages de base sur le bureau comporte l'une des trois options suivantes:

• sudo apt-get install ros-indigo-ros-base pour une installation minimale

• sudo apt-get install ros-indigo-desktop pour avoir les outils GUI supplémentaires de base

• sudo apt-get install ros-indigo-desktop-full pour avoir toutes les fonctionnalités officielles, y compris divers simulateurs et bibliothèques pour la navigation et la perception

Pour une meilleure expérience de travail, l'option complète est recommandée. Pour une installation sur des appareils qui ne seront utilisés que pour exécuter des nœuds, la version de base est suffisante. Quelle que soit l'option que vous choisissez, vous pouvez installer n'importe quel package requis nommé package_name en exécutant:

calculateur de salaire d'entrepreneur à temps plein

sudo apt-get install ros-indigo-

Les traits de soulignement sont remplacés par des tirets dans le nom final, donc stage_ros sera dans le package ros-indigo-stage-ros.

L'étape suivante consiste à initialiser rosdep. Les packages dans ROS peuvent déclarer les composants dont ils dépendent. rosdep vous permet de compiler ces packages sans trop de gestion manuelle des dépendances. Pour l'initialiser, appelez:

sudo rosdep init rosdep update

ROS a plusieurs variables d'environnement utilisées par ses outils. Avec l'installation par défaut, le script bash pour les initialiser se trouve dans /opt/ros/indigo/setup.bash. Les variables doivent être initialisées dans chaque session bash, donc la meilleure solution est de les ajouter à ~/.bashrc.

echo 'source /opt/ros/indigo/setup.bash' >> ~/.bashrc source ~/.bashrc

Certains packages installent des dépendances externes via rosinstall, qui est disponible sous forme de package et installé via sudo apt-get install python-rosinstall.

C'est la fin de l'installation sur Ubuntu. Ce qui suit est une brève introduction à l'installation d'espaces de travail.

Configuration

Depuis Groovy Galapagos , Les espaces de travail ROS sont gérés via catkin. Nous devons définir un répertoire pour tous les packages que nous hébergeons. Dans le répertoire, nous créons un src dossier et appelez catkin_init_workspace forme à l'intérieur. Cela créera divers liens symboliques vers la version ROS actuellement fournie. L'étape suivante consiste également à ajouter cet espace de travail aux variables d'environnement.

Pour effectuer toute cette configuration d'espace de travail, choisissez un répertoire vide et exécutez les commandes suivantes:

mkdir src cd src catkin_init_workspace cd .. catkin_make echo 'source $(pwd)/devel/setup.bash' >> ~/.bashrc source ~/.bashrc

Vous venez de créer un espace de travail dans lequel vous pouvez créer vos propres packages ROS.

Se familiariser avec les outils

Créer n'importe quel code est un grand saut. Familiarisez-vous d'abord avec certains des systèmes fonctionnant dans les coulisses. Notre première étape consistera à exécuter l'interface graphique de base et à voir les messages qu'elle génère.

Pour exécuter quoi que ce soit dans ROS, un processus de base doit être lancé. C'est aussi simple que d'ouvrir une nouvelle fenêtre de terminal et de taper:

roscore

Dans tout votre réseau d'appareils connectés, roscore ne doit être lancé qu'une seule fois, sur l'appareil qui hébergera le hub central pour la répartition des communications.

Le rôle principal de roscore consiste à indiquer aux nœuds à quels autres nœuds ils doivent se connecter et de quelle manière (que ce soit via un port réseau ou une mémoire partagée). L'objectif est de permettre aux nœuds de se soucier uniquement des données qu'ils souhaitent connaître, plutôt que du nœud auquel ils souhaitent se connecter, tout en minimisant le temps et la bande passante nécessaires pour effectuer toutes les communications.

rqt

Après avoir exécuté roscore, nous pouvons lancer l'outil principal de l'interface graphique pour ROS: rqt. Ce que nous voyons est très décevant - une fenêtre vide. rqt héberge une grande variété de plugins qui peuvent être configurés dans n'importe quelle configuration visuelle et n'importe quel nombre de vues prédéfinies.

Pour commencer, exécutons le Direction du robot plugin, en le choisissant dans Plugins > Robot Tools > Robot Steering. Ce que nous obtenons, ce sont deux curseurs, représentant le mouvement linéaire et de rotation que nous voulons que notre robot ait. En haut du plugin, nous voyons une zone de texte avec /cmd_vel dedans. Nous pouvons le renommer en tout ce que nous voulons. Il représente le nom du sujet sur lequel le pilotage publie. Les outils du terminal sont le meilleur endroit pour voir ce qui se passe en arrière-plan.

Outils de terminal

ROS dispose de plusieurs outils puissants pour inspecter ce qui se passe dans le système. Le premier outil que nous allons introduire est rostopic. Cela nous permet d'inspecter les sujets auxquels les nœuds peuvent s'abonner et publier. En cours d'exécution rostopic list donnera:

/cmd_vel /rosout /rosout_agg

Les 2 derniers sujets sont toujours en cours d'exécution et sont liés aux systèmes ROS centraux. Le /cmd_vel sujet est publié par notre direction. Renommer le sujet dans la direction le renommera également ici. Maintenant, nous nous intéressons à ce qui se passe dans le sujet. En cours d'exécution rostopic echo /cmd_vel ne nous montrera rien (sauf si vous avez bricolé les curseurs). Le processus s'exécute jusqu'à ce que nous l'annulions. Déplaçons maintenant le curseur vertical à 20 m / s. En regardant l'écho, nous pouvons voir ce qui suit se répéter encore et encore:

linear: x: 0.2 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0

À quelle fréquence spamme-t-il ce message? rostopic hz /cmd_vel dit à une fréquence moyenne de 10 Hz. Eh bien, combien de sujets comme celui-ci puis-je traiter via ma connexion Wi-Fi lente? rostopic bw /cmd_vel détecte une moyenne de 480 B / s.

Tout cela est bien beau, mais nous avons parlé des types de messages. Ces données sont bonnes pour un humain, mais une application aura besoin des données brutes et devra connaître le type de message pour pouvoir interpréter les données. Le type peut être déterminé avec rostopic type /cmd_vel, nous indiquant que c'est un geometry_msgs/Twist. Tous les outils de terminal ROS appelés sans aucun argument renvoient un message d'aide standard.

Le Wiki ROS est assez bon pour faire une recherche sur le Web de cette chaîne aboutissant à une explication Wiki de ce qu'elle contient et de sa structure. Mais nous n’avons pas à nous y fier. rosmsg est l'outil général pour les types de messages. En cours d'exécution rosmsg show geometry_msgs/Twist retournera:

geometry_msgs/Vector3 linear float64 x float64 y float64 z geometry_msgs/Vector3 angular float64 x float64 y float64 z

Le message se compose de deux vecteurs 3D, représentant la vitesse linéaire et angulaire dans l'espace 3D.

Si nous voulons à quels sujets un nœud est connecté, rosnode info nous donnera des données détaillées sur le nœud. Les outils rostopic, rosmsg et rosnode sont les principaux outils d'inspection des fonctionnalités brutes de ROS. ROS a beaucoup plus de GUI et d'outils de terminal, mais ceux-ci sont hors de notre portée pour cette introduction.

requête média pour tous les appareils

Les principaux outils pour exécuter les nœuds ROS sont rusrun et roslaunch. rosrun peut exécuter des nœuds via rosrun , et roslaunch exécute des nœuds sur la base de fichiers de lancement, avec lesquels nous nous familiariserons très peu car ils sont l'élément le plus complexe de l'automatisation ROS.

Nous pouvons arrêter tout ce que nous avons exécuté pour commencer à travailler sur notre premier code. Pour référence future, il va sans dire que l'exécution de tout ce qui concerne ROS nécessite une instance active de roscore. Un grand nombre de problèmes que vous rencontrez peuvent être résolus en fermant la fenêtre du terminal qui roscore est exécuté à l'intérieur, et en ouvrir un nouveau pour le relancer. Cela met à jour toutes les dépendances qui devaient être rechargées, à la fois dans bash et dans roscore.

Créer une téléopération de manette de jeu

Notre premier objectif est d'imiter la fonctionnalité de Robot Steering en créant un nœud qui publie geometry_msgs/Twist données à /cmd_vel basé sur l'entrée de la manette de jeu. Notre premier arrêt est le joy paquet.

Le joy Paquet

Le joy Le package fournit des pilotes ROS génériques pour les manettes de jeu et les manettes de jeu. Il n'est pas inclus dans l'installation par défaut, il doit donc être installé via:

sudo apt-get install ros-indigo-joy

Après l'installation, nous pouvons exécuter rosrun joy joy_node. Cela nous connectera au joystick ou à la manette de jeu par défaut. En cours d'exécution rostopic list nous montre que nous avons un sujet appelé /joy. L'écoute via rostopic echo nous montre les messages du format suivant (notez que vous devez interagir avec la manette de jeu ou le joystick pour que les messages soient publiés).

header: seq: 4156 stamp: secs: 1450707466 nsecs: 204517084 frame_id: '' axes: [0.0, 0.0, 0.0, -0.0, 0.0, 0.0, 0.0, 0.0] buttons: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Vous pouvez ignorer les en-têtes pour le moment. À part cela, nous avons axes et buttons, expliquant joliment ce qu'ils représentent. Le déplacement des axes et la pression des boutons sur le contrôleur entraîneront la modification de ces nombres. Grâce à nos outils, nous pouvons déterminer que le type de message est sensor_msgs/Joy et le format est:

std_msgs/Header header uint32 seq time stamp string frame_id float32[] axes int32[] buttons

Créer notre téléopération

La première étape de l'écriture de code consiste à créer un package. Dans le src dossier de l'espace de travail, exécutez:

catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

Ici, nous indiquons le nom du package que nous créons, suivi des packages sur lesquels nous prévoyons de dépendre. Pas de soucis, les dépendances peuvent être mises à jour manuellement plus tard.

Nous avons maintenant un toptal_tutorial dossier. Dans le dossier, créez un scripts dossier qui hébergera tous nos scripts Python.

Créons un fichier appelé teleop.py, dans lequel nous allons définir:

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy def joy_callback(data): print data def main(): rospy.init_node('teleop') rospy.Subscriber('joy', Joy, joy_callback) while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

Nous devrons également définir chmod +x teleop.py donc le script devient exécutable. En cours d'exécution rosrun joy joy_node dans un terminal et rosrun toptal_tutorial teleop.py dans un autre, la sortie du terminal de teleop.py sera remplie de messages Joy.

Examinons ce que fait le code.

Tout d'abord, nous importons rospy, qui héberge la bibliothèque pour interagir avec le framework ROS. Chaque package qui définit des messages a un msg sous-paquet contenant des définitions de message. Nous importons Joy pour gérer l'entrée. Il n'est pas nécessaire d'importer des types de messages incorporés (comme Header de std_msgs.msg qui se trouve dans le message Joy) sauf si nous voulons les mentionner explicitement.

différence entre llc s corp et c corp

Notre première étape consiste à initialiser un nœud avec un nom spécifique (dans ce cas, nous l'appelons «téléop»). Ensuite, nous créons un abonné qui s'abonne à la rubrique «joy» de type sensor_msgs.msg.Joy, et qui gère chaque message en appelant le joy_callback fonction. Les rappels reçoivent un paramètre, les données du message. L'accès aux membres des données est simple. Si nous voulions imprimer l'état du premier axe, si nous rappelions le type de message, nous appellerions print data.axes[0], et ce sera un float. La boucle à la fin boucle jusqu'à ce que ROS soit arrêté.

Notre prochaine étape serait de gérer nos données d'une manière ou d'une autre. Nous devrions créer un message Twist qui change en fonction de l'entrée, puis nous le publierions dans le cmd_vel sujet.

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist # new from functools import partial # new def joy_callback(pub, data): # modified cmd_vel = Twist() # new cmd_vel.linear.x = data.axes[1] # new cmd_vel.angular.z = data.axes[0] # new pub.publish(cmd_vel) # new def main(): rospy.init_node('teleop') pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) # new rospy.Subscriber('joy', Joy, partial(joy_callback, pub)) # modified while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

Tout d'abord, nous ajoutons le Twist message, et nous ajoutons la prise en charge des arguments de fonction de liaison via functools.partial. Nous créons un éditeur, pub, qui publie sur cmd_vel un message de type Twist. Nous lions cet éditeur au rappel et lui faisons publier un message Twist sur chaque entrée, les vitesses étant représentées par les deux premiers axes. Ce code fait ce que nous attendons, et nous pouvons voir la sortie résultante via rostopic echo /cmd_vel.

Nous avons encore un problème. Le /joy sujet peut publier à des tarifs avantageux. Si nous surveillons le rostopic hz /cmd_vel et déplacez le stick analogique en cercles, nous pouvons voir un grand nombre de messages. Non seulement cela entraîne une grande quantité de communication, mais les processus qui reçoivent ces messages doivent traiter chacun d'entre eux. Il n'est pas nécessaire de publier ces données si fréquemment, et nous ferions mieux de publier simplement à une fréquence stable de 10 Hz. Nous pouvons accomplir cela avec le code suivant.

#!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist from functools import partial def joy_callback(cmd_vel, data): # modified cmd_vel.linear.x = data.axes[1] cmd_vel.angular.z = data.axes[0] # moved pub.publish(cmd_vel) to main loop def main(): rospy.init_node('teleop') cmd_vel = Twist() # new pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) rospy.Subscriber('joy', Joy, partial(joy_callback, cmd_vel)) # modified rate = rospy.Rate(10) # new while not rospy.is_shutdown(): pub.publish(cmd_vel) # new rate.sleep() # new if __name__ == '__main__': main()

Nous avons modifié le rappel pour recevoir le mutable Twist objet et modifiez-le dans la boucle. Le sleep fonction de rospy.Rate maintient une fréquence de sortie stable.

Le code final donnera le /cmd_vel sujet obtenant des commandes de vitesse à 10 Hz, imitant la sortie du Direction du robot rqt brancher.

Exécution d'un système simulé

Simuler le monde

Notre premier objectif est de créer un environnement dans lequel nous pouvons simuler un scénario que nous voulons réaliser. Le nœud stageros dans le stage_ros package nous permet d'exécuter un robot dans une étape 2D définie via une image. Il existe toute une syntaxe, décrite dans le stage_ros paquet pour les fichiers du monde et comment les générer. C’est assez simple, mais hors de notre portée. Heureusement, le package est livré avec plusieurs mondes de démonstration. Tout d'abord, allons dans le répertoire des fichiers en exécutant:

roscd stage_ros cd world

Dans le dossier, il y a plusieurs fichiers. Lançons-en un.

rosrun stage_ros stageros willow-erratic.world

Cela a créé plusieurs sujets. La signification de chacun d'eux est également documentée avec le package. L'important est qu'il a cmd_vel.

Dans la scène affichée, il y a un carré bleu, représentant le robot que vous contrôlez. En utilisant notre code ou Direction du robot , nous pouvons contrôler ce robot. Essaye le.

Configuration de notre système via les fichiers de lancement

créons un launch dans notre package, et à l'intérieur, créez un fichier appelé teleop.launch. La structure finale du dossier devrait ressembler à ceci:

toptal_tutorial/ ├── CMakeLists.txt ├── launch │ └── teleop.launch ├── package.xml ├── scripts │ └── teleop.py └── src

Dans le teleop.launch fichier, nous définirons un ensemble de nœuds et leurs interconnexions.

robot_

Le nouveau monde se compose de quatre robots, et chacun de leurs sujets a un préfixe de robot_0/cmd_vel. Ainsi, le robot numéro 0 a une rubrique de commande de vitesse appelée robot_0. C'est pourquoi nous plaçons notre contrôle dans un espace de noms appelé roscore, pour ajuster leurs noms au nouveau formulaire. En ce sens, vous pouvez considérer les noms de rubrique comme des dossiers dans un système de fichiers.

comment obtenir votre premier client consultant

Pour exécuter les fichiers de lancement, non roscore est nécessaire. En un sens, roscore est juste un cas particulier de fichier de lancement qui ne fait rien. Si un roslaunch toptal_tutorial teleop.launch est manquant, seul le premier fichier de lancement lancé exécutera un core, tandis que le reste s'y connectera. Maintenant, nous exécutons le lancement avec:

/robot_/base_pose_ground_truth /robot_/base_scan_0 /robot_/base_scan_1 /robot_/camera_info_0 /robot_/camera_info_1 /robot_/cmd_vel /robot_/depth_0 /robot_/depth_1 /robot_/image_0 /robot_/image_1 /robot_/odom

Si tout est correct, cela se traduira par un simulateur avec 4 robots, dont l'un est contrôlé avec notre manette de jeu ou notre joystick. Ce monde a beaucoup plus sous le capot que le précédent. Chacun des quatre robots possède:

rqt

Nous remplaçons par 0, 1, 2 ou 3. Cela nous amène à notre dernier sujet.

Affichage de nos données avec rqt

Nous ne sommes pas allés trop loin dans image_0, mais c'est l'outil parfait pour afficher des données plus complexes. Vous pouvez expérimenter tous les sujets, mais nous nous concentrerons sur les image_1, depth_0, depth_1 et rqt les sujets.

Lançons Plugins > Visualization > Image View et supprimez tous les plugins ouverts. Nous allons maintenant ouvrir 4 visualiseurs d'images (robot_0) et les placer dans une formation de grille 2x2. Enfin, dans le coin supérieur gauche de chacune des vues, choisissons l'un des quatre sujets indiqués pour stage_ros/world.

Nous obtenons une vision stéréo avec perception de la profondeur, avec des caméras basse résolution. Gardez à l'esprit que nous aurions même pu obtenir ce résultat sans notre système d'entrée. Si nous exécutons simplement ceci (à partir du dossier rosrun stage_ros stageros willow-four-erratics-multisensor.world ):

/robot_0/cmd_vel

et ajoutez le Direction du robot plugin avec un sujet appelé export ROS_MASTER_URI=http://:11311/, nous aurions obtenu les mêmes résultats avec les contrôles étant des curseurs à l'écran.

Application des résultats à un système réel

Un grand nombre de matériels ont un support complet pour ROS, très souvent fourni par des volontaires tiers. De nombreuses plates-formes de robot ont des pilotes qui génèrent ces types de messages, et ROS a des nœuds qui prennent une webcam et publient un flux d'images.

Alors que le dernier résultat était une simulation de ce que nous voulons réaliser, le même peut être obtenu avec les modifications suivantes:

• Installez ROS sur l'ordinateur de bord de votre robot
• Créez un fichier de lancement pour l'ordinateur de bord qui connecte ROS à la plate-forme sous-jacente et à tous les capteurs de haut niveau tels que les caméras, les télémètres laser et autres. Les nœuds nécessaires peuvent déjà exister, ou peuvent être mis en œuvre en créant un éditeur / abonné à ROS d'un côté et un pilote pour les communications série de l'autre
• Faire exécuter le fichier de lancement au démarrage
• Sur votre ordinateur distant, ajoutez roscore à votre démarrage bash, ce qui fait que l'ordinateur distant recherche rqt sur ce nom d'hôte et ce port donnés
• Lancer gazebo et / ou tout script de surveillance et de contrôle du robot

Cela revient à exporter simplement la variable d'environnement appropriée sur le périphérique distant, et le reste se gère tout seul. L'exécution de ROS sur un cluster d'ordinateurs ne nécessite qu'une seule étape pour chaque machine.

Conclusion

Nous avons montré comment, avec très peu de codage, vous pouvez avoir un système complexe de variables que vous pouvez manipuler à votre guise. Le système simple éditeur / abonné vous permet de développer rapidement un pipeline logiciel qui traite les données dans un cluster d'ordinateurs, sans vous soucier de l'implémentation sous-jacente de certains éléments.

Alors que nous avons utilisé un simulateur simple, des simulateurs plus complexes comme

|_+_|

(également inclus dans la version de bureau complète) vous permettent de créer Mondes 3D avec physique et capteurs complexes , et peut vous donner une expérience des résultats finaux et du produit bien avant son développement.

Cette introduction était très basique, mais nous espérons que vous vous êtes intéressé davantage à travailler avec ce cadre polyvalent.