WEBVTT

00:04.840 --> 00:12.040
Guten Abend, wir machen heute die Übung in Robotik 1 zur Regelung und

00:12.040 --> 00:18.340
auch noch eine kleinere Einführung in die Robotik-Toolbox, ein

00:18.340 --> 00:21.560
bisschen in MATLAB reinzukommen und dann auch ein bisschen vielleicht

00:21.560 --> 00:23.720
sogar auch Regler zu optimieren.

00:25.460 --> 00:32.520
Als erstes schauen wir uns einfach mal aus der Robotik-Toolbox so

00:32.520 --> 00:35.640
einen Standard-Roboter an und spielen ein bisschen damit rum,

00:35.740 --> 00:38.040
Vorwärtskinematik, Inversekinematik und sowas.

00:39.800 --> 00:45.640
Dann bauen wir uns selber einen Roboter mit einfach nur zwei Gelenken,

00:46.180 --> 00:49.040
den wir schon mal in der Dynamikübung gesehen haben.

00:50.540 --> 00:54.440
Am Ende entwerfen wir dann so einen kaskadierten

00:54.440 --> 01:01.560
Geschwindigkeitsregler für ein Gelenk und wenn wir dann noch Zeit

01:01.560 --> 01:06.760
haben, dann bauen wir auch den Regler nach in Simulink und optimieren

01:06.760 --> 01:08.660
mal die Parameter, spielen damit rum.

01:10.880 --> 01:15.360
Das hatte ich schon in der letzten Übung angeworfen.

01:15.520 --> 01:19.280
Also ihr könnt euch hier an der Uni einfach MATLAB herunterladen und

01:19.280 --> 01:24.400
die Robotik-Toolbox, die gibt es auch umsonst verfügbar auf der

01:24.400 --> 01:26.340
Webseite von Peter Kork.

01:27.500 --> 01:30.500
Also wenn ihr das nachmachen wollt, dann könnt ihr das tun.

01:32.040 --> 01:35.700
Die erste Aufgabe war im Grunde einfach nur so ein Beispiel aus der

01:35.700 --> 01:37.000
Robotik -Toolbox.

01:37.340 --> 01:42.500
Da gibt es nämlich den Puma, einen der Puma-Roboter schon als fertiges

01:42.500 --> 01:42.900
Modell.

01:43.340 --> 01:49.080
Es gibt einige fertige Modelle in der Toolbox und wir können uns auch

01:49.080 --> 01:50.460
angucken, wie der definiert ist.

01:51.140 --> 01:57.740
Sehen wir hier, dass der Roboter sechs Freiheitsgrade hat und wir

01:57.740 --> 02:01.180
sehen hier die DH-Parameter insgesamt.

02:01.740 --> 02:06.440
Die haben wir ja schon im Kinematik-Kapitel kennengelernt und die sind

02:06.440 --> 02:12.440
jetzt hier eben das Theta, das D, das A und das Alpha und dann

02:12.440 --> 02:14.940
gegebenenfalls ein Offset.

02:16.040 --> 02:19.040
Und hier sehen wir er hat eben sechs Gelenke, Q1 bis Q6.

02:20.540 --> 02:23.360
Verschiedene DH-Parameter, die wir hier sehen können.

02:24.660 --> 02:27.420
Und wir können uns, wenn wir uns das damit dann noch nicht vorstellen

02:27.420 --> 02:30.160
können, können wir uns den natürlich auch anzeigen lassen.

02:31.380 --> 02:34.700
Der Roboter hat eine Plot-Funktion, der wir dann eben...

02:36.340 --> 02:39.240
Wir müssen natürlich, bevor wir es plotten können, müssen wir

02:39.240 --> 02:43.660
natürlich festlegen, in welcher Konfiguration der Roboter geplottet

02:43.660 --> 02:44.200
werden soll.

02:44.840 --> 02:47.400
Der hat sechs Freiheitsgrade, das heißt ich definiere mir jetzt

02:47.400 --> 02:52.710
einfach ein Q, dass das kann.

02:55.250 --> 02:59.410
Genau, dann haben wir jetzt hier, das ist jetzt natürlich nur die

02:59.410 --> 03:00.590
Kinematik des Roboters.

03:01.330 --> 03:03.550
In Wirklichkeit hat er natürlich ein Modell.

03:04.250 --> 03:06.810
Und hier sehen wir dann immer an die roten Zylinder, hier sind die

03:06.810 --> 03:11.870
Gelenke und die blauen Elemente sind die Segmente, die es dann

03:11.870 --> 03:12.270
verbinden.

03:13.070 --> 03:15.450
In so einem Beispiel sehen wir natürlich immer nur eine einzelne

03:15.450 --> 03:16.990
Konfiguration vom Roboter.

03:18.390 --> 03:23.230
Die Roboter in der Robotics-Toolbox haben auch so eine Teach-Funktion.

03:24.670 --> 03:28.890
Dann haben wir hier noch zusätzliche Einstellungsmöglichkeiten für die

03:28.890 --> 03:29.290
Gelenke.

03:31.830 --> 03:36.850
Also zum Beispiel das Gelenk 1 ist das Gelenk, das hier um die Z-Achse

03:36.850 --> 03:37.310
rotiert.

03:37.770 --> 03:40.570
Da können wir dann eben den Wert einstellen.

03:41.530 --> 03:45.610
Und hier oben sehen wir immer die Position und die Orientierung von

03:45.610 --> 03:50.450
dem Endeffektor, der

03:54.410 --> 03:58.470
sich dann eben je nachdem, wie wir unsere Winkel einstellen, bewegt.

04:01.210 --> 04:03.790
Genau, also so können wir uns mal den Roboter erstmal anschauen, den

04:03.790 --> 04:06.190
wir hier jetzt uns geladen haben.

04:08.250 --> 04:12.070
Aber wir wollen eigentlich natürlich ein bisschen was mit dem Roboter

04:12.070 --> 04:12.630
selber machen.

04:15.470 --> 04:19.850
Und das Einfachste ist natürlich Vorwärtskinematik.

04:22.370 --> 04:26.190
Das heißt, das, was wir jetzt vorher kennengelernt haben, also aus den

04:26.190 --> 04:29.890
DH -Parametern, kann jetzt eben die Robotics-Toolbox automatisch die

04:29.890 --> 04:31.130
Vorwärtskinematik ableiten.

04:31.610 --> 04:36.070
Und wir können berechnen, wenn sich der Roboter in der Konfiguration Q

04:36.070 --> 04:40.330
befindet, dann ist der Endeffektor an dieser Pose.

04:40.730 --> 04:47.010
Das ist jetzt hier so eine 4x4 homogene Transformationsmatrix, die

04:47.010 --> 04:53.990
eben hier uns die Position gibt und uns dann im oberen 3x3-Matrix die

04:53.990 --> 04:54.730
Orientierung gibt.

04:57.150 --> 04:59.290
Genau, also das ist die Vorwärtskinematik.

05:00.410 --> 05:03.470
Es gibt natürlich auch die Inverse-Kinematik, ist schon eingebaut.

05:04.370 --> 05:07.890
Das heißt, da müssen wir dann erstmal eine Position im Arbeitsraum

05:07.890 --> 05:08.530
vorgeben.

05:11.270 --> 05:18.150
Hier machen wir mal als Beispiel eine Pose, die eine Translation um 0

05:18.150 --> 05:26.170
,7, 0,3 und 0 hat und eine Rotation um die Y-Achse.

05:27.690 --> 05:31.950
Genau, dann haben wir jetzt hier wieder eine 4x4-Matrix, die uns die

05:31.950 --> 05:36.550
Pose angibt, die wir erreichen wollen mit dem Endeffektor von diesem

05:36.550 --> 05:36.950
Roboter.

05:38.190 --> 05:42.370
Wir können die natürlich verpacken, wenn wir wollen, in eine dieser

05:42.370 --> 05:43.430
SE3 -Objekte.

05:44.830 --> 05:49.010
Aber wenn wir jetzt die Inverse-Kinematik machen wollen, dann haben

05:49.010 --> 05:51.850
wir jetzt im Gegensatz zu der Vorwärtskinematik einfach nur das I

05:51.850 --> 05:55.130
hier, also Inverse-Kinematik von der Pose.

05:57.610 --> 06:02.150
Und dann bekommen wir eben einen sechsdimensionalen Vektor heraus, das

06:02.150 --> 06:03.570
ist der Konfigurationsvektor.

06:04.250 --> 06:09.710
In dieser Konfiguration erreicht der Roboter unser Ziel, unser

06:09.710 --> 06:10.430
gewünschtes Ziel.

06:12.090 --> 06:18.150
Das können wir natürlich auch ausprobieren, wenn wir jetzt wieder uns

06:18.150 --> 06:20.010
das teachen lassen.

06:21.070 --> 06:26.590
Dann geht der Roboter jetzt hier in diese Konfiguration, die die

06:26.590 --> 06:27.630
Zielpose erreichen soll.

06:28.390 --> 06:33.990
Und wir sehen, die Zielpose war ja 0,7, 0,3, ist der Endeffektor

06:33.990 --> 06:37.950
angekommen und eine Rotation um die Y-Achse von 90 Grad ist jetzt hier

06:37.950 --> 06:39.750
in RollPitch.io angegeben.

06:41.730 --> 06:44.910
Damit können wir im Grunde die Sachen, die wir in den Kapiteln für

06:44.910 --> 06:47.730
Kinematik und Inverse-Kinematik können wir hier jetzt numerisch

06:47.730 --> 06:50.230
berechnen und benutzen.

06:53.070 --> 06:58.290
Das sind jetzt natürlich so einzelne Konfigurationen.

06:58.450 --> 07:01.450
In Wirklichkeit brauchen wir natürlich auch Trajektorien.

07:01.890 --> 07:04.330
Das heißt, wir machen jetzt mal eine Trajektorie, die der Roboter

07:04.330 --> 07:05.090
abfahren kann.

07:06.830 --> 07:13.610
Das heißt, wir definieren jetzt einfach, dass wir eine zwei Sekunden

07:13.610 --> 07:17.670
lange Trajektorie haben wollen und wir samplen die ab mit einer

07:17.670 --> 07:21.690
Genauigkeit von 0,05 Sekunden.

07:23.310 --> 07:27.790
Das erstellt uns dann eben einen großen Zeitfaktor, der all diese

07:27.790 --> 07:29.630
Zeiten in Einzelschritten enthält.

07:31.690 --> 07:39.130
Und jetzt möchten wir eben eine Trajektorie haben, die besteht aus den

07:39.130 --> 07:43.170
Konfigurationen, aus den Geschwindigkeiten und den Beschleunigungen.

07:43.670 --> 07:47.690
Also das hier sind dann die QDs und die QDD, also jeweils die

07:47.690 --> 07:49.590
Ableitung und die zweite Ableitung.

07:50.770 --> 07:53.130
Und dann können wir uns eine Trajektorie berechnen lassen.

07:54.430 --> 07:56.110
Die Frage ist natürlich, wie wir interpolieren.

07:56.250 --> 07:59.710
Dieses LSBP ist dann die Interpolationsmethode, die wir hier jetzt

07:59.710 --> 08:00.230
benutzen.

08:02.470 --> 08:08.590
Und wir wollen von... habe ich überhaupt schon ein Q0 definiert?

08:09.030 --> 08:11.630
Aber das Q dürfte ja 0 sein.

08:13.070 --> 08:20.170
Und QP war das, was wir aus der Kinematik berechnet haben und dem

08:20.170 --> 08:20.870
Zeitfaktor.

08:23.630 --> 08:28.570
Genau, damit komme ich eben für jeden Zeitwert, Konfiguration,

08:29.810 --> 08:32.210
Geschwindigkeit und Beschleunigung heraus.

08:32.530 --> 08:34.050
Das sind dann eben viele Werte.

08:36.550 --> 08:38.990
Und jetzt kann ich mir das Ganze auch animieren lassen.

08:39.590 --> 08:42.130
Also jetzt in unserem kleinen Bildchen,

08:45.420 --> 08:51.240
da gehe ich jetzt mal einfach die ganzen generierten Qs durch, lasse

08:51.240 --> 08:59.820
mir dafür das Ganze immer plotten, jeweils... wir haben jetzt mehrere

