Robotics Frameworks - Exam

Aufgabe 1)

Einführung in die Robotik-Frameworks: In dieser Aufgabe soll ein autonomer Roboter in einer simulierten Umgebung mit Hilfe eines Robotik-Frameworks programmiert werden. Der Roboter soll selbstständig navigieren, Hindernissen ausweichen und bestimmte Ziele erreichen. Dafür stehen die Middleware ROS, eine modulare Architektur und Kommunikationsmodelle wie Publisher-Subscriber und Service-Client zur Verfügung. Sensoren und Aktuatoren müssen integriert und korrekt kalibriert werden. Die Entwicklung erfolgt hauptsächlich in C++ und Python, und die Simulation wird in Gazebo durchgeführt. Sicherheitsaspekte wie Fehlertoleranz und die Mensch-Roboter-Interaktion müssen berücksichtigt werden.

a)

Implementiere eine einfache ROS-Node in Python, die als Publisher funktioniert und die Position (x, y) des Roboters in der simulierten Umgebung regelmäßig veröffentlicht. Verwende dazu die ROS-Tutorials und beschreibe Schritt für Schritt den Prozess der Erstellung dieser Node.

Lösung:

Schrittweise Anleitung zur Implementierung einer einfachen ROS-Node in PythonDieser Leitfaden hilft Dir bei der Erstellung einer Python-ROS-Node, die die Position des Roboters in der simulierten Umgebung veröffentlicht. Befolge die folgenden Schritte:

• Vorbereitungen:Stelle sicher, dass ROS (Robot Operating System) und Gazebo auf Deinem Computer installiert sind. Diese Anleitung setzt ROS Noetic voraus. Andere Versionen können ähnliche Schritte erfordern.
• Erstelle ein neues ROS-Package:Öffne ein Terminal und navigiere zu Deinem Catkin-Arbeitsverzeichnis (z.B. ~/catkin_ws). Erstelle ein neues ROS-Package mit den folgenden Befehlen:

  cd ~/catkin_ws/srccatkin_create_pkg my_robot_tutorial rospy std_msgs

  Wechsle anschließend in das neu erstellte Package-Verzeichnis:

  cd ~/catkin_ws/src/my_robot_tutorial

• Erstelle das Python-Skript für den Publisher:Erstelle ein Verzeichnis für die Skripte und das eigentliche Skript selbst:

  mkdir scriptscd scriptstouch position_publisher.pychmod +x position_publisher.py

  Öffne die Datei position_publisher.py mit einem Texteditor Deiner Wahl und füge den folgenden Code ein:

  #!/usr/bin/env python3import rospyfrom geometry_msgs.msg import Pointdef position_publisher():    rospy.init_node('position_publisher', anonymous=True)    pub = rospy.Publisher('robot_position', Point, queue_size=10)    rate = rospy.Rate(1)  # 1 Hz    x = 0.0    y = 0.0    while not rospy.is_shutdown():        point = Point()        x += 0.1        y += 0.1        point.x = x        point.y = y        rospy.loginfo(f'Publishing position: x={point.x}, y={point.y}')        pub.publish(point)        rate.sleep()if __name__ == '__main__':    try:        position_publisher()    except rospy.ROSInterruptException:        pass

  • Erklärung des Codes:
    • rospy.init_node('position_publisher', anonymous=True) initialisiert die ROS-Node.
    • pub = rospy.Publisher('robot_position', Point, queue_size=10) definiert den Publisher, der Nachrichten vom Typ geometry_msgs/Point auf dem Topic robot_position veröffentlicht.
    • In der Schleife wird die Position des Roboters um 0,1 Einheiten in x- und y-Richtung erhöht und als Point veröffentlicht.
• Ändere die CMakeLists.txt und package.xml:Stelle sicher, dass die CMakeLists.txt und package.xml-Dateien Deinen Knoten korrekt referenzieren. In der CMakeLists.txt solltest Du rospy als Abhängigkeit hinzufügen, wenn es nicht bereits dort ist.

  find_package(catkin REQUIRED COMPONENTS  rospy  std_msgs)

• Komplettiere das Catkin-Build:Wechsle zurück in das Catkin-Wurzelverzeichnis und führe catkin_make aus, um das Package zu bauen:

  cd ~/catkin_wscatkin_make

• Starte die ROS-Node:Starte den ROS-Master im ersten Terminal:

  roscore

  Öffne ein zweites Terminal, source Deinen Arbeitsbereich und starte die Node:

  source ~/catkin_ws/devel/setup.bashrosrun my_robot_tutorial position_publisher.py

  Die Node wird jetzt die Position des Roboters auf dem robot_position Topic veröffentlichen.

Zusammenfassung:Durch diese Schritte hast Du erfolgreich eine ROS-Node in Python erstellt, die die Position des Roboters regelmäßig veröffentlicht. Du hast gelernt, ein neues ROS-Package zu erstellen, ein Python-Skript für den Publisher zu schreiben, die nötigen Konfigurationsdateien anzupassen, und schließlich die Node zu starten. Diese Grundkenntnisse sind wichtig, um komplexere Robotik-Anwendungen zu entwickeln und in einer simulierten Umgebung zu testen. Viel Erfolg bei Deiner weiteren Arbeit in der Robotik!

b)

Integriere Sensoren (wie Lidar oder Kamera) in die simulierte Roboterumgebung in Gazebo mittels ROS. Erkläre, wie die Sensordaten verarbeitet und mit Hilfe von Datenfusion kombiniert werden können, um eine präzisere Umgebungskarte zu erstellen. Binde dazu relevante ROS-Pakete ein und zeige, wie die Sensordaten in einer ROS-Node abonniert und verarbeitet werden.

Lösung:

