Eine Einführung in das Roboterbetriebssystem: Das ultimative Framework für Roboteranwendungen

Das Robot Operating System (ROS) ist kein eigentliches Betriebssystem, sondern ein Framework und eine Reihe von Tools, die die Funktionalität eines Betriebssystems auf einem heterogenen Computercluster bereitstellen. Seine Nützlichkeit ist nicht auf Roboter beschränkt, aber die Mehrheit der bereitgestellten Tools konzentriert sich auf die Arbeit mit peripherer Hardware.

ROS ist in mehr als 2000 Pakete aufgeteilt, wobei jedes Paket spezielle Funktionen bereitstellt. Die Anzahl der mit dem Framework verbundenen Tools ist wahrscheinlich seine größte Stärke.

Warum sollte ich Robot OS verwenden?

ROS bietet Funktionen für Hardwareabstraktion, Gerätetreiber, Kommunikation zwischen Prozessen über mehrere Maschinen, Tools zum Testen und Visualisieren und vieles mehr.

Das Hauptmerkmal von ROS ist die Art und Weise, wie die Software ausgeführt wird und wie sie kommuniziert, sodass Sie komplexe Software entwerfen können, ohne zu wissen, wie bestimmte Hardware funktioniert. ROS bietet eine Möglichkeit, ein Netzwerk von Prozessen (Knoten) mit einem zentralen Hub zu verbinden. Knoten können auf mehreren Geräten ausgeführt werden und sich auf verschiedene Weise mit diesem Hub verbinden.

Die Hauptwege zum Erstellen des Netzwerks sind das Bereitstellen anforderbarer Dienste oder das Definieren von Herausgeber/Abonnenten-Verbindungen mit anderen Knoten. Beide Methoden kommunizieren über festgelegte Nachrichtentypen. Einige Typen werden von den Kernpaketen bereitgestellt, aber Nachrichtentypen können von einzelnen Paketen definiert werden.

Entwickler können ein komplexes System zusammenbauen, indem sie vorhandene Lösungen für kleine Probleme verbinden. Die Art und Weise, wie das System implementiert ist, ermöglicht uns:

• Ersetzen Sie Komponenten mit ähnlichen Schnittstellen im Handumdrehen, sodass das System nicht mehr für verschiedene Änderungen angehalten werden muss

• Multiplexing von Ausgängen mehrerer Komponenten in einen Eingang für eine andere Komponente, wodurch verschiedene Probleme parallel gelöst werden können

• Verbinden Sie Komponenten, die in verschiedenen Programmiersprachen erstellt wurden, indem Sie einfach die richtigen Konnektoren mit dem Messaging-System implementieren, und vereinfachen Sie die Entwicklung von Software, indem Sie vorhandene Module verschiedener Entwickler verbinden

• Erstellen Sie Knoten über ein Netzwerk von Geräten, ohne sich Gedanken darüber machen zu müssen, wo Code ausgeführt wird, und implementieren Sie Systeme für Interprozesskommunikation (IPC) und Remote Procedure Call (RPC).

• Stellen Sie bei Bedarf eine direkte Verbindung zu Feeds von Remote-Hardware her, ohne zusätzlichen Code schreiben zu müssen, indem Sie die beiden vorherigen Aufzählungspunkte verwenden

Wir wollen zeigen, wie nützlich das ist, indem wir iterativ eine einfache Lösung entwickeln. Es gibt einige entscheidende Vorteile gegenüber anderen Ansätzen. ROS unterstützt mehrere Plattformen und ermöglicht Verbindungen zwischen Prozessen über mehrere Geräte hinweg über Peer-to-Peer-Verbindungen, die im Hintergrund gehandhabt werden. Das Design ermöglicht die Unterstützung jeder Sprache, indem es die C++-Kommunikationsklassen umschließt oder manuell Klassen für die Sprachschnittstelle entwickelt.

ROS wird von seiner eigenen Community erstellt, die für seine Community bestimmt ist. Das hat nach einigen Jahren zu einer großen Menge wiederverwendbarer Pakete geführt, die dank der Architektur des Systems einfach zu integrieren sind.

