WEBVTT

00:09.690 --> 00:13.510
Hallo, ich begrüße euch herzlich zur heutigen Vorlesung.

00:14.770 --> 00:19.510
Wir haben das letzte Mal das Thema Bildverarbeitung abgeschlossen und

00:19.510 --> 00:22.770
wir werden uns jetzt in den nächsten Vorlesungen mit dem Thema

00:22.770 --> 00:24.530
Roboterprogrammierung beschäftigen.

00:25.510 --> 00:28.890
Ich werde ganz zu Beginn zu einer kurzen Motivation eingeben.

00:29.030 --> 00:34.530
Ich glaube, das ist ja selbstverständlich, dass man Möglichkeiten und

00:34.530 --> 00:38.830
Methoden braucht, mit denen man Roboter programmieren kann.

00:39.130 --> 00:42.670
Ich werde ganz schnell, so schnell es geht, auf die klassischen

00:42.670 --> 00:48.510
Roboterprogrammierungsverfahren eingehen und dann speziell heute auf

00:48.510 --> 00:56.830
eine Art der intuitiven Programmierung mithilfe von State Charts, der

00:56.830 --> 00:59.390
sogenannten Grafische Programmierung, eingehen.

01:00.990 --> 01:08.670
Anschließend werden wir uns mit dem Thema der symbolischen Planung

01:08.670 --> 01:09.310
beschäftigen.

01:09.490 --> 01:12.950
Das heißt, wenn wir jetzt irgendwelche Aktionen irgendwie programmiert

01:12.950 --> 01:17.250
haben, wir werden auch in den nächsten Vorlesungen fortgeschrittene

01:17.250 --> 01:20.670
Methoden zur Programmierung von Robotern kennenlernen, also

01:20.670 --> 01:22.710
programmieren durch Beobachtung des Menschen.

01:23.390 --> 01:26.290
Aber unter der Annahme, dass wir jetzt eine Menge von Aktionen

01:26.290 --> 01:29.510
programmiert haben, wie können wir mithilfe von diesen Aktionen

01:29.510 --> 01:31.130
bestimmte Ziele erreichen?

01:31.350 --> 01:37.290
Das heißt zum Beispiel auf ein Objekt stellen, beziehungsweise ein

01:37.290 --> 01:39.910
Objekt greifen und irgendwo anders hinstellen.

01:42.630 --> 01:48.690
So, natürlich kennt man das seit Beginn der Robotik, Robotik im

01:48.690 --> 01:51.370
Einsatz, jetzt hier in der Fertigung.

01:51.370 --> 01:56.090
Die Möglichkeit der Programmierung dieser Roboter ist essentiell, also

01:56.090 --> 02:01.090
nicht nur die Mechatronische oder die Regelungstechnische Herstellung

02:01.090 --> 02:04.890
und Beherrschung oder Beherrschbarkeit dieser Systeme ist wichtig,

02:05.010 --> 02:08.750
sondern wie kann man diese Roboter programmieren, damit sie zum

02:08.750 --> 02:13.430
Beispiel an einer bestimmten Stelle schweißen können, damit sie an

02:13.430 --> 02:16.670
einer bestimmten Stelle ein Objekt manipulieren und an einer anderen

02:16.670 --> 02:18.110
Stelle abstellen.

02:19.690 --> 02:24.810
Und natürlich hat man es in der Robotik nicht nur, vor allem in der

02:24.810 --> 02:28.590
modernen Robotik, nicht nur mit einem einzigen Produkt, was man

02:28.590 --> 02:31.950
herstellen will, sondern es gibt ja Variationen.

02:32.170 --> 02:36.710
Also wenn das Produkt zum Beispiel sich ändert, also ein anderes

02:36.710 --> 02:40.650
Automodell, dann stimmen natürlich die ganzen Programme, die man für

02:40.650 --> 02:47.690
Automodell A erstellt hat, nicht und muss man neu anfangen, Modelle

02:47.690 --> 02:53.430
oder Roboterprogramme, also Programme für die gleichen Roboter, um ein

02:53.430 --> 02:55.140
neues Automodell herzustellen.

02:55.610 --> 03:00.650
Also es gibt viele, die Produkte haben viele Ausgestaltungen, viele

03:00.650 --> 03:02.410
Ausstattungsvarianten.

03:03.390 --> 03:06.230
Hier ist eine höhere Konfigurierbarkeit.

03:06.670 --> 03:10.150
Das heißt, die Frage ist auch der intuitiven oder flexiblen

03:10.150 --> 03:11.430
Programmierung der Roboter.

03:12.590 --> 03:16.490
Ist notwendig oder eine intuitive und flexible Programmierung der

03:16.490 --> 03:20.230
Roboter ist notwendig, damit man eine flexible Fertigung erreichen

03:20.230 --> 03:20.550
kann.

03:21.970 --> 03:24.650
So und da kennen wir jetzt hier so ein paar Beispiele.

03:24.850 --> 03:27.770
Ich glaube, als wir das Thema Bandsteuerung behandelt haben, haben wir

03:27.770 --> 03:33.270
solche Beispiele gesehen, wo ein Roboter beispielsweise hier im

03:33.270 --> 03:36.590
Handwerkbereich bestimmte Aufgaben ausführen kann.

03:36.590 --> 03:40.490
Und das sieht man hier anhand von dem Video.

03:40.790 --> 03:42.910
Also was kommt, worauf kommt es an?

03:43.050 --> 03:46.430
Das heißt, wir müssen ja bestimmte Positionen auf diesem Holzstück

03:46.430 --> 03:47.830
hier anfahren.

03:49.010 --> 03:53.170
Natürlich der Aspekt Sicherheit ist ganz wichtig, dass der Roboter

03:53.170 --> 03:56.110
natürlich Kollisionen mit den Menschen hier detektieren kann und

03:56.110 --> 03:59.310
entsprechend die Maßnahmen hier ergreifen kann.

04:00.190 --> 04:02.330
Die Qualitätssicherung ist auch wichtig.

04:02.330 --> 04:07.090
Das heißt, die Aktionen, die der Roboter ausführt, müssen bestimmte

04:07.090 --> 04:10.670
Genauigkeiten oder Genauigkeitsanforderungen hier erfüllen.

04:11.450 --> 04:14.270
Und die Anwendungen, die sind jetzt nicht nur im Handwerkbereich,

04:14.470 --> 04:20.730
sondern im Pflegebereich oder im Haushalt, woran wir hier zum Beispiel

04:20.730 --> 04:22.830
in Karlsruhe auch arbeiten.

04:24.770 --> 04:29.210
Die Roboter, die wir gerne programmieren wollen, und das ist so unser

04:29.210 --> 04:34.310
Forschungsgebiet hier in Karlsruhe, sind jetzt keine sechs-armigen

04:34.310 --> 04:39.930
Industrieroboter wie vorher im Handwerkbereich oder in der

04:39.930 --> 04:43.010
Automobilindustrie, sondern ihr kennt ja den Arma 3.

04:43.930 --> 04:47.330
Das heißt, wir haben hier Roboter, die beliebige Objekte manipulieren

04:47.330 --> 04:48.630
können, sollen.

04:49.530 --> 04:54.650
Sie sollen natürlich in der Lage sein, komplexe Aufgaben selber zu

04:54.650 --> 04:57.350
lösen, ohne dass man sie immer wieder einprogrammiert.

04:57.450 --> 05:00.450
Wenn sie wissen, welche Aktionen sie ausführen, dann sollen sie in der

05:00.450 --> 05:12.450
Lage sein, mithilfe eines sogenannten symbolischen Planer in der Lage

05:12.450 --> 05:18.030
sein, die Sequenz von Aktionen auszuwählen, die zum Erreichen eines

05:18.030 --> 05:19.950
bestimmten Ziels notwendig sind.

05:20.390 --> 05:24.130
Das heißt, wir haben hier komplexe Umgebungen, Umgebungen inklusive

05:24.130 --> 05:27.150
der Varianten der Objekte, die man greifen kann.

05:27.290 --> 05:31.450
Wir haben hier viele Freiheitsgrade, also jetzt hier bei dem Arma 3.

05:32.190 --> 05:36.530
Wenn man hier sieht, das sind zwei Arme A7 Freiheitsgrade plus zwei

05:36.530 --> 05:38.350
Hände A8 Freiheitsgrade.

05:39.150 --> 05:43.470
Das heißt insgesamt 30 Freiheitsgrade, die programmiert werden müssen

05:43.470 --> 05:48.930
hier, damit dieser Einschränkvorgang hier erfolgreich funktionieren

05:48.930 --> 05:51.450
kann, wie hier im Video zu sehen ist.

05:53.470 --> 06:00.090
Die klassische Programmierung von Industrierobotern erfordert

06:00.090 --> 06:03.530
natürlich Expertenkenntnisse und ist immer mit einem sehr hohen

06:03.530 --> 06:04.590
Aufwand verbunden.

06:05.790 --> 06:09.890
Wir haben einige dieser Themen damals bei der Bandsteuerung

06:09.890 --> 06:10.550
kennengelernt.

06:10.690 --> 06:14.650
Das heißt, wo man zum Beispiel hier über ein Teachpanel den Roboter

06:14.650 --> 06:18.050
entlang der unterschiedlichen Bewegungsfreiheitsgraden im

06:18.050 --> 06:19.850
sechstdimensionalen Raum bewegen kann.

06:20.370 --> 06:25.410
Man sieht hier eine Art Maus oder Joystick, wo man nach links, rechts,

06:25.610 --> 06:30.170
oben, unten, aber auch Drehungen vom Tool Center Point spezifizieren

06:30.170 --> 06:33.590
kann und wo tatsächlich dann diese Bewegungen hier vom Roboter

06:33.590 --> 06:34.450
ausgeführt werden.

06:35.070 --> 06:38.230
Auf der anderen Seite natürlich gibt es hier textuelle

06:38.230 --> 06:40.330
Programmierwerkzeuge.

06:40.630 --> 06:43.410
Das heißt, wo man tatsächlich in Text in irgendeiner

06:43.410 --> 06:48.970
Roboterprogrammiersprache, die natürlich herstellerabhängig ist, die

06:48.970 --> 06:54.830
Programme schreibt wie Go to XY mit irgendeinem Modus der Bewegung.

06:54.830 --> 06:58.470
Und da gibt es hier diese Editoren, in denen man, wie man sieht hier

06:58.470 --> 07:04.110
exemplarisch dargestellt, so ein textuelles Programm für einen Roboter

07:04.110 --> 07:12.370
oder für eine Drehmaschine, damit sie zum Beispiel bestimmte Aktionen

07:12.370 --> 07:12.950
ausführt.

07:13.150 --> 07:18.470
Und zwar soll hier aus diesem Metallstück, wie man sieht, etwas

07:18.470 --> 07:22.610
weggefräst oder weggedreht werden.

07:22.610 --> 07:26.070
Und natürlich diese Aktionen, die man ausführt, also wie weit fährt

07:26.070 --> 07:29.690
das Ding, mit welcher Geschwindigkeit, vielleicht mit welcher Kraft

07:29.690 --> 07:33.590
und so weiter und so fort, damit überhaupt die Zielform, die man

07:33.590 --> 07:35.150
sucht, hier erreicht werden kann.

07:36.130 --> 07:42.190
Also es gibt natürlich hier, das ist also aus der klassischen

07:42.190 --> 07:43.430
Industrie Robotik.

07:43.430 --> 07:48.130
Und da sieht man hier, wo die Tool, also das ist letztendlich ein Tool

07:48.130 --> 07:52.350
Center Point hier vom Roboter, also der diese Aktionen hier ausgeführt

07:52.350 --> 07:52.770
hat.

07:53.290 --> 07:56.250
Und wir müssen natürlich zur Roboterprogrammierung, müssen wir immer

07:56.250 --> 08:02.050
Angaben machen, wo muss unser Tool Center Point sein, damit wir das

08:02.050 --> 08:02.710
Ziel erreichen.

08:02.930 --> 08:06.650
Das heißt, wir müssen Anfang, Endposition, mit welchen Rampen fahren

08:06.650 --> 08:09.990
wir die Trajektoren zwischen Anfang und Zielposition.

08:10.570 --> 08:14.650
Und natürlich, wenn die Umgebung unbekannt ist, was ja nicht der Fall

08:14.650 --> 08:19.590
hier, im Fall von diesem Drehvorgang hier, müssen wir kollisionsfreie

08:19.590 --> 08:21.690
Bewegungstrajektoren generieren.

08:21.950 --> 08:26.730
Und wie ihr merkt, wissen wir schon alles eigentlich über das, was ich

08:26.730 --> 08:27.790
gerade erwähnt habe.

08:27.930 --> 08:32.650
Also zum Beispiel, wie wir die Bahnsteuerung machen, damit wir von A

08:32.650 --> 08:36.890
nach B kommen, mit welcher Geschwindigkeitsrampe, Beschleunigung und

08:36.890 --> 08:38.510
so weiter und so fort.

08:39.510 --> 08:39.890
Okay.

08:41.630 --> 08:46.590
Nun, wir stellen uns natürlich das anders vor in der humanoiden

08:46.590 --> 08:48.230
Robotik, in der Service-Robotik.

08:48.430 --> 08:52.350
Das sind hier Arbeiten, die kommen aus dem Lehrstuhl, also genauer

08:52.350 --> 08:55.570
gesagt aus dem Lehrstuhl von Professor Rüdiger Dillmann, wo ich auch

08:55.570 --> 09:01.230
dort lange gearbeitet habe und auch lange Zeit dort tätig war.

09:02.010 --> 09:07.990
Wo wir auch das Konzept des Programmierens durch Vormachen seit

09:07.990 --> 09:09.650
Dekaden verfolgen.

09:09.770 --> 09:14.530
Das sind hier Ergebnisse aus der Dissertation von Rainer Jeckel und da

09:14.530 --> 09:18.010
geht es darum, so ein Zwei-Arm-System, wie man sieht hier, das sind

09:18.010 --> 09:22.510
zwei Arme mit zwei Fünf-Finger-Handys, mit einem Sensorkopf hier, also

09:22.510 --> 09:28.090
mit einem Kinect- und Stereokamerasystem, geht es darum, tatsächlich

09:28.090 --> 09:32.630
diese komplexen oder komplexere Alltagsaufgaben zu programmieren.

09:33.490 --> 09:37.010
Und die Idee hier, und das wird ein großes Thema der nächsten

09:37.010 --> 09:40.990
Vorlesung sein, also Programmieren durch Vormachen bzw.

09:41.330 --> 09:44.950
interaktive Programmierung, der Mensch führt die Bewegung vor und die

09:44.950 --> 09:46.670
Bewegung von Menschen wird erfasst.

09:46.810 --> 09:50.070
In dem Fall hier werden die Fingerbewegungen erfasst mit Hilfe von

09:50.070 --> 09:52.990
einem Handschuh, was der Mensch hier anhat, wie man sieht.

09:53.590 --> 09:56.990
Der hat, glaube ich, hier 18 oder 22 Freiheitsgrade.

09:58.270 --> 10:02.970
Und es werden zusätzlich die Positionen von Menschen, vom Handgelenk

10:02.970 --> 10:07.030
im Raum, damals über einen magnetischen Trecker, das heißt, wir haben

10:07.030 --> 10:10.790
die Toolcenter- oder die Ristposition, also Handgelenkposition über

10:10.790 --> 10:11.890
diesen magnetischen Trecker.

10:12.370 --> 10:15.930
Wir haben ein Modell der menschlichen Hand und alle diese sensorischen

10:15.930 --> 10:19.650
Daten, die wir hier erfassen, die sind mehr oder weniger eigentlich

10:19.650 --> 10:21.790
das Programm, was wir gerade suchen.

10:22.810 --> 10:26.550
Beziehungsweise das ist das Programm, was der Mensch eingesetzt hat,

10:26.910 --> 10:29.270
um diesen Löffel zu greifen.

10:29.490 --> 10:32.510
Inklusive natürlich die Strategien, man sieht hier, man versucht

10:32.510 --> 10:36.430
nicht, den Löffel direkt zu greifen, sondern an der einen Seite zu

10:36.430 --> 10:39.390
drücken, damit es hochgeht auf der anderen Seite und das Greifen

10:39.390 --> 10:40.150
einfacher wird.

10:41.070 --> 10:45.070
Und was normalerweise passiert und wie wir das sehen werden, das

10:45.070 --> 10:48.730
heißt, diese Bewegungen des Menschen, die müssen jetzt auf das

10:48.730 --> 10:54.030
Zielsystem, das Zielsystem ist das hier, abgebildet werden.

10:54.190 --> 11:00.050
Da sieht man hier, dass praktisch viele Variationen, natürlich diese

11:00.050 --> 11:03.330
Aufgabe von Menschen, die wird nicht nur einmal ausgeführt, sondern

11:03.330 --> 11:06.210
der Mensch muss mehrere Beispiele liefern.

11:06.730 --> 11:10.090
Und da werden mithilfe von Methoden des maschinellen Lernens hier eine

11:10.090 --> 11:13.450
generalisierte Repräsentation von der Aufgabe erstellt.

11:13.450 --> 11:19.990
Das wird in Simulationen hier getestet und anhand von dieser

11:19.990 --> 11:22.610
Repräsentation wird abstrahiert.

11:23.290 --> 11:27.810
Also wird tatsächlich jetzt die Demonstration des Menschen verstanden.

11:28.030 --> 11:30.450
Worauf kommt es an, was hat der Mensch gerade gemacht?

11:30.630 --> 11:33.590
Vielleicht kommt es nicht darauf an, wie er seinen Arm bewegt hat,

