La Système d'exploitation robotique (ROS) n'est pas vraiment un système d'exploitation mais un framework et un ensemble d'outils, qui fournissent les fonctionnalités d'un système d'exploitation sur un groupe hétérogène d'ordinateurs. Son utilité ne se limite pas aux robots mais la plupart des outils fournis se concentrent sur le travail avec du matériel périphérique.

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

Pourquoi devrais-je utiliser SO Robot?

ROS fournit des fonctionnalités pour l'abstraction matérielle, les pilotes de périphériques, la communication inter-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 s'exécute et communique, vous permettant de concevoir des logiciels complexes sans savoir comment certains matériels fonctionnent. ROS fournit un moyen de connecter un réseau fédérateur de processus (nœuds). Les nœuds peuvent s'exécuter sur plusieurs appareils et se connecter à ce hub de différentes manières.

Les principaux moyens de créer un réseau sont de fournir les services requis ou de définir des connexions d'annonceur ou d'abonné avec d'autres nœuds. Les deux méthodes communiquent via des types de messages spécifiques. Certains types sont fournis par des paquets principaux, mais les types de messages peuvent être définis par des paquets individuels.

Les développeurs peuvent mettre en place un système complexe en connectant des solutions existantes à de petits problèmes. La façon dont le système est mis en œuvre nous permet de:

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

  
  
  

• Multiplexez la sortie de plusieurs composants vers une entrée pour un autre composant, permettant la 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ù un code s'exécute et implémentez les systèmes de communication entre processus (IPC) et appel de procédure à distance (RPC).

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

  
  
  

Nous prévoyons de démontrer son utilité 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 de plusieurs périphériques, via des connexions homologues gérées en arrière-plan. La conception permet la prise en charge de n'importe quel langage lors de la détermination des classes de communication C ++ ou du développement manuel de classes pour l'interface du langage.

ROS est fait par sa propre communauté. Après plusieurs années, il en résulte un grand nombre de packages réutilisables et faciles à intégrer grâce à l'architecture du système.

Approches alternatives comme MRPT , CARMEN , LCM , Joueur , Microsoft RDS et d'autres offrent certaines de ces fonctionnalités, mais pas toutes. La plupart du temps, les défauts de conception sont des limitations de la prise en charge de la langue, une mauvaise communication entre les processus ou un manque de prise en charge de divers appareils, 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 en tant que tels, pour des problèmes particuliers, le problème donné sera très simple. Notre objectif est de créer un logiciel pour un ordinateur qui fait partie du processus et nous permet de contrôler et de surveiller à distance un robot, connecté à nous via Wi-Fi, à l'aide d'une manette de jeu sur notre ordinateur et d'une transmission de la caméra montée sur le robot. .

différence entre s corporation et llc

Tout d'abord, nous allons connecter un programme simple à une simulation simple, juste pour démontrer les principes de base de ROS. Nous allons relier une manette de jeu à un ordinateur et essayer de concevoir un bon schéma de contrôle pour passer l'entrée de la manette de jeu pour contrôler les signaux d'un robot.

Les principaux langages pour écrire du code ROS sont C ++ et Python, C ++ est préféré pour les performances inférieures. Nous expliquerons nos exemples dans Python car il a moins de qualificatif dans le code et il n'est pas nécessaire de faire une construction spécifique.

Installation et configuration

Les versions ROS sont désignées par leur nom. À ce jour, la dernière version est Tortue de jade , et la version LTS est Igloo indigo . Passer d'une version à une autre est préférable et la rétrocompatibilité 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 verrons 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 dans le Page officielle . Des machines virtuelles avec ROS déjà installé sont également disponibles.

L'installation dépend de la plate-forme (et la plupart des plates-formes ont des packages groupés) mais les paramètres de l'espace de travail sont les mêmes pour toutes les plates-formes. .

Installation dans 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 l'outil GUI de base supplémentaire

• 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 serviront qu'à exécuter des nœuds, la version ase est suffisante. Mais quelle que soit l'option que vous choisissez, vous pouvez installer n'importe quel package dont vous avez besoin appelé package_name lors de l'exécution:

sudo apt-get install ros-indigo-

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

