.

Simulation und Betrieb des Darwin OP mit Gazebo und ROS

Der Roboter Darwin OP zählt zu den wenigen humanoiden Robotern, die komplett auf Open-Source basieren und im Handel verfügbar sind (ein weiterer ist der Roboter Poppy, der demnächst zum Verkauf steht!). Das macht ihn zu einer Plattform der ersten Wahl für zahlreiche Hobbybastler und Forscher.

Da der Darwin OP eine nicht unwesentliche finanzielle Investition bedeutet, kann sich ein Simulator als sehr nützlich erweisen (auch zum Testen von Risikoverhalten!).

Deshalb erklären wir Ihnen nachstehend, wie der Open-Source Simulator Gazebo mit einem Modell des Darwin OP eingesetzt und mit der ROS Middleware optimal genutzt wird, speziell bei der Simulation des Gehverhaltens.

Dieser Leitfaden basiert auf den Konzepten, die in unserem Tutorial "Gazebo robotik Simulator mit ROS" (auf Englisch) präsentiert werden. Wir empfehlen Ihnen diese Lektüre wärmstens.

Darwin OP marchant dans Gazebo

Vorbereitung

Zunächst ist zu überprüfen, ob alle Bestandteile installiert wurden.

Die Gazebo- und die ROS-Version weisen einige Schwierigkeiten auf. Dieser Leitfaden basiert auf den Versionen ROS Hydro und Gazebo 1.9, der Code ist jedoch auch mit ROS Indigo kompatibel.

  1. Folgen Sie den Installationsanweisungen für Gazebo

  2. Anschließend folgen Sie den Anweisungen für ROS Hydro

  3. Zum Abschluss der Vorbereitungsphase ist folgender Befehl einzugeben:

apt-get Befehl

sudo apt-get install git ros-hydro-desktop-full gazebo ros-hydro-gazebo-plugins ros-hydro-gazebo-ros ros-hydro-gazebo-ros-control ros-hydro-hector-gazebo ros-hydro-hector-gazebo-plugins ros-hydro-effort-controllers ros-hydro-joint-state-controller ros-hydro-joint-state-publisher ros-hydro-turtlebot-teleop 

ROS Pakete zur Simulation des Darwin OP

Jetzt laden Sie die ROS Pakete für Darwin OP herunter, die auf unserem HumaRobotics GitHub zur Verfügung stehen. Anschließend den Workspace samt Quellcode anlegen:

cd ~
mkdir -p ros-darwin/src
cd ros-darwin/src
source /opt/ros/hydro/setup.bash
catkin_init_workspace

Jetzt laden Sie die ROS Pakete für Darwin OP herunter, die auf unserem GitHub HumaRobotics zur Verfügung stehen. Anschließend den Workspace samt Quellcode anlegen:

git clone https://github.com/HumaRobotics/darwin_description.git
git clone https://github.com/HumaRobotics/darwin_control.git
git clone https://github.com/HumaRobotics/darwin_gazebo.git
cd ..
catkin_make
source devel/setup.bash

Vergessen Sie nicht, dass bei jedem gestarteten Terminal der Quellcode ~/ros-darwin/devel/setup.bash

Erster Start

Jetzt steht alles bereit und es wird Zeit für die Testphase!

roslaunch darwin_gazebo darwin_gazebo.launch

Nach der Eingabe dieses Befehls sollte Gazebo starten und das Robotermodell Darwin OP angezeigt werden.

Sehen Sie sich die ausgegebenen Nachrichten genau an und suchen Sie eine Serie von Nachrichten "Loading controller: ..." und dann "Controller Spawner: Loaded controllers:..." (Diese sollten gegen Ende zu sehen sein.)

Diese Nachrichten bedeuten, dass die ROS Controller aktiv sind und die Motoren auf der 0-Position blockieren (wie auf dem Bild zu sehen). Sie können unter Gazebo die "Play" Taste anklicken, um die Simulation effektiv zu starten (wenn Sie nicht lang genug warten, könnte es allerdings sein, dass der Darwin abstürzt, bevor die Controller hochgefahren sind).

Lancement Gazebo avec le modèle de Darwin OP

Schön und gut, aber bis jetzt passiert nicht viel. Denn bisher haben wir lediglich den Darwin OP im ROS angezeigt.