11:33.710 --> 11:38.030
sondern was war der Zustand der Umgebung vorher und wie hat sich der

11:38.030 --> 11:40.970
Zustand der Umgebung nach der Ausführung einer bestimmten Aktion.

11:41.710 --> 11:46.490
Und wenn man diese Demonstrationen verstanden hat, dann hat man

11:46.490 --> 11:52.350
praktisch so eine Menge von Fähigkeiten, die in generalisierter Form

11:52.350 --> 11:57.570
beschrieben sind und die kann man jetzt hier auf diesem System hier

11:57.570 --> 11:58.030
abbilden.

11:58.130 --> 12:04.070
Das ist ja das Video hier, da sieht man auch, klar, natürlich muss

12:04.070 --> 12:06.790
jetzt hier Inversi-Kinematik und so weiter, aber man sieht hier, die

12:06.790 --> 12:09.690
gleiche Strategie wurde auch vom Roboter hier eingesetzt.

12:09.690 --> 12:13.430
Das Video ist zehnmal beschleunigt, das heißt, es läuft ziemlich

12:13.430 --> 12:20.670
langsamer in der Realität und wo der Roboter natürlich diese komplexen

12:20.670 --> 12:25.770
Handhabungsaufgaben, für die er überhaupt keine Modelle hat, dann

12:25.770 --> 12:26.730
ausführen kann.

12:26.990 --> 12:30.850
Wie gesagt, das wird das Thema der nächsten Vorlesungen sein.

12:32.330 --> 12:37.570
Und was wir hier noch einen Schritt weiter machen, natürlich, hier

12:37.570 --> 12:42.870
betreiben wir diese Forschung auch mit den Arma-Robotern und da geht

12:42.870 --> 12:48.190
es hier einen Schritt weiter, wo man sagt, der Roboter soll jetzt Teig

12:48.190 --> 12:53.650
vorbereiten und da guckt der Roboter, das ist so ein bisschen die

12:53.650 --> 12:57.410
Motivation jetzt, der Roboter hat irgendwelche Aktionen gelernt, zum

12:57.410 --> 13:01.750
Beispiel, weil der Mensch das mehrmals demonstriert hat und wenn die

13:01.750 --> 13:07.230
Aufgabe Teig vorbereiten jetzt ansteht, dann muss der Roboter schauen,

13:07.390 --> 13:10.750
kann ich mit dem, was ich an Wissen habe, überhaupt diese Aufgabe

13:10.750 --> 13:11.230
lösen.

13:11.390 --> 13:14.070
Und jetzt guckt er, Teig vorbereiten, was habe ich denn?

13:15.190 --> 13:21.530
Ich habe hier ein paar Objekte, ich habe zwei, zum Beispiel, Becher,

13:21.710 --> 13:26.230
in denen Zutaten stehen, ich habe eine Schüssel und dann sagt er, ich

13:26.230 --> 13:27.490
kann keinen Teig vorbereiten.

13:27.630 --> 13:31.570
Natürlich, weil er hat ja noch nie Teig vorbereitet und jetzt

13:31.570 --> 13:35.410
demonstriert tatsächlich der Mensch diese komplexe Aufgabe von Teig

13:35.410 --> 13:36.030
vorbereiten.

13:36.170 --> 13:37.310
Also was bedeutet das?

13:37.670 --> 13:43.930
Das ist der Mirko hier und der Mirko wird aufgezeichnet, deshalb hat

13:43.930 --> 13:47.750
er diesen Anzug mit diesen Markern hier.

13:47.890 --> 13:52.070
Das ist auch die Lernphase, wo wir Daten generieren, aus denen wir

13:52.070 --> 13:53.410
Roboterprogramme erstellen.

13:53.990 --> 13:58.010
Deshalb ist es auch zulässig, damit man so genaue und rauschfreie

13:58.010 --> 14:01.870
Daten zulässt, dass man Marker auf dem Körper des Menschen und auch

14:01.870 --> 14:06.210
auf die Objekte, wenn man hier sieht, alle diese Becher, also wir

14:06.210 --> 14:10.990
nehmen an, jetzt die zwei Zutaten sind in diesem grünen und in diesem

14:10.990 --> 14:11.630
roten Becher.

14:12.510 --> 14:20.050
Und das ist hier unser Schneebesen, das ist hier die Schüssel, wo der

14:20.050 --> 14:22.230
Teig vorbereitet werden muss.

14:22.810 --> 14:24.650
Und Mirko demonstriert diese Aufgabe.

14:24.650 --> 14:30.410
Wir werden in der Vorlesung sehen, was dieser Graph da oben und diese

14:30.410 --> 14:33.450
Kanten, die auftauchen und verschwinden, bedeuten.

14:35.770 --> 14:43.150
Ganz einfach erklärt, das sind irgendwelche markanten Elemente in der

14:43.150 --> 14:46.690
Demonstration, wie die rechte Hand, die linke Hand, die rote Tasse,

14:46.890 --> 14:48.450
die grüne Tasse und die Schüssel.

14:48.450 --> 14:54.210
Und die Verbindungen sagen uns eigentlich, ob zum Beispiel die

14:54.210 --> 14:59.850
Flüssigkeit 1 und 2 in der orangenen Schlüssel sind oder nicht und

14:59.850 --> 15:03.210
sagen uns zum Beispiel, dass die rechte Hand und die linke Hand

15:03.210 --> 15:07.490
momentan in diesem Zustand gar nichts berühren.

15:08.030 --> 15:13.650
Und man sieht hier, wenn der Mirko jetzt hier etwas greift, wenn die

15:13.650 --> 15:16.850
rechte Hand zum Beispiel den Schneebesen greift, dass diese Linien

15:16.850 --> 15:17.290
hier kommen.

15:17.290 --> 15:19.430
Wenn er das loslässt und so weiter und so fort.

15:21.150 --> 15:24.490
Lasst euch nicht irritieren von den Begriffen O, A, C, was hier

15:24.490 --> 15:29.010
auftaucht, aber schaut der Roboter, was hat er gerade gemacht und dann

15:29.010 --> 15:34.510
sagt er, er hat gegriffen, eingeschränkt, abgestellt, dann nochmal

15:34.510 --> 15:36.590
gegriffen, eingeschränkt, abgestellt.

15:36.730 --> 15:40.930
Das sind alle Aktionen, die er schon mal kannte, weil das haben wir ja

15:40.930 --> 15:42.130
programmiert.

15:42.130 --> 15:46.790
Dann anschließend hat er gegriffen und irgendwas gemacht, was nicht

15:46.790 --> 15:50.930
Bestandteil von meinem Wissen ist und wiederum abgestellt.

15:51.570 --> 15:54.410
Na gut, und da kommen jetzt hier ein paar Tricks und ein paar

15:54.410 --> 15:57.730
weiterführende Methoden, auf die ich nicht hier eingehe, dass der

15:57.730 --> 16:01.210
Roboter zum Beispiel für diese unbekannte Aktion guckt in seinem

16:01.210 --> 16:05.050
Repertoire, welche Aktionen kenne ich, die zum Beispiel ähnlich sind.

16:05.150 --> 16:09.010
In dem Fall war das die Aktion Wischen, weil er das gelernt hat.

16:09.010 --> 16:12.770
Und natürlich die Simulation, die ist hier jetzt nicht gezeigt in dem

16:12.770 --> 16:13.050
Video.

16:13.630 --> 16:17.910
Und wenn wir diese Repräsentation oder dieses Programm erstellt haben,

16:18.050 --> 16:21.650
können wir natürlich das abbilden auf dem Roboter und ausführen, wie

16:21.650 --> 16:23.150
man hier in diesem Video sieht.

16:23.610 --> 16:27.850
So, wir werden das nächste Mal genau verstehen, was tatsächlich hier

16:27.850 --> 16:30.290
alles notwendig ist an Methoden.

16:30.770 --> 16:38.390
Also dieser Graf, der zu sehen war in dem Video und der beschreibt,

16:38.390 --> 16:44.410
welche Hand oder welches Objekt berührt und wann, das ist eigentlich

16:44.410 --> 16:47.770
nichts anderes als eine semantische Repräsentation der Szene.

16:48.390 --> 16:51.810
Das heißt, ohne jetzt, dass ich gucke auf den Menschen, wenn ich so

16:51.810 --> 16:56.230
einen Ausschnitt aus diesem Grafen sehe, ja, wenn ich so einen

16:56.230 --> 17:00.310
Ausschnitt aus diesem Grafen sehe, dann weiß ich, dass der Mensch hier

17:00.310 --> 17:05.250
mit seiner linken Hand die grüne Tasse berührt, dass die erste Zutat

17:05.250 --> 17:13.790
schon in der orangenen Schüssel ist und dass die zweite Zutat, also

17:13.790 --> 17:17.490
Flüssigkeit hier in dem Fall, noch in der roten Tasse ist.

17:17.910 --> 17:21.390
Das heißt, ich kann eigentlich die Umwelt beschreiben, basierend auf

17:21.390 --> 17:24.410
diesen grafischen Repräsentationen, die wir hier sehen.

17:25.130 --> 17:29.410
Wie das hier entsteht und wann eine Kante entsteht und verschwindet,

17:29.410 --> 17:34.230
das nennen wir Segmentierung, das heißt Unterteilung von dieser

17:34.230 --> 17:42.630
Demonstrationen in bedeutungsvollen Teilen, in relevanten Teilen und

17:42.630 --> 17:46.550
deren vielleicht Labeling oder Zuordnung, dass wir sagen, der Teil

17:46.550 --> 17:50.870
heißt Greifen, der Teil heißt Mixen, der Teil heißt Placing und so

17:50.870 --> 17:51.670
weiter und so fort.

17:52.470 --> 17:55.370
Gut, also mehr dazu in der nächsten Vorlesung.

17:56.070 --> 17:59.350
Ja, das würde ich jetzt auch hier weglassen, weil das werden wir

17:59.350 --> 18:02.330
tatsächlich in der nächsten Vorlesung, wie das hier entsteht.

18:02.690 --> 18:05.590
Ich will nur euch ein bisschen motivieren, dass das, was jetzt kommt

18:05.590 --> 18:09.130
als klassisches Programmierverfahren, das sind die Verfahren, die wir

18:09.130 --> 18:12.790
gar nicht mehr benutzen, also zumindest in unserer Forschung.

18:12.950 --> 18:18.170
Natürlich in der Produktion, in der Fertigung werden viele von diesen

18:18.170 --> 18:22.730
klassischen Roboterprogrammiersprachen noch eingesetzt.

18:23.290 --> 18:26.170
So, und da gehen wir durch.

18:27.830 --> 18:30.270
Roboterprogrammierung heißt, wir haben einen Bediener und wir haben

18:30.270 --> 18:31.470
jetzt hier einen Prozess.

18:31.610 --> 18:35.030
Das ist der Roboter, der schweißt, der navigiert, der mit den Menschen

18:35.030 --> 18:38.570
interagiert, der Objekte greifen soll und manipuliert.

18:39.430 --> 18:42.110
Und Programmieren bedeutet, dass der Bediener irgendwelche

18:42.110 --> 18:46.070
Sollvorgaben macht und diese Sollvorgaben natürlich an die Steuerung

18:46.070 --> 18:46.390
gehen.

18:46.550 --> 18:49.590
Die Steuerung braucht Sensorik, wie wir wissen.

18:49.590 --> 18:54.070
Über die Sensorik können wir Sollwert, Soll-Istwert-Vergleiche hier

18:54.070 --> 18:58.450
machen und Regeldifferenzen generieren, an die Stellglieder schicken

18:58.450 --> 19:00.710
und dann die entsprechenden Gelenke bzw.

19:01.650 --> 19:04.130
die entsprechende Position von der Hand verändern.

19:04.330 --> 19:08.450
Das ist der allgemeine Ablauf einer Steuerung.

19:08.630 --> 19:13.270
Die Roboterprogrammiersprachen, die unterteilt man zunächst mal in

19:13.270 --> 19:14.590
zwei Klassen.

19:14.890 --> 19:18.070
Einmal Online-Programmierung und einmal Offline-Programmierung.

19:18.070 --> 19:22.890
Ich glaube, jeder kann jetzt raten, was Online und was Offline heißt.

19:23.590 --> 19:25.590
Will jemand hier Vorschläge machen?

19:26.750 --> 19:27.570
Ah, stimmt.

19:28.170 --> 19:33.490
Will jemand Vorschläge machen, was Online und was Offline ist?

19:34.030 --> 19:36.250
In dem Fall bei der Roboterprogrammierung.

19:37.050 --> 19:42.090
Weil die Folie wird nachher wild und dann vergisst man, was Online und

19:42.090 --> 19:42.790
Offline ist.

19:42.950 --> 19:46.490
Aber ohne, dass jetzt irgendwas auftaucht und ohne, dass ihr auf euren

19:46.490 --> 19:49.170
Laptops guckt und die Folien anschaut.

19:50.050 --> 19:52.270
Kann jemand sagen, was Online und Offline ist?

19:54.470 --> 19:57.190
Oder ich bin mir sicher, alle können das.

19:57.350 --> 19:59.850
Aber will jemand sagen, was Online und Offline ist?

19:59.990 --> 20:00.690
Nein, keiner.

20:01.990 --> 20:05.850
Okay, ich sehe, eure Motivation ist unglaublich groß heute.

20:06.550 --> 20:12.970
So, im Online-Verfahren werden wir vier Varianten kennenlernen.

20:13.730 --> 20:19.490
Das ist die Gen, also wo man hier Punkte anfährt und speichert.

20:20.190 --> 20:23.310
Punkt 1, Punkt 2 könnt ihr euch erinnern, zum Beispiel aus der

20:23.310 --> 20:24.650
Vorlesung Bahnsteuerung.

20:25.470 --> 20:29.750
Dann Playback, wo man eine komplette Bahn mit dem Tool Centerpoint des

20:29.750 --> 20:32.390
Roboters abfährt und abspeichert.

20:33.130 --> 20:38.590
Dann eine sensorgestützte, direkte Online-Programmierung.

20:38.590 --> 20:42.670
Das heißt zum Beispiel, dass man mit dem Greifer hier entlang dieser

20:42.670 --> 20:47.990
Kante fährt und dann diese Trajektorie mal hier abspeichert, um zum

20:47.990 --> 20:53.550
Beispiel ein Gummi hier um diese Kante oder um ein rechteckiges Ding

20:53.550 --> 20:54.870
zu befestigen.

20:55.070 --> 20:58.710
Also das sind zum Beispiel, stellt euch mal vor, der Roboter soll

20:58.710 --> 21:06.130
diese Gummis in den Fenstern von Autos mal verlegen, wo die Scheiben

21:06.130 --> 21:10.310
reingehen und wo man dann mit dem Roboter hinfährt und vielleicht auch

21:10.310 --> 21:14.710
die Kraftprofile und gleichzeitig auch die Positionen mal abspeichert

21:14.710 --> 21:16.710
und natürlich diese Bewegung hier ausführt.

21:17.210 --> 21:19.590
Das wäre ja so was Sensorgestützes.

21:20.090 --> 21:24.090
Dann haben wir Master Slave, wie man sieht, ohne dass wir jetzt auf

21:24.090 --> 21:25.730
die Details eingehen.

21:25.730 --> 21:28.330
Das kommt hier auf den nächsten Folien.

21:29.450 --> 21:33.110
Bedeutet, ich habe zwei Roboter, wie man aus diesem symbolischen Bild

21:33.110 --> 21:35.090
sehen kann.

21:35.350 --> 21:39.930
Ich habe einen kleinen Roboter, also keinen echten Roboter und dieser

21:39.930 --> 21:44.310
kleine Roboter ist der Master und mit diesem kleinen Roboter

21:44.310 --> 21:46.470
programmiere ich einen Slave.

21:47.510 --> 21:51.490
Das heißt, ich habe auf meinem Schreibtisch hier einen Master, der ist

21:51.490 --> 21:56.930
vielleicht von der Kinematik genauso wie der große Slave, der irgendwo

21:56.930 --> 21:57.570
sitzt.

21:58.270 --> 22:01.530
Der muss ja nicht gerade hier, der kann ja irgendwo anders sein.

22:02.230 --> 22:06.330
Und ich bewege die Gelenke von diesem kleinen Roboter, damit ich zu

22:06.330 --> 22:11.470
einer bestimmten Position komme und diese Bewegungen werden dann

22:11.470 --> 22:13.570
praktisch als Programm abgespeichert.

22:13.570 --> 22:19.690
So, die anderen Varianten sind die Offline-Verfahren und man kann sich

22:19.690 --> 22:21.990
jetzt zunächst mal nachdenken, was Online bedeutet.

22:22.290 --> 22:25.550
In all diesen Fällen und aus den Beschreibungen, wie ich das jetzt

22:25.550 --> 22:29.550
erklärt habe, Online bedeutet, ich habe den Roboter und ich bewege den

22:29.550 --> 22:32.090
Roboter zu Punkt 1, Punkt 2, speichere das.

22:32.210 --> 22:36.970
Ich bewege den Roboter entlang einer Linie und speichere diese

22:36.970 --> 22:37.790
Trajektorie.

22:38.480 --> 22:43.450
Oder ich bewege den Roboter entlang der Kante, wie in meinem Beispiel,

22:43.630 --> 22:47.590
oder Fensterrand in einem Auto und speichere auch die Trajektorie.

22:48.450 --> 22:52.310
Oder ich bewege hier den kleinen Roboter und speichere auch die

22:52.310 --> 22:52.730
Trajektorie.

22:52.850 --> 22:56.210
Aber in allen vier Fällen brauche ich einen Roboter.

22:56.210 --> 23:00.870
Das heißt eigentlich, ich muss ja am Roboter sein und ich muss diese