08:59.820 --> 09:07.010
Einträge für jeden Zeiteintrag bekommen und wir pausieren immer unsere

09:07.010 --> 09:12.210
0,05 Sekunden, einfach nur, um mal zu sehen, wie der Roboter jetzt

09:12.210 --> 09:13.310
diese Trajektorien abfährt.

09:13.410 --> 09:18.410
Und hier sieht man jetzt, dass wir von einer Initialkonfiguration eben

09:18.410 --> 09:21.390
dann in die gewünschte Zielkonfiguration übergehen.

09:21.670 --> 09:25.370
Also so können wir uns zum Beispiel mal Trajektorien für den Roboter

09:25.370 --> 09:28.590
hier in der Robotics Toolbox anschauen und animieren lassen.

09:29.810 --> 09:34.350
Also das ist nur so eine kleine Einführungsaufgabe, ist glaube ich

09:34.350 --> 09:37.250
auch ein Tutorial auf der Seite von der Robotics Toolbox dazu.

09:40.330 --> 09:47.350
Was wir nämlich damit machen wollen, ist jetzt einen eigenen Roboter

09:47.350 --> 09:47.970
definieren.

09:49.550 --> 09:53.870
Genau, also die zweite Aufgabe ging im Grunde um einen Roboter, den

09:53.870 --> 09:56.290
wir uns schon mal angeschaut haben in der Dynamikaufgabe.

09:57.650 --> 10:03.070
Das war ein Roboter, der ein Schubgelenk hatte und ein

10:03.070 --> 10:03.930
Rotationsgelenk.

10:06.530 --> 10:11.290
Und den Roboter wollen wir jetzt mal in der Robotics Toolbox selber

10:11.290 --> 10:11.830
nachbauen.

10:12.230 --> 10:14.990
Gehen jetzt davon aus, wir haben unseren Roboter gebaut und wir wollen

10:14.990 --> 10:16.410
ihn jetzt simulieren können.

10:18.030 --> 10:21.110
Und da gehen wir jetzt eben so vor, dass wir zuerst wieder die pH

10:21.110 --> 10:21.970
-Parameter bestimmen.

10:22.090 --> 10:24.750
Das ist jetzt hier nicht so aufwendig, weil der Roboter relativ

10:24.750 --> 10:25.410
einfach ist.

10:25.870 --> 10:28.670
Und dann erstellen wir uns so einen Serial-Link in der Robotics

10:28.670 --> 10:33.210
Toolbox, den den Roboter beschreibt und dann testen wir das Modell und

10:33.210 --> 10:34.990
schauen uns an, was wir damit machen können.

10:36.450 --> 10:43.950
Genau, die pH-Parameter, die haben wir ja schon vorher kennengelernt.

10:44.350 --> 10:48.310
Also hier jetzt auch für die Robotics Toolbox brauchen wir die in dem

10:48.310 --> 10:49.050
gleichen Format.

10:49.730 --> 10:53.990
Also wir haben unser Theta-i, unser Di für das Gelenk, die sich eben

10:53.990 --> 10:57.590
um die alte Z-Achse, auf die alte Z-Achse beziehen.

10:57.890 --> 11:04.250
Und wir haben unser Ai und unser Alpha-i, die sich auf die neue X

11:04.250 --> 11:04.910
-Achse beziehen.

11:06.530 --> 11:10.430
Und ich meine, dann können wir die Transformationsmatrix ausrechnen,

11:10.490 --> 11:12.950
aber das brauchen wir hier jetzt nicht für unseren Anwendungsfall.

11:13.810 --> 11:19.150
Eine Kleinigkeit, die wir noch beachten müssen, also wir haben jetzt

11:19.150 --> 11:23.850
hier den Fall so gewählt, dass wir ein Basis-Koordinatensystem haben,

11:24.930 --> 11:28.470
das einfach vorgegeben ist, das wir hier so haben möchten.

11:30.530 --> 11:33.850
Sag ich mal, nur damit wir es nachher von der Animation her besser

11:33.850 --> 11:38.270
sehen können, wollen wir es so haben, dass unser Basis

11:38.270 --> 11:43.770
-Koordinatensystem hier die X-Achse hat und die Y-Achse hier hin und

11:43.770 --> 11:44.810
die Z-Achse nach oben.

11:45.970 --> 11:52.670
Aber für unseren Roboter muss die erste Z-Achse ja in Richtung des

11:52.670 --> 11:53.450
Gelenks zeigen.

11:54.330 --> 11:57.970
Das heißt, wir haben hier noch so eine Basis-Transformation vorher.

11:58.690 --> 12:04.330
Die können wir auch später in der Robotics-Toolbox angeben, aber wir

12:04.330 --> 12:10.510
müssen dafür natürlich unsere Achsen entsprechend drehen.

12:11.370 --> 12:17.730
Das heißt, unsere Z-Achse soll nachher in Richtung der X-Achse des

12:17.730 --> 12:19.330
Basis -Koordinatensystems zeigen.

12:19.910 --> 12:26.990
Das ist ja das Z0 hier und dafür müssen wir um die Y-Achse drehen.

12:27.390 --> 12:37.170
Also haben wir hier eine Drehung um die Y-Achse und zwar um 90 Grad.

12:38.390 --> 12:40.630
Und das ist die Transformation, die wir vorher anwenden.

12:41.210 --> 12:46.350
Dann ein Offset, um zum ersten Gelenk zu kommen vom Basis

12:46.350 --> 12:47.130
-Koordinatensystem.

12:47.630 --> 12:50.970
Das hat erstmal nichts direkt mit den DH-Parametern zu tun, sondern

12:50.970 --> 12:53.290
einfach nur, wie wir jetzt unseren Roboter definieren wollen.

12:54.070 --> 12:57.550
Dann sind wir eben an der Runde hier angekommen.

12:58.990 --> 13:04.610
Aber wir müssen jetzt die typischen DH-Parameter wieder bestimmen.

13:05.710 --> 13:06.910
Für das erste Gelenk.

13:06.970 --> 13:09.890
Das erste Gelenk ist ja ein Translationsgelenk.

13:10.010 --> 13:23.510
Das heißt, das D1 ist die Variable und das Theta1 dreht um die Z

13:23.510 --> 13:23.930
-Achse.

13:26.630 --> 13:34.050
Und wir möchten jetzt, unser X soll nachher in diese Richtung hier

13:34.050 --> 13:35.190
zeigen, also nach hinten hin.

13:36.270 --> 13:41.590
Und um diese Rotation dann eben zu realisieren, müssen wir unser X

13:41.590 --> 13:44.010
hier um die Z-Achse rotieren.

13:44.750 --> 13:46.230
Und zwar um 90 Grad.

13:46.470 --> 13:50.050
Das ist das Theta1 hier, der Parameter, den wir so bestimmen können.

13:51.970 --> 14:02.530
Dann soll die X-Achse, bleibt natürlich gleich, aber nachher soll

14:02.530 --> 14:04.470
unsere Z-Achse nach unten zeigen.

14:04.950 --> 14:09.270
Das ist das, was man hier sieht.

14:09.390 --> 14:11.590
Also hier sind alle Koordinatensysteme vorgegeben.

14:12.210 --> 14:15.930
Das heißt, unser Alpha1, das rotiert ja um die neue X-Achse, also die

14:15.930 --> 14:16.650
X1 -Achse.

14:17.310 --> 14:24.170
Und hier müssen wir dann eben dafür sorgen, dass unser Z nachher in

14:24.170 --> 14:25.010
diese Richtung zeigt.

14:26.430 --> 14:31.050
Und das ist dann auch wieder eine Rotation um 90 Grad, die wir hier

14:31.050 --> 14:32.630
anwenden müssen in dem Alpha1.

14:34.050 --> 14:37.290
Also das ist das erste Gelenk, das eben zwei Rotationen hat.

14:37.550 --> 14:40.970
Und dann das D1, das wir variabler einstellen können, weil es ein

14:40.970 --> 14:42.190
Translationsgelenk ist.

14:43.210 --> 14:49.090
Und das letzte Gelenk, wir haben ja jetzt nur zwei Gelenke insgesamt,

14:50.330 --> 14:53.150
ist dann eben ein Rotationsgelenk.

14:53.270 --> 14:55.110
Das heißt, das Theta2 ist die Variable.

14:56.630 --> 15:01.870
Und hier haben wir es natürlich auch wieder so gewählt, dass wenn wir

15:01.870 --> 15:04.710
im letzten Gelenk sind, haben wir einfach keine zusätzlichen

15:04.710 --> 15:06.590
Rotationen eingeführt.

15:06.870 --> 15:16.990
Aber es gibt hier natürlich diese Verschiebung um A2 gleich 1, um eben

15:16.990 --> 15:19.550
dann diese Segmentlänge drin zu haben.

15:21.590 --> 15:26.210
Genau, also das ist im Grunde nur einmal eine super kleine Aufgabe zur

15:26.210 --> 15:27.950
Bestimmung von diesen DH-Parametern.

15:29.410 --> 15:32.890
Und mit denen, die wir jetzt für unseren eigenen Roboter definiert

15:32.890 --> 15:40.370
haben, können wir jetzt in der Robotics-Toolbox einen Roboter

15:40.370 --> 15:40.990
aufbauen.

15:42.670 --> 15:47.090
Die Dateien lade ich dann auch nachher noch hoch, die diese Beispiele

15:47.090 --> 15:47.650
alle zeigen.

15:50.230 --> 15:58.790
Was wir zuerst machen, sind die einzelnen Joints zu definieren von

15:58.790 --> 15:59.490
unserem Roboter.

16:00.270 --> 16:05.070
Das besteht ja aus einem Schubgelenk, prismatischem Gelenk nennt man

16:05.070 --> 16:05.510
das auch.

16:06.090 --> 16:08.590
Und in der Robotics-Toolbox gibt es eben eine Funktion, die uns dann

16:08.590 --> 16:10.450
eins von diesen Objekten erstellt.

16:11.010 --> 16:13.790
Und da können wir eben die verschiedenen Parameter eingeben.

16:14.510 --> 16:18.370
Das hier oben sind die von uns bekannten DH-Parameter, also das Theta,

16:18.510 --> 16:22.010
das A und das Alpha, die wir gerade bestimmt haben.

16:22.970 --> 16:27.390
Und das D müssen wir gar nicht angeben, weil das ja die Variable ist.

16:27.970 --> 16:29.670
Also die ist hier gar nicht angegeben.

16:31.290 --> 16:35.010
Und dann haben wir hier noch ein paar Parameter, die sich auf die

16:35.010 --> 16:36.310
Dynamik beziehen.

16:37.150 --> 16:40.350
Die geben wir hier einfach schon mal mit an, weil wir nachher auch ein

16:40.350 --> 16:42.650
bisschen Dynamik mit dem Roboter machen wollen.

16:44.610 --> 16:48.570
Also Masse, Position vom Schwerpunkt, Initial, Matrix und so weiter,

16:49.210 --> 16:50.930
kann man hier angeben.

16:55.890 --> 16:59.770
Genau, und wenn wir das dann ausführen, dann bekommen wir eben ein

16:59.770 --> 17:05.450
Objekt -Prismatic-Joint, das unser Gelenk darstellt, unser erstes.

17:08.730 --> 17:14.110
Und gleichmäßig auch mit dem Prä-Gelenk, der Revolute-Joint.

17:16.070 --> 17:19.770
Hier ist es eben das Theta, das fehlt von den DH-Parametern, weil das

17:19.770 --> 17:20.530
Variable ist.

17:20.650 --> 17:25.030
Also hier haben wir ein E, ein A und ein Alpha, tragen wir hier unsere

17:25.030 --> 17:26.250
DH -Parameter ein.

17:27.950 --> 17:32.230
Und auch hier tragen wir entsprechend für dieses Beispiel ein paar

17:32.230 --> 17:36.650
Dynamik -Parameter ein, um nachher damit rechnen zu können.

17:37.510 --> 17:41.110
Für die Kinematik wird es natürlich ausreichen, nur die DH-Parameter

17:41.110 --> 17:41.810
anzugeben.

17:42.250 --> 17:47.290
Und wenn wir unsere einzelnen Gelenke dann erstellt haben, dann können

17:47.290 --> 17:52.990
wir die verbinden zu einer kinematischen Kette von hintereinander

17:52.990 --> 17:54.010
geschalteten Gelenken.