Alternative Ansätze wie MRPT, CARMEN, LCM, Player, Microsoft RDS und andere bieten einige dieser Funktionen, aber nicht alle. Meistens sind die Designprobleme Einschränkungen der Sprachunterstützung, nicht optimierte Kommunikation zwischen Prozessen oder die fehlende Unterstützung für verschiedene Geräte, was wohl das am schwierigsten zu behebende Problem ist.

Was werden wir bauen?

Da unser Fokus auf dem Framework und nicht auf den eigentlichen Algorithmen für bestimmte Probleme liegt, wird das gegebene Problem ziemlich einfach sein. Unser Ziel ist es, Software für einen Bordcomputer zu entwickeln, mit der wir einen über Wi-Fi mit uns verbundenen Roboter fernsteuern und überwachen können, indem wir ein Gamepad auf unserem Computer und einen Feed von der am Roboter montierten Kamera verwenden.

Zunächst werden wir ein einfaches Programm mit einer einfachen Simulation verbinden, nur um die Grundprinzipien von ROS zu demonstrieren. Wir werden ein Gamepad an einen Computer anschließen und versuchen, ein gutes Steuerschema zu entwerfen, um Gamepad-Eingaben in Steuersignale für einen Roboter umzuwandeln.

Die Hauptsprachen zum Schreiben von ROS-Code sind C++ und Python, wobei C++ aufgrund der besseren Leistung bevorzugt wird. Wir werden unsere Beispiele in Python erklären, da weniger Boilerplates im Code vorhanden sind und keine explizite Erstellung erforderlich ist.

Installation und Konfiguration

ROS-Versionen werden namentlich genannt. Ab diesem Datum ist die neueste Version Jade Turtle und die neueste LTS-Version Indigo Igloo . Die LTS-Version ist vorzuziehen, und die Abwärtskompatibilität ist in ROS nicht garantiert, daher werden alle Beispiele für Indigo geschrieben.

ROS ist auf verschiedenen *NIX-Plattformen verfügbar. Die offiziell unterstützte Version ist auf Ubuntu. Die Versionen OS X, Arch Linux, Debian, Raspbian und Android werden von der Community unterstützt.

Wir werden den Installationsprozess für Ubuntu 14.04 auf dem Desktop durchlaufen. Die Prozesse für alle unterstützten Versionen und Plattformen sind auf der offiziellen Website verfügbar. Virtuelle Maschinen mit installiertem ROS sind ebenfalls verfügbar.

Die Installation ist plattformabhängig (und für die meisten Plattformen werden Pakete bereitgestellt), aber die Arbeitsbereichskonfiguration ist für alle Plattformen gleich.

Installation auf Ubuntu

ROS stellt eigene Repositories zur Verfügung. Der erste Schritt besteht darin, sie hinzuzufügen.

 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

Danach stehen Ihnen alle gehosteten Pakete für alle ROS-Versionen für Ihre Ubuntu-Version zur Verfügung. Beispielsweise unterstützt Ubuntu 14.04 indigo und jade .

Die Installation der Basispakete auf dem Desktop hat eine von drei Optionen:

• sudo apt-get install ros-indigo-ros-base für eine minimale Installation

• sudo apt-get install ros-indigo-desktop für die grundlegenden zusätzlichen GUI-Tools

• sudo apt-get install ros-indigo-desktop-full für alle offiziellen Funktionen, einschließlich verschiedener Simulatoren und Bibliotheken für Navigation und Wahrnehmung

Für die beste Arbeitserfahrung wird die vollständige Option empfohlen. Für die Installation auf Geräten, die nur zum Ausführen von Knoten verwendet werden, ist die Basisversion ausreichend. Unabhängig davon, welche Option Sie wählen, können Sie jedes benötigte Paket mit dem Namen package_name installieren, indem Sie Folgendes ausführen:

 sudo apt-get install ros-indigo-<package-name>

Unterstriche werden im endgültigen Namen durch Bindestriche ersetzt, sodass stage_ros im Paket ros-indigo-stage-ros enthalten ist.

Der nächste Schritt besteht darin, rosdep zu initialisieren. Pakete in ROS können deklarieren, von welchen Komponenten sie abhängen. rosdep können Sie diese Pakete ohne zu viel manuelle Abhängigkeitsbehandlung kompilieren. Rufen Sie zum Initialisieren auf:

 sudo rosdep init rosdep update