Schrittweise Anleitung zur Integration und Verarbeitung von Sensoren in der simulierten Roboterumgebung in Gazebo mittels ROSDieser Leitfaden hilft Dir dabei, Sensoren (zum Beispiel Lidar und Kamera) in eine simulierte Roboterumgebung in Gazebo zu integrieren und die Sensordaten mittels ROS zu verarbeiten und zu fusionieren, um eine präzisere Umgebungskarte zu erstellen. Befolge die folgenden Schritte:

• Vorbereitungen:Stelle sicher, dass ROS (Robot Operating System) und Gazebo auf Deinem Computer installiert sind. Diese Anleitung setzt ROS Noetic voraus. Andere Versionen können ähnliche Schritte erfordern.
• Erstelle eine Gazebo-Umgebung mit Sensoren:Erstelle ein SDF- oder URDF-Modell für Deinen Roboter und füge die benötigten Sensoren (Lidar und Kamera) hinzu.

  <robot name='my_robot'>  <link name='base_link'>    ...  </link>  <!-- Lidar Sensor -->  <gazebo>    <plugin name='my_lidar' filename='libgazebo_ros_laser.so'>      <robotNamespace>/my_robot</robotNamespace>      <frameName>base_link</frameName>      <topicName>/scan</topicName>      <updateRate>10.0</updateRate>    </plugin>  </gazebo>  <!-- Kamera Sensor -->  <gazebo>    <plugin name='my_camera' filename='libgazebo_ros_camera.so'>      <robotNamespace>/my_robot</robotNamespace>      <frameName>base_link</frameName>      <imageTopicName>/camera/image_raw</imageTopicName>      <cameraInfoTopicName>/camera/camera_info</cameraInfoTopicName>    </plugin>  </gazebo></robot>

  Speichere dieses Modell und lade es in Gazebo, indem Du Dein Launch-File entsprechend erstellst oder anpasst.
• Relevante ROS-Pakete einbinden:Stelle sicher, dass Du die nötigen ROS-Pakete installiert hast, die zur Verarbeitung der Sensordaten benötigt werden:
  • sudo apt-get install ros-noetic-hector-slam (für Lidar-Datenverarbeitung und SLAM)
  • sudo apt-get install ros-noetic-image-transport (für die Arbeit mit Kameradaten)
• Abonniere und verarbeite die Sensordaten in einer ROS-Node:Erstelle ein neues Skript, um die Sensordaten zu abonnieren und mittels Datenfusion zu verarbeiten.

  #!/usr/bin/env python3import rospyfrom sensor_msgs.msg import LaserScan, Imagefrom cv_bridge import CvBridge, CvBridgeErrorimport cv2import numpy as npdef callback_lidar(data):    # Verarbeitung der Lidar-Daten    rospy.loginfo(f'Received Lidar data: {data.ranges}')def callback_camera(data):    # Verarbeitung der Kameradaten    bridge = CvBridge()    try:        cv_image = bridge.imgmsg_to_cv2(data, 'bgr8')        # Zeige das Bild an        cv2.imshow('Camera Image', cv_image)        cv2.waitKey(3)    except CvBridgeError as e:        rospy.logerr(e)def sensor_fusion():    rospy.init_node('sensor_fusion_node', anonymous=True)    rospy.Subscriber('/scan', LaserScan, callback_lidar)    rospy.Subscriber('/camera/image_raw', Image, callback_camera)    rospy.spin()if __name__ == '__main__':    try:        sensor_fusion()    except rospy.ROSInterruptException:        pass

  • Erklärung des Codes:
    • Die Funktion callback_lidar(data) verarbeitet die Lidar-Daten, die auf dem 'scan'-Topic empfangen werden.
    • Die Funktion callback_camera(data) verarbeitet die Kameradaten, konvertiert das ROS-Image-Meldungsformat in ein OpenCV-taugliches Format und zeigt das Bild an.
    • Die Funktion sensor_fusion() initialisiert die ROS-Node, abonniert die Sensor-Topics und ruft die entsprechenden Callback-Funktionen auf.
    • Die Funktionen können erweitert werden, um Datenfusion zu implementieren, indem die Informationen aus beiden Sensoren kombiniert werden, um eine präzisere Umgebungskarte zu erstellen.
• Datenfusion und Kartenerstellung:Für die Datenfusion und Kartenerstellung werden meistens SLAM-Algorithmen (Simultaneous Localization and Mapping) wie der Hector SLAM verwendet. Achte darauf, dass Du diese Algorithmen korrekt einbindest und entsprechend konfigurierst, um die Daten von Lidar und Kamera zu kombinieren. In der Regel wird dabei ein Octomap oder ein ähnliches Mapping-Verfahren verwendet.
• Starte alle Nodes und überprüfe die Ausgabe:Stelle sicher, dass alle Nodes korrekt gestartet werden und die Sensordaten wie erwartet abonniert und verarbeitet werden. Starte Gazebo im ersten Terminal:

  roslaunch my_robot_tutorial my_robot_world.launch

  Starte dann Deine Sensor-Fusion-Node in einem zweiten Terminal:

  rosrun my_robot_tutorial sensor_fusion_node.py

Zusammenfassung:Durch diese Schritte hast Du erfolgreich Sensoren wie Lidar und Kamera in Deine simulierte Roboterumgebung in Gazebo integriert und gelernt, wie Du die Sensordaten mit ROS abonnieren und verarbeiten kannst. Diese Daten können weiter für die Erstellung präziser Umgebungskarten mithilfe von Datenfusionstechniken verwendet werden. Die im Guide erwähnten ROS-Pakete und -Techniken bieten Dir eine solide Grundlage für komplexere Robotikanwendungen und -simulationen. Viel Erfolg bei Deiner weiteren Arbeit in der Robotik!