17:55.970 --> 18:00.810
Und das machen wir mit dem Serial-Link-Objekt-Konstruktor.

18:03.430 --> 18:07.150
Und dann haben wir eben jetzt ein Objekt, das unseren Roboter

18:07.150 --> 18:07.730
darstellt.

18:09.810 --> 18:12.810
Und genauso wie bei dem Puma-Roboter, der ist eben auf die gleiche Art

18:12.810 --> 18:15.810
und Weise definiert, können wir den uns hier anschauen.

18:16.030 --> 18:18.630
Also der hat dann auch eine Tabelle von den DH-Parametern, die wir

18:18.630 --> 18:23.410
eingegeben haben und die wir dann eben hier sehen können.

18:23.490 --> 18:27.570
Das erste hat eine Variable in D und das zweite Gelenk eine Variable

18:27.570 --> 18:28.070
in Theta.

18:29.230 --> 18:32.970
Das heißt, den Teil haben wir richtig gemacht.

18:34.150 --> 18:35.930
Und wir haben es ja gerade uns angeschaut.

18:36.850 --> 18:42.470
Wir wollten ja noch einen Offset haben, also eine Basistransformation,

18:42.750 --> 18:45.230
um die Y-Achse.

18:47.190 --> 18:51.630
Und das kann man eben einfach, indem man die Base von dem Roboter

18:51.630 --> 18:52.010
setzt.

18:52.490 --> 18:55.930
Das ist einfach ein Transformations-Objekt, das man hier angeben kann.

18:56.430 --> 18:59.370
Und in unserem Fall machen wir einfach eine Rotation um die Y-Achse.

18:59.850 --> 19:03.570
Dann haben wir noch Offsets.

19:03.890 --> 19:08.270
Die haben wir auch schon in unseren DH-Parameter-Berechnungen

19:08.270 --> 19:09.550
kennengelernt.

19:11.390 --> 19:15.950
Da sind die Offsets für die einzelnen Gelenke drin, um eben zu sagen,

19:16.090 --> 19:19.370
wo ist denn der Nullpunkt von meinem Gelenk.

19:20.590 --> 19:24.490
Das war dann, wenn wir zum Beispiel geschrieben haben in unseren, für

19:24.490 --> 19:28.330
Theta in den DH-Parametern, zum Beispiel Theta 1 plus 90 Grad oder

19:28.330 --> 19:28.650
sowas.

19:29.810 --> 19:31.850
Und hier benutzen wir dann auch eben Offsets.

19:32.030 --> 19:37.310
Also wir können jetzt hier für jeden Teil Offsets definieren.

19:37.950 --> 19:43.390
In unserem Fall setzen wir einfach für das erste Gelenk 90 Grad als

19:43.390 --> 19:43.830
Offset.

19:44.530 --> 19:47.470
Auch für das zweite, das ist das Drehgelenk.

19:47.830 --> 19:49.910
Und für das Schubgelenk setzen wir 1 als Offset.

19:50.550 --> 19:53.410
Einfach nur, um es ein bisschen komplexer zu machen.

19:54.150 --> 19:59.070
Im Gegensatz zu dem, was wir so in der Kinematik gemacht haben, haben

19:59.070 --> 20:01.890
echte Roboter natürlich immer Gelenkwinkelgrenzen.

20:02.830 --> 20:05.270
Und die können wir hier eben festlegen.

20:05.830 --> 20:11.830
Und wir sagen jetzt mit dem QLim, können wir die einzelnen festlegen.

20:12.450 --> 20:13.910
Sagen wir einfach Minimum und Maximum.

20:16.230 --> 20:19.950
Wir sagen jetzt eben, unser Schubgelenk kann zwischen 0 und 0,5 Meter

20:19.950 --> 20:21.110
ausgefahren werden.

20:21.930 --> 20:22.790
Und dann ist Schluss.

20:23.310 --> 20:25.990
Und das Drehgelenk kann beliebig rotieren.

20:26.370 --> 20:27.930
Also ist endlos rotierbar.

20:32.150 --> 20:38.990
Und für die Dynamik legen wir auch mal fest, wo der Gravitationsvektor

20:38.990 --> 20:39.270
ist.

20:40.290 --> 20:43.230
Ist jetzt für die einfache Kinematik am Anfang nicht so wichtig.

20:43.730 --> 20:47.910
Später spielen wir damit so ein bisschen rum, Gravitation und Dynamik.

20:49.870 --> 20:53.270
Genau, also damit hätte man jetzt so einen ganz einfachen,

20:54.610 --> 20:59.750
zweidimensionalen Roboter aufgebaut, den wir dann benutzen können.

21:01.750 --> 21:05.270
Und wie eben können wir den auch plotten und teachen.

21:05.830 --> 21:11.830
Hier sind einfach ein paar Optionen noch gesetzt, damit der Plot

21:11.830 --> 21:13.870
entsprechend formatiert ist.

21:17.930 --> 21:20.290
Wir sehen jetzt hier eben den Roboter von oben.

21:21.330 --> 21:25.030
Also das blaue Segment ist das Segment an dem Schubgelenk.

21:25.170 --> 21:26.870
Das können wir hier so ausfahren.

21:27.990 --> 21:31.010
Das können wir eben ausfahren, bis wir bei 0,5 sind.

21:33.370 --> 21:36.330
Und dann ist für das Gelenk Schluss.

21:37.190 --> 21:42.990
Und wir haben unser Drehgelenk, das wir eben hier rotieren können, das

21:42.990 --> 21:46.370
sich eben komplett rotieren kann.

21:47.290 --> 21:51.970
In dieser Oberfläche hört er halt einfach auf bei minus 180 und plus

21:51.970 --> 21:52.790
180 Grad.

21:53.650 --> 21:56.830
Aber von der Kinematik haben wir es so definiert, dass er durchdrehen

21:56.830 --> 21:57.110
kann.

22:01.600 --> 22:04.100
Also den Roboter haben wir jetzt aufgebaut.

22:04.480 --> 22:07.860
Wir schauen ihn uns hier von oben an, aber natürlich ist der Roboter

22:07.860 --> 22:10.360
selber hier auch immer dreidimensional.

22:12.200 --> 22:14.720
Also können wir uns die Bewegung vielleicht einfacher anschauen.

22:17.400 --> 22:20.440
Und jetzt machen wir eine kleine Trajektorie.

22:20.440 --> 22:24.320
Wollen wir eine Trajektorie aufbauen für den Roboter?

22:26.340 --> 22:31.040
Und die tasten wir uns so ein bisschen ran.

22:31.180 --> 22:36.460
Also wir können natürlich für unseren Roboter die Vorwärtskinematik

22:36.460 --> 22:36.980
berechnen.

22:37.940 --> 22:41.720
Jetzt hier hat unser Roboter nur zwei Konfigurationsparameter.

22:41.900 --> 22:46.080
Das erste ist eben das D, also wie weit er ausgefahren ist.

22:46.440 --> 22:50.020
Das zweite ist die Rotation, wie weit das zweite Gelenk rotiert ist.

22:52.200 --> 22:55.860
Dann wissen wir eben, in welcher Konfiguration sich der Enddefektor

22:55.860 --> 22:56.280
befindet.

22:57.860 --> 23:01.920
Und wenn wir uns dann zum Beispiel fragen, in welcher Orientierung ist

23:01.920 --> 23:05.300
der Enddefektor, dann können wir uns eben die Eulerwinkel zum Beispiel

23:05.300 --> 23:06.280
dazu ausgeben lassen.

23:07.240 --> 23:10.740
Dann wissen wir, in der Konfiguration ist der Enddefektor in dieser

23:12.300 --> 23:12.780
Orientierung.

23:12.780 --> 23:15.780
Die Inversekinematik, da müssen wir so ein bisschen aufpassen.

23:16.620 --> 23:20.560
Es liegt einfach daran, weil wir jetzt, also die Robotikstoolbox geht

23:20.560 --> 23:25.240
allgemein davon aus, dass wir uns im dreidimensionalen Raum befinden,

23:25.460 --> 23:26.760
was man ja auch hier sehen kann.

23:27.880 --> 23:32.460
Das heißt, unsere Pose ist insgesamt sechsdimensional, drei Positionen

23:32.460 --> 23:34.720
und drei Orientierungsfreiheitsgrade.

23:36.060 --> 23:39.020
Und wenn wir dann versuchen, Inversekinematik zu berechnen mit einem

23:39.020 --> 23:43.620
Roboter, der nur zwei Freiheitsgrade hat, so wie dieser hier, dann

23:43.620 --> 23:48.160
kann es in der Berechnung eben Probleme geben, weil wir ja eindeutig

23:48.160 --> 23:50.500
gar nicht alle Posen erreichen können.

23:51.960 --> 23:56.780
Deshalb hat die Inversekinematik-Funktion noch zusätzliche Parameter,

23:57.720 --> 24:06.820
an denen man einstellen kann, welche Positionen und Orientierungen im

24:06.820 --> 24:08.240
Arbeitsraum denn überhaupt wichtig sind.

24:09.420 --> 24:15.980
Und das ist dieser Mask-Teil, wo wir sagen, uns interessiert nur XY

24:17.460 --> 24:20.480
dem Teil und der Rest ist uns egal.

24:21.600 --> 24:25.800
Um eben einzuschränken, in welchem Raum die Inversekinematik suchen

24:25.800 --> 24:26.080
soll.

24:26.920 --> 24:30.000
Und wir haben jetzt einmal Vorwärtskinematik gemacht und dann wieder

24:30.000 --> 24:32.060
Inversekinematik.

24:32.880 --> 24:35.840
Und das heißt, was wir hier rausbekommen von der Inversekinematik sind

24:35.840 --> 24:40.260
natürlich die gleichen Werte, die wir vorher reingegeben haben, weil

24:40.260 --> 24:44.400
der Roboter eben hier dann eindeutig ist.

24:45.340 --> 24:49.360
Gut, also wir können Vorwärtskinematik, Inversekinematik mit unserem

24:49.360 --> 24:50.340
eigenen Roboter machen.

24:51.280 --> 24:58.720
Und jetzt definieren wir ein paar Punkte, zwischen denen wir dann

24:58.720 --> 25:00.540
nachher interpolieren wollen.

25:01.560 --> 25:10.260
Also wir legen einen Startpunkt fest, T1 und einen Endpunkt, T2, also

25:10.260 --> 25:12.840
das ist jetzt eine Pose, die wir haben.

25:13.520 --> 25:17.820
Und dann berechnen wir die Inversekinematik am ersten Punkt der

25:17.820 --> 25:19.080
Trajektorie.

25:20.080 --> 25:23.660
Also welche Konfiguration bringt uns zum Startpunkt und welche

25:23.660 --> 25:25.640
Konfiguration bringt uns zum Endpunkt.

25:26.320 --> 25:27.920
Das ist dann das Q1 und das Q2.

25:31.090 --> 25:35.270
Und die beiden können wir dann eben benutzen, um zu interpolieren.

25:35.350 --> 25:39.970
Das haben wir ja eben schon gemacht, aber vielleicht schauen wir uns

25:39.970 --> 25:42.350
die vorher nochmal kurz an, wie die aussehen.

25:44.110 --> 25:54.590
Wir haben unseren Tooling-Roboter und den können wir hier

25:59.030 --> 26:01.710
anzeigen.

26:01.850 --> 26:09.250
Also die erste Pose ist die Null-Pose und die zweite Pose ist die

26:09.250 --> 26:13.210
Pose, wo das Gelenk hier ausgestreckt ist und er nach oben hin hier

26:13.210 --> 26:13.530
zeigt.

26:14.650 --> 26:20.450
Und zwischen den beiden wollen wir eine Trajektorie bestimmen und uns

26:20.450 --> 26:21.050
plotten lassen.

26:23.110 --> 26:25.250
Ähnlich wie mit dem Puma-Roboter.

26:26.490 --> 26:30.890
Das heißt, auch hier machen wir uns wieder einfach Zeitschritte und

26:30.890 --> 26:35.050
machen eine Trajektorieninterpolation zwischen den Konfigurationen.

26:36.110 --> 26:38.070
Und dann können wir uns das anzeigen lassen.

26:39.950 --> 26:43.010
Und dann sehen wir, um eben von der Startkonfiguration in die

