You are currently viewing ROS Tutorial: UR5 Roboter in Rviz visualisieren – Roboterkinematik erklärt

ROS Tutorial: UR5 Roboter in Rviz visualisieren – Roboterkinematik erklärt

Um mit Robotik anzufangen muss man keinen Roboter zuhause haben. Rviz ist ein Programm um Roboter ganz einfach am Computer zu visualisieren und alles was man dazu braucht ist eine spezielle Beschreibung des Roboters. Wir werden uns anhand des UR5 Roboterarms von Universal Robots ansehen wie man Roboter in Rviz visualisiert. Außerdem werden wir uns die Beschreibung des Roboters, das sogenannte URDF (Universal Robot Description File), ansehen. Im Zuge dessen werden wir auch über Roboterkinematik reden, was zu den elementaren Grundlagen der Robotik gehört. Also dann, auf geht’s!

Notiz: Wenn ihr nur den UR5 Roboter in Rviz starten wollt, ohne mehr über URDFs und Roboterkinematik zu lesen könnt ihr direkt zur Kurzanleitung springen. Dort findet ihr alle nötigen Befehle die ihr braucht. Ansonsten legen wir gleich los!

Rviz installieren und mit dem UR5 Roboter starten

Ich gehe davon aus dass ihr schon die ROS distribution eurer Wahl auf eurem Rechner installiert habt. Wenn nicht, dann wäre jetzt der optimale Zeitpunkt (link). Bei einer normalen ROS-Installation sollte Rviz bereits installiert sein. Falls nicht, müsst ihr folgenden Befehl in eurem Linux-Terminal ausführen:

$ sudo apt-get install ros-$ROS_DISTRO-rviz

Zusätzlich müssen wir das folgende ROS-Package installieren welches den Status (die Winkel) unserer Robotergelenke sendet:

$ sudo apt-get install ros-$ROS_DISTRO-joint-state-publisher-gui

Damit der Roboter in unserer Simulation gut aussieht und nicht nur aus ein paar sich verschiebenden Koordinatensystemen besteht müssen wir Rviz sagen wie unser Roboter aussieht. Dafür installieren wir das universal-robot package aus dem ROS industrial Projekt. Dieses Package bietet viele Dateien und Funktionalitäten die benötigt werden um mit den verschiedenen Robotern von Universal Robots zu arbeiten. Unter anderem enthält es die visuellen Informationen die wir für die Darstellung brauchen. Deswegen klonen wir zuerst das universal-robot Repository in das src-Verzeichnis in unserem Workspace:

~/catkin_ws/src$ git clone -b $ROS_DISTRO-devel https://github.com/ros-industrial/universal_robot.git

Du kannst auch das Repository als Zip-Datei unter diesem Link downloaden und wiederum in dein src-Verzeichnis entpacken, falls du Git nicht benutzten willst/kannst. Also nächstes müssen wir alle Dependencies (Packages die wir zusätzlich benötigen) überprüfen:

~/catkin_ws/src$ cd ..
$ rosdep update
$ rosdep install --rosdistro $ROS_DISTRO --ignore-src --from-paths src

Danach kannst du deinen Workspace bauen und aktivieren (falls der Workspace nicht bereits automatisch in deiner .bashrc-Datei aktiviert wird):

~/catkin_ws$ catkin_make
$ source $HOME/catkin_ws/devel/setup.bash

Um dem Tutorial zu folgen lade jetzt am besten das URDF Tutorial package herunter:

$ sudo apt-get install urdf_tutorial

Die URDF Datei (die Beschreibung unseres Roboterarms) is unter diesem Link gespeichert. Kopiere den Inhalt der Datei in ein Textdokument und speichere es als ur5_rviz.urdf irgendwo auf deinem Computer. Um den Roboter zu visualisieren, führe einfach folgenden Befehl aus wobei du den Pfad zu der gerade erzeugten URDF Datei angeben musst:

$ roslaunch urdf_tutorial display.launch model:='<pfad-zur-urdf-datei>/ur5_rviz.urdf'

Alternativ kannst du auch die Launch-Dateien benutzen die im ur_description package aus dem universal_robot Repository enthalten sind, indem du Folgendes ausführst: 

$ roslaunch ur_description ur5_upload.launch
$ roslaunch ur_description view_ur5.launch

In diesem Tutorial besprechen wir die gespeicherte URDF Datei welche mit display.launch aus dem urdf_tutorial Package in Rviz geöffnet werden kann, da die entsprechenden Dateien im ur_description Package zusätzliche Dinge enthalten die wir im Moment nicht benötigen. Beide Möglichkeiten werden aber in Rviz das gleiche Ergebnis liefern.