ROS hat mehrere Umgebungsvariablen, die von seinen Tools verwendet werden. Bei der Standardinstallation befindet sich das Bash-Skript zum Initialisieren in /opt/ros/indigo/setup.bash . Variablen müssen in jeder Bash-Sitzung initialisiert werden, daher besteht die beste Lösung darin, sie zu ~/.bashrc .

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

Einige Pakete installieren externe Abhängigkeiten über rosinstall , das als Paket verfügbar ist und über sudo apt-get install python-rosinstall .

Dies ist das Ende der Installation auf Ubuntu. Es folgt eine kurze Einführung in die Installation von Workspaces.

Aufbau

Seit Groovy Galapagos werden ROS-Workspaces über catkin verwaltet. Wir müssen ein Verzeichnis für alle Pakete definieren, die wir hosten. Innerhalb des Verzeichnisses erstellen wir einen src -Ordner und rufen darin das Formular catkin_init_workspace auf. Dadurch werden verschiedene symbolische Links zur aktuell bezogenen ROS-Version erstellt. Der nächste Schritt besteht darin, diesen Arbeitsbereich auch zu Umgebungsvariablen hinzuzufügen.

Um diese gesamte Arbeitsbereichskonfiguration durchzuführen, wählen Sie ein leeres Verzeichnis und führen Sie die folgenden Befehle aus:

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

Sie haben nun einen Arbeitsbereich erstellt, in dem Sie Ihre eigenen ROS-Pakete erstellen können.

Sich mit den Tools vertraut machen

Das Erstellen von Code ist ein großer Sprung. Machen wir uns zuerst mit einigen der Systeme vertraut, die hinter den Kulissen laufen. Unser erster Schritt besteht darin, die grundlegende GUI auszuführen und zu sehen, welche Nachrichten sie generiert.

Um irgendetwas in ROS auszuführen, muss ein Kernprozess gestartet werden. Es ist so einfach wie ein neues Terminalfenster zu öffnen und Folgendes einzugeben:

 roscore

In Ihrem gesamten verbundenen Gerätenetzwerk muss roscore nur einmal auf dem Gerät gestartet werden, das den zentralen Hub für die Kommunikationsverteilung hostet.

Die Hauptaufgabe von roscore besteht darin, den Knoten mitzuteilen, mit welchen anderen Knoten sie sich verbinden sollen und auf welche Weise (ob über einen Netzwerkport oder einen gemeinsam genutzten Speicher). Das Ziel besteht darin, den Knoten zu ermöglichen, sich nur darum zu kümmern, welche Daten sie wissen möchten, und nicht, mit welchem ​​Knoten sie sich verbinden möchten, und gleichzeitig die Zeit und Bandbreite zu minimieren, die für die Durchführung der gesamten Kommunikation erforderlich sind.

rechts

Nach dem Ausführen von roscore können wir das Haupt-GUI-Tool für ROS starten: rqt . Was wir sehen, ist sehr enttäuschend – ein leeres Fenster. rqt hostet eine Vielzahl von Plugins, die in jeder visuellen Konfiguration und einer beliebigen Anzahl vordefinierter Ansichten konfiguriert werden können.

Lassen Sie uns zunächst das Robot Steering -Plugin ausführen, indem Sie es in Plugins > Robot Tools > Robot Steering auswählen. Was wir bekommen, sind zwei Schieberegler, die die Linear- und Rotationsbewegung darstellen, die unser Roboter haben soll. Oben im Plugin sehen wir ein Textfeld mit /cmd_vel darin. Wir können es beliebig umbenennen. Es stellt den Namen des Themas dar, zu dem die Steuerung veröffentlicht. Die Terminal-Tools sind der beste Ort, um zu sehen, was im Hintergrund vor sich geht.

Terminal-Tools

ROS verfügt über mehrere leistungsstarke Tools, um zu überprüfen, was im System passiert. Das erste Tool, das wir vorstellen, ist rostopic . Es ermöglicht uns, Themen zu untersuchen, die Knoten abonnieren und veröffentlichen können. Das Ausführen rostopic list ergibt:

 /cmd_vel /rosout /rosout_agg