c)

Erstelle ein einfaches Bewegungssteuerungsskript in C++, das den Roboter auf Basis der Sensordaten steuert und auf einem vorgegebenen Pfad navigiert. Beschreibe den Aufbau dieses Skriptes und wie die Kommunikation zwischen den einzelnen Modulen (Sensoren, Aktuatoren) erfolgt. Zeige die einzelnen Schritte sowie den Codeausschnitt für die Bewegungssteuerung und Hindernisvermeidung.

Lösung:

Schrittweise Anleitung zur Erstellung eines einfachen Bewegungssteuerungsskripts in C++Dieser Leitfaden hilft Dir bei der Erstellung eines C++-Skripts zur Bewegungssteuerung eines Roboters auf Basis von Sensordaten. Das Skript wird dem Roboter ermöglichen, Hindernissen auszuweichen und einem vorgegebenen Pfad zu folgen.

• Vorbereitungen:Stelle sicher, dass ROS (Robot Operating System) und Gazebo auf Deinem Computer installiert sind. Diese Anleitung setzt ROS Noetic voraus. Andere Versionen können ähnliche Schritte erfordern.
• Erstelle ein neues ROS-Package:Öffne ein Terminal und navigiere zu Deinem Catkin-Arbeitsverzeichnis (z.B. ~/catkin_ws). Erstelle ein neues ROS-Package mit den folgenden Befehlen:

  cd ~/catkin_ws/srccatkin_create_pkg robot_movement_tutorial roscpp std_msgs sensor_msgs geometry_msgs

  Wechsle anschließend in das neu erstellte Package-Verzeichnis:

  cd ~/catkin_ws/src/robot_movement_tutorial

• Erstelle das C++-Skript für die Bewegungssteuerung:Erstelle ein Verzeichnis für die Quellcodedateien und das eigentliche Skript selbst:

  mkdir srccd srctouch movement_controller.cpp

  Öffne die Datei movement_controller.cpp mit einem Texteditor Deiner Wahl und füge den folgenden Code ein:

  #include <ros/ros.h>#include <sensor_msgs/LaserScan>#include <geometry_msgs/Twist>class RobotController {public:    RobotController() {        cmd_pub_ = nh_.advertise<geometry_msgs::Twist>("/cmd_vel", 10);        laser_sub_ = nh_.subscribe("/scan", 10, &RobotController::laserCallback, this);    }    void laserCallback(const sensor_msgs::LaserScan::ConstPtr& scan) {        bool obstacle = false;        for (int i = 0; i < scan->ranges.size(); ++i) {            if (scan->ranges[i] < 0.5) {                obstacle = true;                break;            }        }        geometry_msgs::Twist cmd;        if (obstacle) {            cmd.linear.x = 0.0;            cmd.angular.z = 0.5; // Drehung bei Hindernis        } else {            cmd.linear.x = 0.2; // Vorwärtsbewegung            cmd.angular.z = 0.0;        }        cmd_pub_.publish(cmd);    }private:    ros::NodeHandle nh_;    ros::Publisher cmd_pub_;    ros::Subscriber laser_sub_;};int main(int argc, char** argv) {    ros::init(argc, argv, "robot_controller");    RobotController controller;    ros::spin();    return 0;}

  • Erklärung des Codes:
    • Die Klasse RobotController initialisiert den Publisher cmd_pub_ für Bewegungsbefehle und den Subscriber laser_sub_ für die Lidar-Daten.
    • Die Methode laserCallback überprüft die Lidar-Daten und bestimmt, ob ein Hindernis vor dem Roboter liegt. Wenn ein Hindernis erkannt wird (Entfernung < 0.5), wird der Roboter angehalten und dreht sich. Ansonsten bewegt er sich vorwärts.
    • Im main wird die ROS-Node initialisiert, und die RobotController-Klasse wird ausgeführt.
• Ändere die CMakeLists.txt und package.xml:Stelle sicher, dass die CMakeLists.txt die neue Quelle für die Kompilierung referenziert und die notwendigen Abhängigkeiten auflistet.
  • In der CMakeLists.txt füge hinzu:

    add_executable(movement_controller src/movement_controller.cpp)target_link_libraries(movement_controller ${catkin_LIBRARIES})

  • In der package.xml sicherstellen, dass die Abhängigkeiten korrekt aufgelistet sind:

    <build_depend>roscpp</build_depend><build_depend>sensor_msgs</build_depend><build_depend>geometry_msgs</build_depend><exec_depend>roscpp</exec_depend><exec_depend>sensor_msgs</exec_depend><exec_depend>geometry_msgs</exec_depend>

• Komplettiere das Catkin-Build:Wechsle zurück in das Catkin-Arbeitsverzeichnis und führe catkin_make aus:

  cd ~/catkin_wscatkin_make

• Starte die Gazebo-Simulation und die Bewegungssteuerungs-Node:Starte im ersten Terminal die Gazebo-Simulation:

  roslaunch my_robot_tutorial my_robot_world.launch

  Starte in einem zweiten Terminal die Bewegungssteuerungs-Node:

  source ~/catkin_ws/devel/setup.bashrosrun robot_movement_tutorial movement_controller

Zusammenfassung:Durch diese Schritte hast Du ein C++-Skript zur Bewegungssteuerung eines Roboters erstellt, das den Roboter auf Basis der Sensordaten steuert und Hindernissen ausweicht. Du hast gelernt, wie man ROS-Pakete erstellt und konfiguriert, eine ROS-Node in C++ schreibt, die Sensordaten abonniert und verarbeitet sowie die Bewegungsbefehle an die Aktuatoren sendet. Diese Grundkenntnisse sind wichtig, um komplexere Robotik-Anwendungen zu entwickeln und in einer simulierten Umgebung zu testen. Viel Erfolg bei Deiner weiteren Arbeit in der Robotik!