26:43.010 --> 26:48.530
Endkonfiguration zu kommen, fährt er gemeinsam das Gelenk aus und

26:48.530 --> 26:52.890
macht gleichzeitig eine Rotation vom zweiten Gelenk, um dann in der

26:52.890 --> 26:54.070
Zielpose anzukommen.

26:54.850 --> 27:01.410
Jetzt wollen wir uns nochmal den Ablauf dieser Trajektorie plotten

27:01.410 --> 27:01.750
lassen.

27:04.190 --> 27:09.330
Nicht als Ablauf, sondern tatsächlich, welchen Pfad der Enddefektor

27:09.330 --> 27:09.810
abläuft.

27:15.200 --> 27:20.300
Und dafür benutzen wir einfach hier eine der MATLAB-Funktionen.

27:20.640 --> 27:24.540
Und dann sehen wir hier diesen roten Pfad hier.

27:24.640 --> 27:27.260
Das ist der Pfad, den der Enddefektor abläuft.

27:30.560 --> 27:37.080
Und man sieht hier natürlich, wir haben jetzt die Interpolation im

27:37.080 --> 27:38.360
Konfigurationsraum gemacht.

27:39.280 --> 27:41.400
Das haben wir in der letzten Vorlesung uns auch so ein bisschen

27:41.400 --> 27:41.820
angeschaut.

27:42.240 --> 27:44.860
Wenn man die Interpolation im Konfigurationsraum macht, dann bekommt

27:44.860 --> 27:48.660
man eben im Arbeitsraum gegebenenfalls komplexe Trajektorien.

27:49.300 --> 27:53.140
Man hätte natürlich auch die Interpolation erst im Arbeitsraum machen

27:53.140 --> 27:53.420
können.

27:53.520 --> 27:57.860
Dann hätte man im besten Fall eine gerade Linie herbekommen zwischen

27:57.860 --> 27:59.280
Start - und Zielpunkt.

28:05.190 --> 28:08.430
Was wir uns noch anschauen können, was ist denn mit den Gelenkwinkeln

28:08.430 --> 28:09.450
in der Zeit passiert?

28:13.170 --> 28:14.850
Das ist dieses Diagramm.

28:15.390 --> 28:19.490
Und hier sieht man eben, dass wir eine Interpolation gemacht haben.

28:19.690 --> 28:20.970
Also das hier war unser Startpunkt.

28:21.570 --> 28:23.250
Und hier ist unser Zielpunkt.

28:24.070 --> 28:27.150
Und wir haben zwei Sekunden interpoliert.

28:28.410 --> 28:31.670
Und man sieht, die Interpolationsmethode, die wir jetzt hier benutzt

28:31.670 --> 28:37.250
haben, das ist auf jeden Fall eine polynomielle Interpolation und

28:37.250 --> 28:41.410
keine lineare, weil wir sehen, dass es keine Geraden sind, die das

28:41.410 --> 28:45.230
verbinden, sondern eben so Kurven, die wir hier sehen.

28:46.830 --> 28:53.410
Das ist die generierte Trajektorie im Konfigurationsraum für dieses

28:53.410 --> 28:54.050
Beispiel.

29:00.360 --> 29:03.120
Das, was wir sonst noch so gemacht haben in der Vorlesung, ist

29:03.120 --> 29:04.500
natürlich auch alles verfügbar.

29:05.340 --> 29:09.440
Also zum Beispiel berechnen von der Jacobi-Matrix in einer gewissen

29:09.440 --> 29:10.280
Konfiguration.

29:11.620 --> 29:17.180
Können wir einfach die Jacobi-Nullfunktion benutzen.

29:17.260 --> 29:20.220
Es gibt ja auch noch verschiedene Varianten, die wir machen können.

29:20.680 --> 29:23.440
Aber das hier gibt uns die, die wir kennen.

29:25.860 --> 29:31.000
Das ist dann hier unsere Jacobi-Matrix für unseren Roboter, eben mit

29:31.000 --> 29:33.120
sechs Zeilen und zwei Spalten.

29:35.160 --> 29:39.200
Wir haben ja eine Spalte für jedes Gelenk und wir haben eine Zeile für

29:39.200 --> 29:40.820
jeden Freiheitsgrad im Arbeitsraum.

29:42.400 --> 29:48.420
Und hier sieht man eben auch, warum wir diese Mask brauchen, bei der

29:48.420 --> 29:51.560
Inversenkinematik, weil wir natürlich nicht alle diese sechs

29:51.560 --> 29:54.800
Freiheitsgrade mit nur zwei Spalten in unserer Jacobi-Matrix

29:54.800 --> 29:55.640
aufspannen können.

29:56.860 --> 30:04.000
Mit der Jacobi-Matrix können wir natürlich auch herumrechnen, wenn wir

30:04.000 --> 30:04.300
wollen.

30:07.940 --> 30:09.320
Das haben wir ja schon kennengelernt.

30:09.460 --> 30:13.300
Also wir können mit der Jacobi-Matrix, wenn wir sie multiplizieren mit

30:13.300 --> 30:19.200
einer Gelenkwinkelgeschwindigkeit, dann bekommen wir die

30:19.200 --> 30:20.900
Geschwindigkeit vom Endeffektor heraus.

30:23.260 --> 30:34.040
Und hier haben wir mal gesagt, okay, das erste Gelenk bewegt sich mit

30:34.040 --> 30:39.080
0,5 Metern pro Sekunde nach... versucht sich auszustrecken.

30:39.480 --> 30:41.420
Das zweite Gelenk bleibt still stehen.

30:42.400 --> 30:44.540
Dann ist die Frage, wie bewegt sich der Endeffektor?

30:45.640 --> 30:50.500
Und ich meine, das Gelenk geht hier nur so in die X-Richtung, also das

30:50.500 --> 30:51.540
Translationsgelenk.

30:52.000 --> 30:55.080
Wenn das Translationsgelenk ausgefahren wird mit 0,5 Metern pro

30:55.080 --> 30:59.540
Sekunde, dann bewegt sich auch der Endeffektor mit 0,5 Metern pro

30:59.540 --> 31:01.220
Sekunde nach rechts in die X-Richtung.

31:03.360 --> 31:04.820
Das ist natürlich der einfache Fall.

31:06.400 --> 31:11.180
Die Methode funktioniert natürlich auch für alle anderen

31:11.180 --> 31:12.360
Konfigurationen.

31:12.500 --> 31:20.240
Also wenn zum Beispiel das Gelenk gedreht ist, das zweite, um hier die

31:20.240 --> 31:25.940
halbe, also 45 Grad, dann bekommen wir natürlich eine neue Jacobi

31:25.940 --> 31:30.140
-Matrix, die jetzt eben anders aussieht als die vorherige.

31:30.600 --> 31:34.200
Die Jacobi-Matrix ist ja von der aktuellen Konfiguration abhängig.

31:35.660 --> 31:39.020
Und dann können wir uns wieder fragen, okay, wie ist die Endeffektor

31:39.020 --> 31:43.480
-Geschwindigkeit, wenn ich zum Beispiel mein zweites Gelenk rotiere

31:43.480 --> 31:50.420
mit die halbe pro Sekunde in dieser Konfiguration?

31:52.180 --> 31:55.780
Und dann bekomme ich hier eben eine Geschwindigkeit in X- und Y

31:55.780 --> 32:03.040
-Richtung jeweils negativ von minus 1,11 und eben eine Rotation um die

32:03.040 --> 32:05.680
Z -Achse mit minus p halber.

32:08.020 --> 32:14.740
Und das kann man sich auch anschauen hier, wenn man sich den Roboter

32:14.740 --> 32:15.500
hier anschaut.

32:16.020 --> 32:20.560
Also wir sind jetzt hier in dieser Konfiguration und wir wollen uns

32:20.560 --> 32:23.640
jetzt weiter rotieren.

32:24.260 --> 32:26.820
Also dann rotieren wir weiter in diese Richtung hier.

32:28.340 --> 32:31.580
Und wenn wir in diese Richtung rotieren, dann bewegt er sich natürlich

32:31.580 --> 32:36.100
jetzt so diagonal in diese Richtung, also in negative X-Richtung, aber

32:36.100 --> 32:37.880
auch in negative Y-Richtung.

32:40.560 --> 32:43.900
Ist jetzt natürlich für diesen einfachen Roboter geometrisch leicht zu

32:43.900 --> 32:47.160
bestimmen, aber funktioniert natürlich auch für komplexere Roboter.

32:49.000 --> 32:54.220
Genau, also das ist so diese typischen Kinematik-Sachen, die wir

32:54.220 --> 32:54.780
machen können.

32:56.760 --> 33:00.320
Wir können auch mit unserem Roboter Dynamik-Sachen machen.

33:02.400 --> 33:05.740
Das, was wir einfach mal machen, nur damit man uns mal gesehen hat,

33:06.300 --> 33:10.680
wir definieren jetzt, wir definieren die Gravity sowieso hier unten

33:10.680 --> 33:10.940
nochmal.

33:10.940 --> 33:15.900
Wir wollen jetzt einfach mal Recursive Newton Euler machen für eine

33:15.900 --> 33:19.360
bestimmte Konfiguration und dann wollen wir berechnen, welche Kräfte

33:19.360 --> 33:22.160
und Drehmomente wirken am Ende.

33:25.060 --> 33:28.620
Und da können wir einfach die RNE, Recursive Newton Euler Funktion

33:28.620 --> 33:29.080
benutzen.

33:30.340 --> 33:37.620
Und dann bekommen wir als Ergebnis heraus, dass wir eine Kraft haben

33:37.620 --> 33:38.800
von 19,62.

33:39.900 --> 33:42.820
Das liegt einfach daran, dass wir jetzt hier, wir haben jetzt mal

33:42.820 --> 33:52.280
gesagt, die Gravity zieht in X-Richtung und da wir zwei Gewichte haben

33:52.280 --> 33:56.100
mit jeweils ein Kilogramm, das haben wir am Anfang eingestellt, wirken

33:56.100 --> 34:03.280
eben auf insgesamt zwei Kilogramm mal die Beschleunigung, die wir hier

34:03.280 --> 34:03.500
haben.

34:04.320 --> 34:07.420
Dann haben wir hier eben eine lineare Kraft Newton, die jetzt hier

34:07.420 --> 34:07.740
wirkt.

34:08.620 --> 34:12.340
Wir können natürlich auch diese Kräfte umrechnen, das haben wir,

34:12.880 --> 34:14.440
glaube ich, nur in der Vorlesung mal gemacht.

34:15.180 --> 34:21.460
Also wenn wir eine Kraft, einen Kraftfaktor haben, beziehungsweise

34:21.460 --> 34:26.180
eine generalisierte Kraft, die am Endeffektor wirkt, am Ende des Arms

34:26.180 --> 34:30.960
und wir wollen herausfinden, welche Kräfte in den einzelnen Gelenken

34:30.960 --> 34:34.920
wirken, beziehungsweise welche Drehmomente, dann können wir das über

34:34.920 --> 34:38.000
die transponierte Jacobi-Matrix bestimmen.

34:40.320 --> 34:43.580
Das, glaube ich, nur mal in der Vorlesung gemacht.

34:44.780 --> 34:48.240
Und dann sehen wir, wenn wir hier jetzt so eine Kraft am Endeffektor

34:48.240 --> 34:53.820
auswirken, dann führt das zu einer linearen Kraft, zu einem Drehmoment

34:53.820 --> 34:54.660
im zweiten Gelenk.

34:54.860 --> 34:58.420
Also das sind ja die generalisierten Kräfte für die beiden Gelenke,

34:59.720 --> 35:04.940
die man dann hier umrechnen kann vom Arbeitsraum in den

35:04.940 --> 35:07.440
Gelenkwinkelraum über die Jacobi-Matrix.

35:08.720 --> 35:12.500
Habt ihr zu den Robotics Toolbox Kinematik-Sachen vielleicht Fragen?

35:15.160 --> 35:16.300
Habt ihr das mal ausprobiert?

35:16.900 --> 35:18.080
Wer hat es mal ausprobiert?

35:19.340 --> 35:20.160
Ah, sehr viele.

35:20.400 --> 35:21.440
Okay, mindestens einige.

35:22.820 --> 35:24.320
Gut, das ist, glaube ich, ganz nett.

35:24.420 --> 35:27.120
Ich glaube, Sie haben auch einige mehr Beispielroboter, mit denen man