Die beiden letztgenannten Themen laufen immer und beziehen sich auf zentrale ROS-Systeme. Das Thema /cmd_vel wird von unserer Steuerung veröffentlicht. Wenn Sie das Thema in der Steuerung umbenennen, wird es auch hier umbenannt. Jetzt interessiert uns, was in dem Thema vor sich geht. rostopic echo /cmd_vel , wird uns nichts angezeigt (es sei denn, Sie haben an den Schiebereglern herumgebastelt). Der Vorgang läuft, bis wir ihn abbrechen. Bewegen wir nun den vertikalen Schieberegler auf 20 m/s. Wenn wir uns das Echo ansehen, können wir Folgendes immer wieder wiederholen sehen:

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

Wie oft spammt es diese Nachricht? rostopic hz /cmd_vel sagt mit einer durchschnittlichen Rate von 10 Hz. Nun, wie viele solcher Themen kann ich über meine langsame Wi-Fi-Verbindung ausführen? rostopic bw /cmd_vel erkennt durchschnittlich 480 B/s.

Nun, das ist alles schön und gut, aber wir haben über Nachrichtentypen gesprochen. Diese Daten sind gut für einen Menschen, aber eine Anwendung benötigt die Rohdaten und muss den Nachrichtentyp kennen, damit sie die Daten interpretieren kann. Der Typ kann mit rostopic type /cmd_vel bestimmt werden, was uns mitteilt, dass es sich um eine geometry_msgs/Twist handelt. Alle ROS-Terminaltools, die ohne Argumente aufgerufen werden, geben eine Standard-Hilfemeldung zurück.

Das ROS-Wiki ist gut genug, um eine Websuche nach dieser Zeichenfolge zu einer Wiki-Erklärung dessen zu machen, was sie enthält und wie sie strukturiert ist. Aber darauf müssen wir uns nicht verlassen. rosmsg ist das allgemeine Werkzeug für Nachrichtentypen. rosmsg show geometry_msgs/Twist wird Folgendes zurückgegeben:

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

Die Nachricht besteht aus zwei 3D-Vektoren, die Linear- und Winkelgeschwindigkeit im 3D-Raum darstellen.

Wenn wir wissen möchten, mit welchen Themen ein Knoten verbunden ist, gibt uns rosnode info <node-name> detaillierte Daten über den Knoten. Die Tools rostopic , rosmsg und rosnode sind die Hauptwerkzeuge zur Überprüfung der rohen ROS-Funktionalität. ROS hat viel mehr GUI- und Terminal-Tools, aber diese sind für diese Einführung nicht in unserem Rahmen.

Die wichtigsten Tools zum Ausführen von ROS-Knoten sind rusrun und roslaunch . rosrun kann Knoten über rosrun <package_name> <node_name> , und roslaunch führt Knoten basierend auf Startdateien aus, mit denen wir uns ein wenig vertraut machen werden, da sie das komplexeste Element der ROS-Automatisierung sind.

Wir können alles herunterfahren, was wir ausgeführt haben, um mit der Arbeit an unserem ersten Code zu beginnen. Für zukünftige Referenzen versteht es sich von selbst, dass das Ausführen von allem, was mit ROS zu tun hat, eine aktive Instanz von roscore . Viele Probleme, auf die Sie stoßen, können gelöst werden, indem Sie das Terminalfenster schließen, in dem roscore ausgeführt wird, und ein neues öffnen, um es neu zu starten. Dadurch werden alle Abhängigkeiten aktualisiert, die neu geladen werden mussten, sowohl in bash als auch in roscore .

Erstellen von Gamepad-Teleoperation

Unser erstes Ziel ist es, die Funktionalität von Robot Steering zu imitieren, indem wir einen Knoten erstellen, der auf Gamepad-Eingaben basierende geometry_msgs/Twist -Daten in /cmd_vel veröffentlicht. Unsere erste Station ist das joy .

Das joy

Das joy -Paket bietet generische ROS-Treiber für Joysticks und Gamepads. Es ist nicht in der Standardinstallation enthalten, daher muss es installiert werden über:

 sudo apt-get install ros-indigo-joy