23:00.870 --> 23:05.490
Trajektorien oder Punkte von meinem Programm, um diese Punkte von

23:05.490 --> 23:08.930
meinem Programm oder diese Trajektorien zu generieren, muss ich das

23:08.930 --> 23:10.030
direkt am Roboter machen.

23:10.670 --> 23:13.150
Offline bedeutet, ich habe keinen Roboter.

23:13.150 --> 23:16.670
Ja, also das ist so wie jetzt, wenn wir jetzt irgendwas hier

23:16.670 --> 23:17.170
programmieren.

23:17.470 --> 23:18.730
Also zunächst mal textuell.

23:18.870 --> 23:20.110
Ich schreibe hier ein Programm.

23:21.810 --> 23:25.790
Go to position 2, go to position 3, go to position 4.

23:26.090 --> 23:29.770
Ja, und diese Position, die können ja spezifiziert als X, Y, Z, Alpha,

23:29.850 --> 23:30.390
Beta, Gamma.

23:31.390 --> 23:35.870
Und dann wird, also das sollte jetzt hier ein Laptop sein oder ein

23:35.870 --> 23:38.310
Tablet, auf dem man das hier gemacht hat.

23:39.710 --> 23:43.750
Und dann, wie man sieht, hier gibt es ja Unterschiede.

23:43.870 --> 23:47.610
Auf der einen, beziehungsweise sage ich mal mehr Intelligenz hier

23:47.610 --> 23:53.210
einmal, dass man implizit hier die Punkte so wählt, dass man diese

23:53.210 --> 23:54.510
Hindernisse vermeidet.

23:54.710 --> 23:59.450
Beziehungsweise hier, dass man sagt, mit mehr Intelligenz gehe einfach

23:59.450 --> 24:00.250
zu Punkt 4.

24:00.250 --> 24:03.990
Und da ist natürlich eine Kollisionsvermeidung notwendig, damit man

24:03.990 --> 24:07.250
nicht mit diesem Zwischenstück oder mit dem Hindernis in der Mitte

24:07.250 --> 24:08.310
kollidiert.

24:09.090 --> 24:09.590
Textuell.

24:09.710 --> 24:11.250
Das Zweite ist natürlich grafisch.

24:12.550 --> 24:16.110
Und grafisch könnt ihr euch das vielleicht vorstellen, dass ihr

24:16.110 --> 24:20.350
Modelle von der Umgebung habt, Modelle von dem Roboter und dann in

24:20.350 --> 24:23.690
einer grafischen Simulation natürlich die Programme und die Aufgaben

24:23.690 --> 24:25.410
programmiert und dann abspeichert.

24:25.410 --> 24:29.170
Das wäre so eine bewegungsorientierte grafische Programmierung,

24:30.010 --> 24:32.830
beziehungsweise eine grafische Programmierung, wo man sagt, ich will,

24:33.090 --> 24:35.750
dass dieses Objekt hier rüberkommt.

24:35.910 --> 24:40.030
Das heißt, es wäre jetzt so eine aufgabenorientierte grafische

24:40.030 --> 24:40.830
Programmierung.

24:41.570 --> 24:46.630
Okay, was ich vorher in meiner Motivation gezeigt habe, natürlich ist

24:46.630 --> 24:48.110
alles andere als die hier.

24:48.110 --> 24:53.150
Ja, da haben wir nicht jetzt ein Computer oder eine textuelle

24:53.150 --> 24:55.890
Programmierung und eine grafische Programmierung im Vordergrund

24:55.890 --> 24:59.470
gestellt, sondern wir haben den Menschen im Vordergrund gestellt.

24:59.610 --> 25:03.350
Das heißt, wir haben so, natürlich gibt es Kombinationen jetzt

25:03.350 --> 25:06.850
zwischen den beiden, sogenannte Hybride, wo man mal ein bisschen

25:06.850 --> 25:08.310
offline, ein bisschen online macht.

25:08.310 --> 25:12.810
Und was uns hier am stärksten interessiert und was so ein aktuelles

25:12.810 --> 25:17.670
Forschungsthema ist, sind so interaktive Verfahren tatsächlich, wo der

25:17.670 --> 25:19.010
Mensch im Zentrum steht.

25:19.290 --> 25:22.870
Wir nennen sie auch Programmieren durch Vormachen, deshalb heißen sie

25:22.870 --> 25:26.770
PDV, also das steht für Programmieren durch Vormachen.

25:27.370 --> 25:32.510
Und da werden wir, wie bereits gesagt, mehr hier dazu als nächstes

25:32.510 --> 25:34.210
erfahren oder in der nächsten Vorlesung.

25:35.190 --> 25:41.690
So, nun, wenn man diese Verfahren klassifizieren will, dann kann man

25:41.690 --> 25:43.250
das nach mehreren Kriterien machen.

25:43.730 --> 25:47.130
Zunächst nach Programmierort, also direkte Programmierung oder

25:47.130 --> 25:48.430
indirekte Programmierung.

25:49.030 --> 25:51.950
Dann nach Abstraktionsgrad von der Programmierung, da unterscheidet

25:51.950 --> 25:56.090
man implizit, explizit oder Art der Programmierung, ob das direkt,

25:56.230 --> 25:58.550
textuell, grafisch oder gemischte Verfahren.

25:58.550 --> 26:02.550
Und da wollen wir jetzt hier ansteigen und diese Unterschiede und

26:02.550 --> 26:04.590
Differenzen mal kurz erläutern.

26:05.270 --> 26:09.930
So, die Online-Programmierung, die bedeutet, dass die Programmierung

26:09.930 --> 26:14.470
erfolgt direkt am Roboter, das heißt an der Robotersteuerung.

26:14.630 --> 26:17.950
Also der Roboter muss da sein, muss funktionieren, muss sich bewegen,

26:18.090 --> 26:19.650
damit wir diese Programme erstellen.

26:23.010 --> 26:29.250
Und in der Literatur werden auch hier diese Online-Verfahren direkte

26:29.250 --> 26:31.590
oder prozessnahe Programmierung genannt.

26:31.810 --> 26:34.810
Also wenn es zum Beispiel um die Programmierung von Werkzeugmaschinen

26:34.810 --> 26:40.090
geht, die ist anders als einfache Roboter, dann redet man auch von

26:40.090 --> 26:41.530
prozessnaher Programmierung.

26:42.030 --> 26:46.010
Offline bedeutet, die Programmierung erfolgt ohne den Roboter,

26:46.150 --> 26:50.510
mithilfe von textuellen, grafischen oder interaktiven Methoden.

26:50.510 --> 26:54.950
Und in der Literatur werden diese Methoden als indirekte oder

26:54.950 --> 27:00.410
prozessferne Programmiermethoden bezeichnet oder genannt.

27:01.370 --> 27:04.150
Der Abstraktionsgrad implizit bzw.

27:04.550 --> 27:05.270
explizit.

27:05.470 --> 27:11.450
Explizit oder robotorientierte Programmierung, also in der Informatik,

27:11.510 --> 27:15.190
also in den Programmiersprachen, das sind so die imperativen Sprachen.

27:15.190 --> 27:20.450
Das heißt, die Bewegungen zum Beispiel vom Arm und die Greiferbefehle,

27:20.650 --> 27:24.950
ob der Greifer auf oder zu, weil das ja auch eine wesentliche Sache,

27:25.130 --> 27:28.810
die Teil eines Programms sein muss, die sind direkt in einer

27:28.810 --> 27:30.250
Programmiersprache eingebunden.

27:30.470 --> 27:34.010
Und was ganz wichtig ist hier, natürlich beantwortet man hier die

27:34.010 --> 27:36.430
Frage, wie ist etwas zu tun?

27:36.430 --> 27:41.050
Also das heißt, wie kann ich hier dieses Objekt hier rüber stellen,

27:41.230 --> 27:45.010
indem ich zu P2 gehe, dann zu P3 und dann zu P4.

27:45.550 --> 27:49.790
Im Gegensatz dazu steht die implizite Programmierung und in der

27:49.790 --> 27:53.530
Informatik oder Informatikprogrammiersprachen, das sind dann die

27:53.530 --> 27:54.950
deklarativen Sprachen.

27:55.550 --> 27:58.410
Das heißt, die Aufgabe, die der Roboter durchführen soll, wird

27:58.410 --> 28:01.350
beschrieben, zum Beispiel in Form von Zuständen.

28:01.350 --> 28:07.470
Und die Frage hier, die man dann beantworten muss, ist nicht, wie ist

28:07.470 --> 28:12.130
etwas zu tun, wie bei der expliziten, sondern was ist zu tun?

28:12.370 --> 28:16.010
Also zu tun ist, dass man hier zu P4 geht.

28:16.590 --> 28:22.590
Das heißt, hier hat man eine abstrakte Form der Programmierung und

28:22.590 --> 28:25.910
diese abstrakte Form der Programmierung erfolgt in mehreren Phasen.

28:25.910 --> 28:30.170
Also wie gesagt, wir können es nicht hier schaffen, eine

28:30.170 --> 28:35.930
kollisionsfreie Bahn von P1 zu P2 zu erzeugen mit Hilfe von unserem

28:35.930 --> 28:38.510
Programm, ohne dass wir Modelle der Umgebung haben.

28:38.630 --> 28:41.570
Das heißt, wir müssen wirklich wissen über diesen hinteren Raum,

28:42.950 --> 28:44.890
dieses schwarze Stück hier.

28:45.450 --> 28:50.250
Wir müssen natürlich eine geeignete Spezifikation der Aufgabe haben.

28:50.250 --> 28:56.450
Also die Aufgabe zum Beispiel, ein Objekt bei P1 auf P4 zu stellen.

28:57.250 --> 29:01.230
Und dann natürlich anhand von diesem Programm brauchen wir so eine Art

29:01.230 --> 29:05.970
Compiler, Assembler und so weiter, damit wir ein Roboterprogramm

29:05.970 --> 29:06.210
haben.

29:06.350 --> 29:10.010
Weil diese textuelle Beschreibung ist nach wie vor irgendwie eine

29:10.010 --> 29:15.230
Beschreibung in einer Roboter-Hochsprache und die müssen wir natürlich

29:15.230 --> 29:18.270
auf direktem Maschinencode für Roboter abbilden.

29:18.270 --> 29:22.130
Das heißt, wir müssen natürlich diese Roboterprogramme erzeugen.

29:23.190 --> 29:28.530
Und unter Umständen erfolgt vor der Ausführung natürlich, das heißt

29:28.530 --> 29:32.410
unter Umständen in der Regel immer vor der Ausführung von solchen

29:32.410 --> 29:39.950
geschriebenen Programmen, natürlich eine Überprüfung dieser

29:39.950 --> 29:43.390
Roboterprogramme, zum Beispiel mithilfe von Simulationen.

29:43.390 --> 29:46.390
Da wir ja die Modelle der Umgebung, Spezifikationen der Aufgaben,

29:46.510 --> 29:50.210
natürlich auch die Modelle vom Roboter haben, kinematische Modelle und

29:50.210 --> 29:52.830
geometrische Modelle, können wir das hier alles machen.

29:53.970 --> 29:58.030
So, das nächste Kriterium war Art der Programmierung und da

29:58.030 --> 30:01.650
unterscheidet man sich in direkt, textuell, grafisch und gemischt die

30:01.650 --> 30:02.230
Verfahren.

30:02.230 --> 30:07.870
Und da sind wir jetzt hier, wie wir, wie wir das gesehen haben und bei

30:07.870 --> 30:09.410
der direkten Programmierung.

30:09.990 --> 30:15.290
Ja, also das ist der gesamte Block auf der Übersichtsfolie hier.

30:16.110 --> 30:19.280
Da muss man natürlich hier, sag ich mal, den Roboter einstellen.

30:19.950 --> 30:23.150
Das heißt zum Beispiel jetzt für Teach-In bzw.

30:23.470 --> 30:27.950
für Playback, dass man in der Lage ist, den Roboter mal zu bewegen.

30:30.030 --> 30:36.290
Und dann werden wir sehen, wie die unterschiedlichen Varianten hier

30:36.290 --> 30:37.410
funktionieren.

30:37.530 --> 30:40.530
Was sind die Vor- und die Nachteile der unterschiedlichen Varianten?

30:41.390 --> 30:46.430
Einstellen des Roboters gibt es hier mehrere Möglichkeiten.

30:46.670 --> 30:52.390
Vielleicht das älteste Programmierverfahren, das vielleicht keiner

30:52.390 --> 30:55.690
mehr kennt, ist dieses sogenannte Bank-Bank-Robot.

30:55.690 --> 31:01.270
Das heißt, wo der Bewegungsbereich von einem Glied oder von einem

31:01.270 --> 31:06.470
Freiheitsgrad bis zum Anschlag erfolgen kann.

31:06.750 --> 31:10.550
Und das wird durch einen Stopper, also wir haben hier zwei Anschläge

31:10.550 --> 31:14.710
oder zwei Stopper und der Bewegungsfreiheitsgrad, der Bewegungsraum

31:14.710 --> 31:18.970
von diesem Gelenk hier oder von diesem Segment hier wird durch diese

31:18.970 --> 31:20.690
zwei Stopper hier definiert.

31:21.440 --> 31:26.390
Das heißt, natürlich kann sich das Gelenk hier jetzt nicht weiter als

31:26.390 --> 31:29.310
zwischen diesen beiden Anschlägen bewegen.

31:30.170 --> 31:35.090
Und die Zuordnung der Anfahrspunkte, die wir brauchen, die werden zum

31:35.090 --> 31:38.910
Stopper gemacht und die können mit sogenannten Codier-Matrizen

31:38.910 --> 31:39.610
erfolgen.

31:40.590 --> 31:44.290
Natürlich hat man hier sehr kleine Anfahrpunkte, weil man hat ja

31:44.290 --> 31:48.670
eigentlich nur die Punkte an den Anschlägen, die man messen kann.

31:48.670 --> 31:52.130
Und man kann sich vorstellen, dass man damit natürlich nicht so

31:52.130 --> 31:58.430
flexibel und nicht so komplexe Bewegungen hier programmieren kann.

31:58.930 --> 32:05.150
Die Teach-In-Methoden, da fährt man markante Punkte der Bahn mit einer

32:05.150 --> 32:06.230
manuellen Steuerung.

32:06.370 --> 32:11.010
Da gibt es hier diese Teach-Panels, die sind sehr komplex oder sehr

32:11.010 --> 32:13.790
einfach, benutzerfreundlich oder nicht benutzerfreundlich.

32:13.790 --> 32:17.270
Die haben mehrere Funktionalitäten, wie man sieht, und diese

32:17.270 --> 32:21.730
Funktionalitäten, die lassen sich zusammenfassen, wie bewegen zum

32:21.730 --> 32:23.170
Beispiel der einzelne Gelenk hier.

32:23.270 --> 32:28.290
Das heißt, man ist im Gelenkwinkelraum und man kann die einzelnen

32:28.290 --> 32:30.910
Achsen bewegen, wie man will.

32:30.910 --> 32:35.670
Oder man kann den End-Effektor bewegen in Richtung X, Y, Z, Alpha,

32:35.850 --> 32:36.490
Beta, Gamma.

32:36.690 --> 32:41.350
Das heißt, wo für jede Bewegung oder für jede Position vom Tool-Center

32:41.350 --> 32:44.670
-Point dann natürlich die inverse Kinematik gelöst werden muss, damit

32:44.670 --> 32:49.170
die Soll-Vorgaben für die Gelenkwinkel vom Roboter hier generiert

32:49.170 --> 32:49.790
werden können.

32:50.650 --> 32:54.730
Und dann haben diese Teach-Panels die Möglichkeit, Punkte, die man

32:54.730 --> 32:57.430
anfährt, zu speichern oder auch zu löschen.

32:57.430 --> 33:00.590
Also zum Beispiel, wenn man sich in eine Richtung bewegt und es kommt

33:00.590 --> 33:07.430
eine total ungünstige Lösung der inverse Kinematik, der Arm ist hier

33:07.430 --> 33:12.050
und ich bewege ein bisschen, dann kommt eine komplette Umkonfiguration

33:12.050 --> 33:17.230
von dem Arm, die bedeutet, die Gelenke müssen sich sehr lange bewegen.

33:17.490 --> 33:21.270
Das ist natürlich verbunden vielleicht mit großem Energieverbrauch.

33:21.270 --> 33:25.150
Und diesen Punkt will ich jetzt nicht haben, weil wenn ich mich ein

33:25.150 --> 33:28.230
Stück zurück bewege, beispielsweise kommt es nicht zu dieser

33:28.230 --> 33:29.730
Umkonfiguration vom Arm.

33:30.250 --> 33:34.190
Das heißt, die Möglichkeit, dass man Punkte löscht oder speichert und

33:34.190 --> 33:35.330
löscht, ist gegeben.

33:37.310 --> 33:39.950
Dann natürlich, mit welchen Geschwindigkeiten soll ich die Punkte

33:39.950 --> 33:43.790
anfahren, egal ob das im karthesischen Raum oder im Gelenkwinkelraum.

33:44.450 --> 33:49.590
Und dann bei einem Roboter habe ich ja nicht nur die Gelenke vom Arm,

33:49.690 --> 33:53.390
sondern ich habe ja einen Greifer, der entweder offen oder zu ist.

33:53.710 --> 33:57.570
Deshalb muss ich auch diese Befehle für den Greifer, im Falle von

33:57.570 --> 34:05.190
einem einfachen Greifer ist es offen oder zu, oder zwei Befehle, offen

34:05.190 --> 34:05.790
oder zu.