Jetzt wollen wir unserem Freund Darwin mal ein bisschen Beine machen. Wir haben für Sie eine Demo vorbereitet, die sich einfach in einem zweiten Terminal (mit Quellcode) starten lässt: rosrun darwin_gazebo wa

rosrun darwin_gazebo walker_demo.py

Und so sieht das Ganze im Video aus:

ROS-Exposition

Ziel dieses Abschnittes ist es, ein im ROS gezeigtes Modell des Roboters bereitzustellen, um dieses mithilfe anderer Nodes zu steuern und letztendlich den echten Roboter bzw. seine Simulation mit demselben Code steuern zu können.

Sehen wir uns an, welche Elemente bereits vorhanden sind:

rostopic list

In der angezeigten Liste geben eine Reihe von Topics Zugriff auf die Robotersensoren:

/darwin/camera/image_raw #   =>   Zugriff auf das Kamerabild
/darwin/imu #                =>   Stellt die Informationen der Inertialeinheit bereit
/darwin/joint_states #       =>   Liefert Positions-/Geschwindigkeits-/Drehmomentdaten jedes Gelenks

Die Kamera und Inertialeinheit werden von Gazebo Plugins bereitgestellt, die unter darwindescription/urdf/darwin.urdf angemeldet wurden. Der Abschnitt jointstates wird vom robot_statepublisher bereitgestellt, dessen Aufruf und Konfiguration im Package darwincontrol beschrieben sind.

Die Daten dieser Sensoren können durch folgende Befehle direkt abgerufen werden:

rostopic echo /darwin/imu
rostopic echo /darwin/joint_states

Um das Kamerabild zu erhalten, kann das Package image_view verwendet werden:

rosrun image_view image_view image:=/darwin/camera/image_raw

Für die Effektoren ist jedes Gelenk in seiner Position steuerbar (Radians), indem Nachrichten zu den folgenden Topics versandt werden:

/darwin/j_ankle1_l_position_controller/command
/darwin/j_ankle1_r_position_controller/command
/darwin/j_ankle2_l_position_controller/command
/darwin/j_ankle2_r_position_controller/command
/darwin/j_gripper_l_position_controller/command
/darwin/j_gripper_r_position_controller/command
/darwin/j_high_arm_l_position_controller/command
/darwin/j_high_arm_r_position_controller/command
/darwin/j_low_arm_l_position_controller/command
/darwin/j_low_arm_r_position_controller/command
/darwin/j_pan_position_controller/command
/darwin/j_pelvis_l_position_controller/command
/darwin/j_pelvis_r_position_controller/command
/darwin/j_shoulder_l_position_controller/command
/darwin/j_shoulder_r_position_controller/command
/darwin/j_thigh2_l_position_controller/command
/darwin/j_thigh2_r_position_controller/command
/darwin/j_thigh2_l_position_controller/command
/darwin/j_thigh2_r_position_controller/command
/darwin/j_tibia_l_position_controller/command
/darwin/j_tibia_r_position_controller/command
/darwin/j_tilt_position_controller/command
/darwin/j_wrist_l_position_controller/command
/darwin/j_wrist_r_position_controller/command

Um den Kopf des Roboters beispielsweise nach links und dann nach rechts zu drehen, sind folgende Befehle erforderlich:

rostopic pub /darwin/j_pan_position_controller/command std_msgs/Float64 -- 1
rostopic pub /darwin/j_pan_position_controller/command std_msgs/Float64 -- -1

Gehen und Fernsteuerung

Zum Gehen erwartet ein dedizierter Node darwingazebo/scripts/walker.py Gehbefehle zum Topic /darwin/cmdvel.

So können Sie beispielsweise den Roboter mithilfe folgender Befehle vorwärts bewegen und dann anhalten:

rostopic pub /darwin/cmd_vel geometry_msgs/Twist '[1,0,0]' '[0,0,0]' # Vitesse en X: 1
rostopic pub /darwin/cmd_vel geometry_msgs/Twist '[0,0,0]' '[0,0,0]' # Vitesse nulle: arrêt

Die meisten mobilen Roboter unter ROS nutzen dasselbe Topic cmd_vel für den Empfang ihrer Bewegungsbefehle. Das bedeutet, dass Sie durch moduliertes Remapping der Topicnamen existierende Nodes der Fernbedienung wiederverwenden können.

Hier zum Beispiel die Keyboard-Fernbedienung von turtlesim (wenig empfehlenswert, da die Geschwindigkeiten sich nicht eignen):