Nach der Installation können wir rosrun joy joy_node . Dadurch werden wir mit dem Standard-Joystick oder Gamepad verbunden. Das Ausführen rostopic list zeigt uns, dass wir ein Thema namens /joy haben. Das Anhören über rostopic echo zeigt uns Nachrichten im folgenden Format (beachten Sie, dass Sie mit dem Gamepad oder Joystick interagieren müssen, damit Nachrichten veröffentlicht werden).

 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]

Sie können Kopfzeilen vorerst ignorieren. Abgesehen davon haben wir axes und buttons , die schön erklären, was sie darstellen. Durch das Bewegen von Achsen und das Drücken von Tasten auf der Steuerung ändern sich diese Zahlen. Mit unseren Tools können wir feststellen, dass der Nachrichtentyp sensor_msgs/Joy ist und das Format:

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

Aufbau unserer Teleoperation

Der erste Schritt zum Schreiben von Code ist das Erstellen eines Pakets. Führen Sie im src Ordner des Arbeitsbereichs Folgendes aus:

 catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

Hier geben wir den Namen des Pakets an, das wir erstellen, gefolgt von Paketen, auf die wir uns verlassen möchten. Keine Sorge, Abhängigkeiten können später manuell aktualisiert werden.

Wir haben jetzt einen Ordner toptal_tutorial . Erstellen Sie innerhalb des Ordners einen scripts , der alle unsere Python-Skripte enthält.

Lassen Sie uns eine Datei namens teleop.py erstellen und darin Folgendes festlegen:

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

Wir müssen auch chmod +x teleop.py , damit das Skript lauffähig wird. Das Ausführen rosrun joy joy_node in einem Terminal und rosrun toptal_tutorial teleop.py in einem anderen führt dazu, dass die Terminalausgabe von teleop.py mit Joy-Nachrichten gefüllt wird.

Lassen Sie uns untersuchen, was der Code tut.

Zuerst importieren wir rospy, das die Bibliothek für die Interaktion mit dem ROS-Framework hostet. Jedes Paket, das Nachrichten definiert, hat ein msg -Unterpaket mit Nachrichtendefinitionen darin. Wir importieren Joy , um die Eingabe zu verarbeiten. Es besteht keine Notwendigkeit, eingebettete Nachrichtentypen (wie Header aus std_msgs.msg , die sich in der Joy -Nachricht befinden) zu importieren, es sei denn, wir möchten sie explizit erwähnen.

Unser erster Schritt ist die Initialisierung eines Knotens mit einem bestimmten Namen (in diesem Fall nennen wir ihn „teleop“). Danach erstellen wir einen Abonnenten, der das Thema „joy“ vom Typ sensor_msgs.msg.Joy und jede Nachricht durch Aufrufen der Funktion joy_callback . Rückrufe erhalten einen Parameter, die Daten aus der Nachricht. Der Zugriff auf Mitglieder der Daten ist einfach. Wenn wir den Status der ersten Achse drucken wollten, würden wir, wenn wir uns an den Nachrichtentyp erinnern, print data.axes[0] , und es wäre ein Float. Die Schleife am Ende wird wiederholt, bis ROS heruntergefahren wird.

Unser nächster Schritt wäre, irgendwie mit unseren Daten umzugehen. Wir sollten eine Twist-Nachricht erstellen, die sich je nach Eingabe ändert, und sie dann im Thema cmd_vel veröffentlichen.

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

Zuerst fügen wir die Twist -Nachricht hinzu, und wir fügen Unterstützung für das Binden von Funktionsargumenten über functools.partial . Wir erstellen einen Publisher, pub , der an cmd_vel eine Nachricht vom Typ Twist veröffentlicht. Wir binden diesen Publisher an den Callback und lassen ihn bei jeder Eingabe eine Twist-Nachricht veröffentlichen, wobei die Geschwindigkeiten durch die ersten beiden Achsen dargestellt werden. Dieser Code tut, was wir erwarten, und wir können die resultierende Ausgabe über rostopic echo /cmd_vel .