34:05.950 --> 34:08.970
Das heißt, diese Befehle kann man auch hier geben.

34:08.970 --> 34:12.770
Und dann natürlich die Möglichkeit, ein komplettes Programm, was man

34:12.770 --> 34:16.290
gespeichert hat oder was man erstellt hat, hier zu starten,

34:16.590 --> 34:20.050
beziehungsweise zu einem beliebigen Zeitpunkt zu stoppen.

34:21.850 --> 34:27.750
Das ist hier so ein Spielzeug-Teachpad oder Teachbox oder Teachinbox

34:27.750 --> 34:31.790
von so einem kleinen fünfachsigen Roboterarm.

34:31.870 --> 34:36.290
Das ist so vergrößert hier, was man auf diesem Panel sehen kann.

34:36.950 --> 34:39.990
Und man sieht hier eigentlich, was man machen kann.

34:40.190 --> 34:46.270
Man kann in Richtung x und y, x bewegen, minus und plus, y und z, r

34:46.270 --> 34:50.170
und p und o für die unterschiedlichen Orientierungen.

34:52.890 --> 34:56.090
Nicht für die unterschiedlichen Orientierungen, nur für Handgelenk und

34:56.090 --> 34:58.330
Handdrehung, weil es gibt ja zwei Gelenke hier.

35:00.030 --> 35:07.990
Und dann kann man hier Befehle für den Greifer, also ob der Greifer

35:07.990 --> 35:09.050
auf oder zu ist.

35:09.190 --> 35:12.830
Und dann gibt es irgendwelche vorprogrammierten Sachen wie Delete oder

35:12.830 --> 35:20.070
wie Home-Position oder Bewege dich jetzt los oder entferne diesen

35:20.070 --> 35:25.050
Punkt oder Bewege dich in der Umgekehrten, also rückwärts, nicht von

35:25.050 --> 35:28.590
P1 zu P2, sondern von P2 zu P1 und so weiter und so fort.

35:29.210 --> 35:32.450
Das ist tatsächlich was auf so einem Panel.

35:33.030 --> 35:36.390
Natürlich ist es ja sehr minimal hier, wie man sieht hier.

35:37.190 --> 35:41.570
Das ist ja ein kompletter Rechner hier mit Display und ähnliches, wo

35:41.570 --> 35:45.570
man eigentlich viel mehr machen kann, als das, was jetzt hier

35:45.570 --> 35:49.710
exemplarisch auf diesem Bild von dem Mitsubishi RM501 zu sehen ist.

35:51.210 --> 35:54.430
Natürlich gibt es nicht nur Programmierpanel, sondern der eine oder

35:54.430 --> 35:56.590
andere ist vielleicht gerade jetzt auf die Idee gekommen.

35:56.730 --> 36:01.430
Ich nehme so eine 6D-Maus und kann natürlich die 6D-Positionen vom

36:01.430 --> 36:08.770
Tool Center Point auch entsprechend der Bewegungen an dieser Maus oder

36:08.770 --> 36:11.610
an diesem Joystick hier vorgeben.

36:12.970 --> 36:14.670
Da gibt es Vor- und Nachteile.

36:14.670 --> 36:19.790
Natürlich hier bei so einem Joystick kann ich jetzt nicht so exakt

36:19.790 --> 36:22.950
oder die Positioniergenauigkeit, kann ich keine großen

36:22.950 --> 36:25.090
Positioniergenauigkeiten erreichen.

36:25.870 --> 36:29.390
Und da kann ich wahrscheinlich nur in zwei Richtungen mich mal bewegen

36:29.390 --> 36:32.110
bei der Maus oder bei dem Joystick.

36:32.230 --> 36:35.650
Das ist auch nicht so intuitiv, wenn man jetzt einen Arma-Roboter

36:35.650 --> 36:39.650
programmieren will oder Komplexi-Roboter.

36:39.650 --> 36:45.590
Die Space-Maus, die hier zu sehen ist, also eine 6D-Maus.

36:45.990 --> 36:51.070
Das ist so eine Kugel und da wird mit einem Kraftmomentensensor, der

36:51.070 --> 36:52.970
dort befestigt ist an dieser Kugel.

36:53.530 --> 36:57.550
Und die Kräfte, die man da ausübt als User, die werden natürlich als

36:57.550 --> 36:58.850
Abweichungen in XYZ.

36:59.550 --> 37:00.150
Kennt ihr, oder?

37:00.910 --> 37:02.970
Kennt jemand von euch die 6D-Maus?

37:03.330 --> 37:05.310
Ihr spielt bestimmt Computerspiele, oder?

37:05.890 --> 37:11.230
Genau, das sind die Mäuse, die meistens oder manchmal dort zu sehen

37:11.230 --> 37:11.770
sind.

37:12.090 --> 37:15.150
Genau, das heißt, diese Kräfte, die werden als Abweichungen in die

37:15.150 --> 37:17.750
unterschiedlichen Richtungen und dann kann man natürlich den Tool

37:17.750 --> 37:19.390
Center Point bewegen.

37:20.230 --> 37:24.250
Und die Momente, also die Drehungen, die man da ausübt als User, die

37:24.250 --> 37:32.870
werden natürlich als Änderungen der Vorgaben der Orientierung vom Tool

37:32.870 --> 37:34.610
Center Point interpretiert.

37:34.610 --> 37:38.090
Also wir können tatsächlich alle sechs Freiheitsgrade und wenn wir

37:38.090 --> 37:42.130
jetzt Manipulationsaufgaben schweißen, greifen, abstellen und so

37:42.130 --> 37:45.490
weiter und so fort, müssen wir diese Aufgaben im Aufgabenraum

37:45.490 --> 37:49.830
spezifizieren, also nicht im Gelenkwinkelraum des Roboters, sondern im

37:49.830 --> 37:55.370
kartesischen Raum, wo wir die sechs Freiheitsgrade irgendwie erfassen

37:55.370 --> 38:04.330
müssen, beziehungsweise Vorgaben oder Werte für die 6D-Pose vom Tool

38:04.330 --> 38:04.890
Center Point.

38:05.310 --> 38:09.670
Und damit erreicht man auch eine Höhegenauigkeit im Gegensatz hier zu

38:09.670 --> 38:10.770
diesem Joystick.

38:10.770 --> 38:14.410
So, die Vorgehensweise, wie man beim Teaching macht, man fährt

38:14.410 --> 38:18.510
Markantiepunkte der Bahn, wie es eigentlich auf dieser Folie oder in

38:18.510 --> 38:21.190
dieser Box exemplarisch dargestellt ist.

38:21.750 --> 38:25.270
Die Bahn ist dann eine Folge von Zwischenpunkten, man speichert die

38:25.270 --> 38:28.710
Gelenkwinkel der einzelnen Zwischenpunkte.

38:28.710 --> 38:35.330
Man kann hier vielleicht nachträglich irgendwas ergänzen, um zum

38:35.330 --> 38:38.430
Beispiel Parameter wie Geschwindigkeit oder Beschleunigung,

38:38.990 --> 38:43.370
beziehungsweise auch Greiferbefehle mal hier zu integrieren.

38:44.210 --> 38:49.010
Und das wird natürlich in der Automobilindustrie, also

38:49.010 --> 38:53.230
Fertigungsindustrie, aber auch Handhabungsaufgaben hier eingesetzt.

38:54.590 --> 38:58.050
Die zweite Variante ist so ein Playback-Verfahren.

38:59.270 --> 39:02.410
Ich hatte doch ein Video, jetzt kommt das Video nachher.

39:02.930 --> 39:06.590
Ein Playback-Verfahren und bei diesem Playback-Verfahren, wir bewegen

39:06.590 --> 39:10.210
den Tool Center Point entlang einer Trajektorie und wir speichern die

39:10.210 --> 39:11.270
gesamte Trajektorie.

39:11.430 --> 39:14.850
Jetzt könnte man sich vorstellen, natürlich vor ein paar Jahren, wenn

39:14.850 --> 39:17.630
ich diese Trajektorie abspeichere und ich habe vielleicht nicht so

39:17.630 --> 39:22.590
viel Speicherplatz und ich taste die Trajektorie sehr hoch, dass für

39:22.590 --> 39:27.310
jede Bahn natürlich ein großer Speicherbedarf notwendig ist.

39:27.430 --> 39:29.150
Das ist vielleicht heute nicht mehr der Fall.

39:29.830 --> 39:34.050
Aber man braucht hier eine Möglichkeit, dass man tatsächlich den

39:34.050 --> 39:39.190
Roboter oder den Endeffekt vom Roboter entlang dieser Trajektorie

39:39.190 --> 39:43.810
führen kann, indem man wirklich den Roboter anfasst und bewegt.

39:43.810 --> 39:46.870
Das heißt, man braucht so eine Steuerungsstrategie oder

39:46.870 --> 39:52.050
Regelungsstrategie, wo der Roboter einfach mitgeht.

39:53.190 --> 39:57.470
Zum Beispiel mit Zero Force Control oder mit aktiver Compliance.

39:57.710 --> 40:03.310
Also wenn der Roboter zum Beispiel Drehmomentsensoren in den Gelenken

40:03.310 --> 40:08.710
hat und solche aktiven oder Drehmomentsregelungen implementiert sind.

40:08.710 --> 40:13.670
Das ist auch sehr wichtig heutzutage für die Generierung von Daten.

40:13.970 --> 40:19.550
Zum Beispiel haben wir das Beispiel vorher für Teig vorbereiten oder

40:19.550 --> 40:22.010
diesen Löffel mal greifen.

40:22.110 --> 40:23.510
Das hat der Mensch demonstriert.

40:23.690 --> 40:26.410
Aber wir können eigentlich, wenn wir in der Lage sind, den Roboter so

40:26.410 --> 40:30.610
zu bewegen, können wir den Roboter führen und generieren wir viele

40:30.610 --> 40:36.570
Daten am Roboter direkt, um zum Beispiel irgendwelche generalisierten

40:36.570 --> 40:43.390
Repräsentationen, also abstrakte generalisierte Repräsentationen für

40:43.390 --> 40:47.750
die Aufgabe Löffel greifen oder einschenken oder ähnliches.

40:48.230 --> 40:52.170
Das nennt man auch Kinesthetic Teaching und das werden wir auch in der

40:52.170 --> 40:53.250
nächsten Vorlesung kennenlernen.

40:53.370 --> 40:56.270
Dann fährt man die Bahn ab und speichert man die Gelenkwinkel.

40:56.270 --> 41:01.610
Und die Anwendung hier ist natürlich oder diese Verfahren kommen

41:01.610 --> 41:05.510
überall dort zur Anwendung, wo die Trajektorien, die man beschreiben

41:05.510 --> 41:09.790
will, also die Trajektorien, die der Roboter abfahren muss oder soll,

41:10.890 --> 41:12.930
mathematisch sehr schwer zu beschreiben ist.

41:13.030 --> 41:15.690
Weil wenn diese Trajektorien mathematisch sehr einfach zu beschreiben

41:15.690 --> 41:22.550
sind, zum Beispiel Geraden oder irgendwelche explizite mathematische

41:22.550 --> 41:26.850
Kurven, dann muss man das so nicht machen.

41:28.950 --> 41:32.770
Die Voraussetzung hier, dass wir tatsächlich diese komplexen

41:32.770 --> 41:36.110
Trajektorien mit dem Endeffektor des Roboters abfahren können.

41:36.290 --> 41:40.230
Das heißt, wir müssen in der Lage sein, diesen Roboter so zu bewegen,

41:40.530 --> 41:42.670
dass der Endeffektor dieser Trajektor folgt.

41:42.670 --> 41:44.690
Ich habe jetzt hier zwei Videos.

41:44.830 --> 41:47.670
Das eine kennt ihr, das war von der Bahnsteuerung.

41:47.930 --> 41:55.270
Also das ist jetzt hier, wie diese Teach-In durch Vormachen wird das

41:55.270 --> 41:56.090
auch hier genannt.

41:56.230 --> 42:01.970
Das heißt, der Roboter lässt sich führen und man sieht hier, der

42:01.970 --> 42:07.130
Mensch fährt jetzt zu einem Punkt, drückt auf einen Knopf, der am

42:07.130 --> 42:08.850
Handgelenk angebracht ist.

42:08.850 --> 42:16.990
Punkt 1, Punkt 2, das sind die Punkte der Bahn, die man haben will,

42:17.070 --> 42:17.950
die markanten Punkte.

42:18.290 --> 42:21.830
Dann müssen wir dieses Hindernis hier vermeiden, deshalb Punkt 4.

42:23.950 --> 42:28.810
Und anschließend müssen wir uns jetzt hier ein bisschen positionieren.

42:29.090 --> 42:32.170
Punkt 5, also nicht direkt hier in das Loch gehen, sondern ein

42:32.170 --> 42:34.890
bisschen positionieren, deshalb ist der Punkt 5 notwendig.

42:34.890 --> 42:38.730
Und anschließend natürlich in Punkt 6 und wahrscheinlich in Punkt 6

42:38.730 --> 42:41.810
haben wir nicht nur Greifen auf und zu, sondern wir haben die

42:41.810 --> 42:46.170
Information, mit wie viel Kraft müssen wir drücken, damit praktisch

42:46.170 --> 42:48.030
dieses Ding in das Loch reingeht.

42:48.910 --> 42:56.250
So, das ist tatsächlich hier dieses Teach-In und Teach-In jetzt hier,

42:56.870 --> 43:00.730
in dem der Mensch den Roboter führen kann und natürlich hier die

43:00.730 --> 43:06.070
Punkte oder die Zwischenpunkte der Trajektoren abspeichert und dann

43:06.070 --> 43:06.830
der Roboter ausführt.

43:06.930 --> 43:09.030
Man sieht hier solche Befehle ganz am Ende.

43:09.750 --> 43:11.530
Das ist natürlich Punkt 6 hier.

43:12.190 --> 43:16.510
Das ist Punkt 6, jetzt ist es Punkt 5, jetzt ist es Punkt 6.

43:16.950 --> 43:19.950
Aber in Punkt 6 brauchen wir noch einen weiteren Punkt, wo der Greifer

43:19.950 --> 43:20.510
auf ist.

43:20.510 --> 43:22.990
Also einmal Punkt 6, wo der Greifer zu ist.

43:23.190 --> 43:24.290
Jetzt sieht man das gleich.

43:24.450 --> 43:29.270
Und einmal Punkt 7, wo wir an der gleichen Position sind, aber der

43:29.270 --> 43:30.110
Greifer auf ist.

43:31.030 --> 43:33.330
So, natürlich die andere Variante.

43:36.430 --> 43:43.530
Die andere Variante ist natürlich ein Fehler, weil das Teach-In und

43:43.530 --> 43:48.630
nicht Playback, Entschuldigung, das eine Video soll für Teach-In sein

43:48.630 --> 43:51.370
und das hier ist für Playback.

43:51.690 --> 43:56.410
Und zwar, das sind irgendwelche komischen, nicht komischen, komplexen

43:56.410 --> 43:59.310
Trajektoren, die man vielleicht mathematisch nicht beschreiben kann

43:59.310 --> 44:00.530
oder nicht beschreiben will.

44:00.650 --> 44:05.370
Aber man hat so einen Arm wie der neuste Roboter von uns, das ist der

44:05.370 --> 44:06.150
Arma 6.

44:06.730 --> 44:09.790
Da werde ich in der nächsten Vorlesung mehr dazu erzählen.

44:10.590 --> 44:12.470
Und das ist der Simon.

44:12.690 --> 44:15.970
Und wie man sieht hier, der Simon ist in der Lage, über diese

44:15.970 --> 44:21.230
Drehmomentregelung der Gelenke den Arm, mit dem Arm rumzuspielen, zu

44:21.230 --> 44:26.570
führen sozusagen und bestimmte Punkte mal anzufahren.

44:27.330 --> 44:32.930
Also zum Beispiel hier, er dreht das Untergelenk kontinuierlich, weil

44:32.930 --> 44:35.550
man vielleicht an der Stelle irgendwas schrauben will.

44:36.190 --> 44:39.910
Und da der Unterarm sowas erlaubt, macht er das.

44:40.670 --> 44:43.650
Und man sieht hier, das Schultergelenk kann sich auch beliebig lang

44:43.650 --> 44:44.090
drehen.

44:44.530 --> 44:49.350
Der Roboter kann vorne und hinten, also hat keine Vorzugsrichtung für

44:49.350 --> 44:50.250
die Manipulation.

44:50.490 --> 44:51.890
Vorne und hinten ist ihm egal.

44:52.030 --> 44:55.650
Das ist so mehr als das, was der menschliche Schulter kann.

44:56.230 --> 45:00.630
Und wenn wir jetzt so eine Winkbewegung beispielsweise, eine komische

45:00.630 --> 45:05.630
Winkbewegung hier, programmieren wollen, dann führen wir natürlich den

45:05.630 --> 45:06.450
Roboter in die Richtung.

45:06.690 --> 45:09.930
Das heißt, wir können jetzt all diese Trajektoren oder alle diese

45:09.930 --> 45:13.770
Werte der Gelenkwinkel abspeichern und können wir diese Trajektoren

45:13.770 --> 45:14.630
nachher abfahren.

45:16.130 --> 45:18.330
So, die Vor- und Nachteile.

45:18.590 --> 45:24.310
Die Nachteile sind natürlich, schwere Roboter sind sehr schwer zu

45:24.310 --> 45:24.730
bewegen.

45:24.730 --> 45:28.070
Also stellt euch mal vor, ihr habt ja so einen Riesenroboter, der zum

45:28.070 --> 45:32.850
Beispiel den A380 reinigt.