L'étape suivante consiste à démarrer rosdep. Les packages dans ROS peuvent déclarer les composants dont ils dépendent. rosdep vous permet de compiler ces paquets sans dépendre fortement de la gestion manuelle. Pour le démarrer, appelez:

sudo rosdep init rosdep update

ROS a de nombreuses variables environnementales utilisées par ses outils. Avec l'installation par défaut, le script frapper pour les démarrer, il se trouve dans /opt/ros/indigo/setup.bash. Les variables doivent être démarrées dans chaque session de frapper , la meilleure solution est donc 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 d'Ubuntu. Ce qui suit est une brève introduction à la configuration de l'espace de travail.

Réglage

Depuis Groovy Galapagos , Les espaces de travail ROS ont été 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 dossier src et nous appelons catkin_init_workspace de l'Intérieur. Cela créera plusieurs liens symboliques dans la version source actuelle de ROS. L'étape suivante consiste également à ajouter cet espace de travail aux variables d'environnement.

Pour exécuter tous ces paramètres 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.

Familiarisez-vous avec les outils

Créer n'importe quel code est un énorme bond en avant. Tout d'abord, familiarisons-nous avec certains des systèmes fonctionnant dans les coulisses. Notre première étape sera d'exécuter l'interface graphique de base et de voir quels messages elle génère.

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

roscore

Sur votre réseau d'appareils connectés, roscore il ne doit être exécuté qu'une seule fois, sur le périphérique qui hébergera le hub central pour envoyer la communication.

Le rôle principal de roscore c'est-à-dire indiquer aux nœuds auxquels les autres nœuds doivent se connecter et de quelle manière (via le port réseau ou la 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 ou la bande passante dont ils ont besoin pour effectuer toutes les communications.

comment apprendre la programmation c

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 Il 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, nous exécutons le plugin Direction du robot , en le choisissant dans Plugins > Robot Tools > Robot Steering. Ce que nous obtenons, ce sont deux curseurs, qui représentent 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 en elle. On peut lui donner un autre nom. Représente le nom de la rubrique vers laquelle la publication est dirigée. Les outils de 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, il nous permet d'inspecter les sujets auxquels les nœuds peuvent s'abonner et publier. Exécuter rostopic list donner à:

/cmd_vel /rosout /rosout_agg

Les deux derniers sujets sont toujours en cours d'exécution et sont liés aux systèmes ROS de base. Le sujet /cmd_vel est publié par nos adresses. Renommer le sujet dans les adresses le renommera ici aussi. Maintenant, nous nous intéressons à ce qui se passe dans le sujet. Exécuter rostopic echo /cmd_vel il ne nous montrera rien (sauf si vous jouez avec 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 ce message est-il spam? rostopic hz /cmd_vel il dit à une fréquence moyenne de 10 Hz. Eh bien, combien de chansons comme celle-ci puis-je exécuter sur ma connexion Wi-Fi lente? rostopic bw /cmd_vel détecte une moyenne de 480 B / s.

les modules rendent impossible pour les programmeurs de travailler en équipe.

C'est très bien, mais nous parlons de 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 afin d'interpréter les données. Le type de message peut être interprété avec rostopic type /cmd_vel, nous indiquant qu'il s'agit d'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 bon pour faire une recherche sur le Web pour ce résultat de chaîne, sur une explication Wiki de ce qu'il contient et de sa structure. Mais nous n'avons pas à lui faire confiance. rosmsg est l'outil général pour les types de messages. Exécuter rosmsg show geometry_msgs/Twist revenir:

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 vous voulez savoir à quels sujets un nœud se connecte, rosnode info Cela 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 ROS non polies. ROS a beaucoup plus de GUI et d'outils de terminal, mais ceux-ci sont hors de portée dans cette introduction.

Les principaux outils pour exécuter le nœud ROS sont rusrun et roslaunch. rosrun vous pouvez exécuter des nœuds via rosrun et roslaunch il exécute des nœuds basés sur des fichiers de lancement, avec lesquels nous deviendrons peu familiers car ils sont l'élément le plus complexe de l'automatisation ROS.

Nous pouvons arrêter tout ce que nous exécutons pour commencer à travailler sur notre premier code. Pour référence future, il sera évident que l'exécution de tout ce qui concerne ROS nécessite une instance active de roscore. La plupart des problèmes que vous rencontrez peuvent être résolus en fermant la fenêtre du terminal en exécutant roscore et ouvrez-en 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éation de la manette de téléopération