Nachdem du die Launch-Datei ausgeführt hast siehst du den UR5 Roboter schon visualisiert in Rviz! Ganz einfach oder? Neben Rviz startet auch eine kleine GUI mit der wir die einzelnen Robotergelenke steuern können. Da wir aber leider anhand von Schieberegler durch die Gegen schieben nichts lernen schauen wir uns einmal das URDF an das hinter den Kulissen steckt.

Die URDF Datei

Falls du die URDF Datei nicht bereits lokal auf deinem Computer gespeichert hast kannst du sie dir unter diesem Link ansehen. Damit kannst du die Struktur nachvollziehen die wir im Weiteren besprechen. In den URDFs wird das bekannte XML-Format verwendet welches sogennante Tags verwendet welche dann mit informationen jeglicher Art gefüllt werden. Der Roboterarm den unser URDF beschreibt besteht aus Gelenken (eng. Joints) und den steifen Komponenten dazwischen (eng. Links). Da sich die deutschen Wörter recht kompliziert anhören und die englischen Begriffe in sämtlichen Tools der Robotik verbreitet sind, benutzen wir von jetzt an die Anglizismen. Unser URDF hat also die folgende grundlegende Struktur:

<robot name=”ur5”>
  <link name = “...”>
    …
  </link>
  <joint name = “...”>
    …
  </joint>
  ...
</robot>

Im Falle der Links (die verbindenden Teile zwischen den Gelenken) beschreiben wir Rviz einfach deren Geometrie. Man kann in einer URDF für einen selbst enworfenen Roboter sogar eigene Geometrien definieren, aber wir machen uns die Sache einfach und übergeben eine .dae Datei die in dem ur_description Package enthalten ist. Diese wird direkt aus dem CAD Programm in dem der Roboter konstruiert wurde generiert. Damit ist aber rein das Aussehen unseres Roboters beschrieben.

Für die Schulter des Roboterarms sieht das bespielsweiße so aus:

<link name="shoulder_link">
    <visual>
      <geometry>
        <mesh filename="package://ur_description/meshes/ur5/visual/Shoulder.dae"/>
      </geometry>
    </visual>
  </link>

Die Aufgabe der Joints ist es, die Links zu verbinden und zu bewegen. Dazu spezifizieren wir erst einmal die Art von Joint als “revolute” (drehend), also ein ganz normaler Motor der allerdings gewisse Bewegungsgrenzen hat. Um zu beschreiben, welche beiden Links durch den Joint miteinander verbunden werden definieren wir einen parent und einen child Link. Die Tags <origin> und <axis> beschreiben die Roboterkinematik.

<joint name="shoulder_lift_joint" type="revolute">
    <parent link="shoulder_link"/>
    <child link="upper_arm_link"/>
    <origin rpy="0.0 1.570796325 0.0" xyz="0.0 0.13585 0.0"/>
    <axis xyz="0 1 0"/>
    <limit effort="150.0" lower="-3.14159265" upper="3.14159265" velocity="3.15"/>
  </joint>

Die Roboterkinematik ist es wert sich genauer anzusehen also wollen wir versuchen mit Hilfe von Rviz eine Vorstellung davon zu bekommen.

Roboterkinematik

Zur Visualisierung der Roboterkinematik stellen wir uns ein Koordinatensystem in der Mitte eines jeden Joints vor. Um die kinematische Kette zu beschreiben gehen wir einfach von einem initialen Koordinatensystem in der Roboterbasis aus und sehen uns an, wie es durch den Roboter propagiert, bis wir schließlich am letzten Joint in der Kette ankommen. Zwei Eigenschaften des Koordinatensystems können sich dabei verändern. Die Orientierung kann sich ändern, wie wir im linken Bild anhand der farblich gekennzeichneten Koordinatenachsen der einzelnen Joints sehen können. Außerdem kann der Ursprung verschoben werden, verdeutlicht durch die Pfeile im rechten Bild (In diesem Fall zeigen die Pfeile in die entgegengesetze Richtung, was aber nicht weiter tragisch ist).

  • Die Koordinatensysteme in den Mittelpunkten der Joints haben unterschiedliche Orientierungen
  • Die Ursprünge der Koordinatensysteme werden von einem Joint zum nächsten verschoben

In dem URDF wird beschrieben, wie man das vorherige Koordinatensystem auf das Koordinatensystem im nächsten Joint abbildet. Als Beispiel sehen wir uns dazu die beiden Schulter-Joints in dem unteren Bild an mit den jeweiligen angedeuten vor- bzw. nachliegenden Joints.