45:33.410 --> 45:35.970
Es gibt ja solche Roboter, die Flugzeuge reinigen.

45:36.510 --> 45:40.270
Und wir müssen natürlich diese Roboter entlang der Überfläche von dem

45:40.270 --> 45:41.490
Flugzeug mal führen.

45:41.770 --> 45:43.290
Und jetzt müsst ihr den bewegen.

45:43.690 --> 45:47.950
Auch wenn er Drehmomentsensoren hat, ich weiß nicht, wie das gehen

45:47.950 --> 45:48.210
soll.

45:48.530 --> 45:52.830
Also ist klar, glaube ich, dass in dem Fall sowas nicht geht.

45:52.830 --> 45:56.630
Auf der anderen Seite, damit wir das machen können, diese Playback

45:56.630 --> 45:59.750
-Verfahren, haben wir immer einen direkten Kontakt zwischen Menschen

45:59.750 --> 46:00.450
und Robotern.

46:00.750 --> 46:02.830
Und das ist immer eine heikle Sache.

46:03.930 --> 46:05.870
Also Kontakt zwischen Menschen und Robotern.

46:05.990 --> 46:10.990
Wir wissen ja, je näher der Roboter am Menschen kommt, desto präsenter

46:10.990 --> 46:11.930
wird die Situation.

46:12.690 --> 46:15.050
Deshalb sind die meisten Roboter noch in ihren Käfigen.

46:16.690 --> 46:21.950
Das heißt, wir haben hier ein Risiko, ein Sicherheitsrisiko.

46:21.950 --> 46:23.470
Und damit müssen wir umgehen.

46:25.370 --> 46:29.910
Höher Speicheraufwand oder Bedarf bei hoher Abtastrate der

46:29.910 --> 46:30.200
Trajektorien.

46:30.710 --> 46:34.670
Also heutzutage ist das kein Thema mehr, weil ich glaube, was soll das

46:34.670 --> 46:39.330
auch, wenn wir mit 10.000 Hertz die Trajektorien abtasten.

46:39.850 --> 46:43.970
Haben wir jetzt keine riesigen Trajektorien, die man hier abspeichert

46:43.970 --> 46:48.370
und wo man keine Speichertechnologien hat, die sowas realisieren

46:48.370 --> 46:48.690
können.

46:49.990 --> 46:53.630
Natürlich das Problem oder das große Problem, was wir haben, zum

46:53.630 --> 46:58.490
Beispiel im Gegensatz zu Teach-in, dass wir hier schlecht einen Teil

46:58.490 --> 47:00.110
der Trajektorien korrigieren können.

47:00.250 --> 47:03.130
Wir haben ja die gesamte Trajektorie abgespeichert und jetzt, wenn ich

47:03.130 --> 47:06.350
nur einen Teil von dieser Trajektorie abschneiden oder modifizieren

47:06.350 --> 47:09.750
kann, dann muss ich wirklich die gesamte Trajektorie von Anfang an

47:09.750 --> 47:10.190
programmieren.

47:10.350 --> 47:14.650
Also die Roboter nehmen, rumführen und die Werte abspeichern.

47:15.750 --> 47:20.450
So, die vierte Möglichkeit war Master-Slave und wie ich bereits

47:20.450 --> 47:25.650
erwähnt habe, der Bediener oder der Benutzer, der führt einen kleinen

47:25.650 --> 47:28.910
und leicht bewegbaren Master-Roboter.

47:29.110 --> 47:30.210
Das ist der kleine hier.

47:31.290 --> 47:35.710
Und am besten ist es, wenn er kinematisch identisch mit dem Slave ist.

47:35.770 --> 47:39.510
Ja, wirklich eine Kopie, die Anzahl der Freiheitsgrade, die Anordnung

47:39.510 --> 47:41.870
der Freiheitsgrade, die sind identisch zu dem Slave.

47:42.450 --> 47:46.610
Und dann die Bewegungen natürlich von diesem Master, also der Master

47:46.610 --> 47:51.790
ist der kleine, die Bewegungen von dem Master dann auf dem Slave

47:51.790 --> 47:52.870
übertragen.

47:53.030 --> 47:56.110
Und man kann natürlich die Bewegungen synchron ausführen und schauen

47:56.110 --> 47:59.770
zum Beispiel, ob man jetzt am Ziel ist.

47:59.910 --> 48:03.150
Also wenn ich jetzt den Master hier bewegen will, damit er zum

48:03.150 --> 48:08.350
Beispiel diese Kreide greifen will und ich den Slave bewegen will,

48:08.770 --> 48:14.350
damit er diese Kreide greift und ich habe hier meinen Master und ich

48:14.350 --> 48:17.510
sehe, es gibt noch eine Differenz, dann kann ich mich weiterhin in die

48:17.510 --> 48:21.530
Richtung bewegen oder die Gelenke so einstellen, dass ich zu dieser

48:21.530 --> 48:22.270
Position komme.

48:22.470 --> 48:26.410
Also trivial ist es natürlich nicht, aber man benutzt natürlich eine

48:26.410 --> 48:31.330
super Steuerung in dem Fall, und zwar unser Gehirn mit der ganzen

48:31.330 --> 48:34.870
Bildverarbeitung, der ganzen Intelligenz, die wir haben, damit wir an

48:34.870 --> 48:36.090
die Zielposition kommen.

48:37.610 --> 48:42.170
Natürlich, dieses Slave-Roboter wirkt jetzt wie ein Kraftverstärker,

48:42.330 --> 48:45.790
weil wenn ich dort zugreife, jetzt nicht bei der Kreide, sondern bei

48:45.790 --> 48:49.850
einem Koffer oder Ähnlichem, dann kann ich natürlich ganz leicht,

48:50.030 --> 48:54.150
indem ich meinen Master mit einem Finger bewege, vielleicht 100 Kilo

48:54.150 --> 48:55.870
auf der anderen Seite am Slave tragen.

48:57.010 --> 49:01.470
Genau, also Handhabung großer Lasten, beziehungsweise große Roboter,

49:01.710 --> 49:04.590
also auch für die Programmierung von großen Robotern, mein Beispiel

49:04.590 --> 49:07.430
vorher, Reinigungsroboter von Flugzeugen.

49:07.970 --> 49:11.950
Natürlich, die Methode ist ein bisschen teuer, weil ich brauche zwei

49:11.950 --> 49:16.350
Roboter, und der Roboter, der Master ist kein Spielzeugroboter,

49:16.570 --> 49:20.450
sondern muss ja genau sein, damit wir natürlich auch entsprechend die

49:20.450 --> 49:22.890
Bewegungen für den Slave generieren.

49:24.710 --> 49:33.550
Und der Vorteil ist, dass man damit die Möglichkeit hat, auch

49:33.550 --> 49:36.890
schwerste Roboter zu programmieren, über diesen Weg.

49:43.790 --> 49:48.370
Die nächste Variante ist die sensorgestützte Programmierung.

49:48.570 --> 49:52.950
Das ist mein Beispiel hier mit diesem Gummi im Fenster von dem Auto,

49:53.070 --> 49:56.250
beispielsweise, da habe ich ja irgendeine Trajektur, die ich abfahren

49:56.250 --> 49:59.190
will, und ich muss vielleicht mit einer bestimmten Kraft drücken,

49:59.410 --> 50:02.510
damit dieses Gummi hier in diesen Schlitz reinkommt.

50:03.170 --> 50:07.210
Das heißt auch manuell hier, wo der Bediener jetzt den Programmierer

50:07.210 --> 50:11.950
nicht anfasst, sondern man kann natürlich auch sowas machen.

50:12.070 --> 50:15.770
Da gibt es solche Methoden, wo man sagt, fahre mal diese Trajektur

50:15.770 --> 50:19.910
hier, also man hat ja hier einen Löschstift oder einen Laserstift, wie

50:19.910 --> 50:23.390
dieser Laserpointer, den ich habe, und sagt, fahre mal diesen Punkt

50:23.390 --> 50:26.570
an, dann diesen Punkt an, oder die gesamte Trajektur.

50:27.330 --> 50:30.950
Natürlich, das Problem, was man hier hat, man muss diese Bewegungen

50:30.950 --> 50:33.790
von diesem Pointer erfassen.

50:34.850 --> 50:38.390
Das heißt, die Bewegungen müssen erfasst werden, dazu brauche ich

50:38.390 --> 50:42.070
externe Sensorik, also ich brauche irgendeinen Sensor, der erfasst, wo

50:42.070 --> 50:44.930
jetzt der Punkt hier von diesem Pointer ist.

50:45.890 --> 50:49.890
Und die Punkte, die ich natürlich hier angebe, wenn der Roboter hier

50:49.890 --> 50:52.230
schweißen soll, könnt ihr mich sehen hier?

50:52.670 --> 50:55.670
Wenn der Roboter hier schweißen soll, das ist natürlich ein Punkt im

50:55.670 --> 50:58.550
sechssimensionalen Raum, da muss ich natürlich an jedem Punkt die

50:58.550 --> 51:01.550
Inverse Kinematik lösen, damit der Roboter dorthin fahren kann.

51:02.390 --> 51:06.710
Und dann natürlich die Bahn als eine Folge von diesen Gelenkwinkeln,

51:06.730 --> 51:11.330
die ich an diesen Punkten generiert habe, speichern.

51:13.310 --> 51:17.750
So, automatische Methoden, der Sensorgestütze, man gibt einen Start-

51:17.750 --> 51:22.890
und Zielpunkt und dann tastet man die Sollkontur, das wäre jetzt ein

51:22.890 --> 51:27.690
Kraftmomentensensor, wie ich vorher aus meinem Autofenster-Gummi

51:27.690 --> 51:28.410
-Beispiel.

51:29.610 --> 51:33.890
Nachteil, Fehler bei der Erfassung der Bahn, also wenn es zum Beispiel

51:33.890 --> 51:41.270
visuell ist, Verdeckungen von Teilen der Bahn, kein Einbeziehen von

51:41.270 --> 51:46.550
Erfahrung vom Bediener, das heißt, wenn man jetzt hier die Trajektur

51:46.550 --> 51:50.190
einmal programmiert und der Bediener vom Roboter weiß, naja, der kann

51:50.190 --> 51:53.930
ja nicht so weit gehen, oder diese Konfiguration ist schlecht für den

51:53.930 --> 51:57.490
Roboter, diese Erfahrung wird natürlich nicht berücksichtigt, weil der

51:57.490 --> 52:01.450
Mensch drückt nur hier und da und dann werden diese Punkte generiert.

52:02.290 --> 52:06.090
Genau, und das sind hier so Anwendungen, die man hier sieht.

52:06.670 --> 52:10.050
So, insgesamt, diese direkte Programmierung hat Vorteile, das heißt,

52:10.210 --> 52:13.810
schnell bei einfachen Trajektorien kann man sie sofort anwenden, wie

52:13.810 --> 52:14.670
wir gesehen haben.

52:15.470 --> 52:18.030
Die haben geringe Fehler, Einfälligkeit.

52:19.070 --> 52:21.770
Bediener benötigen überhaupt keine Programmierkenntnisse.

52:22.010 --> 52:26.090
Also jeder kann tatsächlich diese Methoden oder solche Roboter

52:26.090 --> 52:26.690
programmieren.

52:26.850 --> 52:29.950
Man muss nicht in Informatik oder in die Robotik-Vorlesung kommen,

52:30.070 --> 52:32.430
damit man überhaupt ein Roboter so programmieren kann.

52:33.130 --> 52:38.030
Und man braucht kein Modell der Umgebung, weil natürlich die Punkte

52:38.030 --> 52:38.410
bzw.

52:38.910 --> 52:42.610
die Bahnen, die man generiert, die berücksichtigen solche Tatsachen,

52:42.770 --> 52:46.190
dass ich irgendwo in der Umgebung Hindernisse habe, die ich vermeide.

52:46.670 --> 52:50.910
Wenn ich weiß, dieser Laptop ist hier, dann tue ich natürlich den

52:50.910 --> 52:54.010
Punkt hier, damit ich mit dem nicht kollidiere und deshalb brauche ich

52:54.010 --> 52:55.230
keine Modelle der Umgebung.

52:55.350 --> 52:58.210
Ist implizit dort, aber wir werden für die Programmierung nicht

52:58.210 --> 52:58.630
gebraucht.

52:59.830 --> 53:04.590
Wenn die Trajektorien komplex sind, dann ist der Aufwand sehr groß und

53:04.590 --> 53:09.410
die sind nur möglich mit und am Roboter, wie wir gesehen haben.

53:09.410 --> 53:12.510
Und die sind natürlich spezifisch für einen Robotertypen.

53:12.590 --> 53:15.790
Eine Trajektorie, die ich auf diese Art und Weise programmiert habe,

53:15.970 --> 53:21.810
für den Arm von Arma 3 beispielsweise, kenne ich nicht für den Arm von

53:21.810 --> 53:26.430
Arma 6 oder für einen KUKA-Roboter auf ABB oder ESCAWA usw.

53:27.570 --> 53:32.390
Und haben wir gesehen, Sicherheitsrisiko, der Mensch ist ja in engem

53:32.390 --> 53:37.130
Kontakt mit der Umgebung, zum Beispiel bei Playback-Verfahren, das

53:37.130 --> 53:40.890
heißt hier Verletzungsgefahr für den Menschen und natürlich diese

53:40.890 --> 53:42.910
Trajektoren, die sind feste Bahnen.

53:43.190 --> 53:47.250
Also es gibt keine Möglichkeit, es sind keine Darstellungen von

53:47.250 --> 53:51.230
Trajektoren, wo wir sagen, oh, wenn hier ein Hindernis kommt, dann

53:51.230 --> 53:54.290
bitte die Trajektoren ein bisschen verändern an der Stelle, damit wir

53:54.290 --> 53:55.230
damit nicht kollidieren.

53:55.750 --> 54:00.370
Es sind ganz fixe oder feste Bahnen, die angefahren werden und die

54:00.370 --> 54:04.030
nicht adaptierbar sind an zum Beispiel neuen Gegebenheiten.

54:05.210 --> 54:09.670
Ich hoffe, das ist nicht so zufriedenstellend für euch, weil

54:09.670 --> 54:12.990
eigentlich, wenn ich weiß, okay, das ist beim Greifen eine

54:12.990 --> 54:17.030
Annäherungsbewegung, es interessiert mich nicht so sehr, wie die

54:17.030 --> 54:17.950
Trajektore aussieht.

54:18.050 --> 54:22.030
Ich will vielleicht nur eine mathematische Repräsentation von dieser

54:22.030 --> 54:25.710
Bewegung haben und diese Bewegung soll ausgeführt werden, ob hier ein

54:25.710 --> 54:28.070
Hindernis ist oder hier ein Hindernis ist.

54:28.470 --> 54:33.090
Das heißt, diese Adaption an der Umgebung oder neuen Gegebenheiten

54:33.870 --> 54:38.530
soll durch diese Trajektorien- oder Bahnenbeschreibung garantiert oder

54:38.530 --> 54:39.250
gegeben sein.

54:40.410 --> 54:43.510
Okay, offline Verfahren, textuell.

54:44.530 --> 54:46.370
Gibt es Programmiersprachen?

54:46.630 --> 54:50.330
Also jeder Roboterhersteller hat seine eigene Programmiersprache, wie

54:50.330 --> 54:56.770
Passro, wie Val, wie V+, wie zum Beispiel Rapid von ABB oder KUKA,

54:56.870 --> 55:00.250
Robot Language von KUKA und so weiter und so fort.

55:00.250 --> 55:05.730
Und natürlich sind das Programmiersprachen, die Programmierung kann

55:05.730 --> 55:09.770
dann unabhängig, das sind ja offline, wir sind ja in diesem Block.

55:10.590 --> 55:13.170
Das heißt, das sind offline Verfahren, das heißt, wir brauchen den

55:13.170 --> 55:14.330
Roboter nicht vor Ort.

55:14.890 --> 55:23.430
Das ist eine gewisse Syntax für die Sprache mit einer Programmierlogik

55:23.430 --> 55:28.170
und damit kann man natürlich komplexe Programme erstellen, die auch

55:28.170 --> 55:32.750
wissensbar sind, zum Beispiel Objektmodelle, Weltmodelle und so weiter

55:32.750 --> 55:33.370
und so fort.

55:33.810 --> 55:36.990
Auswertung von Sensorinformationen auch berücksichtigen.

55:37.750 --> 55:41.350
Natürlich der Nachteil ist, der Bediener hier ist nicht irgendjemand,

55:41.490 --> 55:44.530
der den Roboter bewegt, damit die Aufgabe ausgeführt wird, sondern der

55:44.530 --> 55:48.470
Bediener ist jemand, der tatsächlich Syntax der Sprache, also braucht

55:48.470 --> 55:55.470
Programmierkönntnisse, kennen muss und die korrekt anwenden kann,

55:55.470 --> 55:58.510
damit eine bestimmte Aufgabe erreicht wird.

56:00.110 --> 56:04.790
Das sind irgendwelche Beispiele aus solchen Sprachen, nur damit ihr

56:04.790 --> 56:07.450
einen Eindruck habt, wie diese Programmiersprachen sind.

56:07.850 --> 56:14.390
Es gibt natürlich Normen für diese textuellen Programmiersprachen.

56:15.450 --> 56:20.550
Ganz kurz hier ein Beispiel, das sieht zu einem Befehl N70.

56:20.550 --> 56:24.970
Also man hat hier die Befehle, also wie der Befehlssatz von einem

56:24.970 --> 56:25.430
Rechner.

56:25.570 --> 56:29.550
Man hat einen Befehlssatz für den Roboter und diese Befehlscodierung

