|
|
| (88 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| [[Kategorie:Projekte]] | | [[Kategorie:Projekte]] |
| <!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird.
| | |
| [[Datei:Speedy.jpg|mini|200px|Abb. 1: Speedy das Tempomessgerät]]--> | | [[Datei:Csm_ROS2_de25589e21.png|right|mini|500px|Abb.1: ROS 2<nowiki></nowiki>]] |
| | |
| | |
| '''Autor:''' [[Benutzer:Marius_Kuepper| Marius Küpper]]<br/> | | '''Autor:''' [[Benutzer:Marius_Kuepper| Marius Küpper]]<br/> |
| '''Art:''' Projektarbeit<br> | | '''Art:''' Projektarbeit<br> |
| Zeile 9: |
Zeile 11: |
|
| |
|
| == Thema == | | == Thema == |
| | | Das Unternehmen '''Hanning Elektro-Werke GmbH & Co. KG''' hat der Hochschule Hamm-Lippstadt ein Fahrerloses Transportfahrzeug '''(FTF)''', sowie eine Simulation von diesem zu Forschungszwecken zur Verfügung gestellt. Diese Projektarbeit soll als Anleitung dienen die Simulation in Betrieb zu nehmen und auf dem Weg dahin das verwendete Robot Operating System 2 '''(ROS2)''' zu vermitteln. Es wird unter anderem erklärt, wie Sie dazu eine virtuelle Maschine '''(VM)''' nutzen können, das Linux-Betriebssystem installieren, an das benötigte Repository kommen, '''ROS2''' und alle anderen benötigten Programme und Pakete installieren, die Simulation des '''FTF''' starten und sich darin zurechtfinden und arbeiten können. |
|
| |
|
| == Aufgabenstellung == | | == Aufgabenstellung == |
| Zeile 17: |
Zeile 19: |
| * Optimierung des Artikels | | * Optimierung des Artikels |
| * optional: Bereitstellung von Demoprogrammen zum einfachen Einstieg | | * optional: Bereitstellung von Demoprogrammen zum einfachen Einstieg |
| | | <br clear = all> |
| | |
| | |
| | |
| | |
| | |
| | |
| == Anforderungen an die Projektarbeit == | | == Anforderungen an die Projektarbeit == |
| * Wissenschaftliche Vorgehensweise (Projektplan, etc.), nützlicher Artikel: [[Gantt-Diagramm| Gantt Diagramm erstellen]] | | * Wissenschaftliche Vorgehensweise (Projektplan, etc.), nützlicher Artikel: [[Gantt-Diagramm| Gantt Diagramm erstellen]] |
| Zeile 31: |
Zeile 27: |
| *[[Anforderungen_an_eine_wissenschaftlich_Arbeit| Anforderungen an eine wissenschaftlich Arbeit]] | | *[[Anforderungen_an_eine_wissenschaftlich_Arbeit| Anforderungen an eine wissenschaftlich Arbeit]] |
| *[[Software_Versionsverwaltung_mit_SVN|Regeln zum Umgang mit SVN]] | | *[[Software_Versionsverwaltung_mit_SVN|Regeln zum Umgang mit SVN]] |
| | | <br clear = all> |
| == Projektplan == | | ==Projektplan== |
| Nützlicher Artikel: [[Gantt-Diagramm| Gantt Diagramm erstellen]]
| | [[Datei:MK-Projektplan_neu.png|900px|thumb|left|Abb.2: Projektplan<nowiki></nowiki>]] |
| [[Datei:Projektplan MariusKüpper.png|rahmenlos|rechts]] | | <br clear = all> |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| == Anforderungen == | | == Anforderungen == |
| === Hardwareanforderungen === | | === Hardwareanforderungen === |
| * [https://www.virtualbox.org/wiki/End-user_documentation VirtualBox]
| | '''[https://www.virtualbox.org/wiki/End-user_documentation VirtualBox]:''' |
| * [https://www.cyberbotics.com/doc/guide/system-requirements?version=develop WeBots] | | *'''Prozessor:''' aktuellere AMD- oder Intel-Prozessoren sind ausreichend. <br> |
| | *'''Arbeitsspeicher:''' 8 GB Minimum, aber je mehr, desto besser. <br> |
| | *'''Festplattenspeicherplatz:''' Für die Installation werden nur etwa 30 MB benötigt. Für das Gastbetriebssystem wird allerdings deutlich mehr Speicherplatz benötigt. Sie sollten mindestens 20-30 GB einplanen, je nachdem was Sie vorhaben zu installieren. <br> |
| | '''[https://www.cyberbotics.com/doc/guide/system-requirements?version=develop WeBots]:''' |
| | *'''Prozessor:''' Aktuellere AMD- oder Intel-Prozessoren sind ausreichend. Eine CPU mit vier Kernen wird empfohlen. <br> |
| | *'''Grafikkarte/ -chip:''' Eine NVIDIA oder AMD [https://support.esri.com/de/technical-article/000011375 OpenGL-fähige] (Minimum Version 3.3) Grafikkarte mit mindestens 512 MB Grafikspeicher ist erforderlich. <br> |
|
| |
|
| === Softwareanforderungen === | | === Softwareanforderungen === |
| * [https://www.virtualbox.org/ VirtualBox] | | * [https://www.virtualbox.org/ VirtualBox] '''(Version 6.1.36!)''' |
| * [https://docs.ros.org/ ROS2] | | * [https://docs.ros.org/ ROS2] |
| * [https://tortoisesvn.net/ TortoiseSVN] | | * [https://tortoisesvn.net/ TortoiseSVN] |
| * [https://cyberbotics.com/doc/guide/installation-procedure#installing-the-debian-package-with-the-advanced-packaging-tool-apt WeBots] | | * [https://cyberbotics.com/doc/guide/installation-procedure#installing-the-debian-package-with-the-advanced-packaging-tool-apt WeBots] |
|
| |
|
| == Installation der virtuellen Maschine VirtualBox == | | == [[Installation der virtuellen Maschine VirtualBox|Installation der virtuellen Maschine VirtualBox]] == |
| | == [[ROS2 in Ubuntu einbinden|ROS2 in Ubuntu einbinden]] == |
| | == [[SVN-Repository in Linux erstellen|SVN-Repository in Linux erstellen]] == |
| | == [[Inbetriebnahme unserer WeBots-Simulation|Inbetriebnahme unserer WeBots-Simulation]] == |
| | == [[Der Umgang mit ROS2|Der Umgang mit ROS2]] == |
| | == [[Steuerung des FTF in der Simulation|Steuerung des FTF in der Simulation]] == |
| | == [[Knoten, Nachrichten und Beziehungen|Knoten, Nachrichten und Beziehungen]] == |
| | == [[Mögliche Alternativen|Mögliche Alternativen]] == |
|
| |
|
| * 1. Download der Software
| |
| Direkter Download: [https://download.virtualbox.org/virtualbox/6.1.36/VirtualBox-6.1.36-152435-Win.exe VirtualBox-6.1.36.exe]
| |
| * 2. Nach dem Download das Setup ausführen und abschließen.
| |
| * 3. Wenn möglich, Virtualization oder SVM im BIOS aktivieren. (Befindet sich im BIOS unter den CPU-Einstellungen. Dies sorgt dafür, dass man Virtualbox später mehr Ressourcen zuweisen kann.)
| |
| * 4. Download des Betriebssystems.
| |
| Direkter Download : [https://releases.ubuntu.com/20.04/ubuntu-20.04.5-desktop-amd64.iso Ubuntu 20.04.5 LTS]
| |
| Direkter Download : [https://releases.ubuntu.com/22.04.1/ubuntu-22.04.1-desktop-amd64.iso?_ga=2.104294080.1746881759.1661265452-1939419577.1661265452 Ubuntu 22.04.1 LTS] '''(Empfohlen!)'''
| |
|
| |
|
| <gallery mode="slideshow" caption="Installationsablauf und Einrichtung von VirtualBox" style="max-width:1000px">
| | == Evaluation anderer Studierender == |
| MK-1.png|Schritt 1: Beginnen Sie die Installation von Ubuntu, indem Sie oben auf die Schaltfläche ("Neu") mit dem blauen Stern drücken.
| |
| MK-2.png|Schritt 2: Nach Eingabe des Installationspfades und dem Namen des Betriebssystems werden die Felder "Typ" und "Version" automatisch ergänzt.
| |
| MK-3.png|Schritt 3: Im nächsten Schritt entscheiden Sie, wie viel Arbeitsspeicher Sie der virtuellen Maschine zuweisen. Sie sollten den Schieber in jedem Falle im "grünen Bereich" lassen, da es sonst möglicherweise zu Leistungseinbußen Ihres Computers kommen könnte.
| |
| MK-4.png|Schritt 4: "Festplatte erzeugen" übernehmen.
| |
| MK-5.png|Schritt 5: "VDI (VirtualBox Disk Image)" übernehmen.
| |
| MK-6.png|Schritt 6: "dynamisch alloziert" übernehemen. Die virtuelle Maschine verwendet somit nur den Platz, den sie benötigt. Im nächsten Schritt wird also nur die maximale nutzbare Größe ausgewählt.
| |
| MK-7.png|Schritt 7: Hier wählen Sie den Ordner, in dem Dateien von Ubuntu gespeichert werden. Außerdem wählen Sie die Größe der virtuellen Festplatte aus. Ubuntu benötigt für die ausschließliche Verwendung von ROS2 nur sehr wenig Speicherplatz. 10 GB - 20 GB sind ausreichend.
| |
| MK-8.png|Schritt 8: Nach erfolgreichem Erstellen der virtuellen Maschine werden jetzt noch die Einstellungen dieser verändert um Ubuntu starten zu können. Dazu klicken Sie oben auf die Schaltfläche ("Ändern") mit dem orangen Zahnrad.
| |
| MK-9.png|Schritt 9: Im Pfad "Allgemein", unter dem Reiter "Erweitert" wählen Sie nun bei "Gemeinsame Zwischenablage, sowie "Drag'n'Drop" die Option "bidirektional" aus. Dadurch haben Sie die Möglichkeit zwischen Ihrer virtuellen Maschine, auf der Ubuntu läuft und Ihrem primären Betriebssystem Dateien und alle Inhalte der Zwischenablage zu teilen.
| |
| MK-10.png|Schritt 10: Gehen Sie nun auf den Pfad "Massenspeicher", klicken Sie unter "Controller: IDE" auf die blaue CD mit der Beschriftung "leer". Wählen Sie nun unter "Attribute" die blaue CD am rechten Rand des Fensters aus und klicken auf den 2. Punkt "Abbild auswählen...".
| |
| MK-11.png|Schritt 11: In dem neu geöffneten Fenster wählen Sie die zuvor heruntergeladene iso-Datei (Ubuntu-Betriebssystem) aus und klicken auf "Öffnen".
| |
| MK-12.png|Schritt 12: Nun können Sie die virtuelle Maschine zum ersten Mal starten. Dazu drücken Sie am oberen Rand des Fensters auf den grünen Pfeil "Starten".
| |
| MK-13.png|Schritt 13: Nach einer kurzen Ladezeit erscheint das Installationsinterface von Ubuntu. Wählen Sie zunächst Ihre bevorzugte Sprache aus und drücken auf "Ubuntu installieren".
| |
| MK-14.png|Schritt 14: Wählen Sie jetzt die zu Ihrer Tastatur passende Tastaturbelegung aus und führen die Installation mit einem Mausklick auf den rechten unteren Button "Weiter" fort.
| |
| MK-15.png|Schritt 15: In diesem Fenster wählen Sie die für Sie passende Einstellung aus und drücken auf "Weiter".
| |
| MK-16.png|Schritt 16: Wählen Sie in diesem Schritt unbedingt die obere Option aus! Es werden keine Daten auf Ihrer Festplatte gelöscht, da Ubuntu durch VirtualBox nur Zugriff auf die zuvor erzeugte virtuelle Festplatte hat.
| |
| MK-17.png|Schritt 17: "Weiter".
| |
| MK-18.png|Schritt 18: Wählen Sie hier Ihre zutreffende Zeitzone aus.
| |
| MK-19.png|Schritt 19: Geben Sie nun Ihre Daten und Ihr persönliches Passwort ein. Das automatisch erzeugte "-VirtualBox" bei der zweiten Leerzelle können Sie nach belieben löschen.
| |
| MK-20.png|Schritt 20: Nach Beendigung der Installation können Sie die virtuelle Maschine neu starten.
| |
| MK-21.png|Schritt 21: Drücken Sie nun Enter auf Ihrer Tastatur.
| |
| MK-22.png|Schritt 22: Geben Sie ihr zuvor vergebenes Passwort ein und drücken Sie Enter.
| |
| MK-23.png|Schritt 23: Geschafft! ...naja, fast. Wie Sie eventuell bemerkt haben, lässt sich das Fenster der virtuellen Maschine zwar vergrößern, allerdings bleibt der Desktop auf der ursprünglichen Größe. In den folgenden Schritten werden Sie dies korrigieren.
| |
| MK-24.png|Schritt 24: Öffnen Sie das Terminal. Das Terminal können Sie über die Suchfunktion in den Anwendungen öffnen, welche sich in der linken unteren Ecke des Bildschirms befinden.
| |
| MK-25.png|Schritt 25: Geben Sie nun folgenden Befehl ein und bestätigen Sie mit Enter: sudo apt install build-essential dkms linux-headers-$(uname -r)
| |
| MK-25.png|Schritt 26: Geben Sie Ihr zuvor vergebenes Passwort ein und bestätigen Sie mit Enter. Das Passwort ist bei der Eingabe nicht sichtbar!
| |
| MK-26.png|Schritt 27: Drücken Sie zur Bestätigung "J" und danach Enter.
| |
| MK-27.png|Schritt 28: Wählen Sie nun unter dem Reiter "Geräte" den Punkt "Gasterweiterungen einlegen..." aus.
| |
| MK-28.png|Schritt 29: In dem neu geöffneten Fenster klicken Sie auf "Ausführen".
| |
| MK-29.png|Schritt 30: Nach Beendigung der Installation von Guest Additions drücken Sie zum Abschluss die Enter-Taste.
| |
| MK-30.png|Schritt 31: Nun Schalten Sie die virtuelle Maschine über den Button am rechten oberen Bildschirmrand aus.
| |
| MK-31.png|Schritt 31: Wenn Sie das nächste Mal Ihre virtuelle Maschine starten sind Sie in der Lage das Fenster zu vergrößern, sowie die in Schritt 9 erklärten Funktionen zu nutzen.
| |
| </gallery>
| |
|
| |
|
| == ROS2 in Ubuntu einbinden == | | === Evaluationen === |
|
| |
|
| Die aktuelle Version von ROS2 (Humble Hawksbill), sowie der Vorgänger (Galactic Geochelone) wird über das Terminal von Ubuntu installiert. | | '''"'''Nach der Installation der richtigen Version von VirtualBox konnte ich der Anleitung gut folgen und habe besonders durch die Bilder einfach durch den Installationsprozess gefunden. Die Befehle in den grauen Kästen haben am Ende immer zum gewünschten Ziel geführt. Mir war manchmal nicht klar, welche Version von ROS ich installieren sollte, wenn man die Wahl hatte, zwischen Galactic oder Humble. Da würde ich mir eine bessere Erklärung wünschen. Im Github konnte ich mir den Roboter Epuk herunterladen und mit Hilfe der Anleitung auch steuern. Ohne einmal mit Ubuntu gearbeitet zu haben, konnte ich nach kurzer Zeit und ein bisschen Probieren eine Simulation starten und ein paar Funktionen ausprobieren.'''"''' |
| | Aykut Ersoy, studiert WING an der HSHL im 7. Semester |
|
| |
|
| > Alle Eingaben für das Terminal befinden sich als Copy&Paste in diesen grauen Feldern < | | '''"'''Im Allgemeinen eine gut und detailierte Anleitung für die Einrichtung einer virtuellen Maschine mit ROS2. Der Step by Step Guide hilft immer mit passenden Bildern, um schnell durch die Installation zu finden. Ein Nachteil der VM ist die schlechte Skalierung der Fenster und dadurch halb verdeckte „Akzeptieren“ Felder. Dieses Problem wird jedoch, sobald es möglich ist mit Hilfe der Anleitung gelöst. Die Einbindung in ROS2 klappte danach problemlos. Leider musste ich mich einer Alternative zu Webots bedienen, die sich durch das passende Grundgerüst, leicht mit kleinen Modifikationen installieren und ausführen ließ. Hier hilft es im Zweifelsfall die VM als Administrator zu starten.'''"''' |
| | Marten Eilers, studiert INFO/ MATH an der RWTH Aachen |
|
| |
|
| | === Optimierung des Artikels aufgrund der Evaluationen: === |
| | *Kompatible VirtualBox-Version besser gekennzeichnet |
| | *ROS2-Version besser gekennzeichnet |
| | *Problem mit verdeckten Fenstern erläutert |
| | *VM als Administrator ausführen hinzugefügt |
|
| |
|
| Zunächst muss die ROS2 apt Repository zum System hinzugefügt werden. Dazu autorisieren Sie Ihren GPG Schlüssel mit apt:
| | == Zusammenfassung == |
| | Im Rahmen der Projektarbeit werden alle notwendigen Anforderungen aufgezeigt und schrittweise erläutert. Die virtuelle Maschine VirtualBox, welche sich aufgrund ihrer vielen Features und Einstellmöglichkeiten sehr gut zur Benutzung eignet, wird vorgestellt und die Installation und Einrichtung gezeigt. Um die Simulation von Hanning in Betrieb zu nehmen, wird die Installation von ROS2 erklärt und vorgestellt, wie ein Workspace mit den benötigten Dateien aus SVN aufgebaut wird. Anhand der bereitgestellten Simulation von Hanning wird gezeigt, welche Möglichkeiten zur Steuerung des FTF zur Verfügung stehen. Durch die Steuerung mit SLAM wird das Thema Navigation aufgegriffen und erläutert. Zum Schluss werden Tools (RQt, RViz, roswtf) zur Anschauung von Knoten, Themen und Abhängigkeiten, sowie zum Debugging aufgezeigt und erklärt. |
|
| |
|
| sudo apt update && sudo apt install curl gnupg lsb-release
| | === Lessons Learned === |
| | *Da ich vor Beginn der Projektarbeit wenig Berührungspunkte mit Linux, Java und ROS2 hatte, war es zunächst schwierig für mich einige Inhalte zu durchdringen. Dies wiederum hat mich motiviert, mich besonders eingehend und strukturiert mit dem Thema zu befassen. Durch die intensive Auseinandersetzung konnte ich viele Dinge neu lernen und anwenden. Die Tutorials auf der [[https://docs.ros.org/ ROS2-Seite]], sowie die interaktiven Tutorials von [[https://www.theconstructsim.com/ TheConstruct]] habe ich als besonders hilfreich wahrgenommen. Für zukünftige Aufgaben im Studium, aber auch im späteren Arbeitsleben nehme ich mit, dass es für mich besonders motivierend ist, wenn ich vor komplexe Aufgaben gestellt werde. Außerdem nehme ich mit, dass es eine intensive und strukturierte Erarbeitung möglich macht, sehr komplexe Themen zu erschließen. |
| | *Die Verwendung einer VM hat sich als großer Vorteil herausgestellt, da man Abbilder des Betriebssystems erstellen kann und die Integrität der Simulation durch Veränderungen von Softwareversionen nicht gefährdet. |
| | *Der Installationsvorgang bis zum Starten der Simulation kann mit einer VM umgangen werden, indem ein Abbild einer funktionsfähigen VM erstellt und zur Verfügung gestellt wird. |
| | *Die Verwendung von Docker, um ein Systemabbild zu erstellen, hat sich als kompliziert herausgestellt, da gewisse Container auf dem Dockerhub gar nicht, oder nicht als kompatible Version vorhanden sind. |
| | *Als Neueinsteiger ins Thema ROS2 und geringen Kenntnissen in Python, sowie dem Betriebssystem Linux empfiehlt sich zunächst der Umgang mit den Grundlagen, bevor man sich an eine komplexe Simulation, wie die von Hanning, begibt. |
|
| |
|
| sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
| | === Ausblick === |
| | *Mir war es nicht möglich einen lauffähigen Docker-Container für die Simulation des FTF zu erstellen, daher könnte das Thema "Docker" vom Umfang und der Komplexität als eigenständiges Projekt bearbeitet werden, mit dem Ziel eine dauerhaft lauffähige Simulation als "Abbild" (ohne VM) für spätere Studierende zu ermöglichen. |
|
| |
|
| | == Projektunterlagen == |
| | *[https://svn.hshl.de/svn/Robotik_und_Autonome-Systeme/trunk/Projekte/FTF_Hanning/FTS/src/ Link zu dem SVN_Ordner des Projekts.] |
| | *[https://hshl.sciebo.de/s/M6TQL4AxqOP9aU1 VM Appliance] |
|
| |
|
| Danach fügen Sie die Repository zur Liste Ihrer sources:
| | == Weblinks == |
| | | <div class="toccolours mw-collapsible mw-collapsed"> |
| echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
| | '''Verwendete Software''' |
| | | <div class="mw-collapsible-content"> |
| | | *https://www.virtualbox.org/ |
| Updaten Sie den Cache Ihrer apt Repository:
| | *https://docs.ros.org/ |
| | | *https://tortoisesvn.net/ |
| sudo apt update
| | *https://cyberbotics.com/doc/guide/installation-procedure#installing-the-debian-package-with-the-advanced-packaging-tool-apt |
| | | *https://ubuntu.com/ |
| | | *https://rapidsvn.org/ |
| Zur Sicherheit überprüfen wir noch, ob Ubuntu auf dem neusten Stand ist:
| | *https://code.visualstudio.com/</div> |
| | | </div> |
| sudo apt upgrade
| |
| | |
| | |
| '''Im Fall von Ubuntu 22.04:'''
| |
| | |
| Installation der Vollversion von '''ROS2 Humble für Desktop-PCs''': <code>sudo apt install ros-humble-desktop</code> '''ODER:''' Installation der Basis-Version von '''ROS2 Humble für Raspberrys etc.''': <code>sudo apt install ros-humble-ros-base</code>
| |
| | |
|
| |
|
| '''Im Fall von Ubuntu 20.04:''' | | <div class="toccolours mw-collapsible mw-collapsed"> |
| | '''ROS2''' |
| | <div class="mw-collapsible-content"> |
| | *https://docs.ros.org/en/foxy/index.html |
| | *https://docs.ros.org/en/galactic/index.html |
| | *https://docs.ros.org/en/humble/index.html |
| | *https://www.theconstructsim.com/ |
| | *http://wiki.ros.org/ROS/Tutorials/InstallingandConfiguringROSEnvironment</div> |
| | </div> |
|
| |
|
| Installation der Vollversion von '''ROS2 Galactic für Desktop-PCs''': <code>sudo apt install ros-galactic-desktop</code> '''ODER:''' Installation der Basis-Version von '''ROS2 Galactic für Raspberrys etc.''': <code>sudo apt install ros-galactic-ros-base</code>
| | <div class="toccolours mw-collapsible mw-collapsed"> |
| | '''SVN''' |
| | <div class="mw-collapsible-content"> |
| | *https://rapidsvn.org/ |
| | *https://tortoisesvn.net/</div> |
| | </div> |
|
| |
|
| | <div class="toccolours mw-collapsible mw-collapsed"> |
| | '''WeBots''' |
| | <div class="mw-collapsible-content"> |
| | *https://cyberbotics.com/doc/reference/webots-world-files |
| | *https://docs.ros.org/en/foxy/Tutorials/Advanced/Simulators/Webots.html |
| | *https://cyberbotics.com/doc/guide/tutorials</div> |
| | </div> |
|
| |
|
| Nach der abgeschlossenen Installation muss nun das Environment eingerichtet werden, damit die ROS2-Befehle im Terminal auch verwendet werden können. Wir erweitern dazu die Befehlsliste des Terminals, um somit nicht jedes mal den selben Befehl eingeben zu müssen, wenn wir das Terminal öffnen. Geben Sie den folgenden Befehl ins Terminal ein um die .bashrc zu öffnen:
| | <div class="toccolours mw-collapsible mw-collapsed"> |
| | '''Der Umgang mit ROS2''' |
| | <div class="mw-collapsible-content"> |
| | *https://code.visualstudio.com/ |
| | *http://wiki.ros.org/catkin/package.xml |
| | *https://roboticscasual.com/tutorial-ros2-launch-files-all-you-need-to-know/ |
| | *https://docs.ros.org/en/foxy/Tutorials/Intermediate/Launch/Creating-Launch-Files.html</div> |
| | </div> |
|
| |
|
| gedit ~/.bashrc
| | <div class="toccolours mw-collapsible mw-collapsed"> |
| | '''Steuerung des FTF in der Simulation''' |
| | <div class="mw-collapsible-content"> |
| | *https://github.com/ros-teleop/teleop_twist_keyboard</div> |
| | </div> |
|
| |
|
| | | <div class="toccolours mw-collapsible mw-collapsed"> |
| Nun fügen Sie unter die letzte Zeile des Dokuments zwei neue Zeilen ein und geben in die letzte Zeile (Z.119) folgenden Befehl ein:
| | '''Knoten, Nachrichten und Beziehungen''' |
| | | <div class="mw-collapsible-content"> |
| | | *https://en.wikipedia.org/wiki/Monte_Carlo_localization |
| '''Im Fall von Ubuntu 22.04 (Humble):'''
| | *http://wiki.ros.org/rviz |
| source /opt/ros/humble/setup.bash
| |
| | |
| '''Im Fall von Ubuntu 20.04 (Galactic):'''
| |
| source /opt/ros/galactic/setup.bash
| |
| | |
| [[Datei:Bashrc.png|mini|links|alternativtext=bashrc]]
| |
| | |
| == SVN-Repository in Linux erstellen ==
| |
| | |
| Um die Befehle für die Erstellung einer SVN-Repository zu nutzen muss zunächst das entsprechende Paket installiert werden:
| |
| | |
| sudo apt install subversion
| |
| | |
| Mit der Einagbe <code>svn help checkout</code> kann man sich nun eine Hilfestellung anzeigen lassen, wie man sich eine Kopie der Repository auf Ubuntu lädt.
| |
| | |
| Zunächst sollten Sie sich einen Ordner anlegen, in den die Repository abgelegt wird.
| |
| In diesem Fall wird der Ordner im persönlichen Benutzerordner erstellt.
| |
| | |
| cd
| |
| | |
| mkdir svn
| |
| | |
| Nach anlegen des Ordners "svn" kann nach folgendem Schema die Repository in den zuvor erstellten Ordner abgelegt werden: <code>svn checkout [SVN Checkout URL] [Dateipfad]</code>
| |
| | |
| | |
| '''Beispiel:'''
| |
| svn checkout https://svn-test.hshl.de/svn/Robotik_und_Autonome-Systeme/ /home/hshl/svn
| |
| | |
| == Inbetriebnahme unserer WeBots-Simulation==
| |
| | |
| Installation der benötigten Pakete, Environments und Repositorys:
| |
| | |
| sudo apt install python3-serial
| |
| | |
| sudo apt install python3-colcon-common-extensions
| |
| | |
| sudo apt install ros-${ROS_DISTRO}-navigation2 ros-${ROS_DISTRO}-nav2-bringup '~ros-${ROS_DISTRO}-turtlebot3-.*' ros-${ROS_DISTRO}-laser-geometry ros-${ROS_DISTRO}-webots-ros2
| |
| | |
| wget -qO- https://cyberbotics.com/Cyberbotics.asc | sudo apt-key add -
| |
| | |
| sudo apt-add-repository 'deb https://cyberbotics.com/debian/ binary-amd64/'
| |
| | |
| sudo apt-get update
| |
| | |
| sudo apt-get install webots
| |
| | |
| | |
| Navigieren Sie jetzt ins "FTS" (FTS = Fahrerloses Transportsystem) Verzeichnis.
| |
| | |
| '''Beispiel:''' <code>cd svn/trunk/Projekte/FTS</code>
| |
| | |
| | |
| Durch '''colcon build''' werden die benötigten Daten komprimiert und der Workspace "vernetzt".
| |
| colcon build --packages-select hewagv_simulation openslam_gmapping slam_gmapping
| |
| Eventuell muss die Eingabe wiederholt werden, wenn es zu einer Fehlermedlung kommt.
| |
| Beim zweiten '''colcon build''' sollte der Prozess dann erfolgreich verlaufen.
| |
| | |
| | |
| Als letzten Schritt vor dem Start der Simulation muss nur noch das Environment gesourcet werden.
| |
| source install/local_setup.bash
| |
| | |
| '''Simulation starten:'''
| |
| ros2 launch hewagv_simulation full_system_launch.py
| |
| | |
| | |
| Mit '''Strg + C''' kann die Simulation im Terminal beendet werden.
| |
| | |
| == Der Umgang mit ROS2 ==
| |
| === Workspace erstellen ===
| |
| Um mit ROS2 ein Projekt zu bearbeiten, muss als Erstes ein workspace erstellt werden. Dazu liefert ROS2 einige praktische Befehle um die Erstellung zu vereinfachen. Ein workspace ist ein Verzeichnis mit Unterordnern. In dem Verzeichnis werden die Pakete (package) erstellt.
| |
| | |
| '''1.'''
| |
| Zunächst muss wieder das Environment gesourcet werden.
| |
| | |
| Im Fall von Ubuntu 22.04 (Humble):
| |
| <code>source /opt/ros/humble/setup.bash</code>
| |
| | |
| Im Fall von Ubuntu 20.04 (Galactic):
| |
| <code>source /opt/ros/galactic/setup.bash</code>
| |
| | |
| '''2.'''
| |
| Erstellen Sie nun das Verzeichnis vom workspace.
| |
| <code>mkdir -p ~/ros2_ws/src</code> In diesem Fall heißt das Verzeichnis "ros2_ws". Außerdem wurde in dem Verzeichnis der Unterordner "src" erstellt. Dieser dient später der Übersichtlichkeit, da die Pakete in "src" abgelegt werden und mehrere Pakete im workspace vorliegen können.
| |
| | |
| '''3.'''
| |
| Navigieren Sie ins src-Verzeichnis.
| |
| <code>cd ~/ros2_ws/src</code>
| |
| | |
| '''4.''' | |
| Erstellen Sie das erste Paket im workspace.
| |
| <code>ros2 pkg create --build-type ament_python (Paketname)</code>
| |
| Wählen Sie einen (Paketnamen) für sich aus.
| |
| | |
| Beispiel: <code>ros2 pkg create --build-type ament_python mein_paket</code>
| |
| | |
| Das Terminal sollte nun folgendes ausgeben:
| |
| [Bild]
| |
| Sollten Sie bei der Bearbeitung ihrer Pakete C++ bevorzugen, können Sie den Befehl <code>ros2 pkg create --build-type ament_cmake (Paketname)</code> verwenden.
| |
| Das Paket enthält alle zunächst benötigten Verzeichnisse und Dateien.
| |
| | |
| === Die erste Anwendung ausführen ===
| |
| '''1.'''
| |
| Wenn Sie den Befehl mit dem Zusatz "--node-name (Node-Name)" verwenden, erstellen Sie außerdem noch eine einfache Anwendung, welche "Hello Word" ins Terminal ausgibt.
| |
| <code>ros2 pkg create --build-type ament_python --node-name mein_node mein_paket</code><br>
| |
| | |
| '''2.'''
| |
| Verwenden Sie "colcon build" im Verzeichnis "ros2_ws" um die Anwendung zu komprimieren.
| |
| <code>cd</code>
| |
| <code>cd ros2_ws</code>
| |
| <code>colcon build</code><br>
| |
| | |
| (Falls der workspace viele Pakete enthällt ist es sinvoll nur die benötigten Pakte mit "colcon build" zu generieren: <code>colcon build --packages-select mein_paket</code> Andernfalls kann es zu längeren Wartezeiten führen.)<br>
| |
| | |
| '''3.'''
| |
| Anwendung und ROS2-Installation im Verzeichnis "ros2_ws" verknüpfen.
| |
| <code>source install/local_setup.bash</code><br>
| |
| | |
| '''4.'''
| |
| Anwendung ausführen.
| |
| <code>ros2 run mein_paket mein_node</code><br>
| |
| | |
| === Workspace bearbeiten ===
| |
| [[Datei:MK-VSC.png|right|mini|300px|Abb.: Visual Studio Code<nowiki></nowiki>]]
| |
| '''Visual Studio Code'''
| |
| | |
| Zum Bearbeiten der unterschiedlichen Dateien und Dateiformate empfiehlt sich Vidual Studio Code. Zudem erleichtert der integrierte Datei-Explorer das Navigieren in den Verzeichnissen des workspace's.
| |
| Installation: <code>sudo apt install code</code><br>
| |
| | |
| Visual Studio Code starten: <code>code</code><br>
| |
| | |
| Workspace in Visual Studio Code öffnen:
| |
| <br clear = all>
| |
| [[Datei:MK-packagexml.png|right|mini|300px|Abb.: package.xml<nowiki></nowiki>]]
| |
| | |
| '''package.xml'''<br>
| |
| | |
| Das Dokument ist eine XML-Datei, die zur Beschreibung eines ROS-Pakets verwendet wird. Sie gibt den Namen, die Version und die Abhängigkeiten des Pakets sowie die Dateien an, die in dem Paket enthalten sind. Kann mit Visual Studio Code bearbeitet werden.<br>
| |
| <br clear = all>
| |
| [[Datei:MK-setuppy.png|right|mini|300px|Abb.: setup.py<nowiki></nowiki>]]
| |
| '''setup.py'''<br>
| |
| | |
| Die Datei setup.py ist ein Skript, das zur Installation von Python-Paketen verwendet wird. Es wird in der Regel mit dem Paketmanager pip verwendet, um Pakete aus dem Python Package Index (PyPI) oder aus einem lokalen Quellcodeverzeichnis zu installieren.
| |
| <br clear = all>
| |
| [[Datei:MK-launchpy.png|right|mini|300px|Abb.: launch.py<nowiki></nowiki>]]
| |
| | |
| '''launch.py'''<br>
| |
| | |
| Die Datei launch.py ist ein Python-Skript, das zum Starten einer ROS2-Node oder einer Gruppe von Nodes verwendet wird. Es ist Teil des Launch-Frameworks, einem Werkzeug zur Organisation und Verwaltung des Starts mehrerer ROS2-Nodes und wird nicht beim Erstellen eines workspaces generiert. Die Funktion "generate_launch_description()" ist der Haupteinstiegspunkt in der Datei launch.py. Sie gibt eine LaunchDescription-Funktion zurück, welche eine Liste von Funktionen ist, die die Nodes und andere Ressourcen definieren, die gestartet werden sollen.
| |
| | |
| Die LaunchDescription kann auch andere Arten von Funktionen enthalten, wie "IncludeLaunchDescription" und "ExecuteProcess", die es ermöglichen, den Inhalt anderer launch.py-Dateien einzuschließen oder externe Prozesse zu starten.
| |
| | |
| <br clear = all>
| |
| | |
| [[Datei:MK-world.png|right|mini|300px|Abb.: world.wbt<nowiki></nowiki>]]
| |
| '''world.wbt'''<br>
| |
| | |
| Die world-Datei definiert das Layout der Simulationsumgebung in Webots. Sie enthält Informationen über die Objekte, Materialien und Eigenschaften in der Umgebung sowie die Startposition und Ausrichtung des Roboters.
| |
| | |
| '''Geometrie:''' Die Form, Größe und Position von Objekten in der Umgebung.
| |
| '''Materialien:''' Die physikalischen Eigenschaften von Objekten, wie z. B. ihre Dichte, Reibung und Rückprallverhalten.
| |
| '''Beleuchtung:''' Die Position und Intensität von Lichtquellen in der Umgebung.
| |
| '''Roboter:''' Die Form, Größe und Ausgangsposition des Roboters.
| |
| '''Sensoren:''' Art, Position und Ausrichtung der Sensoren am Roboter, z. B. Kameras und Laser.
| |
| '''Aktuatoren:''' Typ, Position und Ausrichtung der Aktoren am Roboter, z. B. Räder oder Gelenke.
| |
| | |
| Das spezifische Format und die Syntax einer Weltdatei hängen von der verwendeten Physik-Engine ab. Webots verwendet ".wbt", ein proprietäres XML-basiertes Format für seine Welt-Dateien.
| |
| | |
| <br clear = all>
| |
| | |
| == Steuerung des FTF in der Simulation ==
| |
| === Grundlagen ===
| |
| Zur Steuerung eines Roboters in WeBots wird generell das Paket '''"geometry_msgs"''' verwendet. Das '''"geometry_msgs"'''-Paket ist ein ROS-Paket, das eine Reihe von ROS-Nachrichten für geometrische Datentypen, wie Punkte, Vektoren und Posen, definiert. Es ist Teil des Pakets '''"std_msgs"''', das eine Reihe allgemeiner Nachrichtentypen bereitstellt, die in ROS häufig verwendet werden. Jeder dieser Nachrichtentypen hat eine entsprechende Python-Klasse, die im Modul '''"geometry_msgs.msg"''' definiert ist. Zum Beispiel hat die Nachricht "Twist" eine entsprechende Klasse "Twist" und die Nachricht "Pose" eine entsprechende Klasse "Pose". Um einen mobilen Roboter zu steuern, wird der ROS-Nachrichtentyp '''"geometry_msgs/Twist"''', der im '''"geometry_msgs"'''-Paket definiert ist, verwendet. Diese repräsentiert eine 3D-Geschwindigkeitstorsion im linearen und winkeligen Bereich.
| |
| | |
| Die '''"geometry_msgs/Twist"'''-Nachricht hat die folgenden Aufgaben: <br>
| |
| | |
| '''- linear:''' Ein 3D-Vektor, der die lineare Geschwindigkeit des Roboters im Raum darstellt. <br>
| |
| | |
| '''- angular:''' Ein 3D-Vektor, der die Winkelgeschwindigkeit des Roboters im Raum darstellt.
| |
| | |
| | |
| | |
| === Steuerung per Terminal ===
| |
|
| |
| Mit dem Terminal und der "ros2 pub"-Funktion ist es möglich Nachrichten in einem Ros2-Topic zu veröffentlichen. Dazu muss der Name des Topics, in dem veröffentlicht werden soll, verwendet werden und der Nachrichtentyp des Topics angegeben werden.
| |
| Um den FTF nun mit einer Geschwindigkeit von 0,1 m/s in X-Richtung zu bewegen verwenden wir folgenden Befehl im Terminal während die Simulation läuft: <code>ros2 topic pub /cmd_vel geometry_msgs/Twist "linear: { x: 0.1 }"</code> .
| |
| Die Vorwärtsfahrt kann mit der Tastenkombination "Strg-C" beendet werden. Um den Roboter im Kreis fahren zu lassen kann der vorherige Befehl mit dem "angular"-Befehl kombiniert werden.
| |
| <br>
| |
| | |
| | |
| === Steuerung mit einem Python-Skript ===
| |
| | |
| "rclpy" ist eine Python-Client-Bibliothek für das Robot Operating System. Sie ermöglicht es Ihnen, ROS 2-Programme in Python zu schreiben, indem sie eine Reihe von Python-Bindings für die ROS 2-APIs bereitstellt.Außerdem können Sie ROS 2-Knoten erstellen, Themen veröffentlichen und abonnieren, Dienste aufrufen und ankündigen und auf den ROS 2-Parameter-Server zuzugreifen. rclpy bietet außerdem eine Reihe weiterer Funktionen, wie z. B. Unterstützung für Timer, Callbacks und Spinner, die das Schreiben von ROS 2-Programmen in Python erleichtern.<br>
| |
| | |
| '''Aufgabe:''' Schreiben Sie ein Python-Skript, welches den FTF mit einer Geschwindigkeit von 0,5 m/s und einer Winkelgeschwindigkeit von 1 rad/s im Uhrzeigersinn fahren lässt. Die Publishing-Rate kann auf 10 Herz gestellt werden.
| |
| <br>
| |
| <br>
| |
| | |
| === Steuerung per Tastatur und dem "teleop_twist_keyboard"-Paket ===
| |
| | |
| '''Installation des Paketes''' <br>
| |
| | |
| Navigieren Sie im Terminal in den src-Ordner und führen folgenden Befehl aus: <code>sudo apt-get install ros-teleop-twist-keyboard</code> <br>
| |
| | |
| | |
| '''Ausführen''' <br>
| |
| | |
| Navigieren Sie im Terminal in den src-Ordner und führen folgenden Befehl aus: <code>ros2 run teleop_twist_keyboard teleop_twist_keyboard</code> <br>
| |
| Beachten Sie, dass das Paket in einem anderem Terminal gestartet werden muss, als die WeBots.Simulation.
| |
| | |
| | |
| '''Steuerung''' <br>
| |
| | |
| Die Steuerung sollte im Terminal angezeigt werden. Das Programm lässt sich durch die Tastenkombination "Strg-C" beendet werden. <br>
| |
| | |
| | |
| | |
| === Steuerung durch SLAM ===
| |
| | |
| Simultane Lokalisierung und Kartierung (SLAM) ist eine Technik, die von Robotern verwendet wird, um eine Karte ihrer Umgebung zu erstellen und gleichzeitig ihren eigenen Standort innerhalb der Karte zu bestimmen. Dies ermöglicht dem Roboter die Navigation und Erkundung unbekannter Umgebungen, ohne dass externe Lokalisierungssysteme wie GPS erforderlich sind. <br>
| |
| | |
| Das '''"gmapping"'''-Paket ist ein beliebter SLAM-Algorithmus, der Laserentfernungsmesserdaten verwendet, um eine 2D-Belegungsgitterkarte der Umgebung zu erstellen. Er basiert auf dem Monte-Carlo-Lokalisierungsalgorithmus und verwendet einen Partikelfilter, um die Haltung des Roboters (d. h. seine Position und Ausrichtung) auf der Karte zu verfolgen. <br>
| |
| | |
| '''Funktionsweise:''' <br>
| |
| | |
| '''1.''' Der Roboter erzeugt mit einem Laserentfernungssensor die Messdaten.
| |
| | |
| '''2.''' Die Messdaten werden an den gmapping-Knoten weitergeleitet, der die Daten verarbeitet, um eine 2D-Gitterkarte der Umgebung zu erstellen. Die Gitterkarte ist ein 2D-Gitter aus Zellen, von denen jede die Wahrscheinlichkeit darstellt, dass die Zelle von einem Hindernis besetzt ist.
| |
| | |
| '''3.''' Der Knoten "gmapping" verwendet die Laserscandaten, um die Position des Roboters in der Karte zu aktualisieren. Dazu werden Stichproben aus einer Reihe möglicher Posen (d. h. Partikel) gezogen und anhand der Laserscandaten die Wahrscheinlichkeit für jedes Partikel berechnet. Die Partikel mit der höchsten Wahrscheinlichkeit werden dann neu abgetastet, um einen neuen Satz von Partikeln zu erzeugen, die zur Aktualisierung der Schätzung der Roboterposition verwendet werden.
| |
| | |
| '''4.''' Der "gmapping"-Knoten veröffentlicht die aktualisierte Karte und die Posenschätzung in ROS, die mit Tools wie "rviz" visualisiert oder von anderen Knoten für die Navigation oder Lokalisierung verwendet werden können.
| |
| | |
| '''5.''' Der Prozess wird wiederholt, während sich der Roboter durch die Umgebung bewegt und die Karte und die Pose-Schätzung auf der Grundlage neuer Laserscan-Daten aktualisiert werden.
| |
| | |
| Um das FTF in der Simulation zu steuern wird die "Nav2 Goal"-Funktion in RViz verwendet. RViz wird beim Starten der Simulation automatisch geöffnet und visualisiert den Roboter, Punktwolken und andere Daten.
| |
| | |
| == Knoten, Nachrichten und Beziehungen ==
| |
| === rqt_Graph ===
| |
| [[Datei:MK-rqt.png|left|mini|300px|Abb.: rqt_graph<nowiki></nowiki>]]
| |
| Der rqt_graph ist ein Dienstprogramm, das vom rqt-Paket im Robot Operating System bereitgestellt wird. Es ermöglicht Ihnen die Visualisierung des ROS 2-Netzwerkgraphen, der die Knoten und Themen in einem ROS2-System und ihre Verbindung zueinander zeigt.
| |
| Die Schaltfläche "Aktualisieren" muss jedes Mal genutzt werden, wenn andere Nodes gestartet wurden. Ansonsten werden auch nicht mehr die aktuellen Daten angezeigt.
| |
| Die Filteroptionen: Dies sind die drei Kästchen direkt neben der Schaltfläche "Aktualisieren". Mit dem ersten Element können Sie nur zwischen Knoten oder Themen wählen. Mit dem zweiten Feld können Sie nach den Namen der Knoten filtern.
| |
| <br clear = all> | |
| | |
| === RViz ===
| |
| [[Datei:MK-rviz.png|left|mini|300px|Abb.: RViz<nowiki></nowiki>]]
| |
| RViz (kurz für "ROS Visualization") ist ein 3D-Visualisierungsprogramm, mit dem Sie den Zustand verschiedener ROS-Elemente anzeigen können, einschließlich 3D-Visualisierungen von Robotern, Punktwolken und anderen Daten. Sie können RViz verwenden, um Ihren Roboter zu debuggen, indem Sie sein Verhalten und die Daten, die er von den Sensoren empfängt, visualisieren, sowie um die Ergebnisse Ihres Codes zu visualisieren.
| |
| Um RViz zu verwenden, müssen Sie zunächst ROS auf Ihrem System installieren. Dann können Sie RViz von der Kommandozeile aus starten, indem Sie den Befehl <code>rviz</code> ausführen. Dadurch wird das RViz-Fenster geöffnet, das aus einer 3D-Ansicht Ihres Roboters und einer Seitenleiste mit einer Liste der verfügbaren Anzeigetypen besteht.
| |
| Sie können dann verschiedene Anzeigetypen zum RViz-Fenster hinzufügen, indem Sie auf die Schaltfläche "Hinzufügen" in der Seitenleiste klicken und den gewünschten Anzeigetyp auswählen. Sie können zum Beispiel eine "RobotModel"-Anzeige hinzufügen, um das 3D-Modell Ihres Roboters zu visualisieren, oder eine "PointCloud2"-Anzeige, um eine Punktwolke zu visualisieren.
| |
| Sobald Sie die gewünschten Anzeigen hinzugefügt haben, können Sie die verschiedenen Steuerelemente im RViz-Fenster verwenden, um die Ansicht zu bearbeiten und die Daten zu untersuchen. Sie können beispielsweise die 3D-Ansicht schwenken und zoomen, um einen besseren Blick auf den Roboter zu erhalten, oder die Farbe und Größe der Punkte in einer Punktwolkenanzeige anpassen.
| |
| <br clear = all>
| |
| | |
| === Debugging ===
| |
| *'''rqt_console'''
| |
| [[Datei:MK-rqt_console.png|right|mini|300px|Abb.: rqt_console<nowiki></nowiki>]]
| |
| '''Installation:'''<code><code>sudo apt install ros-foxy-rqt*</code></code>
| |
| '''Ausführen:''' <code>ros2 run rqt_console rqt_console</code>
| |
| | |
| Das Fenster rqt_console ist in drei Teilfenster unterteilt:
| |
| | |
| Der erste Bereich gibt die Protokolle aus. Es enthält Daten über die Nachricht, den Schweregrad, den Knoten selbst und andere Informationen. Hier werden Sie die Daten aus den Protokollen extrahieren.
| |
| | |
| Das zweite Feld ermöglicht es Ihnen, die im ersten Feld ausgegebenen Nachrichten zu filtern, indem Sie sie nach folgenden Kriterien ausschließen: Knoten, Schweregrad, oder dass sie ein bestimmtes Wort enthält. Um einen Filter hinzuzufügen, drücken Sie einfach auf das Pluszeichen und wählen den gewünschten Filter aus.
| |
| | |
| Im dritten Bereich können Sie bestimmte Nachrichten hervorheben, während die anderen angezeigt werden.
| |
| | |
| Sie sollten auch wissen, dass Sie die Anzahl der angezeigten Nachrichten ändern können, indem Sie auf das kleine weiße Zahnrad in der rechten oberen Ecke klicken. Versuchen Sie, diese so niedrig wie möglich zu halten, um Leistungseinbußen in Ihrem System zu vermeiden.
| |
| | |
| <br clear = all>
| |
| | |
| *'''roswtf'''
| |
| | |
| '''roswtf''' kann vom Terminal aus ausgeführt werden, indem Sie <code>roswtf</code> eingeben. Standardmäßig analysiert es den aktuellen Zustand des ROS-Systems und erstellt einen Bericht, der alle gefundenen potenziellen Probleme auflistet. Sie können auch zusätzliche Optionen angeben, um das Verhalten von roswtf anzupassen, z. B. den Bericht so zu filtern, dass nur bestimmte Arten von Problemen angezeigt werden, oder die Analyse auf einen bestimmten Namespace zu beschränken.
| |
| | |
| - sucht nach '''Knoten''', die nicht laufen oder die nicht richtig mit anderen Knoten kommunizieren.
| |
| | |
| - sucht nach '''Themen''', die nicht veröffentlicht oder abonniert werden, oder die nicht mit der erwarteten Rate veröffentlicht werden.
| |
| | |
| - prüft auf '''Dienste''', die nicht ordnungsgemäß angekündigt oder aufgerufen werden.
| |
| | |
| - prüft auf Inkonsistenzen im Parameterserver, z. B. auf '''Parameter''', die nicht korrekt gesetzt sind oder nicht wie erwartet verwendet werden.
| |
| | |
| == . ==
| |
| | |
| | |
| == Programmierung ==
| |
| <code></code>
| |
| | |
| == Ergebnis ==
| |
| | |
| | |
| == Zusammenfassung ==
| |
| | |
| | |
| | |
| === Lessons Learned ===
| |
| | |
| | |
| | |
| == Projektunterlagen ==
| |
| [https://svn-test.hshl.de/svn/Robotik_und_Autonome-Systeme/trunk/Projekte/FTF_Hanning/FTS/ Link zu dem SVN_Ordner des Projekts.]
| |
| [https://hshl.sciebo.de/s/Odi0kxe7UoDZlSu VM Appliance]
| |
| | |
| == YouTube Video ==
| |
| Das Video von diesem Projekt finden Sie auf Youtube unter dem Link:
| |
| | |
| == Weblinks ==
| |
| *https://docs.ros.org/en/foxy/Concepts/About-RQt.html | | *https://docs.ros.org/en/foxy/Concepts/About-RQt.html |
| * | | *http://wiki.ros.org/roswtf |
| | | *http://wiki.ros.org/roswtf/Plugins |
| == Literatur ==
| | *https://pypi.org/ |
| | | *https://pypi.org/project/pip/</div> |
| | </div> |
|
| |
|
|
| |
|
| ---- | | ---- |
| → zurück zum Hauptartikel: [[Studentische_Arbeiten|Studentische Arbeiten]] | | → zurück zum Hauptartikel: [[Studentische_Arbeiten|Studentische Arbeiten]] |
