Kommunikation Raspberry Pi mit ROS2

Autoren: Jonas Gerken
Betreuer: Prof. Schneider
Art: Praxissemester
Projektlaufzeit: 02.11.2021 - 20.02.2022

Einleitung

Dieser Artikel beschreibt die Kommunikation von einem Raspberry Pi mit dem Robot Operating System2 (ROS2) (siehe Abb. 1). 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.

Funktionale Anforderungen

F1	Der AlphaBot muss Hindernisse mit Infrarotsensoren erkennen können.
F2	Der AlphaBot muss Hindernisse mit einem Ultraschallsensor erkennen können.
F5	Der Ultraschallsensor muss mit einem Servo-Motor nach rechts und links gedreht werden können.
F3	Der AlphaBot muss Hindernisse umfahren können.
F4	Die Motoren müssen einzeln angesteuert werden können.

Nicht Funktionale Anforderungen

NF1	Es muss ein Alphabot verwendet werden.
NF2	Der AlphaBot muss mit dem ROS2 programmiert werden.
NF3	Der AlphaBot soll mit einem Raspberry Pi gesteuert werden.
NF4	Der AlphaBot soll mit Python programmiert werden.
NF5	Es soll die Python Bibliothek RPi.GPIO verwendet werden.
NF6	Es muss Ubuntu Server 20.04 Server auf dem RPi verwendent werden.

Übersicht

Dokumentation

Zum beginn dieses Artikels werden die verschiedenen Anforderungen an das Projekt aufgezeigt(Tabelle 1/2).

Hilfreiche Software

Raspberry Pi über Secure Shell(SSH) mit Desktop PC verbinden

In dem hier beschriebenen Projekt wurde Secure Shell(SSH) zur Verwendung des RPi's verwendet. Dies ermöglicht die Nutzung des RPi's und Ubuntu Desktop auf einem Bildschirm gleichzeitig. So wird keine HDMI-Verbindung zwischen dem RPi und einem Bildschirm mehr benötigt.

Über SSH kann der AlphaBot später mittels einer WIFI-Verbindung autonom fahren.

Die SSH Verbindung kann über verschiedene Wege erfolgen. Zum einen über das Programm PuTTY oder über das Ubuntu Desktop Terminal.

Im weiteren wird beschrieben, wie SSH auf dem RPi aktiviert wird und wie es mit PuTTY oder in einem Terminal verwendet werden kann.

SSH auf dem Raspberry Pi Aktivieren

Damit SSH genutzt werden kann muss es auf dem Raspberry Pi zuerst aktiviert werden. Dazu sind folgende Schritte wie in Abb. 2 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
beim Booten des Raspberry Pi's wird nun SSH aktiviert

IP-Adresse des RPi herausfinden

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. 3).

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 172.31.14.89, wie in Abb. 4 zusehen ist. Und für WIFI war die IP-Adresse 192.168.10.102.

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 [1].

sudo apt-get install putty

Nach der Installation kann über die folgenden Schritte SSH gestartet werden(Abb. 5):

starten von PuTTY über ein Terminal mit dem Befehl putty
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

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.

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 ssh username@IP-Adresse [2] 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.

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.

Die ersten beiden Befehle zeigen, ob gpiomem schon vorhanden ist.

ls -l /dev/ gpiomem

Ausgabe: crw-rw---- 1 root dialout 239, 0 Apr 1 17:23 /dev/gpiomem

groups

Ausgabe: ubuntu adm dialout cdrom floppy sudo audio dip video plugdev netdev lxd

Um gpiomem dann zu erlauben sind die folgenden zwei Befehle erforderlich.

sudo chown root.gpio /dev/gpiomem

sudo chmod g+rw /dev/gpiomem

Um mit der Programmierung zu beginnen wurde ein Ros2 Workspace mit einem source Ordner erstellt.

mkdir ros_ws

cd ros_ws

mkdir src

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.
ros2 pkg create --build-type ament_python packagename(z.B. sensor_test) --dependencies rclpy std_msgs

Motorsteuerung

Es wurde damit begonnen die Motoren zu programmieren und zu testen. Dazu wurde eine ROS2 Node namens slave.py erstellt, welche 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. 7 Graphisch dargestellt.

Damit überhaupt etwas passiert muss zuerst der ROS2 Code, die slave.py ausgeführt werden.

ros2 run sensor_test Motortest

Unter Demos wird dazu im Detail beschrieben, wie die verschiedenen Programme ausgeführt werden können.

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.