56:31.570 --> 56:35.990
erfüllt gewisse nach einer bestimmten Norm und dann das Programm, was

56:35.990 --> 56:41.210
man erzeugt, ist nichts anderes als eine Menge von mehreren Sätzen,

56:41.410 --> 56:42.330
die man erzeugt.

56:42.430 --> 56:44.470
Das heißt Sätze, die man hat.

56:44.470 --> 56:46.670
Und so einen Satz könnt ihr so sehen.

56:47.470 --> 56:51.650
N70, G00, X20, Z12.

56:51.830 --> 56:54.030
Das heißt Werkzeug im Eilgang.

56:54.310 --> 56:56.810
Das ist so ein Bewegungsmodus, G00.

56:57.910 --> 57:02.330
Das ist irgendein Parameter jetzt für diesen Satz Nummer 70.

57:02.830 --> 57:05.450
Also das ist Befehl 70, sagen wir mal so.

57:06.110 --> 57:10.750
Oder Befehl mit Obcode 70, wenn wir jetzt an den Maschinencode vom

57:10.750 --> 57:12.590
Rechner denken.

57:12.590 --> 57:19.410
Dann irgendein Parameter Eilgang an Positionen X gleich 20 und Z

57:19.410 --> 57:20.550
gleich 12 bewegen.

57:21.510 --> 57:25.870
Ja, also so sieht praktisch so ein Beispiel aus.

57:26.390 --> 57:32.410
Es gibt sehr viele Programmiersprachen wie APT oder XAPT und so weiter

57:32.410 --> 57:32.970
und so fort.

57:33.110 --> 57:35.450
Da will ich jetzt hier nicht drauf eingehen.

57:35.450 --> 57:40.290
Natürlich, historisch wurden auch viele dieser Programme oder diese

57:40.290 --> 57:46.770
Steuerungen in Hardware realisiert, aber auch später mithilfe von

57:46.770 --> 57:50.450
speicherprogrammierbarer Logik, kennen wir aus der technischen

57:50.450 --> 57:55.590
Informatik, also Programmable Logic Controller beispielsweise, wo man

57:55.590 --> 57:58.470
die Programme auch eventuell verändern kann.

57:58.470 --> 58:03.630
Und das sind die Methoden auch, die benutzt werden, zum Beispiel um

58:03.630 --> 58:07.670
Werkzeugmaschinen zu steuern und zu programmieren.

58:08.070 --> 58:12.290
Also wo man auch dort, wie vorher erwähnt, das heißt wir können jetzt

58:12.290 --> 58:20.210
hier Wissensbasen, Umgebung oder Objektmodelle miteinbeziehen und

58:20.210 --> 58:23.690
berücksichtigen, zum Beispiel geometrische Beschreibungen von einem

58:23.690 --> 58:28.570
Werkstück, Bearbeitungsflächen, Kurven und so weiter und so fort oder

58:28.570 --> 58:32.850
irgendwelche technologischen Beschreibungen, zum Beispiel wie groß ist

58:32.850 --> 58:37.150
die Vorschubgeschwindigkeit oder Spindeldrehzahl und so weiter und so

58:37.150 --> 58:37.370
fort.

58:38.830 --> 58:42.750
Also das ist jetzt nicht so wichtig, aber nur zur Info, damit ihr

58:42.750 --> 58:45.590
sowas mal gesehen habt, also wie so eine klassische

58:45.590 --> 58:47.350
Roboterprogrammiersprache aussieht.

58:52.230 --> 58:57.350
Als nächstes diese hybriden Verfahren, also eine Mischung aus beiden.

58:58.510 --> 59:03.030
Das heißt, das sind zum Beispiel die Möglichkeiten, die vielleicht am

59:03.030 --> 59:06.910
einfachsten sind, dass man grafisch solche Bewegungen oder solche

59:06.910 --> 59:12.730
Programme erzeugt, aber gleichzeitig eine sehr sensuelle Erfassung von

59:12.730 --> 59:14.310
der Benutzerverfolgung bzw.

59:14.590 --> 59:18.230
von der Aufgabe hat, damit man sich zum Beispiel auf neue Situationen

59:18.230 --> 59:19.590
anpassen kann.

59:19.890 --> 59:26.730
Und natürlich hier das Einbeziehen von Simulationen, um solche

59:26.730 --> 59:30.050
Programme, die man zunächst mal generiert hat, zu überprüfen, bevor

59:30.050 --> 59:32.230
man das auf einem echten Roboter ausführt.

59:32.230 --> 59:36.710
Die Vorteile hier sind, dass die Programmierer weniger

59:36.710 --> 59:40.190
Programmierkenntnisse als bei textueller Programmierung brauchen.

59:40.990 --> 59:44.990
Einfache Programmierung und leichte Fehlererkennung, weil da erfasst

59:44.990 --> 59:49.450
man ja alles sensoriell und weiß man, ob das gut oder schlecht ist.

59:50.290 --> 59:54.090
Man kann schnell komplexe Programme erstellen.

59:54.090 --> 59:58.990
Also wenn wir jetzt grafische Bausteine haben, der eine heißt Move,

59:59.090 --> 01:00:04.050
der andere heißt Open Gripper oder Close Gripper oder Stop und so

01:00:04.050 --> 01:00:04.830
weiter und so fort.

01:00:04.930 --> 01:00:08.450
Und wir können sie einfach reinziehen und miteinander verbinden und so

01:00:08.450 --> 01:00:09.590
ein Programm erzeugen.

01:00:09.710 --> 01:00:11.930
Ich glaube, das ist natürlich extrem schnell.

01:00:12.650 --> 01:00:16.710
So wie Rapid Prototyping, der Vergleich hier, wenn man will.

01:00:17.410 --> 01:00:21.230
Die Nachteile, immer wenn es um sensorielle Erfassung von Benutzer

01:00:21.230 --> 01:00:30.350
geht, dann hat man es natürlich mit Ungenauigkeiten zu tun.

01:00:30.550 --> 01:00:36.030
Also zum Beispiel visuelle Erfassung vom Benutzer oder wie bei allen

01:00:36.030 --> 01:00:39.890
Online -Verfahren, also irgendwelche Rauschen der Sensordaten, mit

01:00:39.890 --> 01:00:40.990
denen man umgehen kann.

01:00:40.990 --> 01:00:44.750
Man braucht leistungsfähige Hardware für die Modellierung, aber auch

01:00:44.750 --> 01:00:50.290
für die Signalanalyse und es werden auch komplexe Modelle hier

01:00:50.290 --> 01:00:51.270
benötigt.

01:00:53.190 --> 01:00:58.010
Die grafischen Verfahren, die sehen so aus.

01:00:58.010 --> 01:01:02.910
Ja, also das ist eigentlich das Ziel, glaube ich, was jeder gerne

01:01:02.910 --> 01:01:03.270
hätte.

01:01:03.450 --> 01:01:07.370
Natürlich am liebsten, ich stelle mich vor dem Roboter hin und ich

01:01:07.370 --> 01:01:10.990
mache was und der lernt automatisch, sogar mit seinen eigenen Augen,

01:01:11.170 --> 01:01:18.030
guckt er an und schaut, wie ich ein Brot schneide oder wie ich einen

01:01:18.030 --> 01:01:20.970
Kaffee trinke und so weiter und so fort und generiert daraus sein

01:01:20.970 --> 01:01:21.710
eigenes Programm.

01:01:21.710 --> 01:01:27.110
Natürlich ist es ein langer Weg, aber ein aktuelles Forschungsthema

01:01:27.110 --> 01:01:34.150
und auch wenn man so weit ist, braucht man ja eine Möglichkeit, dieses

01:01:34.150 --> 01:01:37.270
Wissen, was man gelernt hat, irgendwie am besten grafisch

01:01:37.270 --> 01:01:42.010
darzustellen, damit man andere Kombinationen generieren kann.

01:01:43.370 --> 01:01:47.030
Die andere Möglichkeit wäre, wenn wir noch nicht so weit wären oder

01:01:47.030 --> 01:01:51.210
diese anderen Methoden nicht benutzen, die wir in der nächsten

01:01:51.210 --> 01:01:54.550
Vorlesung behandeln werden, dann könnten wir das zunächst mal in

01:01:54.550 --> 01:01:55.410
Simulation machen.

01:01:55.790 --> 01:01:57.290
Das heißt, wir haben komplexe Modelle.

01:01:57.490 --> 01:02:00.770
Also zum Beispiel hier, das ist ein Modell von Arma 3 und das ist die

01:02:00.770 --> 01:02:03.290
Küche von uns, unser Labor.

01:02:04.370 --> 01:02:07.770
Man kann ein sogenanntes virtuelles Teach-in machen.

01:02:08.270 --> 01:02:11.590
Ja, das heißt, Teach-in haben wir gerade kennengelernt.

01:02:11.710 --> 01:02:15.550
Wir führen den Arm zu bestimmten Positionen, speichern wir die Punkte

01:02:15.550 --> 01:02:17.190
und fahren wir die Trajektur ab.

01:02:17.350 --> 01:02:19.330
Aber das war ein Online-Verfahren.

01:02:19.430 --> 01:02:20.750
Wir haben immer einen Roboter gebraucht.

01:02:20.890 --> 01:02:22.510
Aber jetzt können wir das virtuell machen.

01:02:23.130 --> 01:02:26.790
Das heißt, wir können Roboter und Umgebung in 3D-Visualisierung hier

01:02:26.790 --> 01:02:29.030
haben und wir können sie manipulieren.

01:02:29.030 --> 01:02:33.450
Wir können den Arm zu dieser Müsli-Box hier zum Beispiel führen.

01:02:33.590 --> 01:02:35.510
Wir können den Greifer auf- und zumachen.

01:02:36.130 --> 01:02:40.110
Und natürlich diese Zustände oder diese Konfigurationen mal speichern.

01:02:41.390 --> 01:02:46.570
Natürlich benötigen wir hier exakte Modelle der Umgebung und benötigen

01:02:46.570 --> 01:02:49.350
wir auch exakte Modelle vom Roboter.

01:02:49.850 --> 01:02:53.250
Und wenn wir das hier haben, dann wollen wir das wahrscheinlich auch

01:02:53.250 --> 01:02:54.390
nicht jedes Mal machen.

01:02:54.390 --> 01:02:57.890
Das heißt, wenn ich einmal Greifen jetzt hier realisiert habe von

01:02:57.890 --> 01:03:00.890
dieser Müsli-Box, dann sollte es auch Greifen von einem Becher

01:03:00.890 --> 01:03:02.010
beispielsweise sein.

01:03:02.550 --> 01:03:06.830
Ohne Berücksichtigung jetzt vom Griff, also die Form des Griffs, weil

01:03:06.830 --> 01:03:12.170
bei Becher und bei Müsli-Box ist natürlich die Konfiguration der Hand

01:03:12.170 --> 01:03:12.570
anders.

01:03:12.750 --> 01:03:15.910
Aber nehmen wir mal an, die Hand ist etwas, was nur auf und zu geht

01:03:15.910 --> 01:03:16.190
jetzt.

01:03:16.190 --> 01:03:21.910
Und dann wollen wir eigentlich diese Sachen, die wir dort generiert

01:03:21.910 --> 01:03:27.830
haben, formalisieren und in formalisierter Form repräsentieren.

01:03:28.610 --> 01:03:31.690
Und da kommen natürlich hier viele Möglichkeiten, die wir aus der

01:03:31.690 --> 01:03:34.490
Informatik kennen oder auch aus der Regelungstechnik.

01:03:34.950 --> 01:03:39.110
Zum Beispiel endliche Zustandsautomaten, Petri Netzi, beziehungsweise

01:03:39.110 --> 01:03:40.010
auch State Charts.

01:03:40.010 --> 01:03:41.770
Hier sind so ein paar Beispiele.

01:03:42.330 --> 01:03:47.150
Das wäre jetzt so ein State Chart, glaube ich, für Bewegen von der

01:03:47.150 --> 01:03:52.350
Plattform, wo man hier anfängt, man berechnet eine Bahn und dann geht

01:03:52.350 --> 01:03:53.790
hier los mit der Bewegung.

01:03:53.950 --> 01:03:57.550
Und man hat zwei hier ganz markante Zustände, die uns sagen, ob die

01:03:57.550 --> 01:04:00.510
Aktion erfolgreich oder nicht erfolgreich ist.

01:04:01.110 --> 01:04:06.010
Also das heißt, das Ziel eigentlich wäre, dass wir solche Blöcke haben

01:04:06.010 --> 01:04:12.060
für solche Aktionen, die wir programmieren oder Teile der Aufgabe, die

01:04:12.060 --> 01:04:15.600
wir programmieren, die wir beispielsweise grafisch darstellen.

01:04:15.800 --> 01:04:19.160
Das gleiche auch bei Petri Netzen, wenn wir Zustände haben und dann

01:04:19.160 --> 01:04:24.060
können wir diese Knoten und die anderen, wie heißen sie, die anderen

01:04:24.060 --> 01:04:30.160
bei Petri Netzen, die vor dem Knoten stehen, die feuern oder nicht

01:04:30.160 --> 01:04:30.500
feuern.

01:04:30.500 --> 01:04:33.040
Weiß jemand, was Petri Netze sind?

01:04:37.440 --> 01:04:41.100
Gut, dann vergessen wir das.

01:04:43.480 --> 01:04:48.140
Vorteil, wir brauchen keinen Roboter, keinen realen Roboter für die

01:04:48.140 --> 01:04:48.920
Programmierung.

01:04:49.240 --> 01:04:52.180
Die Programmierung benötigt weniger Programmierkenntnisse.

01:04:52.440 --> 01:04:53.700
Das ist eigentlich Spielen.

01:04:53.700 --> 01:04:57.560
Das ist wirklich Gamespielen, wenn man eine super Simulation hat.

01:04:58.320 --> 01:05:01.460
Super Simulation in Anführungszeichen, was ja nicht so trivial ist.

01:05:02.060 --> 01:05:05.100
Dann spielt man nur rum und programmiert diese Roboter.

01:05:05.280 --> 01:05:09.420
Einfache Programmierung, natürlich in der Simulation kann man Fehler

01:05:09.420 --> 01:05:14.860
erkennen und man kann komplexe Programme sehr schnell erstellen.

01:05:14.980 --> 01:05:17.980
Natürlich braucht man hier leistungsfähige Hardware für die

01:05:17.980 --> 01:05:22.940
Visualisierung und für die Simulation, was heutzutage vielleicht auch

01:05:22.940 --> 01:05:24.220
kein Thema ist.

01:05:24.660 --> 01:05:28.120
Aber man braucht genaue Simulationsmodelle, weil wenn wir zum Beispiel

01:05:28.120 --> 01:05:35.460
für das Greifen und ihr erinnert euch an das Kapitel Greifen und die

01:05:35.460 --> 01:05:39.640
Griffe für mehrfingerige Hände, die wir generiert haben, da war ein

01:05:39.640 --> 01:05:44.540
zentraler Punkt dort bei der Bestimmung von Stabilität eines Griffes

01:05:44.540 --> 01:05:47.020
die Kontaktmodelle, die wir nutzen.

01:05:47.020 --> 01:05:50.660
Zum Beispiel, wenn wir jetzt hier Soft-Kontakte annehmen zwischen

01:05:50.660 --> 01:05:55.560
Finger und Objekten, weil die Fingerspitze deformierbar ist wie die

01:05:55.560 --> 01:05:59.140
menschliche Fingerspitze oder weil wir deformierbare Objekte greifen,

01:05:59.880 --> 01:06:03.040
dann brauchen wir natürlich sehr exakte oder sehr genaue oder

01:06:03.040 --> 01:06:09.940
anspruchsvolle Kontaktmodelle, die auch leistungsfähige Hardware

01:06:09.940 --> 01:06:12.840
brauchen, damit man tatsächlich die Simulation durchführen kann.

01:06:13.760 --> 01:06:18.740
Die komplexen Modelle, genau, es werden komplexe Modelle für

01:06:18.740 --> 01:06:23.500
realitätsnahe Simulation benötigt, wenn das erforderlich ist und

01:06:23.500 --> 01:06:27.260
natürlich Roboter und Umgebung müssen auch hier modelliert werden.

01:06:28.580 --> 01:06:32.820
So, jetzt wollen wir mal ein Beispiel sehen, also irgendein formelles

01:06:32.820 --> 01:06:37.900
Werkzeug sehen, wie wir, wenn wir jetzt diese Aktionen oder diese

01:06:37.900 --> 01:06:43.360
Fähigkeiten vom Roboter in zum Beispiel Simulation erzeugt haben, mit

01:06:43.360 --> 01:06:47.300
Teach -In, mit Playback und so weiter und so fort, wie können wir das

01:06:47.300 --> 01:06:51.420
beschreiben in einer Form, die erlaubt uns zum Beispiel die Sachen

01:06:51.420 --> 01:06:54.080
immer wieder zu benutzen, also Wiederverwendbarkeit.

01:06:54.080 --> 01:07:01.200
Und da gibt es hier eine Möglichkeit, die Beschreibung solcher

01:07:01.200 --> 01:07:05.240
Aktionen mithilfe von sogenannten State Charts.

01:07:05.840 --> 01:07:09.160
Und warum gerade State Charts zur Programmierung von Robotern?

01:07:09.220 --> 01:07:11.680
Das ist ein Konzept, das wir auch bei uns benutzen.

01:07:14.440 --> 01:07:18.860
Ganz einfach, weil auf der einen Seite ist es eine grafische

01:07:18.860 --> 01:07:24.160
Möglichkeit, also eine grafische Darstellung von Roboteraktionen, man

01:07:24.160 --> 01:07:28.620
sieht hier Move and Grasp, man sieht hier zum Beispiel, das ist hier