Notre premier objectif est d'imiter la fonctionnalité de Robot Steering création d'un nœud qui publie les données de geometry_msgs/Twist a /cmd_vel basé sur une entrée de manette de jeu. Notre premier arrêt est le package joy.

Le paquet joy

Le paquet joy fournit des pilotes ROS génériques pour le joystick 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. Exécuter rostopic list nous montre que nous avons un sujet appelé /joy. Écoutez via rostopic echo Il 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. En dehors de cela, nous avons axes et buttons, qui expliquent bien ce qu'ils représentent. En déplaçant le axes et poussez le boutons dans le contrôleur, cela entraînera une modification de ces nombres. En utilisant 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éation de notre téléopération

La première étape de l'écriture de code consiste à créer un package. Dans le dossier src depuis 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 dont nous prévoyons de dépendre. Ne vous inquiétez pas, les dépendances peuvent être mises à jour manuellement, plus tard.

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

Créons un fichier appelé teleop.py, et à l'intérieur, nous aurons:

#!/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 devons également définir chmod +x teleop.py ainsi le script est exécutable. Exécuter rosrun joy joy_node dans un terminal et rosrun toptal_tutorial teleop.py dans un autre, cela entraînera le remplissage de la sortie du terminal teleop.py de messages Joie .

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 sous-package msg avec 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 trouvent dans le message Joy), sauf si nous voulons les mentionner spécifiquement.