ros2 topic pub /cmd_vel std_msgs/msg/String '{data: forward}'

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. Bei der Motorsteuerung wurden die Geschwindigkeit auf 0% gesetzt damit der AlphaBot erst losfährt wenn die Slave eine Nachricht erhält.

self.PWMA = GPIO.PWM(ENA,500)

self.PWMA.start(0)

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.

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.

ros2 launch sensor_test alphabot_IR_launch.py

In der slave-Node werden den Motoren durch die Initialisierung direkt eine Geschwindigkeit zugeordnet, damit der AlphaBot beim ausführen des Codes direkt losfährt. Durch das ausführen der launch-file werden über die Slave-Node die Sensordaten 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.

print(type(DR_status))

So wurde herausgefunden, dass es sich hier um ein Integer handelt. Mit der Codezeile print(DR_status) wurde festgestellt, dass diese Infrarotsensoren bei einer 1 nichts vor ihnen steht und bei einer 0 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 dem folgenden Sequenzdiagramm ist die Kommunikation zwischen Master und Slave deutlicher zu erkennen(Abb. 10).

So ist in der Abbildung zu sehen, das zunächst die Slave die Sensordaten abfragt und über timer_callback() an den Master published.

Anschließend published der Master anhand der erhaltenden Sensordaten ein Movement an die Slave. Die Slave steuert dann die Motoren an.

In Abb. 11 ist zu der Infrarot Hindernisumfahrung ein Beispiel, wie das in einem Terminal während der Programmausführung aussieht.

So fährt der AlphaBot vorwärts (I heard: "forward"), da für beide IR-Sensoren eine 1 ausgelesen wurde.

Oder er fährt links (I heard: "left"), da für den rechten IR-Sensor eine 0 und für den linken eine 1 ausgelesen wurde.

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. 12 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".

Zudem gibt es unter RQT die Möglichkeit die Sensordaten in einem sogenannten Plot darzustellen.

Dazu muss in RQT unter dem Reiter Plugin, Visualisierung Plot ausgewählt werden, wie in Abb. 13 gezeigt.

In dem Plot kann das Koordinatensystem mit dem in Abb. 14 markierten Bereich in der Größe eingestellt werden.

An der X-Axis muss nichts geändert werden, da diese sich während der Ausführung automatisch erweitert. Unter Y-Axis lässt sich für Bottom der niedrigste Wert und für Top der höchste Wert, welches das Koordinaten System haben soll einstellen.

Um die Sensordaten dem Plot hinzuzufügen wird der Topic-Monitor benötigt. Der Topic Monitor wird über den Reiter Plugin und dann Topics, Topic Monitor geöffnet.

In Abb. 15 sind links über den Topic Monitor die verschiedenen Topics zu sehen. Über den Pfeil links neben den Topics wird ein weiterer Reiter Namens "data" ausgeklappt(Abb. 15 1.) Unter den Topics DR_left und DR_right kann "data" per drag and drop in den Plot gezogen werden. So erscheint in dem Plot oben links eine Legende mit dem Topic Namen und der Farbe des Graphens(Abb. 15 2.). Während der Laufzeit wird dann der Plot für die beiden IR-Sensoren generiert.

Außerdem ist zusehen, das zweimal der blaue Graph auf 0 fällt. So ist hier genauer zu erkennen, dass sich die Sensordaten nur auf 1 und 0 beschränken. Weiter ist zuerkennen, dass der linke Sensor(blauer Plot) anspricht und dort sich zu dem Zeitpunkt ein Hindernis befindet.

Ultraschall Hindernisumfahrung

Zuletzt wurde die Hindernisumfahrung mit dem Ultraschallsensor implementiert. Die Motoren werden wie bei den anderen Programmen angesteuert. Der Code wird mit einem Servomotor, um den Ultraschallsensor nach rechts und links zu drehen, erweitert und die Infrarotsensoren werden durch den Ultraschallsensor ersetzt.

Dazu wurden die beiden Dateien slave_Sonar.py und master_Sonar.py erstellt.

Bei der Implementierung lag zunächst die Schwierigkeit, dass die Master-Node die Sensordaten nicht zum richtigen Zeitpunkt erhalten hat. So wurden zum Beispiel die Sensordaten für rechts und links gepublished, sind aber erst im zweiten durchlauf der Master-Node bei dem subscriber angekommen.

Der funktionierende Code kann in dem SVN-Repository unten in diesem Artikel unter Demo nachgeschlagen werden.

Der Ablauf für die Hindernisumfahrung mit Ultraschallsensor ist in Abb. 17 dargestellt.