01:07:28.620 --> 01:07:33.420
die Aufgabe Bring me the green cup, also Bring Object.

01:07:34.120 --> 01:07:38.060
Und dieses Bring Object ist nichts anderes als Move and Grasp, also

01:07:38.060 --> 01:07:43.540
gehe mal zur Tasse, die du vielleicht visuell gefunden hast und greife

01:07:43.540 --> 01:07:43.940
das.

01:07:44.800 --> 01:07:49.720
Dann gehe mal zur Übergabeposition, also zu dem Knoten oder zu dem

01:07:49.720 --> 01:07:53.880
Punkt, wo das Objekt übergeben wird und übergebe das Objekt und sag

01:07:53.880 --> 01:07:58.360
mir, ob das erfolgreich war oder ob ein Fehler Erfolg ist.

01:07:58.840 --> 01:08:02.460
Und man sieht hier, dass man von jedem Zustand hier diesen Übergang in

01:08:02.460 --> 01:08:03.460
diesen Fehlerzustand.

01:08:03.520 --> 01:08:07.220
Das heißt, wir wollen in jedem Zustand wissen, ob tatsächlich die

01:08:07.220 --> 01:08:09.900
Ausführung der Aktion erfolgreich war oder nicht.

01:08:10.940 --> 01:08:16.400
Und es gibt hier unterschiedliche Farben in diesen Diagrammen und die

01:08:16.400 --> 01:08:19.860
deuten nur eine Sache an, dass zum Beispiel hier dieses Move and

01:08:19.860 --> 01:08:23.220
Grasp, das ist eine ziemlich komplexe Sache, bewege dich und greife

01:08:23.220 --> 01:08:27.920
und das ist nur ein Zustand, das ist ein Zustand, der aus mehreren

01:08:27.920 --> 01:08:29.340
Unterzuständen besteht.

01:08:29.640 --> 01:08:32.880
Das heißt, es ist so eine hierarchische Darstellung von diesen

01:08:32.880 --> 01:08:33.600
Roboteraktionen.

01:08:34.980 --> 01:08:40.140
Allgemein ist das Lernen von Aktionen aus Beobachtung von Menschen,

01:08:40.320 --> 01:08:44.280
wie ich das so propagiert habe zu Beginn der Vorlesung, ist natürlich

01:08:44.280 --> 01:08:48.260
ein schwieriges Problem und wir werden in der nächsten Vorlesung

01:08:48.260 --> 01:08:51.280
sehen, warum das ein schwieriges Problem ist.

01:08:51.940 --> 01:08:54.840
Weil wir mit der Perzeption, weil wir mit unterschiedlichen

01:08:54.840 --> 01:08:58.080
Körperformen zu tun haben, also dass der Roboter nicht so wie der

01:08:58.080 --> 01:09:01.260
Mensch aussieht und dass wir unsicherheit in der Ausführung haben.

01:09:01.480 --> 01:09:05.600
Und wir wissen, die textuelle Programmierung von komplexen Robotern

01:09:05.600 --> 01:09:09.100
ist auch schwierig, weil die Systeme komplex sind, die

01:09:09.100 --> 01:09:13.120
Roboterfähigkeiten stark zustandsbehaftet sind.

01:09:13.560 --> 01:09:16.700
Also müssen tatsächlich die aktuellen Zustände, in welchen Zuständen

01:09:16.700 --> 01:09:18.750
die Roboter sind, bei der Programmierung.

01:09:19.500 --> 01:09:23.220
Und meistens diese Fähigkeiten, die wir programmieren, bestehen aus

01:09:23.220 --> 01:09:25.570
Unterfähigkeiten, also Subfähigkeiten.

01:09:26.780 --> 01:09:31.160
Also wie ich bereits erwähnt habe, Bring Object besteht aus Move and

01:09:31.160 --> 01:09:35.220
Grasp und Move and Grasp besteht natürlich aus Bewege die Plattform,

01:09:36.240 --> 01:09:40.920
generiere eine Greif-Pose, generiere eine kollisionsfreie Bahn, führe

01:09:40.920 --> 01:09:47.160
die Trajektor aus und dann gehe zur Übergabeposition und dann übergebe

01:09:47.160 --> 01:09:47.920
mal das Objekt.

01:09:48.040 --> 01:09:50.900
Das heißt, wir haben immer so eine Hierarchie eigentlich in dieser

01:09:50.900 --> 01:09:54.520
Repräsentation von Aktionen, die wir nutzen.

01:09:55.980 --> 01:09:59.200
Eine textuelle Programmierung, die wäre vielleicht machbar, aber

01:09:59.200 --> 01:10:03.480
natürlich unübersichtlich und die würde natürlich Informatiker

01:10:03.480 --> 01:10:07.240
benötigen, die auch Robotik-Kenntnisse haben.

01:10:07.640 --> 01:10:12.920
Also Robotik und Kenntnisse auch der künstlichen Intelligenz, wie wir

01:10:12.920 --> 01:10:13.140
sehen.

01:10:15.180 --> 01:10:18.520
Das hat vielleicht eine grafische Programmierung.

01:10:18.880 --> 01:10:22.760
Und was sind diese grafischen mit Zustandsautomaten, Petri Netzi und

01:10:22.760 --> 01:10:26.140
so weiter, aber speziell hier mit State Charts.

01:10:26.300 --> 01:10:27.600
Und was sind State Charts?

01:10:27.600 --> 01:10:33.800
Das sind ein Formalismus, also ein grafischer Formalismus, den man

01:10:33.800 --> 01:10:37.460
nutzt zur Beschreibung komplexer Systeme.

01:10:38.640 --> 01:10:43.320
Das wurde 1987 von Harrell hier vorgeschlagen.

01:10:44.500 --> 01:10:48.660
Und man sieht hier ein Beispiel, man hat hier drei Zustände A, B und

01:10:48.660 --> 01:10:48.920
C.

01:10:50.000 --> 01:10:51.740
A, B, C und D.

01:10:52.060 --> 01:10:55.740
D ist ein Zustand mit den Kinderzuständen A und C.

01:10:55.740 --> 01:10:59.820
Das heißt, man merkt schon jetzt die Hierarchie.

01:11:00.760 --> 01:11:04.080
Und die Buchstaben auf diesen Kanten, das sind hier irgendwelche

01:11:04.080 --> 01:11:04.860
Ereignisse.

01:11:05.140 --> 01:11:08.660
Das heißt, ich wechsle vom Zustand B, natürlich wenn ich irgendeine

01:11:08.660 --> 01:11:14.680
Eingabe oder ein Ereignis A habe und von Zustand A, wenn ein Ereignis

01:11:14.680 --> 01:11:19.760
Gamma hier auftritt, unter der Bedienung, dass P erfüllt ist.

01:11:20.580 --> 01:11:24.880
Das heißt, man hat Zustände und man hat Übergänge und die Übergänge,

01:11:24.980 --> 01:11:29.440
die zwischen den Zuständen erfolgen, wenn bestimmte Ereignisse

01:11:29.440 --> 01:11:30.900
passieren.

01:11:31.560 --> 01:11:37.020
Ich schließe die Hand des Roboters erst dann, wenn ich nah genug am

01:11:37.020 --> 01:11:37.720
Objekt bin.

01:11:37.940 --> 01:11:40.960
Also wenn zum Beispiel der Abstand nah genug ist, dann schließe ich

01:11:40.960 --> 01:11:41.360
die Hand.

01:11:42.880 --> 01:11:46.660
Aber ich kann auch zusätzlich hier irgendwelche Bedienungen

01:11:46.660 --> 01:11:47.360
formulieren.

01:11:47.620 --> 01:11:55.220
P und diese Bedienungen, also die in Klammern hier, die müssen erfüllt

01:11:55.220 --> 01:11:59.560
sein, damit überhaupt, auch wenn dieses Ereignis auftritt, der Wechsel

01:11:59.560 --> 01:12:01.100
von A nach C erfolgt.

01:12:02.080 --> 01:12:05.540
Allgemein die wichtigsten Features von diesen State Charts sind, die

01:12:05.540 --> 01:12:09.670
sind hierarchisch, die erlauben sogenannte Unterlevel Transitionen.

01:12:09.670 --> 01:12:15.270
Also man sieht hier, wir haben keine Transition zwischen Zustand D und

01:12:15.270 --> 01:12:20.450
B, sondern ich habe eine direkte Transition zwischen B und A, wo A ein

01:12:20.450 --> 01:12:22.150
Unterzustand von D ist.

01:12:24.610 --> 01:12:27.690
Dann Orthogonalität, werden wir gleich sehen, was das bedeutet.

01:12:28.170 --> 01:12:33.690
Und wir haben hier Zustandsaktionsphasen, die nennt man Entry, Exit

01:12:33.690 --> 01:12:34.850
und Throughout.

01:12:34.850 --> 01:12:40.130
Der Punkt ist, dass man mithilfe von dieser Repräsentation, von diesen

01:12:40.130 --> 01:12:44.010
Graphen, keinen Datenfluss beschreiben kann.

01:12:44.430 --> 01:12:48.630
Also wir beschreiben Zustände und Übergänge dieser Zustände, aber

01:12:48.630 --> 01:12:51.970
Datenfluss, was ja natürlich notwendig ist für uns in der Robotik,

01:12:52.050 --> 01:12:53.890
wird dadurch nicht abgedeckt.

01:12:54.050 --> 01:12:58.010
Und die Frage war für uns, wie können wir diesen schönen Mechanismus,

01:12:58.010 --> 01:13:05.310
was hierarchisch ist, was Interlevel Transitionen und Orthogonalität,

01:13:05.450 --> 01:13:09.970
dass wir zum Beispiel zwei Prozesse oder zwei Zustände parallel laufen

01:13:09.970 --> 01:13:15.330
können, wie können wir das so erweitern, dass wir das in der Robotik

01:13:15.330 --> 01:13:22.570
nutzen können, indem wir auch in diesem Formalismus eine, oder den

01:13:22.570 --> 01:13:27.190
Formalismus so erweitern, ergänzen, dass wir Datenfluss spezifizieren

01:13:27.190 --> 01:13:27.430
können.

01:13:28.650 --> 01:13:34.010
So, und ganz kurz jetzt zu den Eigenschaften, was sie bedeuten.

01:13:34.350 --> 01:13:39.050
Also Hierarchie, wir haben einen State 1 oder Zustand 1 und Zustand 1

01:13:39.050 --> 01:13:47.750
ist auf dem Top Level Zustand, hat zwei Unterzustände, 1,1 und 1,2 und

01:13:47.750 --> 01:13:50.970
man sieht hier natürlich Übergänge zwischen diesen Zuständen und wenn

01:13:50.970 --> 01:13:55.790
ich in den Zustand 1 reingehe, das war zum Beispiel Move and Grasp,

01:13:55.790 --> 01:13:57.670
dann gehe ich immer in 1,1, ja?

01:13:58.530 --> 01:14:01.010
So, also Beispiel nur zwei Unterzustände.

01:14:01.750 --> 01:14:06.590
Dann steht 1,1 hat wiederum Kinderzustände, ja?

01:14:07.330 --> 01:14:12.570
Und diese Kinderzustände sind 1,1,1, 1,1,1,2 und so weiter und so fort

01:14:12.570 --> 01:14:19.230
und man sieht hier, dass wir beim Betreten eines Zustands immer den

01:14:19.230 --> 01:14:21.570
initialen Kind-Zustand betreten.

01:14:21.570 --> 01:14:27.030
Das heißt, wir betreten immer den Zustand 1 in diesem Zustand.

01:14:27.190 --> 01:14:33.190
Also im Zustand State 1 betreten wir State 1,1, deshalb der rote Pfeil

01:14:33.190 --> 01:14:40.810
hier, im Zustand 1,1 betreten wir immer den Zustand 1,1,1, 1,1,1,

01:14:40.890 --> 01:14:42.890
deshalb der rote Pfeil hier und so weiter und so fort.

01:14:43.470 --> 01:14:45.170
Also das, was wir hier erschienen.

01:14:45.930 --> 01:14:50.350
Das zweite war Inter-Level Transitionen und Inter-Level Transitionen

01:14:50.350 --> 01:14:55.790
bedeutet, dass wir nicht nur diese Übergänge hier zwischen Zuständen

01:14:55.790 --> 01:14:59.530
innerhalb eines Zustands haben, ja?

01:14:59.810 --> 01:15:01.730
Also das sind Übergänge z.B.

01:15:01.970 --> 01:15:07.730
zwischen Zustand 1,1 und 1,2 und 1,2 und 1,1 bzw.

01:15:08.230 --> 01:15:12.990
hier für die Kinderzustände, sondern dass wir sowas haben, ja?

01:15:12.990 --> 01:15:17.670
Also dass ich tatsächlich von einem Unterzustand von Zustand A in

01:15:17.670 --> 01:15:21.630
einen Unterzustand von Zustand B wechseln kann, ja?

01:15:22.970 --> 01:15:25.730
Das sieht ja der Formalismus, das kann man machen.

01:15:25.910 --> 01:15:29.890
Jetzt ist es gut oder schlecht für uns in der Robotik, was glaubt ihr?

01:15:30.010 --> 01:15:33.570
Genau, die Wahrscheinlichkeit war 50%, dass die Antwort richtig ist,

01:15:33.690 --> 01:15:33.870
ja?

01:15:34.630 --> 01:15:36.170
Jetzt kommt, warum?

01:15:36.570 --> 01:15:39.230
Es macht es schwieriger, über das System nachzudenken.

01:15:39.230 --> 01:15:43.550
Ja, in der Tat, es macht es schwieriger, über das System nachzudenken,

01:15:43.730 --> 01:15:44.230
aber spezieller.

01:15:45.270 --> 01:15:48.410
Stellt euch mal vor, wir wollen diese Programme, die wir erstellt

01:15:48.410 --> 01:15:51.310
haben und die wir auf die Art und Weise formalisiert haben,

01:15:51.410 --> 01:15:54.650
wiederverwenden in einem anderen Kontext, ja?

01:15:55.090 --> 01:15:56.010
Und wir wollen z.B.

01:15:56.190 --> 01:16:02.070
diesen Zustand 1,2,3, steht 1,2,3, durch einen anderen Zustand

01:16:02.070 --> 01:16:02.710
ersetzen.

01:16:03.030 --> 01:16:06.150
Also wir wollen irgendeine andere Komponente verwenden und dort

01:16:06.150 --> 01:16:06.510
setzen.

01:16:06.510 --> 01:16:11.890
Da müssen natürlich die Vorbedienungen, die Bedienungen oder die

01:16:11.890 --> 01:16:18.150
Ereignisse und die Bedienungen, die für diesen Übergang zuständig

01:16:18.150 --> 01:16:22.370
sind, müssen überprüft werden, wenn ich einen Teil von meinem Code

01:16:22.370 --> 01:16:23.550
wiederverwenden kann.

01:16:23.690 --> 01:16:27.630
Das heißt, diese Interlevel Transaktionen eigentlich sind ein

01:16:27.630 --> 01:16:32.090
Hindernis für die Wiederverwendbarkeit von Codes, die ich schon habe

01:16:32.090 --> 01:16:34.150
für bestimmte Aktionen.

01:16:34.730 --> 01:16:38.630
Okay, werden wir sehen, wie wir das hier machen.

01:16:38.910 --> 01:16:42.370
Und Orthogonalität habe ich auch gesagt, das heißt, diese

01:16:42.370 --> 01:16:43.730
Unterzustände, z.B.

01:16:43.910 --> 01:16:47.650
1,1 und 1,2, die kann ich parallel ausführen.

01:16:48.310 --> 01:16:51.890
Also das heißt, diese gestrichelte Linie hier markiert die parallele

01:16:51.890 --> 01:16:53.450
Ausführung der zwei Zustände.

01:16:53.450 --> 01:16:55.350
Das ist, was meine Orthogonalität hat.

01:16:55.890 --> 01:16:59.570
Dann gibt es diese Zustandsphasen, das heißt zunächst mal, wenn ich

01:16:59.570 --> 01:17:05.130
einen Zustand betrete, also State 1 z.B., dann wird die Activity Entry

01:17:05.130 --> 01:17:13.370
ausgeführt, bevor der erste Zustand in diesem Zustand betreten wird.

01:17:13.370 --> 01:17:21.210
Dann wird die Activity Throughout ausgeführt, während Zustand oder

01:17:21.210 --> 01:17:23.090
State 1,1 ausgeführt wird.

01:17:23.850 --> 01:17:27.930
Und wenn wir aus dem Zustand rausfliegen oder rausgehen, dann wird die

01:17:27.930 --> 01:17:36.930
Activity Exit ausgeführt, vor dem Verlassen von Zustand 1.

01:17:38.290 --> 01:17:44.230
Das sind drei Aktivitäten, die tatsächlich in den unterschiedlichen

01:17:44.230 --> 01:17:46.550
Zustandsphasen ausgeführt werden.

01:17:46.650 --> 01:17:49.490
Das heißt, wir wissen eigentlich, wann wir in einen Zustand reingehen,

01:17:49.630 --> 01:17:54.650
wann es fertig ist und wann gerade irgendetwas läuft, also eine Aktion

01:17:54.650 --> 01:17:56.070
noch am Laufen ist.

01:17:56.870 --> 01:18:01.770
So, um diese Limitationen, die ich bereits gesagt habe, also dass wir

01:18:01.770 --> 01:18:08.950
keine Datenspezifikation hier machen können, aufzulösen, haben wir

01:18:08.950 --> 01:18:13.350
eine kleine Erweiterung von diesen State Charts gemacht und zwar in