d)

Diskutiere die Sicherheitsaspekte der Mensch-Roboter-Interaktion in einem öffentlichen Raum. Welche Maßnahmen müssen ergriffen werden, um Fehlertoleranz sicherzustellen und Unfälle zu vermeiden? Entwickle dabei ein Konzept basierend auf ROS, das eine robuste und sichere Interaktion ermöglicht. Berücksichtige dabei sowohl Hardware- als auch Software-basierte Lösungen und erkläre, wie diese in deine bestehende Architektur integriert werden können.

Lösung:

Diskussion der Sicherheitsaspekte der Mensch-Roboter-Interaktion in einem öffentlichen RaumDie Interaktion von Robotern mit Menschen in öffentlichen Räumen stellt besondere Sicherheitsherausforderungen dar. In diesem Kontext müssen Maßnahmen ergriffen werden, um Fehlertoleranz sicherzustellen und Unfälle zu vermeiden. Diese Maßnahmen umfassen sowohl Hardware- als auch Software-basierte Lösungen.

• Hardware-basierte Lösungen:
  • Not-Aus-Schalter (E-Stop): Jeder Roboter in einem öffentlichen Raum sollte mindestens einen gut zugänglichen Not-Aus-Schalter haben, der den Roboter sofort abschaltet, wenn eine Gefahrensituation auftritt.
  • Schutzabdeckungen und weiche Materialien: Roboter sollten mit Schutzabdeckungen und weichen Materialien ausgestattet sein, um Verletzungen im Falle eines Zusammenstoßes zu minimieren.
  • Sicherheits-sensoren: Verwendung von Lidar, Kameras, Infrarotsensoren und Ultrasonic-Sensoren, um die Umgebung und die Nähe von Menschen ständig zu überwachen.
  • Redundante Systeme: Duale Systeme zur Überwachung kritischer Funktionen des Roboters, um sicherzustellen, dass Fehler in einem System nicht zum vollständigen Ausfall führen.
• Software-basierte Lösungen:
  • Fehlertolerante Algorithmen: Entwicklung von Algorithmen, die robust gegen Sensor- und Aktuatorfehler sind und den Roboter in den sicheren Zustand versetzen können.
  • Bewegungsplanung und Hindernisvermeidung: Implementierung fortschrittlicher Bewegungsplanungsalgorithmen wie RRT (Rapidly-exploring Random Trees) und A* zur Vermeidung dynamischer Hindernisse.
  • Verhalten in Notsituationen: Definition von Notfallverhalten, z. B. das sofortige Anhalten und Kommunizieren eines Problems an den Bediener.
• Integration in die bestehende ROS-Architektur:
  • Not-Aus-Schalter: Implementiere einen Not-Aus-Schalter, der mit dem ROS-System verbunden ist. Verwende ein bool-Topic wie /emergency_stop, das auf true gesetzt wird, wenn der Schalter betätigt wird.

    #include <std_msgs/Bool.h>ros::Publisher e_stop_pub = nh.advertise<std_msgs::Bool>("/emergency_stop", 10);std_msgs::Bool e_stop_msg;e_stop_msg.data = true;e_stop_pub.publish(e_stop_msg);

  • Sicherheits-sensoren: Verwende ROS-Topics, um Sensordaten zu sammeln und diese in sichere Bewegungsalgorithmen einzubeziehen. Zum Beispiel können Lidar-Daten zur Hindernisvermeidung wie folgt abonniert und verarbeitet werden:

    #include <sensor_msgs/LaserScan.h>void lidarCallback(const sensor_msgs::LaserScan::ConstPtr& scan) {    // Process scan data    if (detectObstacle(scan)) {        stopRobot();    }}ros::Subscriber lidar_sub = nh.subscribe("/scan", 10, lidarCallback);

  • Fehlertolerantes Verhalten: Implementiere in der Steuerungs-Node Fehlertoleranz, indem Du Überprüfungen für Sensorausfälle und andere kritische Fehler implementierst:

    try {    // Erhalte Sensor-Daten} catch (const std::exception& e) {    ROS_ERROR("Sensor error: %s", e.what());    stopRobot();}

• Beispielmäßiges Sicherheitskonzept basierend auf ROS:
  • Node-Redundanz: Implementiere redundante Nodes, z. B. zwei Nodes zur Überwachung der Lidar-Daten und eine Voting-Logik, die entscheidet, ob eine Gefahr vorliegt.

    void lidarCallback1(const sensor_msgs::LaserScan::ConstPtr& scan) {    // Verarbeite Daten von Lidar 1}void lidarCallback2(const sensor_msgs::LaserScan::ConstPtr& scan) {    // Verarbeite Daten von Lidar 2}bool voteForSafetyCheck() {    // Implementiere Voting-Logik    return (obstacle_detected_by_lidar1 || obstacle_detected_by_lidar2);}ros::Subscriber lidar_sub1 = nh.subscribe("/scan1", 10, lidarCallback1);ros::Subscriber lidar_sub2 = nh.subscribe("/scan2", 10, lidarCallback2);

  • Kommunikation und Protokollierung: Nutze ROS-Logging und Nachrichten, um den Status des Roboters ständig zu kommunizieren und alarmiere Bediener bei Sicherheitsproblemen.

    ROS_INFO("Robot operating normally");if (emergency) {    ROS_WARN("Emergency stop activated!");}

  • Interaktion mit Benutzern: Verwende Sprach-, Text- oder visuelle Schnittstellen, um Menschen in der Nähe über den Status des Roboters zu informieren und Sicherheits- oder Betriebsanweisungen zu geben.

Zusammenfassung:In dieser Anleitung haben wir die wichtigsten Sicherheitsaspekte der Mensch-Roboter-Interaktion in öffentlichen Räumen diskutiert und sowohl Hardware- als auch Softwarebasierte Lösungen vorgestellt. Durch die Integration von Not-Aus-Schaltern, Safety-Sensoren, Fehlertoleranten Algorithmen und Bewegungssteuerungen in das bestehende ROS-System können wir die Sicherheit und Robustheit eines autonomen Roboters erhöhen. Diese Maßnahmen sind essenziell, um eine sichere Interaktion von Robotern mit Menschen in öffentlichen Räumen zu gewährleisten.

Aufgabe 2)

Installation und Konfiguration von ROSInstallation und Einrichtung des Robot Operating Systems (ROS) für die Roboterentwicklung.

• Installiere ROS: sudo apt install ros--desktop-full
• Initialisiere rosdep: sudo rosdep init && rosdep update
• Umgebungsvariablen setzen: source /opt/ros//setup.bash
• Catkin-Workspace einrichten: mkdir -p ~/catkin_ws/src && cd ~/catkin_ws/ && catkin_make
• Workspace-Setup-Skript ausführen: source devel/setup.bash
• Dependencies installieren: rosdep install --from-paths src --ignore-src -r -y

a)