35:27.120 --> 35:28.420
auch mal sinnvolle Dinge machen kann.

35:28.920 --> 35:31.400
Hier jetzt in der Kürze der Zeit machen wir natürlich nur so ein paar

35:31.400 --> 35:32.520
kleinere Dinge.

35:35.680 --> 35:39.300
Gut, also das war im Grunde mal alles, konnte man sehen, dass alles,

35:39.400 --> 35:41.640
was wir so in den Vorlesungen mal gemacht haben, natürlich schon

35:41.640 --> 35:43.700
jemand implementiert hat, in Tools gepackt hat.

35:47.180 --> 35:49.520
Und eigentlich wollten wir auch noch so ein bisschen Regelungen

35:49.520 --> 35:51.120
machen, das heißt, den Teil machen wir jetzt.

35:53.460 --> 35:57.460
Erst ein bisschen theoretisch, also wir schauen uns wieder den Teil

35:57.460 --> 35:59.480
an, ich glaube, den gab es auch schon in der Vorlesung.

36:00.080 --> 36:03.840
Einfach ein Gelenk, einen Roboterarm zum Beispiel, der einen

36:03.840 --> 36:08.340
Elektromotor hat und einen mechanischen Teil hinten dran, also ein

36:08.340 --> 36:09.440
Arm, der bewegt werden soll.

36:11.480 --> 36:14.580
Und da haben wir natürlich die zwei Systeme, die dann eben jeweils

36:14.580 --> 36:17.020
geregelt werden sollen in Kombination.

36:18.580 --> 36:23.760
Und wir zeichnen erst unseren Regelkreis, dann machen wir Laplace

36:23.760 --> 36:26.860
-Transformation und dann stellen wir unsere Übertragungsfunktion auf.

36:27.560 --> 36:32.100
Und der Teil ist immer nicht auf dem Übungsblatt, aber wir versuchen

36:32.100 --> 36:36.800
dann auch noch für das System, was wir jetzt hier beschrieben haben,

36:36.800 --> 36:43.740
dann in Simulink, was Teil von was wir in MATLAB benutzen können, das

36:43.740 --> 36:47.360
System nachzubauen und dann mal die Regelparameter dafür zu

36:47.360 --> 36:47.880
optimieren.

36:48.220 --> 36:50.880
Wir machen dann so einen PED-Regler dafür.

36:51.840 --> 36:55.980
Das ist im Grunde unser System, was wir uns jetzt einfach mal

36:55.980 --> 36:59.900
vereinfacht in ein Blockdiagramm gemalt haben.

37:00.500 --> 37:05.960
Also irgendwie haben wir hier so einen Regler, der laufen soll.

37:06.500 --> 37:09.960
Der soll uns eine Spannung erzeugen, die UA.

37:10.680 --> 37:13.000
Mit der Spannung wird dann eben der Motor betrieben.

37:14.280 --> 37:18.820
Der Motor ist ein Elektromotor und führt eben dazu, dass wir gewisses

37:18.820 --> 37:20.420
Drehmoment am Ende haben.

37:21.260 --> 37:24.620
Das Drehmoment wird dann benutzt, um den Roboterarm eben zu

37:24.620 --> 37:25.160
beschleunigen.

37:25.720 --> 37:29.940
Und am Ende hat der Roboterarm eine gewisse Geschwindigkeit, mit der

37:29.940 --> 37:30.620
er sich bewegt.

37:31.440 --> 37:33.660
Und die Geschwindigkeit ist die, die uns interessiert.

37:33.880 --> 37:39.960
Also wir wollen eine Soll-Geschwindigkeit vorgeben am Anfang und dann

37:39.960 --> 37:43.260
die Ist-Geschwindigkeit von diesem Roboterarm regulieren.

37:48.820 --> 37:54.560
Der Teil ist aus der Vorlesung.

37:55.900 --> 38:00.080
Also weil wir jetzt natürlich geschachtelte Systeme haben, also intern

38:00.080 --> 38:04.220
zum Beispiel eine Stromregelung oder Drehmomentregelung für den Motor,

38:06.020 --> 38:08.100
die es natürlich gibt.

38:10.640 --> 38:14.300
Da wir ja eine Geschwindigkeitsregelung machen wollen, müssen wir noch

38:14.300 --> 38:21.020
drumherum nochmal eine Regelung bauen, die eben die Geschwindigkeit

38:21.020 --> 38:21.480
regelt.

38:22.620 --> 38:24.920
Und jetzt in diesem Beispiel hören wir hier auf, wenn man dann noch

38:24.920 --> 38:27.860
zum Beispiel eine Positionsregelung aufbauen will, dann wird die

38:27.860 --> 38:30.180
nochmal oben drauf sitzen.

38:30.640 --> 38:33.200
Aber das ist im Grunde das, was wir in dieser Übung machen wollen.

38:33.900 --> 38:38.580
Hier ist das Bild, was wir schon mal in der Vorlesung hatten.

38:39.120 --> 38:46.000
Und jetzt hier für unseren Teil in der Übung ignorieren wir den linken

38:46.000 --> 38:49.260
Teil einfach und wir fangen hier an.

38:49.420 --> 38:58.280
Also wir gehen davon aus, hier das UA ist unsere Stellgröße und wir

38:58.280 --> 39:04.560
wollen die Stromstärke im Motor regeln.

39:07.580 --> 39:11.780
Und das ist unser erstes System, der Motor eben.

39:11.960 --> 39:14.300
Und hinten am Motor hängt dann der Roboterarm.

39:16.180 --> 39:23.660
Und aus dem Motor kommt eben das Drehmoment heraus, mit dem der Motor

39:23.660 --> 39:24.420
angetrieben wird.

39:25.920 --> 39:29.700
Das ist dann für den Teil unsere Stellgröße, aber wir wollen die

39:29.700 --> 39:35.480
Geschwindigkeit, die Gelenkwinkelgeschwindigkeit dann von dem

39:35.480 --> 39:36.860
Roboterarm regeln.

39:37.260 --> 39:40.660
Also das sind dann unsere zwei Systeme, die wir betrachten.

39:44.210 --> 39:48.210
Und im ersten Teil schauen wir uns dann eben erst mal nur den Motor

39:48.210 --> 39:48.830
selbst an.

39:49.930 --> 39:53.470
Und in der ersten Aufgabe sollten wir nur die Blockdiagramme dafür

39:53.470 --> 39:53.970
zeichnen.

39:54.170 --> 39:56.850
Und wir fangen jetzt einfach mal von innen nach außen an, eben mit dem

39:56.850 --> 39:57.130
Motor.

40:01.360 --> 40:06.360
Also irgendwo haben wir eben unseren Motor als Block.

40:07.340 --> 40:12.840
Aus unserem Motor kommt eben die aktuelle Stromstärke raus.

40:15.420 --> 40:21.980
Eigentlich interessiert uns ja das Drehmoment, mit dem es angetrieben

40:21.980 --> 40:22.200
wird.

40:22.760 --> 40:26.420
Aber jetzt für unseren Fall nehmen wir an, dass wir einen Motor haben,

40:26.540 --> 40:30.980
wo Stromstärke proportional zum Drehmoment ist, was in den meisten

40:30.980 --> 40:33.300
Fällen auch stimmt.

40:36.500 --> 40:38.900
Als Ausgabe kommen wir dann eben die Stromstärke.

40:40.800 --> 40:44.180
Und als Eingabe haben wir eine Sollvorgabe für den Strom.

40:44.400 --> 40:47.680
Also das ist die, die wir vorgeben wollen.

40:50.160 --> 40:54.020
Und dann bilden wir eben die Differenz zwischen Ist-Stromstärke und

40:54.020 --> 40:54.900
Soll -Stromstärke.

40:56.360 --> 41:01.920
Diese Differenz geht in unsere Stromregelung.

41:04.460 --> 41:09.140
Und aus unserer Stromregelung kommt die Spannung, die wir an den Motor

41:09.140 --> 41:15.460
anlegen, um dann eben die entsprechende Stromstärke zu erzeugen.

41:16.340 --> 41:22.180
Also das ist dann die innere Stromregelung, die wir anbringen, die

41:22.180 --> 41:27.480
eben aus einer Soll-Stromstärke mit dem Vergleich mit der aktuellen

41:27.480 --> 41:32.120
Ist -Stromstärke eine Spannung bestimmt für den Motor, dem der dann

41:32.120 --> 41:34.960
eben angetrieben wird.

41:35.740 --> 41:40.320
Und das Bild nehmen wir jetzt im Grunde und müssen das jetzt erweitern

41:40.320 --> 41:42.360
um den nächsten Teil.

41:43.160 --> 41:46.760
Also den Teil haben wir dann als Blockdiagramm vereinfacht

41:46.760 --> 41:47.360
dargestellt.

41:48.620 --> 41:52.440
Und der nächste Teil ist dann eben die Mechanik, die hinten dran

41:52.440 --> 41:54.720
hängt, die wir jetzt noch unterbringen müssen.

41:55.440 --> 41:59.000
Und das heißt, wir haben jetzt hier, das ist das, was wir eben gerade

41:59.000 --> 42:02.000
gesehen haben, die Stromregelung, die wir jetzt hier einfach

42:03.560 --> 42:04.320
reinkopiert haben.

42:04.960 --> 42:10.600
Wir wissen, am Ende hinter dem Motor ist halt noch der Roboterarm.

42:11.760 --> 42:13.800
Der hängt einfach hier dran.

42:15.080 --> 42:20.740
Und aus dem Roboterarm kommt eben ein Messen, wie schnell er sich

42:20.740 --> 42:24.420
bewegt, also die Gelenkwinkelgeschwindigkeit.

42:25.140 --> 42:28.520
Und wir haben natürlich die Sollvorgabe, also wie schnell soll sich

42:28.520 --> 42:29.700
der Arm drehen.

42:31.320 --> 42:35.560
Und wir nehmen dann eben die Ist-Geschwindigkeit, führen die wieder

42:35.560 --> 42:41.640
zurück und bilden dann hier eben die Regeldifferenz aus den beiden

42:41.640 --> 42:43.700
Werten, aus Soll und Ist.

42:44.380 --> 42:51.900
Und das Ganze geht dann eben in unsere Geschwindigkeitsregelung.

42:53.240 --> 42:57.740
Und dann haben wir jetzt eben um die Stromregelung herum, haben wir

42:57.740 --> 43:02.340
jetzt unsere Geschwindigkeitsregelung aufgebaut mit unseren einzelnen

43:02.340 --> 43:03.240
Teilen.

43:04.420 --> 43:08.860
Hier aus den Teilen, also aus der Geschwindigkeitsregelung, muss

43:08.860 --> 43:13.260
natürlich wieder eine Sollstromstärke herauskommen.

43:15.300 --> 43:20.920
Das heißt, gegebenenfalls muss man hier immer mit den Einheiten

43:20.920 --> 43:21.400
aufpassen.

43:22.120 --> 43:23.400
Aber das sehen wir später auch nochmal.

43:24.160 --> 43:27.620
Ja, also das ist im Grunde einfach mal für jetzt einen konkreten

43:27.620 --> 43:32.800
Anwendungsfall eine kaskadierte Regelungsblockdiagramme mal zeichnen.

43:35.400 --> 43:41.060
Und was wir natürlich jetzt noch machen müssen, ist im Grunde die

43:41.060 --> 43:45.860
einzelnen Systeme hier, den Motor und den Roboterarm genau

43:45.860 --> 43:51.620
modellieren, damit wir den nachher auch Übertragungsfunktionen

43:51.620 --> 43:55.020
aufstellen können und dann auch die Regelung für das System simulieren

43:55.020 --> 43:55.360
können.

43:56.520 --> 44:02.160
Und deshalb ist die zweite Aufgabe eben, erst mal Laplace

44:02.160 --> 44:04.780
-Transformationen von Gleichungen zu machen.

44:06.100 --> 44:10.740
Und die Frage ist immer, wo kommen die Gleichungen her?

44:11.560 --> 44:13.120
Das ist wahrscheinlich offensichtlich.

44:15.060 --> 44:20.740
Die sind ja nicht beliebig gestellt worden, sondern die Gleichungen

44:20.740 --> 44:25.280
selbst kommen ja aus den Parameter und so weiter.

