|
|
| (149 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) |
| Zeile 4: |
Zeile 4: |
| '''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Schneider]]<br/> | | '''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Schneider]]<br/> |
| '''Art:''' Praxissemester<br> | | '''Art:''' Praxissemester<br> |
| '''Projektlaufzeit:''' 02.11.2021-20.02.2022 | | '''Projektlaufzeit:''' 02.11.2021 - 20.02.2022 |
|
| |
|
|
| |
|
| Zeile 12: |
Zeile 12: |
| == Einleitung == | | == Einleitung == |
|
| |
|
| Dieser Artikel beschreibt die Kommunikation von einem [https://de.wikipedia.org/wiki/Raspberry_Pi Raspberry Pi] mit dem [[Robot_Operating_System_2|Robot Operating System2 (ROS2)]]. Dazu wird erklärt, wie ein Raspberry Pi mit einem PC über SSH(Secure Shell) verbunden werden kann und wie der AlphaBot über den Raspberry Pi und ROS2 gesteuert wurde. Außerdem wird beschrieben was es für grafische Anzeige Möglichkeiten unter ROS2 gibt. | | Dieser Artikel beschreibt die Kommunikation von einem [https://de.wikipedia.org/wiki/Raspberry_Pi Raspberry Pi(RPi)] mit dem [[Robot_Operating_System_2|Robot Operating System2 (ROS2)]]. In Abb. 1 sind die Nodes master und slave zu sehen, welche auf der RPi ausgeführt werden. Über die Topics, wie cmd_vel oder die SONAR-Topics, kommunizieren die Nodes mit einander. Dazu wird erklärt, wie ein Raspberry Pi mit einem PC über [https://de.wikipedia.org/wiki/Secure_Shell Secure Shell (SSH)] verbunden werden kann und wie der AlphaBot über den RPi und ROS2 gesteuert wurde. Außerdem wird beschrieben was es für grafische Anzeige Möglichkeiten unter ROS2 gibt. |
|
| |
|
| == Übersicht == | | ==== Aufgabenstellung ==== |
| === Dokumentation === | | |
| | Das Ziel war es einen [[AlphaBot|AlphaBot]] mit ROS2 zu programmieren und fahren zu lassen, damit er Hindernisse mit Infrarotsensoren und dem Ultraschallsensor umfahren kann. |
| | |
| | ==== Projektplanung ==== |
| | |
| | [[Datei:Projektplan_JonasGerken.png|left|mini|700px|Abb 2: Projektplan]] |
|
| |
|
| Zum beginn dieses Artikels werden die verschiedenen Anforderungen an das Projekt aufgezeigt(Tabelle 1/2).
| | <br clear=all> |
|
| |
|
| ==== Funktionale Anforderungen ==== | | ==== Funktionale Anforderungen ==== |
| Zeile 23: |
Zeile 28: |
| {| class="wikitable" | | {| class="wikitable" |
| |F1 | | |F1 |
| |Der Roboter muss Hindernisse mit Infrarotsensoren erkennen können. | | |Der AlphaBot muss Hindernisse mit Infrarotsensoren erkennen können. |
| |- | | |- |
| |F2 | | |F2 |
| |Der Roboter muss Hindernisse mit einem Ultraschallsensor erkennen können. | | |Der AlphaBot muss Hindernisse mit einem Ultraschallsensor erkennen können. |
| |- | | |- |
| |F5 | | |F5 |
| Zeile 32: |
Zeile 37: |
| |- | | |- |
| |F3 | | |F3 |
| |Der Roboter muss Hindernisse umfahren können. | | |Der AlphaBot muss Hindernisse umfahren können. |
| |- | | |- |
| |F4 | | |F4 |
| Zeile 41: |
Zeile 46: |
| {| class="wikitable" | | {| class="wikitable" |
| |NF1 | | |NF1 |
| |Es muss ein Alphabot verwendet werden. | | |Es muss ein AlphaBot verwendet werden. |
| |- | | |- |
| |NF2 | | |NF2 |
| |Der Roboter soll mit [[Robot Operating System 2| ROS2]] programmiert werden. | | |Der AlphaBot muss mit ROS2 programmiert werden. |
| |- | | |- |
| |NF3 | | |NF3 |
| |Der Roboter soll mit einem [[Raspberry Pi| Raspberry Pi]] gesteuert werden. | | |Der AlphaBot soll mit einem RPi gesteuert werden. |
| |- | | |- |
| |NF4 | | |NF4 |
| |Der Roboter soll mit Python programmiert werden. | | |Der AlphaBot soll mit Python programmiert werden. |
| |- | | |- |
| |NF5 | | |NF5 |
| |Es soll die Python Bibliothek [[RPi.GPIO python Bibliothek| RPi.GPIO]] verwendet werden. | | |Es soll die Python Bibliothek [https://pypi.org/project/RPi.GPIO/ RPi.GPIO] verwendet werden. |
| |- | | |- |
| |NF6 | | |NF6 |
| |Es muss [[Raspberry Pi| Ubuntu Server 20.04 Server]] auf dem RPi verwendent werden. | | |Es muss [[Raspberry Pi| Ubuntu Server 20.04 Server]] auf dem RPi verwendent werden. |
| |-
| |
| |NF7
| |
| |Es kann [https://de.wikipedia.org/wiki/Secure_Shell Secure Shell(SSH)] zur Nutzung des Raspberry Pi's verwendet werden.
| |
| |-
| |
| |NF8
| |
| |Für eine SSH-Verbindung kann [https://de.wikipedia.org/wiki/PuTTY PuTTY] verwendet werden.
| |
| |} | | |} |
|
| |
|
| ===== Hardware ===== | | == Übersicht == |
| | === Dokumentation === |
|
| |
|
| # [[AlphaBot|AlphaBot]]
| |
| # [[Raspberry Pi|Raspberry Pi]]
| |
|
| |
|
| ===== Software =====
| |
|
| |
|
| # [[Raspberry Pi| Ubuntu Server 20.04]]
| |
| # ROS2
| |
| # [[Using the Raspberry Pi’s GPIO to control hardware components| RPi.GPIO python Bibliothek]]
| |
| # [https://de.wikipedia.org/wiki/PuTTY PuTTY]
| |
|
| |
|
| ==== Raspberry Pi über Secure Shell(SSH) mit Desktop PC verbinden ==== | | ===== verwendete Hardware ===== |
|
| |
|
| In dem hier beschriebenen Projekt wurde [https://de.wikipedia.org/wiki/Secure_Shell Secure Shell(SSH)] zur Verwendung des RPi's verwendet.
| | # AlphaBot |
| Dies ermöglicht die Nutzung des RPi's und Ubuntu Desktop auf einem Bildschirm gleichzeitig.
| | # Raspberry Pi 4 |
| So wird keine HDMI-Verbindung zwischen dem RPi und einem Bildschirm mehr benötigt.
| | # mciro-SD Karte mit SD-Karten Adapter |
| | # HDMI-Kabel |
| | # Netzwerkkabel |
| | # Netzwerkswitch |
|
| |
|
| Über SSH kann der AlphaBot später mittels einer WIFI-Verbindung autonom fahren.
| | ===== verwendete Software ===== |
|
| |
|
| Die SSH Verbindung kann über verschiedene Wege erfolgen. Zum einen über das Programm [https://de.wikipedia.org/wiki/PuTTY PuTTY] oder über das Ubuntu Desktop Terminal.
| | # Ubuntu Server 20.04 |
| | # Python |
| | # ROS2 |
| | # Secure Shell (SSH) |
| | # [https://de.wikipedia.org/wiki/PuTTY PuTTY] |
|
| |
|
| Im weiteren wird beschrieben, wie SSH auf dem RPi aktiviert wird und wie es mit PuTTY oder in einem Terminal verwendet werden kann.
| | ==== [[ Raspberry Pi über Secure Shell(SSH) mit Desktop PC verbinden | Raspberry Pi über Secure Shell(SSH) mit Desktop PC verbinden]] ==== |
|
| |
|
| ===== SSH auf dem Raspberry Pi Aktivieren ===== | | ==== [[ Programmierung / Funktionsweise der ROS2 Codes | Programmierung / Funktionsweise der ROS2 Codes ]] ==== |
|
| |
|
| [[Datei:SSH_Datei_erstellen.png|right|mini|500px|Abb 1: Ordner mit der SSH-Datei <nowiki></nowiki>]]
| | ==== [[ Darstellung der Ergebnisse | Darstellung der Ergebnisse ]] ==== |
| | |
| Damit SSH genutzt werden kann muss es auf dem Raspberry Pi zuerst aktiviert werden.
| |
| Dazu sind folgende Schritte wie in Abb. 1 gezeigt zu befolgen:
| |
| | |
| # SD-Karte mit einem SD-Karten-Adapter in ein Kartenleseslot an einem PC stecken
| |
| # im boot-Verzeichnis (hier: "system-boot") mit rechter Maustaste Drop-Down-Menu öffnen
| |
| # unter dem Reiter Neu "Textdokument" auswählen
| |
| # ssh als Namen eingeben, zunächst wird die Datei ssh.txt heißen
| |
| # im Windows-Explorer unter dem Reiter Ansicht Haken bei Dateinamenserweiterung setzen, damit die Dateiendung angezeigt wird
| |
| # die nun angezeigte .txt Dateiendung entfernen
| |
| # die darauf folgende Warnung mit JA bestätigen(Abb. 2)
| |
| # beim Booten des Raspberry Pi's wird nun SSH aktiviert
| |
| | |
| <br clear=all>
| |
| | |
| ===== IP-Adresse des RPi herausfinden =====
| |
| | |
| [[Datei:Log In Bildschirm.jpg|right|mini|250px|Abb 2: Beispiel <nowiki><log in Bildschirm</nowiki>]] | |
| | |
| Damit der Raspberry Pi über SSH verbunden werden kann, wird die IPv4-Adresse des Raspberry Pi's benötigt.
| |
| | |
| | |
| Dafür wird der RPi mit einem HDMI-Kabel an einem Bildschirm und an das dazugehörige Stromkabel angeschlossen.
| |
| | |
| Allgemein muss der RPi für eine SSH-Verbindung mit dem Internet verbunden sein.
| |
| Hier kann der RPi mit einem Ethernet Kabel oder über einer WIFI-Verbindung verbunden werden.
| |
| Für die Ethernet-Verbindung wird zwischen den RPi und den Computer ein Netzwerk-Switch zwischengeschaltet.
| |
| | |
| Und um den RPi mit WIFI zu verbinden, muss die RPi Netzwerk Konfiguration verändert werden. Wie das gemacht wird kann in dem Artikel zur Installation von Ubuntu Server nachgelesen werden.
| |
| | |
| | |
| Wenn letzteres das Stromkabel angeschlossen wurde, bootet der RPi und der Login Bildschirm wird angezeigt, wo nach dem Benutzernamen (hier: ubuntu) und nach dem Passwort (hier: Hshl2021) gefragt wird(Abb. 2).
| |
| | |
| <br clear=all>
| |
| | |
| Nach der Anmeldung auf dem Raspberry Pi, kann die IPv4-Adresse auf dem Start Bildschirm abgelesen werden.
| |
| | |
| Für den hier verwendeten RPi war die Ethernet IP-Adresse <code> 172.31.14.89</code>, wie in Abb. 3 zusehen ist. Und für WIFI war die IP-Adresse 192.168.10.102.
| |
| | |
| | |
| [[Datei:StartBild_Ubuntu_Server.png|left|mini|300px|Abb 3: Beispiel <nowiki>IP-Adresse</nowiki>]]
| |
| <br clear=all>
| |
| | |
| ===== PuTTY für die SSH Verbindung =====
| |
| | |
| Wie oben erwähnt, kann die freie Software PuTTY zur Herstellung von Secure Shell Verbindungen verwendet werden.
| |
| Auf einem Pc mit Ubuntu wird PuTTY über die Kommandozeile installiert [https://wiki.ubuntuusers.de/PuTTY/].
| |
| | |
| | |
| <code> sudo apt-get install putty </code>
| |
| | |
| [[Datei:PuTTY Konfiguration.png|right|mini|350px|Abb. 5: PuTTY Start Bildschirm]]
| |
| | |
| | |
| | |
| Nach der Installation kann über die folgenden Schritte SSH gestartet werden(Abb. 5):
| |
| | |
| # starten von PuTTY über ein Terminal mit dem Befehl <code> putty </code>
| |
| # Reiter Session auswählen
| |
| # bei Host-Name die IP-Adresse des RPi angeben
| |
| # als Connection Type SSH auswählen
| |
| # überprüfen ob Port 22 eingestellt ist
| |
| # gegeben falls spezifischen Namen geben
| |
| # mit save die Ip-Adresse abspeichern
| |
| # auf Open klicken, um SSH zu starten
| |
| | |
| | |
| <br clear=all>
| |
| | |
| Dann öffnet sich ein neues Fenster, wo sich mit den zuvor gezeigten Anmeldedaten(username: ubuntu, Passwort: Hshl2021) auf dem RPi angemeldet werden kann.
| |
| | |
| Nach dem Anmelden sieht der PuTTY-Bildschirm, wie in Abb. 6 gezeigt aus.
| |
| Hier ist außerdem zusehen das die SSH-Verbindung über WIFI hergestellt wurde und die IP-Adresse eine andere ist, wie bei Ethernet.
| |
| | |
| Um die IP-Adressen auseinander zuhalten, ist es am besten, bei der ersten Nutzung des RPi's die Ip-Adressen einmal nachzuschauen.
| |
| | |
| [[Datei:Putty_Login.png|left|mini|350px|Abb. 6: PuTTY Login Bildschirm]]
| |
| <br clear=all>
| |
| | |
| Nun ist die SSH-Verbindung über PuTTY hergestellt.
| |
| | |
| ===== SSH über ein Terminal verwenden =====
| |
| Eine SSH-Verbindung über ein Ubuntu Terminal herzustellen ist im Vergleich zu PuTTY einfacher.
| |
| | |
| Dafür muss nur der Befehl <code> ssh username@IP-Adresse </code> [https://wiki.ubuntuusers.de/SSH/] in einem Terminal eingegeben werden.
| |
| Danach erscheint direkt im Terminal der Login-Bildschirm.
| |
| | |
| Hier kann sich wie gewohnt mit den genannten Daten angemeldet werden.
| |
| | |
| ==== Microcontroller coding mit der Integration von ROS2 ====
| |
| | |
| In diesem Abschnitt wird die Programmierung des Raspberry Pi's mit ROS2 beschrieben. Dazu gehört die Motorsteuerung, genau sowie die Infrarot Sensoren oder dem Ultraschallsensor um Hindernisse umfahren zu können.
| |
| | |
| Da es die Bibliothek wiringPi, welche für die Ansteuerung der GPIO Pins über CPP nicht mehr unterstützt wird, haben wir uns für die Python Bibliothek "RPi.GPIO" entschieden. Für mehr Informationen siehe hier: [[Raspberry Pi|Raspberry Pi]]
| |
| | |
| Da es beim ausführen von den Codes auf dem RPi zu dem Fehler "RuntimeError: Not running on a RPi!" kam, können die folgenden Befehle helfen.
| |
| Die hier genannten Befehle müssen bei jedem Neustart des RPi's erneut ausgeführt werden. Weiteres wurde dazu nicht gefunden.
| |
| | |
| ls -l /dev/ gpiomem
| |
| crw-rw---- 1 root dialout 239, 0 Apr 1 17:23 /dev/gpiomem
| |
| groups
| |
| ubuntu adm dialout cdrom floppy sudo audio dip video plugdev netdev lxd
| |
| | |
| <code> sudo chown root.gpio /dev/gpiomem </code>
| |
| | |
| <code> sudo chmod g+rw /dev/gpiomem </code>
| |
| | |
| Um mit der Programmierung zu beginnen wurde ein Ros2 Workspace mit einem source Ordner erstellt.
| |
| | |
| <code>
| |
| mkdir ros_ws
| |
| | |
| cd ros_ws
| |
| | |
| mkdir src
| |
| </code>
| |
| | |
| In dem source Ordner wurde dann das ROS2 Package mit den benötigten Bibliotheksabhängigkeiten erstellt.
| |
| Dazu gehören rclpy, der ROS2 Client Library für Python und std_msgs, um die Standard Nachrichten, wie Int8, Float64 oder String in ROS2 nutzen zu können.
| |
| <br>
| |
| <code> ros2 pkg create --build-type ament_python packagename(z.B. sensor_test) --dependencies rclpy std_msgs </code>
| |
| | |
| | |
| ===== Motorsteuerung =====
| |
| | |
| [[Datei:Motortest.png|right|mini|500px|Abb. 10 Hindernisumfahrung Beispiel]]
| |
| | |
| Es wurde damit begonnen die Motoren zu programmieren und zu testen. Dazu wurde eine ROS2 Node namens slave.py erstellt, welche zu diesem Zeitpunkt die Programmierung zur Steuerung der Motor GPIO Pins beinhaltet. Dazu werden bestimmte Nachrichten wie forward, backward, right, left oder stop manuell an diese ROS2 Node gepublished.
| |
| | |
| Der Ablauf ist dazu in Abb. 10 Graphisch dargestellt.
| |
| | |
| | |
| | |
| Damit überhaupt etwas passiert muss zuerst der ROS2 Code, die slave.py ausgeführt werden.
| |
| | |
| | |
| <code> ros2 run sensor_test Motortest </code>
| |
| | |
| | |
| Unter Demos wird dazu im Detail beschrieben was bei der Ausführung zu beachten ist.
| |
|
| |
| Danach ist der subscriber in einer Art Standby Modus und wartet auf eingehende Nachrichten.
| |
| | |
| | |
| Im nächsten Schritt sendet jemand manuell eine Movement Nachricht an den subscriber.
| |
| | |
| | |
| <code> ros2 topic pub /cmd_vel std_msgs/msg/String '{data: forward}'</code>
| |
| | |
| Diese Nachricht wird in einer Dauerschleife gesendet, bis das publishen gestoppt wird.
| |
| | |
| | |
| Die Node "motor_subscriber" empfängt dann die zuvor gesendete Nachricht über den dort definierten subscriber.
| |
| | |
|
| |
| Anhand dieser Nachricht entscheidet die Node über eine If-Schleife welche GPIO Pins angesteuert werden müssen.
| |
| Dazu gibt es 3 Pins für den linken Motor und 3 Pins für den rechten Motor.
| |
| Jeweils einen für vorwärts, einen für rückwärts und einen um die Motoren zu aktivieren. Die Aktivierung erfolgt in der Initialisierungsfunktion. Dadurch wird ermöglicht, das der AlphaBot beim ausführen des Codes sofort losfährt.
| |
| Jetzt endlich werden bei der Nachricht "forward" die beiden GPIO Pins für das vorwärts Fahren auf HIGH gesetzt und der AlphaBot fährt vorwärts.
| |
| | |
| | |
| | |
| | |
| | |
| In Abb. 8 ist zusehen wie links die Nachricht "forward" gepublished wird und rechts die Node "motor_subscriber" diese Nachricht empfängt.
| |
| Zudem ist zu sehen das nach dem pub Befehl eine loop beginnt, das heißt, dass die Nachricht in gleichmäßigen Zeitabständen gepublished wird.
| |
| | |
| [[Datei:Terminal_Motor_Controll.png|left|mini|800px|Abb. 8: Terminal Ausgabe]]
| |
| | |
| <br clear=all>
| |
| | |
| ===== Infrarot Hindernisumfahrung =====
| |
| | |
| [[Datei:Infrared.png|right|mini|500px|Abb. 9 Infrarot Hindernisumfahrung]]
| |
| | |
| Nachdem die Motoren mit ROS2 implementiert und getestet wurden, wurde die Hindernisumfahrung mit Infrarotsensoren implementiert.
| |
| Hierfür wurden zwei neue Dateien mit den Namen "master_IR.py" und "slave_IR.py" in dem source Ordner des ROS2 Packages erstellt.
| |
| | |
| | |
| Der Ablauf für die Hindernisumfahrung mit Infrarotsensoren ist in Abb. 9 abgebildet.
| |
| | |
| | |
| Das Programm wird mit einer ROS2 launch-file ausgeführt. Die launch-file beinhaltet alle auszuführenden ROS2-Nodes. Dazu gehört der package Name und der Name der auszuführenden Datei. Mit dem folgenden Befehl werden dann beide Nodes ausgeführt.
| |
| | |
| <code> ros2 launch sensor_test alphabot_IR_launch.py </code>
| |
| | |
| | |
| Dann fährt der AlphaBot los und die Sensordaten werden über die Slave-Node an die Master-Node gepublished.
| |
| | |
| | |
| Nachdem die Master-Node die Sensordaten erhalten hat, entscheidet sie über eine IF-Schleife in welche Richtung der AlphaBot fahren kann.
| |
| | |
| | |
| Der unterschied zur Motorsteuerung oben ist, das hier der Master anhand der Sensordaten forward, right, left oder backward an die Slave-Node published.
| |
| | |
| | |
| Für die Sensordaten musste zunächst der richtige Datentype herausgefunden werden. Dazu kann dieser Code in der Slave-Node unter der timer_callback() Funktion nachdem DR_status deklariert wurde integriert werden.
| |
| | |
| <code>
| |
| print(type(DR_status))
| |
| </code>
| |
| | |
| So wurde herausgefunden, dass es sich hier um ein Integer handelt.
| |
| Mit der Codezeile <code> print(DR_status) </code> wurde festgestellt, dass diese Infrarotsensoren bei einer <code>1</code> nichts vor ihnen steht und bei einer <code>0</code> etwas im Weg ist.
| |
| | |
| So published die Master-Node "forward" wenn die Slave-Node für beide Sensoren eine 1 published und steuert beide GPIO Pins zum vorwärts fahren an.
| |
| Wenn z.B. der rechte Sensor eine "0" und der linke eine "1" angibt, dann ist rechts ein Hindernis. Der master sendet der Slave die Nachricht "left", sodass die Slave-Node die GPIO Pins zum rückwärts fahren des Linken Motors ansteuert.
| |
| | |
| | |
| In Abb 10 ist dazu ein Beispiel, wie der master und die slave miteinander kommunizieren.
| |
| Dort ist zum Beispiel zusehen, das die Master-Node(commander) "forward" published, da beide Sensoren eine 1 ausgeben. Die Slave-Node(IR_Publisher) empfängt die Nachricht forward, was an dem I heard zu erkennen ist.
| |
| | |
| [[Datei:IR_Left.jpg|left|mini|500px|Abb. 10 Hindernisumfahrung Beispiel]]
| |
| | |
| <br clear=all>
| |
| | |
| In ROS2 können die Programmierten Nodes und Topics in einem RQT-Graph grafisch Dargestellt werden wie schon in den ROS2 Tutorials gezeigt.
| |
| Für die Infrarot Hindernisumfahrung könnte der Graph dann wie in Abb. 11 gezeigt aussehen.
| |
| | |
| Dort ist zusehen das der master zu den beiden Topics "IR_right und IR_left" subscript und über die Topic "cmd_vel" published. Auf der anderen Seite, die Slave, published über die Topics "IR_right und IR_left" und subscript zur Topic "cmd_vel".
| |
| | |
| [[Datei:RQT_Graph_Infrared.jpeg|left|mini|600px|Abb. 11 Infrarot Hindernisumfahrung]]
| |
| | |
| <br clear=all>
| |
| | |
| | |
| [[Datei:RQT_Plot_Infrared.png|left|mini|700px|Abb. 12 Infrarot Hindernisumfahrung]]
| |
| | |
| <br clear=all>
| |
| | |
| ===== Ultraschall Hindernisumfahrung =====
| |
| | |
| [[Datei:Ultraschall_Diagram.jpg|right|mini|350px|Abb. 7 Ultraschall Hindernisumfahrung]]
| |
| | |
| | |
| <br clear=all>
| |
| | |
| [[Datei:Ultraschall_Example.jpg|left|mini|500px|Abb. 7 Ultraschall Hindernisumfahrung]]
| |
| <br clear=all>
| |
| | |
| [[Datei:Ultraschall_RQT_Graph.jpg|left|mini|500px|Abb. 7 Ultraschall Hindernisumfahrung]]
| |
| <br clear=all>
| |
| | |
| === Demo ===
| |
| | |
| Checkout URL : https://svn.hshl.de/svn/Robotik_und_Autonome-Systeme/trunk/Projekte/AlphaBot_PI_ROS2/
| |
| | |
| Der Code kann direkt aus dem SVN-Verzeichnis ausgeführt werden.
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! # !! Name
| |
| |-
| |
| | 1 || Motortest
| |
| |-
| |
| | 2 || Infrared_Obstacle_Avoidance
| |
| |-
| |
| | 3 || Ultrasonic_Obstacle_Avoidance
| |
| |}
| |
|
| |
|
| === Software === | | ==== [[ Demo | Demo]] ==== |
|
| |
|
| == [[Zusammenfassung_Praxissemester_Gerken|Zusammenfassung]] == | | == [[Zusammenfassung_Praxissemester_Gerken|Zusammenfassung]] == |
| Zeile 360: |
Zeile 101: |
|
| |
|
| * [https://wiki.ubuntuusers.de/PuTTY/ PuTTY Installation] | | * [https://wiki.ubuntuusers.de/PuTTY/ PuTTY Installation] |
| | * [https://wiki.ubuntuusers.de/SSH/ SSH ] |
|
| |
|
|
| |
|
| ---- | | ---- |
| → zurück zum Hauptartikel: [[Robot_Operating_System_2|Robot Operating System2 (ROS2)]] | | → zurück zum Hauptartikel: [[Robot_Operating_System_2|Robot Operating System2 (ROS2)]] |