Hier wurde wie bei der Infrarot-Hindernisumfahrung eine Launch-file erstellt, welche zunächst gestartet wurden muss.

ros2 launch sensor_test alphabot_Sonar_launch.py

Wenn die launch-file ausgeführt wurde, fährt der AlphaBot los und die Slave-Node published die Sensordaten über die Topic Sonar/middle an die Master-Node.

Anhand dieser Daten überprüft die Master-Node über eine if-Schleife, ob die Entfernung kleiner 50 ist. Solange der Wert über 50 ist, wird die Nachricht "forward" gepublished und der AlphaBot fährt geradeaus.

Wenn die Entfernung kleiner 50 wird, hält die Slave-Node bei erhalt der Nachricht "stop" von der Master-Node, den AlphaBot an. Weiter published die Master-Node die Nachricht "lookRight". Wenn die Slave-Node diese Nachricht erhält, steuert sie die GPIO Pins für den Servomotor an, um den Sensor nach rechts zu drehen. Das funktioniert mit dem sogenannten DutyCycle.

self.p.ChangeDutyCycle(2.5)

Dann published die Master-Node "rightData" und nachdem die Slave-Node das erhalten hat, published sie die Sensordaten über die Topic "Sonar/right".

Mit dem gleichen Prinzip wird der Sensor als nächstes nach links gedreht. Das passiert über die Nachrichten "lookLeft" und "leftData".

Zuletzt wird der Ultraschallsensor mit der Nachricht "lookForward" und dem entsprechendem DutyCylce 7.5 zur Ausgangsposition zurückgedreht.

Die Master-Node wertet die Daten über eine weitere if-Schleife aus und published die Nachricht, in welche Richtung der AlphaBot fahren kann.

So wird "backward" gepublished, wenn links und rechts der Wert kleiner 50 ist, oder "right", wenn der rechte Wert größer ist wie der linke Wert. Und ansonsten wird "left" gepublished.

Die Slave-Node steuert anhand der erhaltenden Nachricht die GPIO Pins an, um das Hindernis zu umfahren.

In dem hier gezeigten Sequenzdiagramm wird die Kommunikation zwischen Master und Slave aufgezeigt(Abb.18).

So ist zusehen, wann die Slave Sensordaten an den Master published und wann der Master Movements an die Slave published.

Die Terminalausgabe während das Programm ausgeführt wird, könnte wie in Abb. 19 aussehen.

Dort ist zu erkenne, dass nur middle_data gepublished wird bis dieser Wert unter 50 fällt.

Dann werden zusätzlich die Sensordaten für links und rechts gepublished, nachdem der Servo nach rechts und links gedreht wurde.

In dem RQT-Graph zur Ultraschall Hindernisumfahrung wurden die Sensordaten Topics zu einer Gruppe zusammengefasst, da nur ein Ultraschallsensor mit 3 ROS2 Topics verwendet wurde(Abb. 20).

Das wurde gemacht, um die Sensordaten für links, Mitte und rechts auseinander zuhalten.

Allgemein ist das Prinzip, wie bei der Infrarot Hindernisumfahrung, nur das die Slave über drei verschiedene Topics die Sensordaten published.

Und über die cmd_vel Topic werden zusätzlich die Servo-Movements gepublished.

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.

Schritt für Schritt Anleitung unter Ubuntu um den Code auszuführen:

ein neues Terminal öffnen
zum Verzeichnis des Packages gehen cd svn/Projekte/AlphaBot_PI_ROS2
colcon build beziehungsweise colcon build --packages-select sensor_test zum kompilieren des ROS2 Codes ausführen
. install/setup.bash

1. Motortest:

ros2 run sensor_test Motortest im Terminal ausführen
Manuelle Nachricht publishen ros2 topic pub /cmd_vel std_msgs/msg/String '{data: forward}'
durch STRG C das publishen der Nachricht stoppen

2. Infrared_Obstacle_Avoidance:

ros2 launch sensor_test alphabot_IR_launch.py im Terminal ausführen
AlpaBot fährt autonom und umfährt Hindernisse mit Infrarotsensoren

3. Ultrasonic_Obstacle_Avoidance:

ros2 launch sensor_test alphabot_Sonar_launch.py im Terminal ausführen
AlpaBot fährt autonom und umfährt Hindernisse mit Ultraschallsensor

Zusammenfassung

Weiterführende Links

PuTTY Installation

→ zurück zum Hauptartikel: Robot Operating System2 (ROS2)