44:25.400 --> 44:27.200
Die hat man vielleicht schon hier gesehen teilweise.

44:28.000 --> 44:33.080
Das sind im Grunde die Differenzialgleichungen, die unser System hier

44:33.080 --> 44:33.700
jetzt beschreiben.

44:33.880 --> 44:37.420
Natürlich ziemlich vereinfacht, aber wir wollen ja natürlich erst mal

44:37.420 --> 44:38.900
so sehen, wie der Prozess abläuft.

44:40.100 --> 44:46.220
Und die erste Gleichung kommt eben aus dem Elektromotor, den wir hier

44:46.220 --> 44:46.520
haben.

44:47.300 --> 44:51.260
Und zwar aus dem zweiten Kirchhoff'schen Gesetz.

44:51.820 --> 44:56.580
Also wir haben jetzt hier vereinfacht angenommen, der Stromkreis hier

44:56.580 --> 45:00.320
in dem Motor lässt sich über einen Widerstand, eine Induktivität

45:00.320 --> 45:00.940
darstellen.

45:02.000 --> 45:06.660
Und in unserem Fall nehmen wir mal an, dass die durch den Rotor hier

45:06.660 --> 45:10.380
induzierte Spannung, die ignorieren wir mal, sondern uns interessiert

45:10.380 --> 45:15.900
nur eine Spannung, die durch den Widerstand kommt.

45:16.380 --> 45:25.720
Also einfach mal nach der Formel rr mal r mal i und eine Spannung, die

45:25.720 --> 45:27.540
durch die Induktivität entsteht.

45:28.740 --> 45:34.560
Bei der Induktivität müssen wir die Ableitung der Stromstärke

45:34.560 --> 45:37.340
beachten, also wie sich die Stromstärke ändert.

45:40.160 --> 45:45.080
Und nach dem Kirchhoff'schen Gesetz kann man eben sich für eine

45:45.080 --> 45:47.480
Richtung entscheiden und diesen Stromkreis durchgehen.

45:48.020 --> 45:52.420
Und wenn man das macht, dann alle Spannungen aufaddiert, dann sind die

45:52.420 --> 45:53.320
insgesamt 0.

45:54.820 --> 45:57.780
Und in unserem Fall haben wir natürlich hier noch die angelegte

45:57.780 --> 45:58.700
Spannung ua.

45:59.600 --> 46:09.120
Das heißt insgesamt haben wir dann hier r plus ul minus ua.

46:10.340 --> 46:22.580
Wenn wir das umformen nach ua und einsetzen, also ua ist ja ra mal ia

46:22.580 --> 46:30.960
plus la mal die Ableitung nach der Zeit von ia.

46:33.180 --> 46:42.080
Und das ist eben die Gleichung, die wir in der Aufgabe Laplace

46:42.080 --> 46:43.020
transformieren sollten.

46:43.520 --> 46:48.480
Das ist wie gesagt ein sehr vereinfachtes Modell dann eben für unseren

46:48.480 --> 46:49.480
Elektromotor.

46:55.100 --> 46:57.720
Aber jetzt zur eigentlichen Aufgabe, also wenn wir jetzt diese

46:57.720 --> 47:01.380
Gleichung für unser System bestimmt haben, unser Ziel ist natürlich

47:01.380 --> 47:04.280
irgendwann die Übertragungsfunktion aufzustellen im Frequenzraum.

47:04.280 --> 47:08.240
Aber dafür müssen wir erstmal Laplace Transformation anwenden.

47:10.000 --> 47:17.540
Zum Glück können wir da meistens uns einfach auf Regeln verlassen, die

47:17.540 --> 47:18.940
wir einfach kennen.

47:19.160 --> 47:21.460
Also das heißt, wir müssen oft gar nicht dieses Integral selbst

47:21.460 --> 47:25.680
bestimmen, was der Definition folgt.

47:26.680 --> 47:33.280
Und ja, hier im Beispiel sollen wir im Grunde die Funktion ua von t

47:33.280 --> 47:34.340
Laplace transformieren.

47:35.380 --> 47:40.580
Und wenn wir das Ganze einsetzen, dann können wir einfach ein paar

47:40.580 --> 47:43.140
Regeln, die wir kennengelernt haben, anwenden.

47:44.700 --> 47:47.540
Das eine ist, die Laplace Transformation ist linear.

47:48.660 --> 47:53.780
Das heißt, wir können die Faktoren hier rausziehen und auch das Plus

47:53.780 --> 47:54.680
hier rausziehen.

47:55.400 --> 48:00.820
Dann bleibt eben übrig Ra mal die Laplace Transformation von ia von t.

48:01.260 --> 48:07.200
Und hier bleibt La mal die Laplace Transformation von der Ableitung

48:08.040 --> 48:09.520
von ia von t.

48:10.580 --> 48:15.160
Und dann haben wir ja noch die Ableitungsregel kennengelernt.

48:15.300 --> 48:18.480
Also wenn wir so etwas der Form haben, Laplace Transformierte der

48:18.480 --> 48:26.420
Ableitung, dann wird das umgeformt in s mal die Laplace

48:26.420 --> 48:27.140
Transformierte.

48:28.260 --> 48:38.820
Das heißt, Ableiten wird eben zur Multiplikation und der Rest ist dann

48:38.820 --> 48:41.860
im Grunde einfach nur das, was wir schon kennen.

48:43.200 --> 48:48.400
Das heißt, die Laplace Transformation von der Differenzialgleichung

48:48.400 --> 48:54.060
hier oben ist dann eben hier unten der Teil.

48:55.220 --> 48:58.440
Natürlich haben wir hier vorne noch unser ua von s stehen.

49:00.780 --> 49:05.960
Und linearitätsgesetz, Differenzationsgesetz angewendet.

49:06.270 --> 49:08.920
Wir haben gar nicht selber Laplace bestimmt.

49:10.260 --> 49:14.880
Und fast das Gleiche können wir für den mechanischen Teil auch machen.

49:16.660 --> 49:22.020
Da schauen wir uns vielleicht mal auch kurz an, wo diese Formel

49:22.020 --> 49:22.540
herkommt.

49:23.640 --> 49:29.280
Also wir haben natürlich die allgemeine Dynamikgleichung, die wir

49:29.280 --> 49:30.240
schon kennengelernt haben.

49:30.520 --> 49:35.300
Also m von q mal q Punkt plus die Coriolis-Kräfte plus die

49:35.300 --> 49:36.320
Gravitationskräfte.

49:38.740 --> 49:44.520
Und in unserem Fall gehen wir davon aus, dass die Gravitation hier in

49:44.520 --> 49:47.940
die Ebene hinein zeigt, also für uns jetzt erstmal nicht wichtig ist.

49:48.460 --> 49:53.080
Sie wirkt nicht entlang irgendeiner der für uns relevanten Achsen.

49:56.660 --> 50:02.400
Und das heißt für unseren vereinfachten Fall hier in der Ebene können

50:02.400 --> 50:05.060
wir eben davon ausgehen, wir haben irgendeinen Treckheitsmoment von

50:05.060 --> 50:13.120
unserem System hier mit der Gelenkwinkelbeschleunigung multipliziert.

50:13.520 --> 50:15.500
Und wir gehen davon aus, wir haben jetzt hier einfach eine

50:15.500 --> 50:17.380
Drehzahlabhängige Reibungskonstante.

50:17.760 --> 50:20.300
Das muss natürlich auch nicht immer so sein, aber in unserem Fall

50:20.300 --> 50:21.640
jetzt, um es einfach zu halten.

50:22.820 --> 50:28.600
Und wie gesagt, die Gravitation wirkt ja einfach in die Ebene hinein,

50:28.700 --> 50:32.220
das heißt in unserem Fall spielt die jetzt keine Rolle für das System.

50:33.420 --> 50:39.460
Das, was wir dort dann berechnet haben, ist im Grunde die Last, die

50:39.460 --> 50:42.300
anliegt an dem Motor, das ML.

50:43.880 --> 50:49.840
Und das ML zeigt eben genau in die andere Richtung, beziehungsweise

50:49.840 --> 50:53.160
ist ein Drehmoment, das heißt es rotiert genau in die andere Richtung,

50:53.880 --> 50:57.720
wie das MA, das wir bestimmen wollen, also was wir dann anlegen vom

50:57.720 --> 50:58.080
Motor.

51:00.440 --> 51:06.620
Und das heißt eben, die beiden, die Last und das, was erzeugt wird,

51:07.680 --> 51:08.880
die müssen eben gleich sein.

51:09.340 --> 51:12.060
Und das nutzen wir aus, um dann eben jetzt unsere Gleichung

51:12.060 --> 51:17.000
aufzustellen, für den entsprechenden Teil des Roboters.

51:18.000 --> 51:22.340
Und hier ist es auch wieder so, wir wissen, insgesamt muss das

51:22.340 --> 51:26.780
Drehmoment 0 sein und dann können wir es einsetzen hier.

51:27.200 --> 51:31.880
Wir wissen, G ist jetzt für unseren Fall 0, beziehungsweise ist

51:31.880 --> 51:34.180
einfach orthogonal zu der Bewegung, die wir durchführen.

51:34.800 --> 51:37.320
Und dann bekommen wir hier eine Differenziergleichung für unser

51:37.320 --> 51:37.740
System.

51:39.220 --> 51:45.300
Was wir hier jetzt natürlich gemacht haben, ist, unsere Variable, die

51:45.300 --> 51:46.580
wir betrachten, zu ändern.

51:47.060 --> 51:51.740
Also hier sind wir im Gelenkwinkelraum,

51:55.780 --> 51:56.300
sage ich mal,

51:59.320 --> 52:03.800
und hier sind wir in der Geschwindigkeit von den Gelenken.

52:05.940 --> 52:09.960
Das heißt, wir haben einfach Theta Punkt, haben wir gesagt, ist Omega

52:09.960 --> 52:13.140
und Theta Punkt Punkt ist dann eben Omega Punkt.

52:15.440 --> 52:18.980
Weil die Variable, die uns ja interessiert, die wir regeln wollen, ist

52:18.980 --> 52:19.720
die Geschwindigkeit.

52:22.740 --> 52:26.060
Und dann haben wir eben die Gleichung, die das beschreibt.

52:26.980 --> 52:29.880
Ja, und dann ist es hier jetzt wieder fast das Gleiche.

52:32.620 --> 52:34.780
Das heißt, hier macht man wieder das Gleiche.

52:34.980 --> 52:37.080
Wir müssen das Ganze in Laplace transformieren.

52:38.920 --> 52:43.120
Und wenn wir es Laplace transformieren wollen, dann müssen wir uns

52:43.120 --> 52:45.520
wieder anschauen, was sind die einzelnen Komponenten.

52:47.140 --> 52:49.400
Und ich meine, wir haben die Gleichung halt so gewählt, dass sie

52:49.400 --> 52:51.360
relativ einfach sind.

52:51.480 --> 52:55.480
Deshalb sind sie hier von der gleichen Form, können wieder Linearität

52:55.480 --> 53:01.000
ausnutzen, um das Ganze zu vereinfachen.

53:03.120 --> 53:10.420
Und dann können wir wieder die Ableitungsregel verwenden, um eben

53:10.420 --> 53:18.540
unser d dt von Omega umzuformen nach S mal der Laplace

53:18.540 --> 53:19.200
transformierten.

53:20.280 --> 53:23.400
Und hier ist es auch nur das Omega.

53:24.000 --> 53:27.980
Und das heißt, hier haben wir dann eine von der Struktur her

53:27.980 --> 53:32.180
identische Form, weil eben auch die Differenzialgleichung von der

53:32.180 --> 53:33.300
Struktur identisch war.

53:33.940 --> 53:37.980
Nur jetzt hier für die entsprechenden Symbole von dem Roboterarm.

53:39.260 --> 53:42.580
Gut, also hier haben wir natürlich wieder die gleichen Regeln

53:42.580 --> 53:43.140
angewendet.

53:43.720 --> 53:47.640
Die Frage ist, warum haben wir das jetzt nochmal gemacht, die ganze

53:47.640 --> 53:48.680
Laplace Transformation?

53:49.440 --> 53:53.840
Die Idee ist eben, dass wir die Übertragungsfunktion aufstellen wollen

53:53.840 --> 53:57.860
für die einzelnen Teile, also für den Motor und den Roboterarm.

