Kommunikation Raspberry Pi mit ROS2: Unterschied zwischen den Versionen
| Zeile 118: | Zeile 118: | ||
Um mit der Programmierung zu beginnen wurde ein Ros2 Workspace (ros_ws) mit einem source Ordner (src) erstellt. | Um mit der Programmierung zu beginnen wurde ein Ros2 Workspace (ros_ws) mit einem source Ordner (src) erstellt. | ||
<code> | |||
mkdir ros_ws | mkdir ros_ws | ||
cd ros_ws | cd ros_ws | ||
mkdir src | mkdir src | ||
</code> | |||
In diesem Ordner wurde dann das ros2 Package mit den benötigten Bibliotheksabhängigkeiten erstellt. | In diesem Ordner wurde dann das ros2 Package mit den benötigten Bibliotheksabhängigkeiten erstellt. | ||
<code> ros2 pkg create --build-type ament_python packagename(z.B. sensor_test) --dependencies rclpy std_msgs </code> | |||
Version vom 14. Februar 2022, 12:51 Uhr
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). 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.
Übersicht
Dokumentation
Anforderungen
Hardware
Software
Raspberry Pi mit Ubuntu Server verbinden über SSH(Secure Shell)
Hier wird zunächst erklärt was SSH ist, wie es aktiviert wird und wie es verwendet werden kann.
Für dieses Projekt wurde Secure Shell(SSH) verwendet, um den RPi Bildschirm unter Ubuntu Desktop anzeigen zulassen. So wird keine HDMI-Verbindung zwischen dem RPi und einem Bildschirm mehr benötigt. So kann der Roboter später auch über eine WIFI-Verbindung frei herum fahren.
Die SSH Verbindung kann über verschiedene Wege erfolgen. Zum einen über das Programm PuTTY oder über das Ubuntu Desktop Terminal.
SSH auf dem Raspberry Pi Aktivieren
Damit SSH genutzt werden kann muss es auf dem Raspberry Pi zuerst aktiviert werden. Dazu sind folgende Schritte zu befolgen:
- SD-Karte mit einem SD-Karten-Adapter in ein Kartenleseslot an einem PC stecken
- im boot-Verzeichnis ("system-boot") eine leere Textdatei mit dem Namen "ssh.txt" erstellen
- in diesem Ordner die rechte Maustaste drücken, dann auf Neu und dort auf Textdokument
- im Windows-Explorer unter dem Reiter Ansicht Haken bei Dateinameserweiterung setzen
- .txt Dateiendung entfernen
- Warnung mit JA bestätigen
- beim Booten des Raspberry Pi's wird nun SSH aktiviert(Abb. 1)
Netzwerk Konfiguration
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 angeschlossen. Nach dem der Raspberry Pi gebootet ist, erscheint ein login Bildschirm, wo nach dem Benutzernamen (ubuntu) und nach dem Passwort (Hshl2021) gefragt wird (Abb. 2).
Nach der Anmeldung auf dem Raspberry Pi, kann die IPv4-Adresse auf dem Start Bildschirm abgelesen werden, wie in Abb. 3 gezeigt.
Für die Verbindung über Ethernet muss nur der RPi und der PC mit einem Lan-Kabel verbunden werden. Damit beides im gleichen Netzwerk ist wird ein Netzwerk-Switch zwischengeschaltet. Jetzt kann die SSH-Verbindung mit dem Befehl "ssh username@IP-Adresse" hergestellt werden. Danach wird nach dem RPi Passwort gefragt. Nach der Eingabe des Passworts wird die SSH Verbindung hergestellt.
Um ein Wifi-Netzwerk zu nutzen muss die RPI Netzwerk config geändert werden. Wie das gemacht werden kann kann in dem Artikel
Dabei ist darauf zu achten, das die IP-Addressen für Wifi und Ethernet unterschiedlich sind.
PuTTY für die SSH Verbindung
PuTTY ist eine freie Software zur Herstellung von Secure Shell Verbindungen. Auf einem Pc mit Ubuntu wird Putty über die Kommandozeile installiert [1].
sudo apt-get install putty
Nach der Installaltion kann es über den Befehl "putty" in einem Terminal ausgeführt werden und ein neues Fenster öffnet sich(Abb.5). Unter Session wird bei Host-Name bzw. IP-Addresse die IP-Addresse des Raspberry Pi's angegeben. Und im Bereich Connection type wird der Type "SSH" ausgewählt und überprüft, ob bei "Port" die Zahl 22 steht.
Um den SSH Server zu starten wird unten im Fenster auf Open geklickt. Dann öffnet sich ein neues Fenster, wo sich mit den zuvor gezeigten Anmeldedaten auf dem RPi angemeldet werden kann.
Nun ist die SSH-Verbindung über PuTTY hergestellt.
Um eine SSH-Verbindung über das Ubuntu Terminal herzustellen ist der folgende Befehl nötig [2]:
ssh username@IP-Adresse
Für den verwendeten RPi war der username "ubuntu" und die IP-Adresse für Ethernet war "172.31.14.89" und für Wifi war es "192.168.10.102".
Microcontroller coding mit der Integration von Ros 2
- 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
cd /dev sudo chmod og+rwx gpio*
In diesem Abschnitt wird die Programmierung des Raspberry Pi's mit ROS2 beschrieben. Dazu gehört die Motorsteuerung, genau sowie die Infrarot Sensoren und/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
Um mit der Programmierung zu beginnen wurde ein Ros2 Workspace (ros_ws) mit einem source Ordner (src) erstellt.
mkdir ros_ws
cd ros_ws
mkdir src
In diesem Ordner wurde dann das ros2 Package mit den benötigten Bibliotheksabhängigkeiten erstellt.
ros2 pkg create --build-type ament_python packagename(z.B. sensor_test) --dependencies rclpy std_msgs
Motorsteuerung
In dem Verzeichnis /ros_ws/src/packagename/packagename wird nun die Datei "slave.py" erstellt.
Der Code beginnt mit verschiedenen Importirrungen von Bibliotheken, wie die ROS2 Bib rclpy, RPi.GPIO und die verschiedenen benötigten Nachrichten Datentypen. Vor der Klassenerstellung werden den verwendeten GPIO-Pin Nummern Namen zugeordnet.
IN1 = 12
In der Slave Node wird der /cmd_vel topic subscriber mit der auszuführenden motors_callback Funktion deklariert.
self.sub = self.create_subscription(String, 'cmd_vel', self.motors_callback, 10)
Danach werden die GPIO-Pins für die Motoren deklariert.
Hier ein Beispiel, wie das für den rechten Motor implementiert wurde:
GPIO.setup(IN1, GPIO.OUT) #right wheel forward
GPIO.setup(IN2, GPIO.OUT) #right wheel backward
GPIO.setup(ENA, GPIO.OUT) #enable right wheel
Damit die Slave_Node weiß, wann was passieren soll, werden in einer if-Schleife alle Funktionen wie forward, left, right oder auch backward programmiert.
msg.data = 'forward'
GPIO.output(IN1, GPIO.HIGH) #right wheel forward
GPIO.output(IN2, GPIO.LOW) #right wheel backward
GPIO.output(IN3, GPIO.LOW) #left wheel backward
GPIO.output(IN4, GPIO.HIGH) #left wheel forward
self.get_logger().info('I heard: "%s"' % msg.data)
Um die Motoren mit ROS2 zu testen wurde die Slave-Node über "ros2 run"ausgeführt und über "ros2 topic pub" wurde die Nachricht "forward" an die Slave gesendet, um den Roboter vorwärts zu bewegen.
ros2 run sensor_test Driver
ros2 topic pub /cmd_vel std_msgs/msg/String '{data: forward}'
Infrarot Hindernissumfahrung
Nachdem die Motoren Programmiert wurden, wurde der Slave-Node der publisher für die Infrarot Sensordaten hinzugefügt.
self.sensor_publisher_right = self.create_publisher(Int8, 'IR_right', 1)
Und über die timer_callback Funktion werden die Sensordaten gepublished.
def timer_callback(self):
DR_status = GPIO.input(DR)
msg_right = Int8()
msg_right.data = DR_status
self.sensor_publisher_right.publish(msg_right)
self.get_logger().info('Publishing right: "%s"' % msg_right.data)
Zusätzlich wurde die Master-Node "master.py" erstellt, wo die Sensor Subcriber und ein ObstacleAvoidanceModule für die Motorsteuerung implementiert wurden, damit der Roboter autonom Hindernisse umfahren kann.
self.sub_right = self.create_subscription(Int8, 'IR_right', self.right_callback, 10)
In der AvoidanceModule Funktion wird über eine IF-Schleife entschieden, wie die Motoren angesteuert werden sollen. Hier wird zum Beispiel die Nachricht forward" an die Slave-Node gepublished wenn die Master-Node für den linken und rechten Infrarotsensor eine "1" erhält.
def AvoidanceModule(self):
msg = String()
if self.front_right == 1 and self.front_left == 1:
msg.data = 'forward'
self.pub.publish(msg)
self.get_logger().info('Publishing Move: "%s"' % msg.data)
Zuletzt werden über die right_callback Funktion die Sensordaten herhalten und die AvoidanceModule Funktion wird aufgerufen.
def right_callback(self, msg):
self.front_right = msg.data
self.AvoidanceModule()
Ultraschall Hinderniss Umfahrung
Für die verschiedenen Programme können die
Der RQT-Graph zur Graphischen Darstellung
Demo
Software
Zusammenfassung
Weiterführende Links
→ zurück zum Hauptartikel: Robot Operating System2 (ROS2)