rosrun turtlesim turtle_teleop_key /turtle1/cmd_vel:=/darwin/cmd_vel

Mit dem besser geeigneten Node der Keyboard-Fernbedienung des Turtlebot können Geschwindigkeiten angepasst, aber auch der Roboter gestoppt werden. Allerdings können damit keine Befehle zur seitlichen Fortbewegung versandt werden. Er steht hier zur Verfügung:

rosrun turtlebot_teleop turtlebot_teleop_key /turtlebot_teleop/cmd_vel:=/darwin/cmd_vel

API Python

Um Anwendern den Einsatz des Roboters zu erleichtern, haben wir eine ROS-Client-API in Python geschrieben. Das bedeutet, diese API kommuniziert lediglich über die ROS-Dienste und ist dadurch für das Netzwerk transparent. In diesem Fall ist es also egal, ob der Roboter echt ist oder nur simuliert wird.

Um diese API zu testen, sehen Sie sich einfach das Demo-Script darwingazebo/scripts/walkerdemo.py an:


```python
#!/usr/bin/env python
import rospy
from darwin_gazebo.darwin import Darwin

if __name__=="__main__":
    rospy.init_node("walker_demo")

    rospy.loginfo("Instantiating Darwin Client")
    darwin=Darwin()
    rospy.sleep(1)

    rospy.loginfo("Darwin Walker Demo Starting")

    darwin.set_walk_velocity(0.2,0,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(1,0,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(0,1,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(0,-1,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(-1,0,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(1,1,0)
    rospy.sleep(5)
    darwin.set_walk_velocity(0,0,0)

    rospy.loginfo("Darwin Walker Demo Finished")
```

Sehen wir uns diesen Code genauer an:


```python
#!/usr/bin/env python

import rospy from darwin_gazebo.darwin import Darwin ```

Hier signalisieren wir, dass unser Script durch Python interpretiert wird, dann laden wir die ROS Library und unsere Darwin API.


```python
if __name__=="__main__":
    rospy.init_node("walker_demo")
    
    rospy.loginfo("Instantiating Darwin Client")
    darwin=Darwin()
    rospy.sleep(1)
```

In diesem Abschnitt wird ein ROS Node mit dem Namen walker_demo angelegt. Dieses Element ist für die Kommunikation mit der ROS Infrastruktur notwendig. Anschließend wird eine Instanz der Darwin Klasse erstellt, die unsere Python API einschließt. Die Latenzzeit von 1 Sekunde stellt sicher, dass alle Topics geladen werden.


```python
    darwin.set_walk_velocity(0.2,0,0)
    rospy.sleep(3)
    darwin.set_walk_velocity(1,1,0)
    rospy.sleep(5)
    darwin.set_walk_velocity(0,0,0)    
```

Hier wird die eigentliche API aufgerufen, indem Geschwindigkeitsbefehle versandt werden. Diese können sich aus mehreren Teilen zusammensetzen (Übersetzungen in X, Y und Theta-Rotation). Durch die Geschwindigkeit 0 kann der Roboter angehalten werden. Die Aufrufe sind nicht blockend, deshalb wird eine Latenzzeit hinzugefügt, um dem Roboter Zeit zu geben, sich ein wenig mit der angegebenen Geschwindigkeit zu bewegen.

Außerdem können die Gelenke mithilfe der Funktion set_angles direkt gesteuert werden.

Um den Kopf des Roboters beispielsweise nach links und dann nach rechts zu drehen, sind folgende Befehle erforderlich:


```python
    darwin.set_angles({"j_pan":1})
    rospy.sleep(1)
    darwin.set_angles({"j_pan":-1})
    rospy.sleep(1) 
```

Schlussbemerkung

Nicht alles konnte in diesem Tutorial abgedeckt werden, Sie verfügen jedoch über eine gute Basis für den Einstieg mit Darwin und Gazebo.

In einem der nächsten Artikel werden wir uns gezielter mit den Bewegungs-APIs beschäftigen und komplexe Animationen beschreiben. Außerdem sehen wir uns an, wie der Node funktioniert, der dem Gang des Nao zugrunde liegt.

Und wenn Sie Glück haben, dann bekommen Sie vielleicht von mir ein Modell für einen anderen Roboter. Hat hier jemand etwas von einem Hexapoden gesagt?

Dr. Philippe Capdepuy, Forschungsingenieur bei Generation Robots und HumaRobotics