Stelle sicher, dass die ROS-Umgebung korrekt initialisiert ist. Beschreibe die Schritte und warum jede dieser Schlüsselschritte notwendig ist, um sicherzustellen, dass ROS korrekt funktioniert.

Lösung:

Sicherstellen, dass die ROS-Umgebung korrekt initialisiert istUm sicherzustellen, dass die ROS-Umgebung korrekt initialisiert ist, muss jeder Schritt in der Installations- und Konfigurationsprozedur genau befolgt werden. Hier sind die Schritte und die Erklärungen, warum sie notwendig sind, um sicherzustellen, dass ROS korrekt funktioniert:

• Installiere ROS: sudo apt install ros-<distribution>-desktop-fullDieser Schritt installiert ROS auf Deinem System. Die Desktop-Full-Version enthält alles, was Du für die Entwicklung und den Betrieb von ROS benötigst, einschließlich GUI-Tools wie Rviz und rqt.
• Initialisiere rosdep: sudo rosdep init && rosdep updaterosdep ist ein Befehlszeilentool, das die für Dein System erforderlichen Abhängigkeiten auflöst. Die Initialisierung und das Update von rosdep stellen sicher, dass alle notwendigen Abhängigkeiten und Abhängigkeitspfade korrekt eingerichtet sind.
• Umgebungsvariablen setzen: source /opt/ros/<distribution>/setup.bashDieser Befehl setzt die notwendigen Umgebungsvariablen, damit ROS auf Deinem System läuft. Dies umfasst das Hinzufügen von ROS-spezifischen Pfaden zur PATH-Umgebungsvariable und das Festlegen anderer erforderlicher Variablen.
• Catkin-Workspace einrichten: mkdir -p ~/catkin_ws/src && cd ~/catkin_ws/ && catkin_makeCatkin ist das Build-System von ROS. Dieser Schritt erstellt einen neuen Workspace, in dem Du Deine ROS-Pakete erstellen und verwalten kannst. Der Befehl catkin_make baut den Workspace und erstellt alle notwendigen Konfigurationsdateien.
• Workspace-Setup-Skript ausführen: source devel/setup.bashNach dem Erstellen des Workspaces musst du dieses Skript ausführen, damit die Umgebungsvariablen für Deinen neuen Workspace gesetzt werden. Dies ermöglicht es dir, auf die Pakete und Ressourcen in deinem Workspace zuzugreifen.
• Dependencies installieren: rosdep install --from-paths src --ignore-src -r -yDieser Schritt verwendet rosdep, um alle notwendigen Abhängigkeiten für die Pakete im src-Verzeichnis Deines Workspaces zu installieren. Dies ist wichtig, um sicherzustellen, dass alle Pakete korrekt gebaut und ausgeführt werden können.

b)

Nach der Einrichtung des Catkin-Workspaces soll ein einfaches ROS-Paket erstellt werden. Im Verzeichnis ~/catkin_ws/src, erstelle ein Paket namens my_robot_package mit den Abhängigkeiten roscpp und std_msgs. Zeige die dazugehörigen Befehle und erkläre kurz die Bedeutung jedes einzelnen.

Lösung:

Erstellen eines einfachen ROS-Pakets nach der Einrichtung des Catkin-WorkspacesUm ein ROS-Paket namens my_robot_package mit den Abhängigkeiten roscpp und std_msgs im Verzeichnis ~/catkin_ws/src zu erstellen, müssen folgende Schritte ausgeführt werden:

• Navigiere zum src-Verzeichnis Deines Catkin-Workspaces:

  cd ~/catkin_ws/src

  Dieser Schritt wechselt in das Quellverzeichnis (src) Deines Catkin-Workspaces, in dem sich Deine ROS-Pakete befinden.
• Lege das neue ROS-Paket an:

  catkin_create_pkg my_robot_package roscpp std_msgs

  Der Befehl catkin_create_pkg erstellt ein neues ROS-Paket mit dem Namen my_robot_package. Die nachfolgenden Argumente roscpp und std_msgs legen die Abhängigkeiten fest, die Dein Paket benötigt. Dieser Befehl erzeugt die erforderliche Verzeichnisstruktur und die notwendigen Konfigurationsdateien wie package.xml und CMakeLists.txt.