Wir haben noch ein Problem. Das /joy Thema kann zu günstigen Preisen veröffentlicht werden. Beobachten wir das rostopic hz /cmd_vel und bewegen den Analogstick im Kreis, sehen wir jede Menge Nachrichten. Das führt nicht nur zu einer großen Menge an Kommunikation, sondern die Prozesse, die diese Nachrichten erhalten, müssen jede von ihnen verarbeiten. Es besteht keine Notwendigkeit, diese Daten so häufig zu veröffentlichen, und wir sollten besser nur mit einer stabilen Rate von 10 Hz veröffentlichen. Wir können das mit dem folgenden Code erreichen.

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

Wir haben den Callback so modifiziert, dass er das veränderliche Twist -Objekt empfängt und innerhalb der Schleife modifiziert. Die sleep -Funktion von rospy.Rate behält eine stabile Ausgangsfrequenz bei.

Der endgültige Code führt dazu, dass das /cmd_vel Thema Geschwindigkeitsbefehle mit 10 Hz erhält, was die Ausgabe des Robot Steering rqt Plugins imitiert.

Ausführen eines simulierten Systems

Simulation der Welt

Unser erstes Ziel ist es, eine Umgebung zu schaffen, in der wir ein Szenario simulieren können, das wir erreichen möchten. Der Knoten stageros im Paket stage_ros ermöglicht es uns, einen Roboter innerhalb einer 2D-Bühne auszuführen, die über ein Bild definiert ist. Es gibt eine vollständige Syntax, die im Paket stage_ros für World-Dateien und deren Generierung beschrieben ist. Es ist ziemlich einfach, aber außerhalb unseres Bereichs. Glücklicherweise enthält das Paket mehrere Demowelten. Gehen wir zuerst in das Verzeichnis der Dateien, indem wir Folgendes ausführen:

 roscd stage_ros cd world

Innerhalb des Ordners befinden sich mehrere Dateien. Lass uns einen laufen lassen.

 rosrun stage_ros stageros willow-erratic.world

Dadurch entstanden mehrere Themen. Die Bedeutung von jedem von ihnen ist auch mit dem Paket dokumentiert. Der wichtige Teil ist, dass es cmd_vel hat.

Innerhalb der angezeigten Bühne befindet sich ein blaues Quadrat, das den Roboter darstellt, den Sie steuern. Indem wir entweder unseren Code oder Robot Steering verwenden, können wir diesen Roboter steuern. Versuch es.

Einrichten unseres Systems über Startdateien

Lassen Sie uns einen launch in unserem Paket erstellen und darin eine Datei namens teleop.launch . Die endgültige Ordnerstruktur sollte wie folgt aussehen:

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

In der Datei teleop.launch definieren wir eine Reihe von Knoten und deren Verbindungen.

 <launch> <arg name="world_file" default="$(find stage_ros)/world/willow-four-erratics-multisensor.world" /> <node pkg="stage_ros" type="stageros" name="simulated_world" args="$(arg world_file)"></node> <group ns="robot_0"> <node pkg="joy" type="joy_node" name="joy_input"></node> <node pkg="toptal_tutorial" type="teleop.py" name="joy_convert"></node> </group> </launch>

Die neue Welt besteht aus vier Robotern, und jedes ihrer Themen hat das Präfix robot_<n> . Der Roboter Nummer 0 hat also ein Geschwindigkeitsbefehlsthema namens robot_0/cmd_vel . Deshalb haben wir unsere Steuerung in einen Namensraum namens robot_0 , um ihre Namen an die neue Form anzupassen. In diesem Sinne können Sie sich Themennamen als Ordner in einem Dateisystem vorstellen.

Um Startdateien auszuführen, wird kein roscore benötigt. In gewissem Sinne ist roscore nur ein Sonderfall einer Startdatei, die nichts tut. Wenn ein roscore fehlt, führt nur die erste gestartete Startdatei einen Core aus, während der Rest eine Verbindung zu ihm herstellt. Jetzt führen wir den Start aus mit:

 roslaunch toptal_tutorial teleop.launch

Wenn alles stimmt, entsteht ein Simulator mit 4 Robotern, von denen einer mit unserem Gamepad oder Joystick gesteuert wird. Diese Welt hat viel mehr unter der Haube als die vorherige. Jeder der vier Roboter hat:

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