Die Koordinatensysteme in der Basis und den Schlutergelenken

Wir starten mit dem initialen Koordinatensystem das im Zentrum der Basis des Roboters liegt. Das ist der Punkt der die Position des Roboters in Relation zu seiner Umgebung definiert und an dem die kinematische Kette unseres Roboters startet. Um das initiale Koordinatensystem auf das zweite Koordinatensystem im Zentrum des ersten Schulter Joint zu verschieben muss man es nur entlang der z-Achse verschieben. Genau so ist es im <origin> und <axis> tag des URDF beschrieben. 

<origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.089159"/>
<axis xyz="0 0 1"/>

Das attribut xyz innerhalb des <origin> Tags definiert eine lineare Verschiebung entlang der Koordinatenachsen im Kartesischen Raum. Wir sehen in dem URDF dass das erste Koordinatensystem 0.089159 m entlang der z-Achse verschoben werden muss um zum zweiten Koordinatensystem zu gelangen, wobei sich die anderen Achsen nicht verändern. Der <axis> tag definiert die Achse um die sich der jeweilige Joint dreht, wohlgemerkt nachdem das Koordinatensystem verschoben wurde.

Um zum dritten Koordinatensystem zu gelangen ist etwas mehr nötig. Zusätzlich zu einer Verschiebung auf der y-Achse sehen wir auch eine rotation um die y-Achse. Die Beschreibung für den Joint der die Schulter des Roboterarms hebt sieht dementsprechend so aus:

<origin rpy="0.0 1.570796325 0.0" xyz="0.0 0.13585 0.0"/>
<axis xyz="0 1 0"/>

Das rpy-Attribut steht für roll, pitch und yaw. Das sind einfach Namenskonventionen die folgendermaßen definiert sind:

  • Roll: Rotation um die x-Achse
  • Pitch: Rotation um die y-Achse
  • Yaw: Rotation um die z-Achse

Die Rotation wird in Radiant (rad) angegeben, das heißt das Koordinatensystem wird um 1.570796325 rad (90 Grad) um die y-Achse gedreht. In diesem Schema des Verschiebens und Rotierens fahren wir fort bis wir den letzten Joint unseres Roboters erreicht haben. Anhand der URDF Datei kannst du so die komplette Kinematik des Roboters nachvollziehen.

Ich hoffe das hat euch etwas geholfen um zu verstehen wie die Struktur des Roboters – seine Kinematik – im allgemeinen beschrieben wird. Im Falle des UR5 hat der Hersteller Universal Robots diese Pose als Nullkonfiguration definiert. Man kann wenn nötig auch eine andere Nullstellung festlegen die besser für die jeweilige Applikation passt die man im Sinn hat.

Nun wissen wir, wie wir unseren Roboter mit Hilfe einer simplen Datei beschreiben um ihn zu visualisieren und rudimentär zu steuern. Dieses Setup ist großartig um z.B. Bewegungsplanung (Motion Planning) für den Roboter zu entwickeln. Um jedoch der Realität noch einmal ein Stück weit näher zu kommen wollen wir unseren Roboter nicht nur visualisieren. Wir wollen auch simulieren wie sich der Roboter in der echten Welt verhält in der die Gesetze der Physik gelten. Deswegen schauen wir uns im nächsten Tutorial an wie wir unser URDF erweitern müssen um die gleiche Art der Beschreibung in einem mächtigen Simulationstool zu nutzen. Gazebo!

Kurzanleitung

Wenn ROS bereits auf deinem PC installiert ist, sollte Rviz das auch sein. Wenn nicht, kannst du es mit folgendem Befehl installieren:

$ sudo apt-get install ros-$ROS_DISTRO-rviz

Installiere das ur5_description Package aus dem ROS industrial Projekt indem du das universal_robot Repository klonst. Danach müssen wir die Dependencies überprüfen:

~/catkin_ws/src$ git clone -b $ROS_DISTRO-devel https://github.com/ros-industrial/universal_robot.git
~/catkin_ws/src$ cd ..
$ rosdep update
$ rosdep install --rosdistro $ROS_DISTRO --ignore-src --from-paths src

Baue dann deinen Workspace:

~/catkin_ws$ catkin_make
$ source $HOME/catkin_ws/devel/setup.bash

Um deinen Roboter in Rviz zu visualisieren, führe einfach die folgenden Befehle aus:

$ roslaunch ur_description ur5_upload.launch
$ roslaunch ur_description view_ur5.launch

Wenn du den Roboter auch in Gazebo simulieren möchtest mache gleich weiter mit dem nächsten Artikel.