• Wechsle zurück zum Hauptverzeichnis des Catkin-Workspaces:

  cd ~/catkin_ws

  Dieser Schritt bringt Dich zurück zum Hauptverzeichnis des Catkin-Workspaces, damit Du den Build-Prozess starten kannst.
• Build den Catkin-Workspace:

  catkin_make

  Der Befehl catkin_make kompiliert alle Pakete im Catkin-Workspace, einschließlich des neu erstellten Pakets my_robot_package. Dabei werden auch die Abhängigkeiten geprüft und eingebunden.
• Setze die Umgebungsvariablen erneut:

  source devel/setup.bash

  Nachdem das Paket gebaut wurde, sollten die Umgebungsvariablen erneut gesetzt werden, damit die Änderungen an Deinem Workspace aktiv werden. Dies erlaubt ROS, Dein neues Paket zu erkennen und zu nutzen.

Aufgabe 3)

Stellen Sie sich vor, Sie haben ein robotisches System, das die Entfernung zu einem Objekt misst und die gemessenen Daten an einen zentralen Rechner sendet, der die Daten weiterverarbeitet und auf diesem basierend Befehle an den Roboter zurücksendet. Die Kommunikation innerhalb dieses Systems erfolgt mittels ROS (Robot Operating System).

a)

• Nodes: Beschreibe zwei mögliche Nodes, die in diesem System eingesetzt werden könnten und deren jeweilige Rollen. Erkläre, wie diese Nodes in ROS definiert und gestartet werden.

Lösung:

• Nodes:

Beschreibung der Nodes:

• Sensor-Node: Diese Node ist verantwortlich für das Erfassen der Entfernungsmessungen zu einem Objekt. Der Sensor-Node erhält die Daten vom Sensor (z.B. einem LIDAR-Sensor oder Ultraschallsensor) und veröffentlicht diese in einem bestimmten Topic, damit andere Nodes im System diese Daten abgreifen können. Controller-Node: Diese Node verarbeitet die gesammelten Sensordaten, führt die notwendigen Berechnungen durch und sendet die entsprechenden Befehle zurück an den Roboter. Der Controller-Node kann auf Basis der Entfernungsmessungen Entscheidungen treffen, wie z.B. Bewegungsbefehle, um Kollisionen zu vermeiden oder bestimmte Ziele zu erreichen.

Definition und Start der Nodes in ROS:

• Sensor-Node: Die Definition eines Sensor-Nodes in einer Python-Datei könnte wie folgt aussehen:

   #!/usr/bin/env pythonimport rospyfrom sensor_msgs.msg import Range# Definition der Callback-Funktion def sensor_callback(data): rospy.loginfo('Distance: %f', data.range) # Initialisierung des Nodes rospy.init_node('sensor_node', anonymous=True) # Subscriben zum Sensor-Topic rospy.Subscriber('sensor_data', Range, sensor_callback) # ROS-Node ausführen rospy.spin()

  Um den Sensor-Node zu starten, kann das folgende Kommando in der Kommandozeile verwendet werden:

   rosrun  sensor_node.py

• Controller-Node: Die Definition eines Controller-Nodes könnte wie folgt aussehen:

   #!/usr/bin/env pythonimport rospyfrom sensor_msgs.msg import Rangefrom geometry_msgs.msg import Twist # Definition der Callback-Funktion def control_callback(data): cmd = Twist() if data.range < 1.0: cmd.linear.x = 0.0 cmd.angular.z = 1.0 else: cmd.linear.x = 0.5 cmd.angular.z = 0.0 # Publisher cmd_pub = rospy.Publisher('cmd_vel', Twist, queue_size=10) cmd_pub.publish(cmd)# Initialisierung des Nodesrospy.init_node('controller_node', anonymous=True) # Subscriben zum Sensor-Topic rospy.Subscriber('sensor_data', Range, control_callback) # ROS-Node ausführenrospy.spin()

  Um den Controller-Node zu starten, kann das folgende Kommando in der Kommandozeile verwendet werden:

   rosrun  controller_node.py

b)

• Topics: Definiere zwei Topics, die in dem oben beschriebenen Szenario verwendet werden könnten. Beschreibe, welche Arten von Nachrichten über diese Topics gesendet werden und die Bedeutung der Datenfelder in den Nachrichten.

Lösung:

• Topics:

Definition von zwei Topics:

• sensor_data: Dieses Topic wird verwendet, um die Entfernungsmessungen vom Sensor-Node an andere Nodes zu übermitteln. Die Nachrichtenart, die über dieses Topic gesendet wird, könnte vom Typ sensor_msgs/Range sein. Die sensor_msgs/Range Nachricht hat folgende relevante Datenfelder:
  • header: enthält Metadaten wie Zeitstempel und den Koordinatenrahmen des Sensors
  • radiation_type: Typ der Strahlung (z.B. Ultraschall oder Infrarot)
  • field_of_view: Öffnungswinkel des Sensors
  • min_range: Minimale Entfernung, die der Sensor messen kann
  • max_range: Maximale Entfernung, die der Sensor messen kann
  • range: Tatsächliche Entfernungsmessung
• cmd_vel: Dieses Topic wird verwendet, um Bewegungsbefehle vom Controller-Node zum Roboter zu senden. Die Nachrichtenart, die über dieses Topic gesendet wird, könnte vom Typ geometry_msgs/Twist sein. Die geometry_msgs/Twist Nachricht hat folgende relevante Datenfelder:
  • linear: enthält einen Vektor x, y, z, der die linearen Geschwindigkeiten in den jeweiligen Achsen angibt (in der Regel wird nur die x-Achse für Vorwärts-/Rückwärtsbewegungen genutzt)
  • angular: enthält einen Vektor x, y, z, der die Winkelgeschwindigkeiten in den jeweiligen Achsen angibt (in der Regel wird nur die z-Achse für Drehbewegungen um die Vertikale Achse genutzt)