54:00.100 --> 54:04.720
Und die Übertragungsfunktion bezieht sich ja immer auf den Ausgang und

54:04.720 --> 54:11.070
den Eingang von einem Übertragungsglied.

54:13.130 --> 54:18.590
Und was wir eben suchen, ist eben dieses G von S im Frequenzbereich,

54:19.350 --> 54:25.290
das sich eben zusammensetzt aus Y von S durch U von S.

54:25.890 --> 54:30.690
Und das Y von S ist eben der Ausgang von diesem Übertragungsglied und

54:30.690 --> 54:31.970
das U von S der Eingang.

54:34.530 --> 54:36.710
Und diese Übertragungsfunktion wollen wir eben aufstellen.

54:39.210 --> 54:44.230
Das ist die Aufgabe danach.

54:45.190 --> 54:47.930
Und da haben wir jetzt ja schon die Laplace transformierten Funktionen

54:47.930 --> 54:50.930
aufgestellt, die wir jetzt nur noch umformen müssen.

54:52.670 --> 54:57.750
Und im Ganzen läuft es darauf hinaus, dass wir hier eben Ausgang durch

54:57.750 --> 55:01.170
Eingang teilen im Frequenzbereich und dann einfach einsetzen.

55:03.270 --> 55:15.470
Also unser Ia von S geteilt durch Ra mal Ia von S plus La mal S mal Ia

55:15.470 --> 55:16.010
von S.

55:18.890 --> 55:25.770
Und hier haben wir natürlich einen gemeinsamen Term, das Ia von S, das

55:25.770 --> 55:32.310
überall vorkommt, das können wir halt rauskürzen, indem wir den Bruch

55:32.310 --> 55:33.090
vereinfachen.

55:33.170 --> 55:39.830
Bleibt oben eins stehen und unter dem Bruch bleibt stehen das Ra und

55:39.830 --> 55:41.650
das S mal das La.

55:43.530 --> 55:47.950
Und das ist eine der typischen Formen für solche

55:47.950 --> 55:49.330
Übertragungsfunktionen.

55:49.570 --> 55:53.650
Sehen wir dann auch gleich, wenn wir das versuchen dann in Simulink zu

55:53.650 --> 55:58.070
benutzen, dass das sehr einfach dann einzugeben ist.

55:59.450 --> 56:03.210
Das heißt, damit ist die Übertragungsfunktion für den Motor

56:03.210 --> 56:10.290
aufgestellt und das Ganze müssen wir natürlich noch machen für den

56:10.290 --> 56:10.870
Roboterarm.

56:11.670 --> 56:13.370
Aber wie gesagt, hier ist es einfach das Gleiche.

56:14.090 --> 56:22.690
Also hier hat man wieder entsprechend die Omega-Teile, die sich dann

56:22.690 --> 56:23.410
rauskürzen.

56:26.510 --> 56:31.690
Und am Ende bleibt wieder so eine Funktion der Form übrig, 1 durch Js

56:31.690 --> 56:36.150
plus Kv, also ein Polynom mit S drin.

56:38.430 --> 56:48.410
Das ist der theoretische Teil und das wollen wir jetzt mal versuchen

56:48.410 --> 56:52.790
anzuwenden in einem tatsächlichen Regler.

56:53.010 --> 56:57.110
Aber vielleicht erst mal der theoretische Teil soweit klar zu den

56:57.110 --> 56:59.070
Reglern, Übertragungsfunktionen und so weiter.

57:02.920 --> 57:08.300
Dann versuchen wir das mal in Simulink.

57:09.220 --> 57:12.560
Also was wir jetzt gemacht haben, wenn wir so ein Robotergelenk regeln

57:12.560 --> 57:16.440
wollen, ist wir stellen Übertragungsfunktionen für die einzelnen

57:16.440 --> 57:18.040
Systeme auf, die dort vorkommen.

57:19.120 --> 57:24.860
Und mit den dann aufgestellten Übertragungsfunktionen können wir eine

57:24.860 --> 57:29.180
Simulation in Simulink aufbauen und dann können wir zum Beispiel für

57:29.180 --> 57:32.860
einen PED-Regler oder so verschiedene Parameter ausprobieren und

57:32.860 --> 57:34.360
schauen, wie verhält sich das Gelenk?

57:34.700 --> 57:37.180
Also was ist das Antwortverhalten auf bestimmte Eingaben?

57:38.200 --> 57:38.860
Schauen wir uns an.

57:39.260 --> 57:42.860
Und wir können auch so Autotune-Verfahren und so weiter benutzen.

57:44.080 --> 57:46.060
Aber das wollen wir mal ausprobieren.

57:48.120 --> 57:50.600
Die Frage ist, wie überführen wir das Ganze?

57:51.000 --> 57:54.940
Also wir haben jetzt unser Block-Diagramm hier, das haben wir ja

57:54.940 --> 57:56.860
selber gezeichnet.

57:57.500 --> 58:02.040
Im Grunde bauen wir das nach in Simulink und wir brauchen unsere

58:03.480 --> 58:08.480
Übertragungsfunktionen hier für den Motor und für die Mechanik, um

58:08.480 --> 58:10.860
eben die Parameter für die einzelnen Gelenke setzen zu können.

58:13.260 --> 58:17.680
Genau, also der rote Teil hier, für den ist wichtig, was wir für den

58:17.680 --> 58:20.640
Motor bestimmt haben und der blaue Teil, für den ist wichtig, was wir

58:20.640 --> 58:21.900
für die Mechanik bestimmt haben.

58:22.220 --> 58:26.460
Das ist nur das Bild, wie das dann gleich aussehen wird, also wie wir

58:26.460 --> 58:29.180
das nachgebaut haben in Simulink.

58:29.280 --> 58:31.820
Und man sieht, das sieht sehr ähnlich zu dem aus, wie wir auch Block

58:31.820 --> 58:32.780
-Diagramme zeichnen.

58:33.500 --> 58:37.240
Also wir haben hier unseren Motor, wir haben unseren Roboterarm, die

58:37.240 --> 58:41.740
haben wir modelliert als linear zeitinvariante Systeme.

58:43.400 --> 58:47.040
Wir haben hier jetzt für dieses Beispiel, haben wir einfach mal PI

58:47.040 --> 58:51.260
-Regler genommen, einen für die Stromregelung und einen für die

58:51.260 --> 58:56.660
Geschwindigkeitsregelung und wir können eben verschiedene

58:56.660 --> 59:02.460
Geschwindigkeiten vorgeben und dann schauen am Ende, wie verhält sich

59:02.460 --> 59:05.360
das System, so die Idee.

59:08.740 --> 59:15.280
Bevor wir das jetzt starten, haben wir hier die verschiedenen

59:15.280 --> 59:17.400
Parameter für unser System jetzt festgelegt.

59:18.080 --> 59:23.640
Also wir haben jetzt eben nur die Gleichung für den Elektromotor mit

59:23.640 --> 59:25.740
RA und LA festgelegt.

59:27.380 --> 59:30.300
Um ein konkretes System zu haben, müssen wir natürlich wissen, was

59:30.300 --> 59:32.680
sind die Widerstände und Induktivitäten hier drin.

59:33.240 --> 59:38.360
Wir haben jetzt hier einfach mal irgendwelche Werte genommen, brauchen

59:38.360 --> 59:49.220
entsprechend die Konstanten für unseren Motor, für unseren Roboterarm.

59:50.520 --> 59:57.600
Und hier über die TF-Funktion können wir eine Transformationsfunktion

59:57.600 --> 59:58.020
bestimmen.

59:59.300 --> 01:00:04.000
Und wir haben eben gesehen, unsere Transformationsfunktion war 1 durch

01:00:04.000 --> 01:00:13.860
LA mal S plus RA und die Transformationsfunktionen haben eben diese

01:00:13.860 --> 01:00:19.140
Form, dass wir eben den Nenner hier angeben können und der Nenner ist

01:00:19.140 --> 01:00:23.820
dann eben ein Teil, so ein Polynom von S, S², S³ und so weiter.

01:00:24.500 --> 01:00:27.920
Das heißt, hier geben wir an, dass das LM mal S multipliziert wird und

01:00:27.920 --> 01:00:33.360
das RM mal S³, wenn man so will, also einfach nur so da steht.

01:00:33.480 --> 01:00:37.440
Das sieht man vielleicht besser, wenn man es gleich hier zeigt, wenn

01:00:37.440 --> 01:00:38.700
wir die TF-Funktion anwenden.

01:00:39.180 --> 01:00:44.500
Dann sehen wir, aus diesem 1 und LM RM macht er dann hier das 1 durch

01:00:44.500 --> 01:00:47.480
0,88 mal S plus 0,238.

01:00:48.160 --> 01:00:51.040
Also das ist jetzt unsere konkrete Übertragungsfunktion für unseren

01:00:51.040 --> 01:00:54.660
Motor, die wir benutzen wollen.

01:00:55.080 --> 01:01:01.500
Für den Arm genauso, also hier müssen wir dann eben die Reibungs- und

01:01:01.500 --> 01:01:07.560
Inertia -Parameter festlegen, die jetzt hier auch Werte haben, die

01:01:07.560 --> 01:01:09.340
jetzt für diesen Fall eben Sinn machen.

01:01:09.920 --> 01:01:13.100
Und dann können wir wieder die TF-Funktion benutzen, um die

01:01:13.100 --> 01:01:14.740
Transformationsfunktion aufzustellen.

01:01:14.840 --> 01:01:18.960
Hier wieder Zähler und Nenner getrennt entsprechend und dann haben wir

01:01:18.960 --> 01:01:24.640
hier jetzt eben diese Funktion Faktor mal S plus anderen Faktor und

01:01:24.640 --> 01:01:27.280
dann haben wir jetzt hier eine Transformationsfunktion für den

01:01:27.280 --> 01:01:27.900
Roboterarm.

01:01:28.300 --> 01:01:31.000
Also das ist im Grunde nur das, was wir theoretisch ausgerechnet

01:01:31.000 --> 01:01:33.100
haben, eingegeben, jetzt für konkrete Werte.

01:01:33.960 --> 01:01:37.600
Genau und dann, das hier ist dann die Trajektorie, mit der wir dann

01:01:37.600 --> 01:01:38.160
testen wollen.

01:01:38.300 --> 01:01:42.420
Das hat jetzt nichts konkret mit der Regelung zu tun, sondern das ist

01:01:42.420 --> 01:01:45.540
einfach nur unser Testbeispiel der Trajektorie.

01:01:46.920 --> 01:01:48.520
Dann machen wir mal Simulink auf.

01:01:50.240 --> 01:01:53.000
Auf dem Laptop hier ist ein altes MATLAB, aber ich habe das auch

01:01:53.000 --> 01:01:54.920
getestet auf meinem Laptop.

01:01:55.060 --> 01:01:58.880
Es funktioniert auch immer noch mit der neuesten Version, mit der

01:01:58.880 --> 01:01:59.960
2019er Version.

01:02:01.960 --> 01:02:05.440
Also die Block-Diagramme aufbauen und so, das haben wir jetzt schon

01:02:05.440 --> 01:02:06.360
alles vorbereitet.

01:02:07.480 --> 01:02:11.520
In Simulink kann man sich aus verschiedenen Tool-Bibliotheken und so

01:02:11.520 --> 01:02:14.340
kann man sich die einzelnen Blöcke zusammenziehen für die Zeit

01:02:14.340 --> 01:02:18.380
-Invarianten -Glieder und so weiter und für die PID-Controller.

01:02:19.900 --> 01:02:21.180
Aber das ersparen wir uns mal.

01:02:22.920 --> 01:02:26.240
Also hier haben wir jetzt unser Gesamtsystem.

01:02:27.600 --> 01:02:37.880
Wir haben hier unseren Motor und das Simulink ist verbunden mit

01:02:37.880 --> 01:02:39.420
unserer aktuellen MATLAB-Session.

01:02:40.660 --> 01:02:48.320
Das heißt über diese Einstellung hier, dass das Segment hier Motor

01:02:48.320 --> 01:02:49.680
heißt bzw.

01:02:49.920 --> 01:02:53.300
sich auf die Motor-Variable bezieht, weiß er, wo er die

01:02:53.300 --> 01:02:55.820
Transferfunktion, die Übertragungsfunktion finden kann.