01:18:13.350 --> 01:18:18.090
dem sogenannten AMAX Framework, was wir ja auch für die Programmierung

01:18:18.090 --> 01:18:19.990
von unseren Robotern benutzen.

01:18:20.830 --> 01:18:23.950
Der Datenfluss ist natürlich sehr wichtig, wie wir wissen, wie die

01:18:23.950 --> 01:18:28.730
Verwendbarkeit erfordert, dass wir bestimmte Parameter adaptieren, wie

01:18:28.730 --> 01:18:31.650
Kontrollparameter, Kinematikparameter, Objektparameter.

01:18:31.850 --> 01:18:35.730
Also wenn ich zum Beispiel in einem komplexen Programm jetzt nur die

01:18:35.730 --> 01:18:39.990
Komponente ersetzen will, die die Inversi-Kinematik berechnet, und

01:18:39.990 --> 01:18:42.890
diese Komponente jetzt für einen anderen Roboter, weil ich dieses

01:18:42.890 --> 01:18:47.430
komplexe Programm, das ich zum Teig vorbereiten, auf dem AMAX auf

01:18:47.430 --> 01:18:50.870
irgendeinen anderen Roboter übertrage, der natürlich andere Kinematik

01:18:50.870 --> 01:18:55.350
und andere Parameter hat, dann muss ich natürlich in der Lage sein,

01:18:55.870 --> 01:18:59.790
Repräsentationen zu finden, die mir erlauben, diesen Code wieder zu

01:18:59.790 --> 01:19:03.770
verwenden, dass diese Parameter tatsächlich spezifiziert werden können

01:19:03.770 --> 01:19:08.670
und dass ich meinen Core-Code wiederverwenden kann.

01:19:08.930 --> 01:19:16.290
So, das heißt, was wir hier gemacht haben, wir haben als erstes eine

01:19:16.290 --> 01:19:22.210
Datenflussspezifikation basierend auf Transitionsbasierter Datenfluss,

01:19:22.450 --> 01:19:25.070
mit dem wir diese Datenflussspezifikation spezifizieren.

01:19:26.190 --> 01:19:30.810
Dann haben wir diese Interlevel-Transitionen eliminiert, da sie die

01:19:30.810 --> 01:19:34.690
Verwendbarkeit, wie ich bereits erwähnt habe oder erklärt habe,

01:19:35.190 --> 01:19:35.650
verhindern.

01:19:36.210 --> 01:19:40.710
Und haben zwei wichtige Zustände hinzugefügt zu jedem Zustand und die

01:19:40.710 --> 01:19:42.650
heißen Erfolg und Misserfolg.

01:19:42.850 --> 01:19:45.190
Ja, das ist eigentlich, worauf es ankommt in der Robotik.

01:19:45.530 --> 01:19:49.310
Es ist nicht nur, dass wir jetzt in einen Zustand eintreten und

01:19:49.310 --> 01:19:53.410
irgendwas ausführen, sondern wir müssen wissen, war die Ausführung von

01:19:53.410 --> 01:19:56.950
dem Zustand mit den gegebenen Parametern, also über Ziel und so

01:19:56.950 --> 01:19:58.730
weiter, erfolgreich oder nicht erfolgreich.

01:19:58.730 --> 01:20:04.790
Das heißt, jeder Zustand und jeder Kindzustand hat immer diese zwei

01:20:04.790 --> 01:20:07.210
Zustände, Success und Failure.

01:20:08.530 --> 01:20:14.690
Und natürlich braucht man in der Robotik eine dynamische Struktur und

01:20:14.690 --> 01:20:15.870
keine statische Struktur.

01:20:16.090 --> 01:20:21.470
Das heißt, wenn ich zum Beispiel hier diesen Zustand zur Laufzeit

01:20:21.470 --> 01:20:24.730
ändern will, also Zustand 3, dann muss das erlaubt sein.

01:20:24.730 --> 01:20:28.130
Und dieser Zustand 3 muss nicht immer auf dem gleichen Rechner

01:20:28.130 --> 01:20:31.230
beispielsweise laufen, weil Zustand 3 ist zum Beispiel die

01:20:31.230 --> 01:20:35.530
Objekterkennung und die Objekterkennung läuft auf ein GPU und nicht

01:20:35.530 --> 01:20:40.210
auf ein normales CPU, auf dem zum Beispiel ein Real-Time-Control

01:20:40.210 --> 01:20:40.870
-System läuft.

01:20:41.650 --> 01:20:44.710
So, das heißt, wir müssen auch die Möglichkeit haben, innerhalb von

01:20:44.710 --> 01:20:49.410
dieser Struktur tatsächlich die Verteilung von diesen Zuständen und

01:20:49.410 --> 01:20:54.310
diese Zustände beschreiben jetzt Fähigkeiten für uns.

01:20:54.530 --> 01:20:57.590
Also wie ich bereits gesagt habe, Remote Zustand 3 könnte die

01:20:57.590 --> 01:21:06.630
komplette Objekterkennung und die 6D-Positionsschätzung des Roboters

01:21:06.630 --> 01:21:06.790
sein.

01:21:07.630 --> 01:21:12.830
Okay, und was ganz wichtig ist für die Entwicklung, ist, dass wir

01:21:12.830 --> 01:21:17.710
nicht nur diese grafischen Zustände, die wir wirklich einfach in einen

01:21:17.710 --> 01:21:21.990
grafischen Editor mal reinziehen und nutzen, um Aufgaben,

01:21:22.110 --> 01:21:26.810
Roboterprogramme zu erzeugen, sondern wir sind ja Entwickler noch, wir

01:21:26.810 --> 01:21:29.350
sind noch nicht so weit, dass man sagt, okay, das ist ja fertig.

01:21:29.590 --> 01:21:33.990
Wir wollen direkt die Verlinkung hier von diesem Zustand zum C++ Code,

01:21:34.250 --> 01:21:36.390
was tatsächlich dort implementiert ist.

01:21:36.950 --> 01:21:40.970
Und das ist tatsächlich was, was dieses Framework hier erlaubt.

01:21:41.090 --> 01:21:43.270
Also gerne könnt ihr das natürlich testen.

01:21:43.450 --> 01:21:47.910
Ich wollte das hier vorführen, aber da wird die Zeit heute nicht mehr

01:21:47.910 --> 01:21:48.330
reichen.

01:21:49.830 --> 01:21:53.910
Ich habe aber ein Video, das zeige ich nachher und werde ich nachher

01:21:53.910 --> 01:21:58.070
nächstes Mal die Software auch zeigen.

01:21:58.070 --> 01:22:01.990
Ihr könnt das auch downloaden und damit rumspielen und sagen, was euch

01:22:01.990 --> 01:22:03.570
gefällt und nicht gefällt vielleicht.

01:22:03.930 --> 01:22:07.070
Also ama.x.humanoids.kit.edu.

01:22:09.330 --> 01:22:13.030
Transitionsbasierter Datenfluss haben wir so realisiert, dass wir

01:22:13.030 --> 01:22:16.910
beliebige Datentypen dort zulassen oder ermöglicht haben.

01:22:17.150 --> 01:22:20.930
Also die grundlegenden Integerflow, Double, String und so weiter.

01:22:20.930 --> 01:22:24.370
Aber komplexe Datentypen, die wir in der Robotik zum Beispiel

01:22:24.370 --> 01:22:29.150
brauchen, also zum Beispiel Position, 6D-Pose, komplette Matrizen, um

01:22:29.150 --> 01:22:32.470
Bilder beispielsweise zu übertragen, Listen und so weiter und so fort.

01:22:33.630 --> 01:22:37.070
Und dann haben wir drei Parameter Container pro Zustand.

01:22:37.630 --> 01:22:42.550
Also einmal Eingabe, Input Parameter, wie man sieht hier.

01:22:43.050 --> 01:22:46.810
Dann haben wir Lokale Parameter von diesem Zustand und dann haben wir

01:22:46.810 --> 01:22:48.070
Ausgangsparameter.

01:22:48.910 --> 01:22:56.250
Und wir haben Parameter Abbildungen pro Transition, das heißt die zum

01:22:56.250 --> 01:23:00.590
Beispiel die Output-Parameter von diesem vorherigen Zustand auf die

01:23:00.590 --> 01:23:03.070
Input -Parameter von dem nächsten Zustand abbilden.

01:23:03.070 --> 01:23:07.730
Natürlich sind das hier die Ereignisparameter laut HRL

01:23:07.730 --> 01:23:13.390
-Spezifikationen, die für diesen Übergang, also für den Wechsel von

01:23:13.390 --> 01:23:17.390
diesem Zustand in diesen Zustand führen.

01:23:19.070 --> 01:23:23.030
So, das hat natürlich den Vorteil, dass durch diesen spezifizierten

01:23:23.030 --> 01:23:26.850
Datenfluss keine solchen Seiteneffekte haben, die man normalerweise

01:23:26.850 --> 01:23:30.610
hat, wenn man globale Variablen in seinem C++-Code hat, durch diese

01:23:30.610 --> 01:23:33.650
Abbildungsmechanismen, die man hier hat.

01:23:34.350 --> 01:23:39.950
So, Verteilung über andere Rechner, über mehrere Rechner, über eine

01:23:39.950 --> 01:23:45.270
Kommunikationsmittelwelle, das ist 0C1.

01:23:46.750 --> 01:23:52.010
Und wie man sieht, die Möglichkeit hier, dass man tatsächlich hier

01:23:52.010 --> 01:23:56.810
solche Zustände beispielsweise auf host X und die hier auf host Y und

01:23:56.810 --> 01:24:00.150
wie ich bereits erwähnt habe, man könnte jetzt die Bildverarbeitung

01:24:00.150 --> 01:24:03.810
hier laufen und das ist nur ein Remote-Zustand, was auf einem anderen

01:24:03.810 --> 01:24:04.690
Rechner läuft.

01:24:04.690 --> 01:24:08.070
Natürlich, damit hat man die Vorteile, dass man Lastverteilung auf

01:24:08.070 --> 01:24:12.410
unterschiedlichen Rechnern, wenn man weiß, zum Beispiel die mit einem

01:24:12.410 --> 01:24:16.450
bestimmten Zustand verbundenen Ressourcen, die übersteigen die

01:24:16.450 --> 01:24:22.150
Kapazitäten des lokalen Hosts oder des Hosts, auf dem diese Anwendung

01:24:22.150 --> 01:24:26.130
läuft, dann könnte man natürlich geeignete Lastverteilungsmechanismen

01:24:26.130 --> 01:24:30.090
dort implementieren und realisieren, die eine erhöhte Sicherheit und

01:24:30.090 --> 01:24:32.590
Fehlertoleranz erlauben.

01:24:32.590 --> 01:24:41.090
Und natürlich kann man damit auch die Software oder diese Fähigkeiten

01:24:41.090 --> 01:24:45.330
oder diese Zustände nah an der Hardware platzieren.

01:24:45.590 --> 01:24:49.210
Es muss nicht alles zentral auf einem Roboter laufen, da kann ja ein

01:24:49.210 --> 01:24:53.570
Teil auf einem Kopfrechner laufen und der andere zum Beispiel auf

01:24:53.570 --> 01:24:55.450
einem Armrechner und ähnliches.

01:24:55.450 --> 01:25:00.210
Das heißt, damit ist es natürlich ein Vorteil für die Entwicklung von

01:25:00.210 --> 01:25:01.370
Robotern allgemein.

01:25:03.290 --> 01:25:07.370
Dynamische Struktur habe ich, glaube ich, mehrmals erwähnt, dass auch

01:25:07.370 --> 01:25:11.670
die Möglichkeit gegeben ist, solche Zustände zu Laufzeit

01:25:11.670 --> 01:25:12.550
auszutauschen.

01:25:13.910 --> 01:25:18.150
Dass man beispielsweise bei der Bildverarbeitung zwischen zwei

01:25:18.150 --> 01:25:22.430
unterschiedlichen Algorithmen wechseln kann, die in zwei State Charts

01:25:22.430 --> 01:25:29.750
implementiert sind, um zum Beispiel eine bessere 6D-Positionsschätzung

01:25:29.750 --> 01:25:30.410
zu erreichen.

01:25:31.810 --> 01:25:36.070
Und das Ganze, wie ich bereits gesagt habe, ist integriert in diesem

01:25:36.070 --> 01:25:40.430
AMAX in unser Software-Framework mithilfe von einem grafischen Editor

01:25:40.430 --> 01:25:45.450
mit einer ganzen Menge von Tools, um sowas zu spezifizieren.

01:25:46.070 --> 01:25:49.070
Das ist, wie ich bereits gesagt habe, Bring Object und man sieht jetzt

01:25:49.070 --> 01:25:50.750
hier die Hierarchie Move und Grasp.

01:25:50.890 --> 01:25:53.390
Das sind wiederum eine ganze Menge von Unterzuständen.

01:25:53.390 --> 01:25:58.290
Das ist hier Move to Handover Position und dann Hand Object Handover.

01:25:59.430 --> 01:26:05.270
Und ich glaube, ich zeige ganz kurz, wie das Ganze hier funktioniert.

01:26:07.390 --> 01:26:12.010
Es sind also, nehmen wir mal an, wir wollen nur so Winken realisieren

01:26:12.010 --> 01:26:12.930
mit dem Roboter.

01:26:13.190 --> 01:26:16.730
Da brauchen wir jetzt hier nicht Kinematiken und so weiter, sondern

01:26:16.730 --> 01:26:20.390
irgendwelche, sage ich mal, Basisbausteine.

01:26:21.110 --> 01:26:22.990
Das läuft fast in Echtzeit.

01:26:23.270 --> 01:26:28.450
Also dieses Video, da ist jemand am Rechner und editiert dieses

01:26:28.450 --> 01:26:28.890
Programm.

01:26:29.270 --> 01:26:31.310
Es ist natürlich nur kinderleicht jetzt.

01:26:32.250 --> 01:26:36.650
Wir haben auch für die Schule eigentlich siebte Klasse, die zu uns

01:26:36.650 --> 01:26:41.470
gekommen sind, damit sie mit sowas auch schnell den AMAX programmieren

01:26:41.470 --> 01:26:41.850
können.

01:26:43.130 --> 01:26:47.530
Und da hat man gesehen, glaube ich, wie das Programm aussieht.

01:26:47.670 --> 01:26:50.770
Natürlich, ob er an der Position angekommen ist.

01:26:50.970 --> 01:26:57.550
Man hat hier eine Echtzeit Visualisierung von den aktuellen Zuständen,

01:26:57.630 --> 01:26:59.030
zwischen denen man immer wechselt.

01:26:59.030 --> 01:27:03.090
Das ist natürlich nach vorne, nach hinten beim Winken, aber das könnt

01:27:03.090 --> 01:27:08.550
ihr greifen vom Objekt, Objektlokalisierung, Visual Servoing,

01:27:10.350 --> 01:27:13.150
Greifstabilitätsprüfung und so weiter und so fort.

01:27:14.370 --> 01:27:16.250
Okay, gut.

01:27:17.190 --> 01:27:18.550
Ich habe mehr Beispiele.

01:27:18.790 --> 01:27:24.070
Insgesamt haben wir jetzt so insgesamt 330 solche Zustände, die mit

01:27:24.070 --> 01:27:26.730
Funktionen oder mit Funktionalitäten verbunden sind.

01:27:26.730 --> 01:27:34.090
Und da sieht man hier diese Funktionalitäten für Objektgreifen, für

01:27:34.090 --> 01:27:37.710
Einschenken, für Abstellen von einem Objekt.

01:27:39.550 --> 01:27:43.250
Und diese Funktionalitäten natürlich, die sind jetzt nicht nur hier

01:27:43.250 --> 01:27:47.490
realisiert, sodass sie auf dem AMA 3 ausgeführt werden.

01:27:47.490 --> 01:27:51.790
Die werden gerade jetzt auch benutzt, zum Beispiel um die Fähigkeiten

01:27:51.790 --> 01:27:56.330
oder die Programme für AMA 6 zu entwickeln, wo man nur diese Parameter

01:27:56.330 --> 01:28:00.110
tatsächlich von dem Roboter abändern kann.

01:28:00.850 --> 01:28:05.830
Okay, nun wissen wir jetzt eine ganze Menge, wie wir Programme

01:28:05.830 --> 01:28:11.390
erstellen und zwar mithilfe von klassischen Methoden, aber auch

01:28:11.390 --> 01:28:12.890
mithilfe von grafischen Methoden.

01:28:12.890 --> 01:28:17.210
Und wir haben so oft den Begriff Aktion gesehen und wir wollen das

01:28:17.210 --> 01:28:21.770
nächste Mal sehen, wie können wir tatsächlich Sequenzen von Aktionen

01:28:21.770 --> 01:28:26.270
generieren, basierend auf Repräsentationen der Umgebung, damit wir ein

01:28:26.270 --> 01:28:28.730
Ziel für eine Aufgabe lösen können.

01:28:28.730 --> 01:28:34.010
Also wir sind mehr oder weniger auf dem Gebiet, was man symbolische

01:28:34.010 --> 01:28:37.970
Planung nennt, was natürlich notwendig ist oder wie wir sehen werden

01:28:37.970 --> 01:28:42.930
notwendig ist, um aus den Fähigkeiten, die man programmiert oder aus

01:28:42.930 --> 01:28:47.410
Beobachtung des Menschenlernens automatisch Pläne erzeugt, damit man

01:28:47.410 --> 01:28:48.350
eine Aufgabe löst.

01:28:49.130 --> 01:28:52.050
Okay, für heute bedanke ich mich für die Aufmerksamkeit und wir sehen

01:28:52.050 --> 01:28:52.870
uns am Montag.