Notre première étape consiste à initialiser un nœud avec un nom spécifique (dans ce cas, nous l'appelons 'teleop'). Après cela, nous créons un abonné qui s'abonne au type de sujet 'joy' sensor_msgs.msg.Joy, et qui gère chaque message en appelant la fonction joy_callback. Les rappels reçoivent un paramètre, les données du message. L'accès aux données membres est simple. Si nous voulions imprimer l'état du premier axe , si nous nous souvenons du type de message, nous appellerions print data.axes[0], et ce serait un float. Le nœud à la fin des nœuds, jusqu'à ce que ROS s'éteigne.

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

#!/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()

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

Nous avons toujours un problème. Le sujet /joy peut afficher de grandes vitesses. Si nous surveillons le rostopic hz /cmd_vel et nous déplaçons le stick analogique en cercles, nous pouvons voir de nombreux messages. Il en résultera non seulement un grand nombre de communications, mais aussi les processus qui reçoivent ces messages doivent traiter chacun d'eux; il n'est pas nécessaire de publier autant de données si fréquemment, et en fait, il est préférable de publier à une fréquence stable de 10 Hz. Nous pouvons l'obtenir 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 modifions le callback pour recevoir l'objet mutable Twist et modifiez-le à l'intérieur de la boucle. La fonction sleep de rospy.Rate maintient une fréquence de sortie stable.

Le code final aboutira au sujet /cmd_vel obtenir des vitesses de commande de 10 Hz, imitant ainsi la sortie du plugin Direction du robot rqt

Exécution d'un système simulé

Simuler le monde

Notre premier objectif est de créer un environnement dans lequel nous pouvons simuler le scénario que nous voulons réaliser. Le nœud stageros à l'intérieur du paquet stage_ros Cela nous permettra d'exécuter un robot dans une étape 2D définie par une image. Il y a toute une synthèse décrite dans le paquet stage_ros pour les archives du monde et comment les générer. C'est assez simple mais hors de portée. Heureusement, le package est livré avec plusieurs démos mondiales. Allons d'abord au répertoire des fichiers par exécution:

roscd stage_ros cd world

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

rosrun stage_ros stageros willow-erratic.world

Différents thèmes ont été créés. La signification de chacun d'eux est également documentée avec le package. L'important est qu'il ait cmd_vel.

réalité augmentée vs réalité mixte

À l'intérieur de la scène, il y a une boîte bleue, cela représente le robot que vous contrôlez. En utilisant notre code ou Direction du robot nous pouvons contrôler ce robot. Essayez-le!

Configuration de notre système à l'aide des fichiers de lancement

Nous créons d'abord un dossier launch ou lanzamiento à l'intérieur de 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

À l'intérieur du fichier teleop.launch Nous définirons plusieurs nœuds et leurs interconnexions.

robot_

Le nouveau monde se compose de 4 robots et chacun de leurs thèmes a un préfixe appelé robot_0/cmd_vel. Ainsi, le robot numéro 0 a un thème de vitesse de commande appelé robot_0. C'est pourquoi nous mettons notre contrôle dans l'espace de noms nommé roscore et ainsi nous ajusterons leurs noms à la nouvelle forme. De cette façon, vous pouvez considérer les noms de sujets comme des dossiers dans un système de fichiers.

Vous n'avez pas besoin de roscore pour exécuter les fichiers de lancement. D'une certaine manière, roscore c'est juste un cas particulier de fichier de lancement qui ne fait rien. Si un roslaunch toptal_tutorial teleop.launch seul le premier fichier de lancement lancé exécutera un noyau, tandis que le reste s'y connectera. Maintenant, nous allons exécuter 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 en ordre, cela se traduira par un simulateur avec 4 robots, où chacun est contrôlé avec la manette de jeu ou le joystick. Ce monde a beaucoup plus de contenu que le précédent. Chacun des quatre robots possède les éléments suivants:

rqt

Nous remplaçons par 0, 1, 2 ou 3. Et avec cela, nous arrivons à notre dernier sujet.

Affichage de nos données avec rqt

Auparavant, nous ne nous sommes pas penchés sur image_0 mais c'est l'outil parfait pour visualiser des données plus complexes. Vous pouvez expérimenter tous les thèmes, mais nous nous concentrerons sur les thèmes image_1, depth_0, depth_1 et rqt.

En cours d'exécution Plugins > Visualización > Vista Imagen nous supprimons tous les plugins ouverts. Nous allons maintenant ouvrir 4 visionneuses d'images (robot_0) et les mettre dans une grille 2x2. Enfin, dans le coin supérieur gauche de chacune des vues, nous choisirons l'un des quatre thèmes établis pour stage_ros/world.

Ce que nous obtenons, c'est une vision stéréo de perception profonde avec des caméras basse résolution. Notez que nous aurions pu obtenir ce résultat sans notre système de saisie. Si nous exécutons simplement ceci (depuis le dossier rosrun stage_ros stageros willow-four-erratics-multisensor.world ):

/robot_0/cmd_vel

Et nous ajoutons le plugin Direction du robot avec un sujet appelé export ROS_MASTER_URI=http://:11311/ Nous aurions pu avoir le même résultat si les commandes étaient à l'écran.

Appliquer les résultats dans un système réel

De nombreux matériels prennent entièrement en charge ROS, souvent grâce à des tiers. De nombreuses plates-formes de robots ont des pilotes qui génèrent ces types de messages et ROS a des nœuds qui activent la webcam et publient un flux d'images.

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

• Installez ROS sur l'ordinateur de bord de votre robot
• Crée 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, la lunette laser et autres. Les nœuds nécessaires peuvent déjà exister ou peuvent être mis en œuvre en créant un éditeur / abonné pour 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 rqt lorsque vous démarrez dans Bash, l'ordinateur distant examinera cet hôte et ce port
• Démarre gazebo et / ou tout script pour surveiller et contrôler le robot

En fin de compte, seul l'environnement variable approprié doit être exporté sur le périphérique distant et tout le reste est fait par lui-même. L'exécution de ROS sur un cluster d'ordinateurs ne prend qu'une étape pour se préparer sur chaque machine.

conclusion

Nous avons montré comment, avec chaque code, aussi petit soit-il, vous pouvez avoir un système complexe de variables que vous pouvez manipuler comme vous le souhaitez. Le système simple éditeur / abonné permet le développement rapide de logiciels qui traitent les données sur un cluster d'ordinateurs, tout en vous laissant l'esprit tranquille afin que vous ne vous inquiétiez pas de la mise en œuvre sous-jacente de certains éléments.

Alors que nous utilisons un simulateur simple, d'autres simulateurs plus complexes comme

|_+_|

(qui est inclus dans la version de bureau complète) vous permettent de créer Mondes 3D avec capteurs physiques complexes Et cela vous donne une expérience des résultats finaux et du produit avant qu'il ne soit développé.

Cette introduction était un peu basique, mais on espère que vous vous sentirez plus intéressé à travailler avec ce cadre polyvalent.