Bedeutung der Datenfelder:Die Datenfelder in den Nachrichten geben spezifische Informationen über den Zustand des Systems bzw. die beabsichtigten Bewegungen des Roboters.

• Im Falle des sensor_data Topics helfen die Felder des sensor_msgs/Range Nachrichtentyps, die Entfernung zu Objekten genau zu bestimmen und diese Information anderen Nodes zur Verfügung zu stellen.
• Im Falle des cmd_vel Topics geben die Felder des geometry_msgs/Twist Nachrichtentyps präzise Befehle zur Steuerung der Bewegung des Roboters. Lineare Geschwindigkeiten steuern die Vorwärts- und Rückwärtsbewegung, während Winkelgeschwindigkeiten die Drehbewegung des Roboters steuern.

c)

• Services: Entwerfe einen Service, der in diesem Szenario nützlich sein könnte. Beschreibe die zugehörige .srv-Datei (die Anfragen und Antworten definiert) und erkläre, wie dieser Service in ROS aufgerufen und implementiert wird. Gib auch ein Beispiel, wie ein Request und eine Response in diesem Service aussehen könnten.

Lösung:

• Services:

Entwurf eines nützlichen Services:

• Service zur Anfrage und Änderung der Sensorkonfiguration: In diesem Szenario könnte es nützlich sein, einen Service zu haben, der die Abfrage oder Änderung der Konfiguration des Sensors ermöglicht. Beispielsweise könnte dieser Service verwendet werden, um den Messbereich oder die Messfrequenz des Sensors dynamisch anzupassen.

Beschreibung der .srv-Datei:Die zugehörige SetSensorConfig.srv-Datei könnte folgendermaßen aussehen:

 float32 min_range  # Minimale Entfernung, die der Sensor messen kann float32 max_range  # Maximale Entfernung, die der Sensor messen kann float32 frequency  # Messfrequenz --- bool success       # Indikator, ob die Konfiguration erfolgreich war string message      # Nachricht zur Rückmeldung 

Implementierung des Services in ROS:Die Implementierung des Services erfolgt in zwei Schritten: Definition des Service-Servers und Aufruf des Service-Clients.

• Server: Die Definition und Implementierung des Service-Servers könnte wie folgt aussehen:

  #!/usr/bin/env python import rospy from .srv import SetSensorConfig, SetSensorConfigResponse # Service-Callback-Funktion def handle_set_sensor_config(req): # Hier würden die aktuellen Sensor-Konfigurationen angepasst werden rospy.loginfo('Setting Sensor Config: min_range=%f, max_range=%f, frequency=%f', req.min_range, req.max_range, req.frequency) success = True  # Platzhalter logik, um den Erfolg zu bestimmen message = 'Sensor configuration updated successfully' if success else 'Failed to update sensor configuration' return SetSensorConfigResponse(success, message) # Initialisierung des Service-Servers def sensor_config_server(): rospy.init_node('sensor_config_server') service = rospy.Service('set_sensor_config', SetSensorConfig, handle_set_sensor_config) rospy.loginfo('Sensor Config Service is ready.') rospy.spin() if __name__ == '__main__': sensor_config_server() 

• Client: Die Definition und Implementierung des Service-Clients könnte wie folgt aussehen:

  #!/usr/bin/env python import rospy from .srv import SetSensorConfig # Aufrufen des Service def set_sensor_config_client(min_range, max_range, frequency): rospy.wait_for_service('set_sensor_config') try: set_sensor_config = rospy.ServiceProxy('set_sensor_config', SetSensorConfig) resp = set_sensor_config(min_range, max_range, frequency) return resp.success, resp.message except rospy.ServiceException as e: rospy.logerr('Service call failed: %s', e) if __name__ == '__main__': rospy.init_node('sensor_config_client') success, message = set_sensor_config_client(0.2, 5.0, 10.0) rospy.loginfo('Service response: %s - %s', success, message) 

Beispiel für eine Request und eine Response:

• Request: min_range = 0.2, max_range = 5.0, frequency = 10.0
• Response: success = True, message = 'Sensor configuration updated successfully'

Aufgabe 4)

Du hast ein Projekt, bei dem Du einen mobilen Roboter in einer simulierten Umgebung testen möchtest, bevor Du ihn in der realen Welt einsetzt. Die Simulationssoftware Gazebo bietet Dir hierfür eine Open-Source-3D-Simulationsumgebung, die unter anderem in Kombination mit dem Robot Operating System (ROS) eingesetzt werden kann. Gazebo unterstützt physikalische Simulationen wie Kollision und Trägheit, und es gibt die Möglichkeit, Plug-ins zur Erweiterung der Funktionalität zu nutzen. Zudem können 3D-Objekte und Umgebungen importiert werden, um die Simulation so realitätsnah wie möglich zu gestalten.

a)

Beschreibe die Schritte, die notwendig sind, um einen mobilen Roboter in Gazebo zu erstellen und zu simulieren. Gehe dabei auch auf die Integration mit ROS ein. Erkläre, welche physikalischen Modelle und Simulationen berücksichtigt werden müssen, um eine realistische Umgebung zu schaffen.

Lösung:

Schritte zur Erstellung und Simulation eines mobilen Roboters in Gazebo, inklusive Integration mit ROS: Die Simulation eines mobilen Roboters in Gazebo und dessen Integration mit ROS erfordert mehrere wichtige Schritte. Hier ist ein detaillierter Ablaufplan:

• Installation von Gazebo und ROS: Stelle sicher, dass sowohl Gazebo als auch ROS (Robot Operating System) auf Deinem System installiert sind. Befolge die Anleitungen zur Installation und Konfiguration, die auf den offiziellen Webseiten verfügbar sind.
• Erstellung des Roboter-Modells: Erstelle ein 3D-Modell Deines mobilen Roboters. Dies kann mit Software wie Blender oder direkt in Gazebo erfolgen. Du kannst auch vorhandene Modelle importieren und anpassen.
• Konfiguration der URDF-Dateien: Die Unified Robot Description Format (URDF) Datei beschreibt den Roboter für ROS. Sie enthält Informationen über die Links (Teile des Roboters) und Joints (Verbindungen zwischen den Teilen). Definiere die Geometrie, Trägheit, Materialien und die kinematische Struktur Deines Roboters.
• Erstellung der Gazebo-Plugins: Entwickle oder nutze bereits vorhandene Gazebo-Plugins, um die Funktionalität Deines Roboters zu erweitern. Diese Plugins können verschiedene Aspekte wie Sensoren, Aktoren und Steuerungseinheiten simulieren.
• Integration mit ROS: Nutze ROS-Pakete wie „gazebo_ros“ zur Integration von Gazebo mit ROS. Erstelle Launch-Dateien, um die Simulation zu starten und zu steuern. Die Launch-Dateien ermöglichen das Laden der Roboter-Modelle und Plugins sowohl in Gazebo als auch in ROS.
• Physikalische Simulationen: Um eine realistische Umgebung zu schaffen, müssen verschiedene physikalische Modelle und Simulationen berücksichtigt werden, darunter:
  • Kollision: Definiere Kollisionselemente in Deinem URDF, um sicherzustellen, dass der Roboter mit Objekten in der Umgebung interagiert.
  • Trägheit: Bestimme die Trägheitstensoren jedes Teils Deines Roboters, um authentische Bewegungen zu gewährleisten.
  • Schwerkraft: Stelle sicher, dass die Simulation die Schwerkraft korrekt anwendet.
  • Reibung: Berücksichtige Reibungskoeffizienten für jede Kontaktfläche, um realistisches Bewegungsverhalten zu simulieren.
• Testen und Debuggen: Starte die Simulation und teste die Bewegungen und Interaktionen Deines Roboters. Nutze die ROS-Tools für Echtzeit-Datenaufnahme und -Analyse, um das Verhalten des Roboters zu überprüfen und zu verbessern.

Durch diese Schritte kannst Du sicherstellen, dass Dein mobiler Roboter in der simulierten Umgebung von Gazebo realitätsnah agiert und sich optimal auf den Einsatz in der realen Welt vorbereitet.

b)

Angenommen, Du hast ein Plug-in entwickelt, das die Funktionalität Deines Roboters erweitern soll. Beschreibe den Prozess der Implementierung und Integration dieses Plug-ins in Gazebo. Welche spezifischen Komponenten müssen angepasst werden und wie wird das Plug-in in der Simulationsumgebung aktiviert?

Lösung:

Prozess der Implementierung und Integration eines Plug-ins in Gazebo:Die Implementierung und Integration eines Plug-ins, das die Funktionalität eines Roboters in Gazebo erweitert, erfordert mehrere Schritte. Hier findest Du eine detaillierte Anleitung zum gesamten Prozess:

• Entwicklung des Plug-ins: Erstelle das Plug-in mit einer Programmiersprache wie C++ oder Python. Verwende die Gazebo-API, um spezifische Funktionen zu definieren, die Dein Roboter benötigt. Achte darauf, dass das Plug-in die Standards und Schnittstellen von Gazebo einhält. Ein einfaches C++-Plug-in könnte beispielsweise wie folgt aussehen:

#include <gazebo/gazebo.hh>#include <gazebo/physics/physics.hh>namespace gazebo { class MyRobotPlugin : public ModelPlugin { public: void Load(physics::ModelPtr _model, sdf::ElementPtr _sdf) { // Initialize model and access properties this->model = _model; this->sdf = _sdf; // Your custom code here } private: physics::ModelPtr model; sdf::ElementPtr sdf; }; GZ_REGISTER_MODEL_PLUGIN(MyRobotPlugin)}

• Kompilieren des Plug-ins: Schreibe ein CMakeLists.txt-Skript, um das Plug-in zu kompilieren. Stelle sicher, dass Gazebo und die anderen erforderlichen Bibliotheken verlinkt sind.

cmake_minimum_required(VERSION 2.8.3)project(my_robot_plugin)find_package(gazebo REQUIRED)include_directories(${GAZEBO_INCLUDE_DIRS})link_directories(${GAZEBO_LIBRARY_DIRS})add_library(MyRobotPlugin SHARED MyRobotPlugin.cc)target_link_libraries(MyRobotPlugin ${GAZEBO_LIBRARIES})

• Konfiguration des SDF: Definiere Dein Plug-in in der SDF-Datei (Simulation Description Format) des Roboters. Hier bindest Du das Plug-in an das Roboter-Modell:

<model name='my_robot'> <plugin name='my_robot_plugin' filename='libMyRobotPlugin.so'> </plugin></model>

• Integration mit ROS: Falls erforderlich, implementiere ROS-Schnittstellen in Deinem Plug-in, um mit ROS-Knoten zu kommunizieren. Dies kann durch ROS-Publisher und -Subscriber oder Service-Server und -Clients erfolgen.

#include <gazebo/gazebo.hh>#include <gazebo/physics/physics.hh>#include <ros/ros.h>#include <std_msgs/String.h>namespace gazebo { class MyRobotPlugin : public ModelPlugin { public: void Load(physics::ModelPtr _model, sdf::ElementPtr _sdf) { // ROS node handle if (!ros::isInitialized()) { int argc = 0; char** argv = NULL; ros::init(argc, argv,