01:02:56.740 --> 01:03:00.780
Also muss dann eine Variable mit dem Namen Motor existieren und es

01:03:00.780 --> 01:03:04.000
muss eine Variable mit dem Namen Roboterarm existieren und das muss

01:03:04.000 --> 01:03:07.500
eben so eine Übertragungsfunktion sein, die wir gerade erstellt haben.

01:03:10.420 --> 01:03:13.800
Dann haben wir hier unseren eigentlichen Regler.

01:03:14.220 --> 01:03:17.360
Also dieser Regler ist jetzt einfach nur ein PI-Regler,

01:03:21.060 --> 01:03:27.100
bei dem wir eben da P und I einstellen können als Werte.

01:03:28.000 --> 01:03:32.720
Und dann haben wir hier einen PI-Regler für die äußere

01:03:32.720 --> 01:03:36.340
Geschwindigkeitsregelung, wo wir auch P und I einstellen können.

01:03:38.460 --> 01:03:39.500
Dann haben wir hier noch ein

01:03:42.760 --> 01:03:45.860
lineares Glied, das einfach nur multipliziert mit einem Faktor.

01:03:47.580 --> 01:03:49.200
Das ist eben der Faktor, der umrechnet.

01:03:49.880 --> 01:03:55.880
Aus unserem Motor kommt ja eine Ist-Stromstärke raus, aber die

01:03:55.880 --> 01:03:59.760
Stromstärke muss noch umgerechnet werden in einen Drehmoment.

01:04:00.940 --> 01:04:02.060
Das ist das, was hier passiert.

01:04:04.180 --> 01:04:09.060
Einfach mit einer Konstante, wo wir davon ausgehen, dass der Motor die

01:04:09.060 --> 01:04:11.300
Stromstärke linear mit dem Drehmoment zusammenhängt.

01:04:13.880 --> 01:04:15.900
Und dann haben wir hier unsere Eingabe.

01:04:16.340 --> 01:04:20.320
Das ist die QDV-Variable, die haben wir einfach gerade definiert als

01:04:20.320 --> 01:04:21.480
eine der drei Tore.

01:04:24.260 --> 01:04:30.460
Gut, das Ganze können wir uns auch anschauen.

01:04:34.870 --> 01:04:38.650
Wenn wir jetzt quasi einmal den Play-Button hier drücken, dann wird es

01:04:38.650 --> 01:04:41.950
für uns einmal durchsimuliert mit den aktuellen Einstellungen für

01:04:41.950 --> 01:04:43.710
unsere PI-Regler.

01:04:49.510 --> 01:04:54.330
Genau, das ist jetzt, kann man nicht so gut sehen, weil die Linien so

01:04:54.330 --> 01:05:01.310
dünn sind, aber das Gelbe hier ist die Soll-Vorgabe.

01:05:01.750 --> 01:05:04.830
Also wir haben jetzt so eine Geschwindigkeit vorgegeben, die halt erst

01:05:04.830 --> 01:05:07.330
so verläuft und dann wieder so verlaufen soll.

01:05:08.390 --> 01:05:13.190
Und das Blaue, was da so ein bisschen hergekrakelt ist, ist die

01:05:13.190 --> 01:05:17.410
tatsächliche Geschwindigkeit, die realisiert wurde von dem System.

01:05:18.490 --> 01:05:20.910
Es passt also schon relativ gut zusammen.

01:05:21.870 --> 01:05:25.150
Jetzt haben wir nur die Parameter, die jetzt eingestellt sind, P

01:05:25.150 --> 01:05:26.410
gleich 1 und I gleich 0.

01:05:27.530 --> 01:05:31.170
Also es passt irgendwie, aber wir wollen uns ja eigentlich auch ein

01:05:31.170 --> 01:05:33.250
paar andere Verhalten anschauen, wo das dann nicht so gut

01:05:33.250 --> 01:05:33.690
funktioniert.

01:05:36.190 --> 01:05:42.330
Also gehen wir mal hier rein und drücken den Tune-Button.

01:05:43.790 --> 01:05:49.150
Dann können wir so ein bisschen rumspielen mit den Verhalten von dem

01:05:49.150 --> 01:05:49.450
Regler.

01:05:51.390 --> 01:05:54.990
Dann können wir sehen, ob das System nachher zum Beispiel überschwingt

01:05:54.990 --> 01:05:57.610
oder so, wenn wir jetzt hier irgendwas verändern.

01:05:58.850 --> 01:06:00.090
Genau, also hier sehen wir das jetzt.

01:06:00.690 --> 01:06:04.810
Das ist der Teil von der Geschwindigkeitsregelung.

01:06:06.230 --> 01:06:10.730
Hier sehen wir in gestrichelt, hier so, wo es nach oben geht und dann

01:06:10.730 --> 01:06:13.670
so kurz rumspringt und das Ziel erreicht.

01:06:14.270 --> 01:06:17.070
Das ist die Antwort von unserem Block aktuell.

01:06:17.950 --> 01:06:21.910
Also wie schnell er im Grunde einen Wert einregelt.

01:06:23.310 --> 01:06:30.810
Und das Blaue hier ist eine Antwort, die jetzt uns das Simulink

01:06:30.810 --> 01:06:32.710
vorschlägt, zu tun.

01:06:33.810 --> 01:06:35.310
Wir können das einfach mal befolgen.

01:06:35.990 --> 01:06:39.550
Wir werden sehen, dass es für unser Beispiel nicht unbedingt ideal

01:06:39.550 --> 01:06:39.870
ist.

01:06:41.230 --> 01:06:48.250
Dann kann ich hier Update Block klicken und dann habe ich jetzt neue

01:06:48.250 --> 01:06:49.170
Parameter.

01:06:49.170 --> 01:06:55.290
Wenn ich das Ganze dann noch mal laufen lasse, dann bekomme ich hier

01:06:55.290 --> 01:06:56.730
so etwas.

01:06:57.970 --> 01:06:59.970
Das Verhalten hat sich jetzt ein bisschen geändert.

01:07:00.210 --> 01:07:03.550
Also wir sehen jetzt hier, die Soll-Vorgabe geht hier runter und die

01:07:03.550 --> 01:07:08.690
Ist -Vorgabe kommt nicht direkt hinterher, also folgt nicht, aber

01:07:08.690 --> 01:07:09.270
folgt schon.

01:07:09.910 --> 01:07:12.250
Und dann haben wir hier so ein nach unten hin, so ein leichtes

01:07:12.250 --> 01:07:12.930
Überschwingen.

01:07:13.230 --> 01:07:15.870
Dann haben wir unsere Soll-Vorgabe hier exakt erreicht.

01:07:16.690 --> 01:07:19.670
Und dann, wenn es wieder nach oben geht, dann sind wir immer so ein

01:07:19.670 --> 01:07:21.190
bisschen hinter der Soll-Vorgabe her.

01:07:22.990 --> 01:07:25.310
Weil es so klein ist, konnte man das eben nicht sehen.

01:07:25.450 --> 01:07:29.170
Dadurch, dass es eben so schnell gefolgt ist, war das ziemlich am

01:07:29.170 --> 01:07:29.570
Zittern.

01:07:31.150 --> 01:07:36.950
Okay, haben wir jetzt hier halt so ein bisschen weicheren Verlauf,

01:07:37.070 --> 01:07:42.250
sage ich mal, der dafür aber dem Ziel, wenn es sich schnell bewegt,

01:07:42.310 --> 01:07:45.010
immer ein bisschen hinterher hinkt.

01:07:46.690 --> 01:07:51.430
Gut, wir können das Gleiche nochmal für den anderen PI-Regler machen.

01:07:53.950 --> 01:07:59.270
Und dann können wir gleich auch mal Werte einstellen, die dann nicht

01:07:59.270 --> 01:08:00.470
so gutes Verhalten zeigen.

01:08:01.930 --> 01:08:05.670
Der zweite Regler, der steckt natürlich schon hinter dem ersten.

01:08:06.090 --> 01:08:10.430
Deshalb haben wir jetzt hier auch so interessante Kurvenverläufe, die

01:08:10.430 --> 01:08:10.970
wir hier sehen.

01:08:12.370 --> 01:08:16.370
Aber wir können hier auch mal die Default-Werte für den zweiten Regler

01:08:16.370 --> 01:08:16.850
übernehmen.

01:08:18.030 --> 01:08:19.170
Schauen, was dann passiert.

01:08:19.910 --> 01:08:21.210
Und wir das durch simulieren.

01:08:22.170 --> 01:08:23.610
Genau, dann ändert sich nicht so viel.

01:08:25.170 --> 01:08:30.870
Aber was wir hier machen können, sind solche, hier gibt es solche

01:08:30.870 --> 01:08:34.330
Einstellungen, wie das Verhalten sein soll.

01:08:34.850 --> 01:08:37.590
Also soll es sich schnell verhalten oder soll es sich langsam

01:08:37.590 --> 01:08:38.110
verhalten?

01:08:38.570 --> 01:08:42.070
Soll es aggressiv sein oder soll es robust sein?

01:08:43.650 --> 01:08:47.350
Wir können zum Beispiel, wenn wir hier sagen, es soll aggressiver

01:08:47.350 --> 01:08:52.770
sein, dann erzeugt es eher stärkeres Überspringen, als wenn wir sagen,

01:08:53.010 --> 01:08:54.350
dass es robust sein soll.

01:08:55.450 --> 01:09:00.150
Also robust ist im Grunde sehr wenig Überspringen und wir können

01:09:00.150 --> 01:09:03.850
sagen, wir wollen aber lieber aggressiv, also lieber schnell da sein.

01:09:04.150 --> 01:09:07.030
Und hier ist im Grunde schnell und langsam, also wie schnell soll das

01:09:07.030 --> 01:09:07.970
System reagieren?

01:09:08.690 --> 01:09:12.230
Da kann ich dann jetzt eben verschieben und wenn ich sage, das System

01:09:12.230 --> 01:09:19.670
soll sehr schnell reagieren, dann erzeuge ich eben stärkeres

01:09:21.130 --> 01:09:23.390
Überspringen, indem ich sage, es soll schnell reagieren.

01:09:25.850 --> 01:09:32.410
Wenn wir die Parameter dann einfach mal anwenden auf unser System, ich

01:09:32.410 --> 01:09:35.270
vermute, dann sieht man es, sieht man immer noch nicht.

01:09:36.910 --> 01:09:40.830
Hier an dem Ganzen ist immer so ein bisschen, weil wir zwei Regler

01:09:40.830 --> 01:09:46.410
haben, schafft es meistens der Zweite, das Verhalten vom Ersten wieder

01:09:46.410 --> 01:09:47.190
auszugleichen.

01:09:48.190 --> 01:09:55.630
Deshalb lassen wir den hier auch mal schnell Dinge tun.

01:09:57.670 --> 01:10:01.610
Und schauen mal, ob das Auswirkungen auf unser Verhalten hat.

01:10:02.650 --> 01:10:08.010
Jetzt haben wir noch mal, zumindest für unsere Zwecke, jetzt

01:10:08.010 --> 01:10:10.710
irgendwie, jetzt versucht er besonders schnell, das Ziel einzuhalten.

01:10:10.870 --> 01:10:13.970
Also wir haben jetzt nicht mehr das Hinterherhecheln, was wir eben

01:10:13.970 --> 01:10:20.190
hatten und haben jetzt hier ein anderes Regelverhalten erzeugt.

01:10:21.790 --> 01:10:24.710
Also da kann man halt mit rumspielen und sich dann aussuchen, was

01:10:24.710 --> 01:10:28.430
möchte ich jetzt für meinen konkreten Anwendungsfall eigentlich haben.

01:10:28.770 --> 01:10:32.830
Also wie viel Überspringen, wie viel Verzögerung kann ich mir erlauben

01:10:32.830 --> 01:10:37.810
und dann eben die Regelparameter in Simulationen erstmal ausprobieren

01:10:37.810 --> 01:10:41.370
und dann eben auf dem richtigen Roboter testen.

01:10:43.430 --> 01:10:48.690
Genau, ja, das ist eigentlich alles für die Übung heute.

01:10:49.890 --> 01:10:52.370
Dann könnt ihr mal schauen, ob ihr das ausprobieren wollt.

01:10:53.490 --> 01:10:54.770
Ja, danke.