Wir ersetzen <n> durch 0, 1, 2 oder 3. Das bringt uns zu unserem letzten Thema.

Anzeigen unserer Daten mit rqt

Wir sind nicht zu tief in rqt , aber es ist das perfekte Werkzeug, um komplexere Daten anzuzeigen. Sie können mit allen Themen experimentieren, aber wir konzentrieren uns auf die Themen image_0 , image_1 , depth_0 und depth_1 .

Lassen Sie uns rqt starten und alle geöffneten Plugins entfernen. Jetzt öffnen wir 4 Bildvisualisierer ( Plugins > Visualization > Image View ) und platzieren sie in einer 2x2-Rasterformation. Schließlich wählen wir in der oberen linken Ecke jeder der Ansichten eines der vier angegebenen Themen für robot_0 aus.

Was wir bekommen, ist Stereovision mit Tiefenwahrnehmung, mit Kameras mit niedriger Auflösung. Bedenken Sie, dass wir dieses Ergebnis auch ohne unser Eingabesystem hätten erzielen können. Wenn wir dies einfach ausführen (aus dem Ordner stage_ros/world ):

 rosrun stage_ros stageros willow-four-erratics-multisensor.world

und das Robot Steering -Plug-in mit einem Thema namens /robot_0/cmd_vel , hätten wir die gleichen Ergebnisse erhalten, wenn die Steuerelemente Schieberegler auf dem Bildschirm wären.

Anwenden der Ergebnisse auf ein reales System

Viel Hardware bietet volle Unterstützung für ROS, die sehr oft von Freiwilligen Dritter bereitgestellt wird. Viele Roboterplattformen verfügen über Treiber, die diese Art von Nachrichten generieren, und ROS verfügt über Knoten, die eine Webcam aufnehmen und einen Bild-Feed veröffentlichen.

Während das letzte Ergebnis eine Simulation dessen war, was wir erreichen wollen, kann dasselbe mit den folgenden Modifikationen erreicht werden:

• Installieren Sie ROS auf dem Bordcomputer Ihres Roboters
• Erstellen Sie eine Startdatei für den Bordcomputer, der ROS mit der zugrunde liegenden Plattform und allen hochrangigen Sensoren wie Kameras, Laser-Entfernungsmessern und anderen verbindet. Die erforderlichen Knoten können bereits vorhanden sein oder implementiert werden, indem auf der einen Seite ein Herausgeber/Abonnent für ROS und auf der anderen Seite ein Treiber für die serielle Kommunikation erstellt wird
• Lassen Sie die Startdatei beim Start ausführen
• Fügen Sie auf Ihrem Remote-Computer export ROS_MASTER_URI=http://<robot_hostname>:11311/ zu Ihrem Bash-Start hinzu, sodass der Remote-Computer auf diesem angegebenen Hostnamen und Port nach roscore sucht
• Starten rqt und/oder beliebige Skripte zur Überwachung und Steuerung des Roboters

Es läuft wirklich darauf hinaus, nur die richtige Umgebungsvariable auf dem Remote-Gerät zu exportieren, und der Rest erledigt sich von selbst. Zum Ausführen von ROS auf einem Computercluster muss nur dieser eine Schritt für jede Maschine ausgeführt werden.

Fazit

Wir haben gezeigt, wie Sie mit sehr wenig Codierung ein komplexes System von Variablen haben können, die Sie nach Lust und Laune manipulieren können. Das einfache Publisher/Subscriber-System ermöglicht es Ihnen, schnell eine Software-Pipeline zu entwickeln, die Daten in einem Cluster von Computern verarbeitet, ohne sich Gedanken über die zugrunde liegende Implementierung bestimmter Elemente machen zu müssen.

Während wir einen einfachen Simulator verwendet haben, können Sie mit komplexeren Simulatoren wie gazebo (ebenfalls in der vollständigen Desktop-Version enthalten) 3D-Welten mit Physik und komplexen Sensoren erstellen und Ihnen ein Erlebnis der Endergebnisse und des Produkts vermitteln, lange bevor es entwickelt wird.

Diese Einführung war sehr einfach, aber wir hoffen, dass Ihr Interesse an der Arbeit mit diesem vielseitigen Framework geweckt wurde.