Inhaltsverzeichnis - Institut für Robotik und Prozessinformatik

1
Inhaltsverzeichnis
1
EINLEITUNG........................................................................................................5
1.1 Motivation der Arbeit................................................................................................5
1.2 Ziel der Arbeit............................................................................................................6
1.3 Inhalt der folgenden Kapitel.....................................................................................6
2
BESCHREIBUNG VON GELENKEN MIT MEHREREN FREIHEITSGRADEN ...7
2.1 Denavit-Hartenberg-Parameter ...............................................................................7
2.2 Erweiterung der DH-Parameter ..............................................................................8
2.2.1 Kugelgelenke ...................................................................................................8
2.2.2 Kardangelenke .................................................................................................9
2.2.3 Eindeutige Festlegung der Parameter ............................................................10
2.3 Beispiele für die Verwendung der erweiterten DH-Parameter ...........................11
2.3.1 Beispiel 1: Rotatorisches Gelenk, Sphärisches Gelenk, Sphärisches Gelenk 11
2.3.2 Beispiel 2: Sphärisches Gelenk, Prismatisches Gelenk, Sphärisches Gelenk12
2.3.3 Beispiel 3: Kardangelenk, Prismatisches Gelenk, Sphärisches Gelenk.........13
2.4 Alternative Beschreibungen von Gelenken mehrerer Freiheitsgrade ................15
2.4.1 RPY Transformationen ..................................................................................15
2.4.2 Merlets Beschreibung ....................................................................................15
3
EINE EINHEITLICHE NOTATION FÜR UNIVERSELLE ROBOTER ................16
3.1 Elemente der Datenstruktur...................................................................................16
3.1.1 Knoten des Graphen.......................................................................................17
3.1.2 Kanten des Graphen .......................................................................................17
3.1.3 Die 3 Transformationen .................................................................................17
3.2 Algorithmus für die Knotenindizierung ................................................................18
3.3 Beispiele für die Knotenindizierung.......................................................................19
3.3.1 SCARA Roboter (serielle Roboterstruktur)...................................................19
3.3.2 Hexa Parallelroboter ......................................................................................20
3.3.3 Delta Parallelroboter ......................................................................................21
4
DIE APPLIKATION ............................................................................................22
4.1 Strukturübersicht über die Applikation................................................................22
4.2 Anwenderoberfläche................................................................................................23
4.3 Das Kinematikmodul...............................................................................................26
4.4 Lösung der Inversen Kinematik am Beispiel des Hexa Parallelroboters ...........27
2
4.4.1 Lösungsverfahren...........................................................................................27
4.4.2 Gleichungsprototyp........................................................................................29
5
ZUSAMMENFASSUNG UND AUSBLICK .........................................................31
5.1 Evaluierung mit anderen kinematischen Strukturen...........................................31
5.2 Einbinden der Vorwärtskinematik für Hexa und Delta ......................................31
5.3 Berechnung des Parameters α ................................................................................31
5.4 Integration eines Bahnplanungsverfahrens ..........................................................31
5.5 Verfahren zur universellen Lösung von IKP und DKP .......................................31
5.6 Interaktives Definieren von kinematischen Strukturen.......................................32
A
IMPLEMENTIERUNG ........................................................................................33
A.1 Modulabhängigkeit..................................................................................................33
A.2 Funktionsheader ......................................................................................................34
A.2.1 Modul „parGui“ .............................................................................................34
A.2.2 Modul „parDisplay“.......................................................................................38
A.2.3 Modul „parMotion“ .......................................................................................38
A.2.4 Modul „parKinematics“ .................................................................................39
A.2.5 Modul „parMath“...........................................................................................40
A.2.6 Modul „parGraph“ .........................................................................................41
A.2.7 Modul „parRead“ ...........................................................................................43
A.2.8 Modul „parEdge“ ...........................................................................................43
A.2.9 Modul „parNode“...........................................................................................45
A.2.10 Modul „parIndexList“....................................................................................47
A.2.11 Modul „parTool“............................................................................................48
B
WEITERE KINEMATIKEN UND DEREN KNOTENINDIZIERUNG....................51
B.1 Werkzeugmaschine Eclipse.....................................................................................51
B.2 Porty (unsymmetrische Parallelstruktur) .............................................................51
C
BEISPIELE VON SCHNITTSTELLENDATEIEN ...............................................52
C.1 Schnittstellendatei des Hexa Parallelroboters.......................................................52
C.2 Schnittstellendatei des Delta Parallelroboters ......................................................53
LITERATURVERZEICHNIS .....................................................................................55
3
Abbildungsverzeichnis
1.1
2.1
2.2
2.3
2.4
2.5
2.6
2.7
3.1
3.2
3.3
3.4
3.5
4.1
4.2
4.3
4.4
4.5
4.6
A.1
B.1
B.2
Parallelkinematiken aus RobcadTM ..................................................................................... 6
DH-Parameter für rotatorische Gelenke ............................................................................. 8
Lage des Koordinatensystems bei einem Kugelgelenk ...................................................... 9
Lage der Koordinatensysteme bei aufeinanderfolgenden Kardangelenken ..................... 10
RSS-Kette ......................................................................................................................... 12
SPS-Kette.......................................................................................................................... 13
KPS-Kette ......................................................................................................................... 14
Kugelgelenk aus [Merl00] ................................................................................................ 15
Hexa Graph und Elemente der Datenstruktur................................................................... 16
Transformationen für eine Kante...................................................................................... 18
SCARA Roboter und korrespondierender Graph ............................................................. 20
Hexa Parallelroboter und korrespondierender Graph ....................................................... 20
Delta Parallelroboter und korrespondierender Graph....................................................... 21
Struktur der Applikation ................................................................................................... 22
Anwenderoberfläche in ROBCADTM integriert ............................................................... 23
Anwenderoberfläche......................................................................................................... 24
Komponenten des Kinematikmoduls................................................................................ 27
Lösungsverfahren für die Inverse Kinematik am Beispiel einer kinematischen Kette..... 28
Kinematische Kette des Hexa ........................................................................................... 29
Modulabhängigkeiten der Applikation ............................................................................. 33
Kinematische Struktur der Eclipse und zugehöriger Graph ............................................. 51
Porty Parallelroboter und zugehöriger Graph................................................................... 51
4
Tabellenverzeichnis
2.1 Erweiterte Parameter für die RSS-Kette........................................................................... 12
2.2 Erweiterte Parameter für die SPS-Kette ........................................................................... 13
2.3 Erweiterte Parameter für die KPS-Kette........................................................................... 14
5
1 Einleitung
Größer werdende Absatzmärkte und damit steigende Verkaufsraten industrieller Produkte
erfordern schnellere Taktraten bei der Fertigung. Herkömmliche, serielle Roboterstrukturen
können den daraus folgenden Ansprüchen hinsichtlich Geschwindigkeit und Beschleunigung
nicht gerecht werden. Parallele und hybride Roboterstrukturen erzielen durch eine geringere
Eigenmasse höhere Geschwindigkeiten und Beschleunigungen bei zunehmender Genauigkeit.
Sie sind also in der Lage, den steigenden Anforderungen in der Fertigungstechnik gerecht zu
werden. An der Technischen Universität Braunschweig wurde der Sonderforschungsbereich
SFB 562 „Robotersysteme für Handhabung und Montage“ [HeSchWa99] eingerichtet, in
dem neue Roboterstrukturen für die industrielle Fertigung untersucht und geschaffen werden
sollen. Hierfür sind u. a. sowohl eine Steuerung, eine Regelung als auch eine graphische Simulation für parallele und hybride Roboterstrukturen zu erstellen. Die Implementierung der
graphischen Simulation hat innerhalb des industriellen Robotersimulationssystems RobcadTM
zu erfolgen. Dabei soll eine universelle Schnittstelle zum Austausch der kinematischen Daten
zwischen Teilprojekten des Sonderforschungsbereichs geschaffen werden. Diese soll so verwendet werden, daß ein Auswechseln der Roboterstruktur leicht möglich wird und die graphische Simulation durch das Austauschen der entsprechenden Kinematikmodule für verschiedene Strukturen ohne große Änderungen durchgeführt werden kann.
1.1
Motivation der Arbeit
Bei seriellen Robotern haben sich als Notation die Denavit-Hartenberg-Parameter [DeHa55]
durchgesetzt. Sie werden sowohl in der Forschung als auch in der Industrie eingesetzt und
erleichtern den Austausch kinematischer Daten. Für Parallelroboter ist bisher keine einheitliche Notation vorhanden. In verschiedenen Arbeiten auf dem Gebiet der Parallelrobotik werden sehr spezielle Notationen verwendet, die jeweils an die behandelte Struktur bzw. an das
entsprechende Problem angepaßt sind. Außerdem werden Gelenke mit mehreren Freiheitsgraden, wie sie oft bei Parallelrobotern vorkommen, unterschiedlich beschrieben. Dies macht
den Austausch der kinematischen Daten zwischen verschiedenen, an der Entwicklung von
Software für universelle Roboter beteiligten Teilprojekten äußerst schwierig.
Kommerzielle Robotersimulationssysteme wie RobcadTM oder IGRIPTM sind bisher nicht in
der Lage parallele kinematische Strukturen zu simulieren. In der Version 3.7.1 von RobcadTM
und dem Advanced Modeling Paket lassen sich maximal Parallelkinematiken, wie sie Abbildung 1.1 zu entnehmen sind, modellieren [Rose2000]. Diese bestehen allesamt aus einzelnen
rotatorischen Gelenken bzw. aus rotatorischen Gelenken und einem prismatischen Gelenk.
Hierbei gibt es immer ein festes Roboterglied (fixed link) und ein aktives Gelenk, dessen
nachfolgendes Glied als input_link bezeichnet wird. Die sich bewegenden Glieder sind mit
coup link bzw. output link bezeichnet, wobei sich nach letzteren weitere Gelenke und Glieder
definieren lassen.
Diese 3 Möglichkeiten reichen jedoch für eine Simulation und somit für den Sonderforschungsbereich nicht aus, da die Möglichkeit zur Verwendung von häufig bei Parallelrobotern vorhandenen Gelenken, wie z.B. Kugel- und Kardangelenken, in geschlossenen kinematischen Ketten nicht möglich ist. Des weiteren ist es nicht möglich mehrere geschlossene kinematische Ketten wieder zusammenzuführen, z.B. an der Arbeitsplattform eines Parallelroboters.
6
Abbildung 1.1: Parallelkinematiken aus RobcadTM
1.2
Ziel der Arbeit
Das Ziel dieser Arbeit ist es eine einheitliche Repräsentation universeller Roboter zu finden.
Dabei müssen durch diese Repräsentation auch serielle Roboter beschrieben werden können.
Zu diesem Zweck ist es nötig zunächst für Gelenke mit mehreren Freiheitsgraden eine einheitliche Darstellung zu finden. Dabei ist es wünschenswert, wenn sich diese Darstellung an
bereits bekannten und bewährten Repräsentationen für Gelenke mit nur einem Freiheitsgrad,
nämlich den Denavit-Hartenberg-Parametern, orientiert.
Die kinematischen Daten für Parallelroboter sollen in der gefundenen Notation in einer Datei
abgespeichert werden können und über diese mit anderen Teilprojekten ausgetauscht werden.
Eine Simulation für die, in der Datei stehenden Struktur soll in dem Robotersimulationssystem RobcadTM implementiert werden, wobei auf eine universelle Lösung, bei der nur die
Schnittstellendatei und ein Kinematikmodul ausgetauscht werden sollen, zu achten ist. Eine
Anwenderoberfläche mit deren Hilfe der Roboter auf intuitiv zu bedienende Art und Weise
bewegt werden kann, ist in das Simulationssystem RobcadTM zu integrieren.
1.3
Inhalt der folgenden Kapitel
Das zweite Kapitel beschäftigt sich mit der Beschreibung von Gelenken mit mehreren Freiheitsgraden.
Das dritte Kapitel stellt dann eine einheitliche Notation für universelle Roboter inkl. einer
Datenstruktur vor.
Im vierten Kapitel wird die Implementierung einer graphischen Simulation für universelle
Roboter vorgestellt, in der die gefundene Notation angewendet wird.
Das letzte Kapitel bietet einen Ausblick auf die Zukunft des Projektes, wobei es auch die
Grenzen der Simulation aufzeigt.
7
2 Beschreibung von Gelenken mit mehreren Freiheitsgraden
Für Gelenke mit einem Freiheitsgrad hat sich in der Vergangenheit eine Beschreibung mit
Hilfe der DH-Parameter bewährt. Sowohl bei parallelen als auch bei hybriden Roboterstrukturen findet man jedoch sehr oft Gelenke mit mehreren Freiheitsgraden vor, z.B. Kugelgelenke oder Kardangelenke. Diese lassen sich auch mit den bekannten DH-Parametern beschreiben. Allerdings sind dazu mehrere Koordinatensystemübergänge notwendig. Um dies zu
vermeiden wird im folgenden Kapitel eine Erweiterung der DH-Parameter für Gelenke mit
mehreren Freiheitsgraden vorgestellt und mit Alternativen verglichen. Den Abschluß des
Kapitels bilden einige Beispiele zur Verwendung der erweiterten DH-Parameter.
2.1
Denavit-Hartenberg-Parameter
Die DH-Notation ist eine Möglichkeit zur Beschreibung von Gelenken mit einem Freiheitsgrad und hat sich bestens für die Beschreibung rotatorischer und prismatischer Gelenke bewährt. Ein DH-Koordinatensystemübergang wird durch die folgende Transformationsgleichung dargestellt:
Ti = Rot ( zi −1 ,θ i )Trans( zi −1 ,d i )Trans( xi ,ai ) Rot ( xi ,α i )
i −1
Die einzelnen Parameter sind dabei folgendermaßen definiert:
•
•
•
•
θi bezeichnet den Winkel von der Achse xi-1 zur Achse xi, gedreht um die Achse zi-1.
Handelt es sich um ein rotatorisches Gelenk, so ist dieser Parameter variabel.
di bezeichnet den Abstand vom Ursprung des Koordinatensystems i-1 zum Schnittpunkt
der Achsen zi-1 und xi, gemessen entlang der Achse zi-1. Handelt es sich um ein prismatisches Gelenk, so ist dieser Parameter variabel.
ai bezeichnet den kürzesten Abstand zwischen den Achsen zi-1 und zi.
αi bezeichnet den Winkel von der Achse zi-1 zur Achse zi, gedreht um die Achse xi.
Um Eindeutigkeit zu gewährleisten, gibt es außerdem die nachfolgenden Regeln für die Lage
der Koordinatensysteme:
1. Die Achse zi-1 ist die Bewegungsachse des i-ten Gelenks.
2. Die Achse xi liegt entlang der Gelenknormalen und zeigt in Richtung des höher indizierten Gelenks.
3. Die Achse yi wird durch das Rechtshandkoordinatensystem eindeutig festgelegt.
Abbildung 2.1 zeigt die Verwendung der DH-Parameter anhand eines Beispiels mit 2 rotatorischen Gelenken.
8
Abbildung 2.1: DH-Parameter für rotatorische Gelenke
2.2
Erweiterung der DH-Parameter
Um Gelenke mit mehreren Freiheitsgraden beschreiben zu können, könnte man mehrere DHKoordinatensystemübergänge verwenden. Kugelgelenke ließen sich so z.B. mit Hilfe von
drei DH-Parameterübergängen ausdrücken. Das hätte zur Folge, daß man insgesamt 12 Parameter zur Beschreibung eines einzelnen Kugelgelenks benötigen würde. Auf weitere Alternativen und die einzelnen Vor- und Nachteile bei der Beschreibung von Gelenken mehrerer
Freiheitsgrade wird in Abschnitt 2.4 eingegangen.
Oben genanntes Problem läßt sich lösen, indem man eine weitere Rotation um die y-Achse
hinzufügt und so insgesamt nur fünf Parameter zur Beschreibung benötigt [ThoWa01]. Die
zusätzliche Rotation erfolgt um die bereits um zi-1 gedrehte y-Achse. Die Transformationsgleichung ergibt sich dann wie folgt:
Ti = Rot ( zi−1 ,θ i )Trans( zi−1 ,d i ) Rot ( y 'i −1,β i )Trans( xi ,ai ) Rot ( xi ,α i )
i −1
2.2.1
Kugelgelenke
Will man mit Hilfe dieser Parameter Kugelgelenke beschreiben, so muß man die Lage der
Koordinatensysteme eindeutig festlegen. Da es nicht nur eine Bewegungsachse bei Kugelgelenken gibt, kann man nicht mehr die Festlegung treffen, daß die z-Achse entlang der Bewegungsachse liegt.
Wenn man eine Kette von aufeinanderfolgenden Kugelgelenken betrachtet, dann sind diese
durch Punkte im Raum festgelegt. Verbindet man diese Punkte mittels Geraden, so erhält
man die Lage der Gelenknormalen. Wie bei den herkömmlichen DH-Parametern legt man
nun die x-Achse entlang dieser Geraden. Zur Festlegung der z-Achse legt man zwei Ebenen
9
so durch das Gelenk, daß die Normalen der Ebenen mit den vorherigen bzw. nachfolgenden
Gelenknormalen übereinstimmen. Nun bringt man diese beiden Ebenen zum Schnitt und erhält als z-Achse den Richtungsvektor der Schnittgerade der beiden Ebenen. Die y-Achse wird
dadurch eindeutig festgelegt, daß es sich um ein Rechtshandkoordinatensystem handelt.
Abbildung 2.2 zeigt die Lage des Koordinatensystems im Kugelgelenk, in einer kinematischen Kette, die aus einem rotarischen Gelenk, einem Kugelgelenk und noch einem rotatorischen Gelenk besteht. Dabei entsprechen die erweiterten DH-Parameter für das rotatorische
Gelenk den DH-Parametern, mit der Ausnahme, daß der zusätzliche Parameter β = 0° existiert.
Abbildung 2.2: Lage des Koordinatensystems bei einem Kugelgelenk
2.2.2
Kardangelenke
Auch Kardangelenke können mit der erweiterten DH-Notation beschrieben werden. In diesem Fall sind die variablen Parameter θ und β. Durch die Festlegung der Lage der x-Achse
entlang der Gelenknormalen in Richtung höherer Gelenkindizes, ist dann auch eindeutig die
Zuordnung der z- und y-Achse zu den beiden Gelenkachsen bestimmt. Abbildung 2.3 zeigt
dies für zwei aufeinanderfolgende Kardangelenke.
10
Abbildung 2.3: Lage der Koordinatensysteme bei aufeinanderfolgenden Kardangelenken
2.2.3
Eindeutige Festlegung der Parameter
Zusammenfassend sind hier noch einmal die notwendigen Vereinbarungen für eine eindeutige Festlegung der erweiterten DH-Parameter und der Koordinatensysteme aufgelistet:
•
Der Ursprung des Koordinatensystems des i-ten Robotergliedes liegt im i+1-ten Gelenk.
•
Die z-Achse des Koordinatensystems des i-ten Robotergliedes ist bei nachfolgenden rotatorischen und prismatischen Gelenken die Bewegungsachse des i+1-ten Gelenks. Ist das
nachfolgende Gelenk ein Kugelgelenk so verläuft die z-Achse des Koordinatensystems
des i-ten Gliedes entlang der Schnittgerade zweier Ebenen die jeweils die Gelenknormalen des i-ten und i+1-ten Gelenkes als Normalen haben. Handelt es sich um ein Kardangelenk, so verläuft die z-Achse entlang der 1. Bewegungsachse des Kardangelenks.
•
Die x-Achse des i-ten Koordinatensystems verläuft entlang der Gelenknormalen und zeigt
in Richtung nachfolgender Gelenke. Der Parameter ai gibt dabei den Abstand der beiden
Koordinatensysteme an.
•
Liegt ein Kugelgelenk vor, so sind die Parameter θi, βi und αi variabel. Bei einem Kardangelenk sind dies θi und βi. Bei rotatorischen und prismatischen Gelenken ist dies wie
zuvor θi bzw. di. In jedem Fall gilt aber: 0° ≤ βi ≤ 180°
11
2.3
Beispiele für die Verwendung der erweiterten DH-Parameter
Es folgen einige Beispiele von kinematischen Ketten und den zugehörigen Tabellen für die
erweiterten DH-Parameter und eine Beschreibung wie die jeweiligen Parameter zustande
kommen. Im folgenden sind die Bezeichnungen der kinematischen Ketten abgekürzt. Dabei
steht R für ein rotatorisches Gelenk, P für ein prismatisches Gelenk, S für ein sphärisches
Gelenk (Kugelgelenk) und K für ein Kardangelenk. Eine kinematische Kette aus rotatorischem, prismatischen und Kugelgelenk wäre demnach eine RPK-Kette.
2.3.1
Beispiel 1: Rotatorisches Gelenk, Sphärisches Gelenk, Sphärisches
Gelenk
Wie der Abbildung 2.4 zu entnehmen ist, handelt es sich bei dem ersten Gelenk dieser Kette
um ein rotatorisches Gelenk. Da dies ein Gelenk mit nur einem Freiheitsgrad ist, erfolgt die
Beschreibung analog zu den bekannten DH-Parametern. Interessant ist die Lage des i-1-ten
Koordinatensystems. Da es sich bei dem i-ten Gelenk um ein Kugelgelenk handelt, läßt sich
die Lage der Achse zi-1 durch die Schnittgerade von den zwei Ebenen bestimmen, die als
Normale die Gelenknormale von Gelenk i-1 bzw. i haben. Die x-Achse des i-1-ten Koordinatensystems liegt entlang der Gelenknormalen von Glied i-1 und die y-Achse wird so gewählt,
daß das Rechtshandsystem komplett wird.
Bei dem Gelenk i-1 handelt es sich um ein rotatorisches Gelenk handelt, daher ist θi-1 variabel. Der Abstand entlang der z-Achse vom Koordinatensystem i-2 zum Koordinatensystem i1 ist durch di-1 angegeben. Der Abstand der entlang der Gelenknormalen durch ai-1. Um die zAchsen zur Deckung zu bringen ist außerdem eine Drehung um die Achse xi-1 mit αi-1 = 90°
erforderlich. Man kann sehen, daß die erweiterten DH-Parameter den DH-Parametern bis auf
den zusätzlichen Parameter βi-1 = 0° entsprechen.
Das zweite Gelenk ist ein Kugelgelenk, daher sind θi, βi und αi variabel. Der Parameter ai
gibt den Abstand der Koordinatensysteme i-1 und i entlang der Gelenknormalen zu Gelenk i
an. Der Abstand entlang der Achse zi-1 wird durch di ausgedrückt und ist bei Kugelgelenken
immer Null.
Analog zum Gelenk i läßt sich auch das nachfolgende 2. Kugelgelenk in der Kette beschreiben.
12
Abbildung 2.4: RSS-Kette
Gelenk
i-1
i
i+1
θ
var
var
var
d
β
a
d i-1
0
0
0
var
var
a i-1
ai
a i+1
α
90°
var
var
Tabelle 2.1: Erweiterte Parameter für die RSS-Kette
2.3.2
Beispiel 2: Sphärisches Gelenk, Prismatisches Gelenk, Sphärisches
Gelenk
Abbildung 2.5 ist eine graphische Darstellung der SPS-Kette.
Das erste Gelenk in der Kette ist ein Kugelgelenk. Demnach sind die drei Parameter θi-1, βi-1
und αi-1 variabel. Das nachfolgende Gelenk ist ein prismatisches Gelenk, was zur Folge hat,
daß die Ursprünge der Koordinatensysteme i-2 und i-1 deckungsgleich sind, also sowohl di-1
und ai-1 gleich Null sein müssen.
Die Parameter für das prismatische Gelenk sehen folgendermaßen aus: di ist variabel und ai
gleich 0. Für die übrigen Parameter betrachtet man die Lage der Koordinatensysteme i-1 und
i. Die z-Achse des Koordinatensystems i liegt entlang der Schnittgerade der Ebenen die als
Normalen die Gelenknormalen von Gelenk i und Gelenk i+1 haben. Die Achse xi liegt entlang der Schubachse, also der Gelenknormalen von Gelenk i. Daraus ergibt sich dann die
Lage der Achse yi. Gemäß dieser Lage ist eine Drehung um zi-1 mit θi = -90° und eine Drehung um die eben gedrehte Achse y´i-1 mit βi = 90° erforderlich.
Die Parameter θi+1, βi+1 und αi+1 sind variabel, weil das 3. Gelenk wieder ein Kugelgelenk ist.
Der Parameter di+1 ist gleich Null und ai+1 gibt den Abstand entlang der Gelenknormalen zum
13
nachfolgenden Gelenk an. Für den Fall, daß es sich um ein prismatisches Gelenk handelt, ist
dieser Parameter wieder gleich Null, da dann die Ursprünge der Koordinatensysteme i und
i+1 deckungsgleich wären.
Abbildung 2.5: SPS-Kette
Gelenk
i-1
i
i+1
θ
var
-90
var
d
β
a
0
var
0
var
90°
var
0
0
a i+1
α
var
0°
var
Tabelle 2.2: Erweiterte Parameter für die SPS-Kette
2.3.3
Beispiel 3: Kardangelenk, Prismatisches Gelenk, Sphärisches Gelenk
Das erste Gelenk, dieser Kette ist ein Kardangelenk (siehe Abbildung 2.6). Da die Rotationen
von Links zu besetzen sind, müssen die Parameter θi-1 und βi-1 variabel sein. Aus dem gleichen Grund sind die Achsen zi-2 und yi-2 die Bewegungsachsen des Gelenks. Da das nachfolgende Gelenk ein prismatisches Gelenk ist, sind die Ursprünge der Koordinatensysteme i-2
und i-1 deckungsgleich und die Achse zi-1 verläuft entlang der Gelenknormalen von Gelenk i.
Sieht man sich die Abbildung an, erkennt man, daß zunächst eine Drehung um die Achse zi-2
im Winkel von 90° erforderlich wäre. Dies wird aber schon durch die Angabe „θi-1 ist variabel“ ausgedrückt. Abschließend ist noch eine Rotation um die x-Achse mit αi-1 = 90° erforderlich.
Das zweite Gelenk bildet ein prismatisches Gelenk. Der variable Parameter ist hier di. Das
Koordinatensystem i läßt sich wie folgt bestimmen: Das nachfolgende Gelenk ist ein Kugelgelenk, also liegt die Achse zi entlang der Schnittgerade der Ebenen die die Gelenknormalen
14
des i-ten Gelenks bzw. des i+1 Gelenks als Normalen haben. Die Achse xi zeigt in Richtung
der Gelenknormalen des i-ten Gelenks und die Achse yi wird so gelegt, daß ein Rechtshandsystem entsteht. Die Lage dieses Koordinatensystems, macht zunächst eine Rotation um zi-1
mit θi = -90° erforderlich. Anschließend erfolgt eine Rotation um die bereits gedrehte Achse
y´i-1 mit βi = 90°. Da sich dann das Koordinatensystem in der gewünschten Lage befindet ist
keine weitere Rotation um die x-Achse erforderlich und somit αi = 0°. Ebenso ist ai gleich
Null.
Das letzte Gelenk ist ein Kugelgelenk. Die Parameter für die Rotationen sind alle variabel.
Der Parameter di+1 wird auf Null gesetzt, weil kein Versatz in Richtung der z-Achse vorhanden ist. Schließlich gibt ai+1 den Abstand zum Gelenk i+2 entlang der Gelenknormalen an.
Wäre dieses Gelenk ein prismatisches Gelenk, so wäre ai+1 = 0.
Abbildung 2.6: KPS-Kette
Gelenk
i-1
I
i+1
θ
var
-90°
var
d
β
a
0
var
0
var
90°
var
0
0
a i+1
α
90°
0°
var
Tabelle 2.3: Erweiterte Parameter für die KPS-Kette
15
2.4
Alternative Beschreibungen von Gelenken mehrerer Freiheitsgrade
Dieser Abschnitt stellt alternative Möglichkeiten zur Beschreibung von Gelenken mit mehreren Freiheitsgraden vor und welche Vor- bzw. Nachteile sie gegenüber den erweiterten DHParametern haben.
2.4.1
RPY Transformationen
Anstelle der erweiterten DH-Parameter könnte man Gelenke mit mehreren Freiheitsgraden
auch mit Hilfe von RPY Transformationen beschreiben. Dies würde allerdings nur etwas an
der Art der Transformationen ändern, aber keinen Vorteil bringen. Ein Nachteil dabei ist, daß
die Art der Beschreibung nicht mehr mit den bereits vorhandenen DH-Parametern für Gelenke mit einem Freiheitsgrad konsistent wäre.
2.4.2
Merlets Beschreibung
Merlet [Merl00] gibt eine Möglichkeit für die Beschreibung der 2d-Orientierung eines Vektors im Raum an, die er wie folgt festlegt:
cosµi cosθ i sinα i +sinµi cosα i
wi = sinµi cosθ i sinα i −cosµi cosα i
sinθ i sinα i
Der Vektor w für ein Kugelgelenk, daß durch 3 rotatorische Gelenke dargestellt wird, ist in
Abbildung 2.7 zu sehen. Dabei schneiden sich die 3 Bewegungsachsen der rotatorischen Gelenke in einem Punkt und liegen in einer Ebene. Diese Notation hat den Nachteil, daß sich die
Orientierung eines Vektors im 3D-Raum zwar festlegen läßt, jedoch nicht die Orientierung
um diesen Vektor. Dies würde zu Inkonsistenzen führen, falls sich in einer kinematischen
Kette z.B. sowohl Kugelgelenke als auch prismatische Gelenke befinden, da keine eindeutige
Beschreibung vorläge.
Abbildung 2.7: Kugelgelenk aus [Merl00]
16
3 Eine einheitliche Notation für universelle Roboter
Wenn man die verschiedenen Arbeiten auf dem Gebiet der Parallelrobotik betrachtet, so findet man unterschiedliche Beschreibungsformen für verschiedene kinematische Strukturen.
Jeder Autor hat eine individuelle Systematik, zugeschnitten auf das Problem, mit dem er sich
gerade beschäftigt. Man möchte jedoch eine einheitliche Beschreibungsform universeller
Roboter finden. Mit Hilfe der erweiterten DH-Parameter wurde die Voraussetzung dazu geschaffen. Was außerdem benötigt wird, ist eine abstrakte Repräsentation der kinematischen
Struktur universeller Manipulatoren, so daß man eine geeignete Datenstruktur finden und
somit die Struktur des Roboters eindeutig abspeichern kann.
Die hier gefundene Lösung basiert auf einem gerichteten Graph, einem Ansatz von Belifiore
und Benedetto [BeBe00]. In diesem Kapitel werden die einzelnen Elemente der Graphstruktur näher erläutert. Anschließend folgt ein Algorithmus für die Knotenindizierung im Graphen, um eine eindeutige Vergabe der Knotennummern zu gewährleisten. Schließlich endet
das Kapitel mit einem Beispiel einer Schnittstellendatei, die mit Hilfe der Applikation, die in
Kapitel 4 beschrieben wird, eingelesen werden kann. Sie stellt die Beschreibung eines universellen Roboters dar, wie sie vom Anwender vorgenommen werden muß.
3.1
Elemente der Datenstruktur
Die Datenstruktur ist ein gerichteter Graph, wobei die Knoten die Roboterglieder repräsentieren und die Kanten die Gelenke des Roboters. Zur Übersicht ist der Graph für den Hexa Parallelroboter, die einzelnen Elemente und deren Inhalt in Abbildung 3.1 dargestellt.
Abbildung 3.1: Hexa Graph und Elemente der Datenstruktur
17
3.1.1
Knoten des Graphen
Die Knoten des Graphen repräsentieren die Glieder des Roboters. Für die Simulation bedeutet dies, daß sie Daten über die CAD-Entitäten enthalten. Im einzelnen sind dies:
•
Die Art der CAD-Entität. Hierbei kann es sich um ein einfaches Glied (S-Link), ein verzweigtes Glied (M-Link) oder eine Plattform (Base, Tool) handeln.
•
Der Name der CAD-Entität. Hierbei handelt es sich um den Namen eines Verzeichnisses
in dem die Geometriedaten der entsprechenden CAD-Entität gespeichert sind.
•
Die absolute Position der CAD-Entität in Weltkoordinaten.
3.1.2
Kanten des Graphen
Die Kanten des Graphen repräsentieren die Gelenke des Roboters. Sie enthalten unter anderem die erweiterten DH-Parameter. Im einzelnen sind folgende Daten in den Kanten gespeichert:
•
Der Nachfolgende Knoten. Da es sich um einen gerichteten Graphen handelt, muß der
Nachfolger gespeichert sein.
•
3 Transformationen, die die relative Lage der Gelenke zueinander beschreiben. Diese
Transformationen werden in Abschnitt 3.1.3 beschrieben.
•
Der Gelenktyp. Hier wird festgelegt, ob es sich z.B. um ein rotatorisches, prismatisches,
Kardan- oder Kugelgelenk handelt.
•
Die Stellbereiche des Gelenks. Hier können Einschränkungen für den Bewegungsspielraum des Gelenks vorgegeben werden.
•
Die Art des Gelenks. Hier steht, ob es sich um ein aktives oder passives Gelenk handelt.
3.1.3
Die 3 Transformationen
In den Kanten sind 3 Transformationen gespeichert, die die Lage der Koordinatensysteme in
den Gelenken zueinander beschreiben. Im folgenden sind die 3 Transformationen aufgelistet
und erklärt:
Tfix, 1 : Dies ist eine feste Transformation. Sie wird benötigt, um vom Basisframe zum jeweils ersten Gelenk einer kinematischen Kette zu gelangen, da dies unter Umständen
nicht alleine durch die erweiterten DH-Parameter erreicht werden kann. Diese
Transformation enthält 6 Variablen (x, y, z, ϕx, ϕy, ϕz) für alle 6 Freiheitsgrade.
18
Tparams : Diese Transformation enthält die erweiterten DH-Parameter θ, d, β, a, α. Die Gelenkvariablen werden während der Laufzeit vom Programm modifiziert.
Tfix, 2 : Dies ist eine feste Transformation. Sie wird benötigt, um vom jeweils letzten Gelenk
einer kinematischen Kette zum Toolframe zu gelangen, da auch dies nicht in jedem
Fall durch die erweiterten DH-Parameter erreicht werden kann. Diese Transformation enthält ebenfalls 6 Variablen (x, y, z, ϕx, ϕy, ϕz) für alle 6 Freiheitsgrade.
Die Gesamttransformationen ergibt sich für einen Übergang von Roboterglied i-1 zu Glied i
aus der Verknüpfung der 3 Transformationen nach folgender Formel:
i-1
Ti= Tfix, 1 Tparams Tfix, 2
In jedem Fall ist die Transformation Tparams gesetzt, denn sie beschreibt die Lage der Gelenke
zueinander. Sind Tfix, 1 bzw. Tfix, 2 nicht gesetzt, so bestehen Tfix, 1 und Tfix, 2 aus Einheitsmatrizen.
Abbildung 3.2 verdeutlicht diesen Zusammenhang noch einmal.
Abbildung 3.2: Transformationen für eine Kante
3.2
Algorithmus für die Knotenindizierung
Da eine einheitliche Repräsentation der Roboterstrukturen erreicht werden soll, muß auch die
Indizierung der Knoten im Graphen für gleiche Strukturen dieselbe sein. Zu diesem Zweck
wird in diesem Abschnitt ein Algorithmus zur Knotenindizierung vorgestellt.
19
Bei der Knotenindizierung wird wie folgt vorgegangen:
1. Markieren aller Knoten im Graphen als noch nicht besucht und setzen des Indexes
auf 1.
2. Beginnen mit dem Knoten an dem sich der Basisframe befindet.
3. Den Index an den aktuellen Knoten vergeben.
4. Eine Liste der Nachfolgenden Knoten erstellen, diese nach der Reihenfolge ihres kürzesten geometrischen Abstandes sortieren und mit dem 1. Knoten in der Liste fortfahren. Der Abstand zwischen 2 benachbarten Knoten ξ und η ist folgendermaßen definiert:
( xξ − xη , yξ − yη , zξ − zη ) T
oder
falls
das
Ergebnis
Null
ist:
(ϕ xξ − ϕ xη ,ϕ yξ − ϕ yη ,ϕ zξ − ϕ zη ) ξ und η repräsentieren dabei die Transformationen
Tfix, 1⋅TParams⋅Tfix, 2.
5. Indexzähler um 1 erhöhen.
6. Mit 3. fortfahren bis der Toolframe erreicht ist, dann mit dem jeweils nachfolgenden
Knoten in der Liste weitermachen. Solange mit 3. fortfahren, bis alle Knoten besucht
sind.
7. Ende.
3.3
Beispiele für die Knotenindizierung
Der folgende Abschnitt beinhaltet einige kinematische Strukturen und ihre dazu gehörenden
Repräsentationen als Graph. Insbesondere wird die Indizierung der einzelnen Knoten dargestellt. Auf der linken Seite ist immer eine Abbildung der kinematischen Struktur zu sehen,
gefolgt von einer schematischen Darstellung dieser Struktur in der Mitte, in der bereits den
einzelnen Gliedern Knotennummern zugeordnet sind. Rechts sieht man dann letztendlich den
korrespondierenden Graph zu der Roboterstruktur mit den entsprechenden Knoten und Kanten. Zwei weitere Strukturen und deren Knotenindizierung finden sich in Anhang B.
3.3.1
SCARA Roboter (serielle Roboterstruktur)
Bei seriellen Roboterstrukturen liegt ein Spezialfall eines Graphen vor, eine einfache Liste.
Die Indizierung der Knoten ist dementsprechend sehr einfach: Beginnend am Basisframe
werden die Roboterglieder sequentiell durchnumeriert, bis der Toolframe erreicht ist. Abbildung 3.3 stellt dies dar.
20
Abbildung 3.3: SCARA Roboter und korrespondierender Graph
3.3.2
Hexa Parallelroboter
Der Hexa Parallelroboter besteht aus sechs, an der Basisplattform angehefteten und symmetrisch angeordneten, kinematischen Ketten, welche sich aus 3 Gelenken, die 2 Glieder verbinden zusammensetzen. Die Indizierung der Knoten beginnt wieder am Basisframe, der den
Index 1 bekommt. Danach wird das erste Glied der geometrisch nächsten Kette indiziert. Den
Index 3 bekommt das 2. Glied in dieser Kette. Die Arbeitsplattform mit dem Toolframe bekommt 4 als Index zugewiesen. Jetzt behandelt man, die vom Basisframe ausgehende zweitnächste kinematische Kette und numeriert sie mit 5 und 6. Danach nimmt man wieder vom
Basisframe aus gesehen die nächste noch nicht indizierte Kette. Das führt man so lange durch
bis alle Knoten indiziert sind. Abbildung 3.4 zeigt die Knotenindizierung für den Hexa Parallelroboter.
Abbildung 3.4: Hexa Parallelroboter und korrespondierender Graph
21
3.3.3
Delta Parallelroboter
Der Delta Roboter ähnelt von seiner kinematischen Struktur her dem Hexa Parallelroboter.
Anstelle von 6 aktiven rotatorischen Gelenken, die an der Arbeitsplattform angeheftet sind,
hat er jedoch nur 3 aktive Gelenke. Die ersten Glieder einer jeweiligen Kette verzweigen sich
dann nochmal, so daß auch hier 6 Kugelgelenke folgen (siehe Abbildung 3.5). Der Rest der
Struktur entspricht der des Hexa. Der Delta Parallelroboter besitzt aufgrund dieser Struktur
nur 3 Freiheitsgrade, was sich leicht mit Hilfe von Grüblers erweiterter Theorie [Cros64] überprüfen läßt.
Für vollparallele Strukturen lautet der Ansatz:
m = 6(l − n − 1) +
n
k =1
dk
Dabei entspricht m der Anzahl der Freiheitsgrade. Der Anzahl der Verbindungen zwischen
den Gelenken entspricht der Parameter l. Im Fall des Delta sind es 10, denn er hat 3 Hebel +
6 Schubstangen + die Basis, die immer mitgerechnet wird. Die Gesamtzahl der Gelenke n
beträgt 15, da 3 rotatorische Gelenke und 12 Kugelgelenke vorhanden sind. Die Berechnung
von dk ergibt sich aus den jeweiligen Freiheitsgraden des betrachteten Gelenks. Damit erhält
man:
m = 6(10 −15−1) + 3⋅1+12⋅3
m = 6⋅( −6) + 39
m =3
Ähnlich wie beim Hexa verläuft auch die Knotenindizierung. Begonnen wird mit dem Basisframe. Den Index 2 erhält die von hier aus nächste Verzweigung. Je nachdem wie das Koordinatensystem in dieser Verzweigung liegt, wird der Index 3 jetzt an eine der beiden folgenden Schubstangen vergeben. Den Index 4 erhält der Toolframe. Index 5 bekommt die andere
Schubstange in dieser Kette. Jetzt wird gemäß dem Abstand die zweite zu indizierende Kette
ausgewählt. Die Verzweigung und die beiden Schubstangen bekommen die Indizes 6-8. Das
gleiche Verfahren wird dann auf die letzte Kette angewendet. Jetzt sind alle Knoten indiziert.
Abbildung 3.5 zeigt die Indizierung für den Delta.
Abbildung 3.5: Delta Parallelroboter und korrespondierender Graph
22
4 Die Applikation
In den vorangehenden Kapiteln wurde eine einheitliche Repräsentation universeller Roboter
und deren Gelenke beschrieben. Jetzt wird eine Applikation zur Simulation universeller Roboter vorgestellt, die diese Notation verwendet. Zuerst folgt eine Übersicht über die Struktur
der Applikation. In den darauffolgenden Abschnitten werden die einzelnen Komponenten
dieser Applikation näher erläutert.
4.1
Strukturübersicht über die Applikation
Abbildung 4.1 zeigt eine schematische Darstellung der einzelnen Module der Applikation
und wie sie mit ihrer Umgebung interagieren.
Modul mit Inverser und Vorwärtskinematik
Kinematikmodul berechnet die neuen Parameter
und stellt sie der Datenstruktur zur Verfügung
Applikation zur
Simulation universeller Roboter
Datenstruktur
Anwenderoberfläche
Schnittstellendatei
mit Definition der
Kinematischen
Struktur
Applikation liest Kennt die NaDatei in die Da- men der CAD
tenstruktur ein Komponenten
Greift auf Robcadfunktionen zur Berechnung
und graphischen Darstellung zu
Robcad
TM
Bibliothek mit
CAD Komponenten
z.B. mit Robcad modelliert
Abbildung 4.1: Struktur der Applikation
Den Kern der Applikation bildet das Hauptprogramm mit seiner Datenstruktur und seiner
Anwenderoberfläche. Dieser Teil des Programms bleibt in jedem Fall gleich, auch wenn sich
die zu simulierende kinematische Struktur ändert. Was der Anwender austauschen muß, falls
er einen neuen Roboter simulieren möchte, ist rot eingefärbt. Wenn es sich um eine andere
kinematische Struktur handelt, müssen natürlich die CAD-Komponenten ausgetauscht werden und gegebenenfalls neu modelliert werden. Dies kann mit RobcadTM geschehen oder mit
einem anderen CAD-System, dessen Daten RobcadTM in der Lage ist einzulesen. Die neuen
Namen der Komponenten müssen außerdem in die neue Schnittstellendatei eingetragen werden. Die Schnittstellendatei muß komplett neu geschrieben werden, da sich die Lage der Gelenke und Roboterglieder zueinander von Struktur zu Struktur unterscheidet. Da die allgemeine Inverse- und Vorwärtskinematik für Parallelroboter zum gegenwärtigen Zeitpunkt
noch nicht gelöst ist, muß außerdem auch das Kinematikmodul für jeden Roboter individuell
angepaßt werden.
23
In den folgenden Abschnitten werden Anwenderoberfläche und Kinematikmodul genauer
erläutert. Auf die Datenstruktur mit der Schnittstellendatei wurde bereits in Kapitel 3 näher
eingegangen.
4.2
Anwenderoberfläche
Abbildung 4.2 zeigt die Oberfläche mit dessen Hilfe der Anwender den Roboter bewegen
kann, wie sie in das Simulationssystem RobcadTM integriert ist. Die eigentliche Oberfläche
befindet sich auf der rechten Seite des Bildes. Im großen Fenster, welches die CAD-Welt
darstellt, ist ein modellierter Hexa-Parallelroboter zu sehen. Die restlichen Bedienelemente
entstammen dem RobcadTM-Simulationssystem. Abbildung 4.3 zeigt die Anwenderoberfläche
der Applikation noch einmal vergrößert.
HexaParallelroboter
RobcadBedienelemente
Abbildung 4.2: Anwenderoberfläche in RobcadTM integriert
Anwenderoberfläche
24
Schnittstellendatei einlesen
Teach-Panel
Position anfahren
Kollisionsüberwachung
Zustandsanzeigen
Abbildung 4.3: Anwenderoberfläche
Die Anwenderoberfläche wurde mit Hilfe von ROBUilTM, einer in RobcadTM integrierten und
auf Tcl/Tk basierenden Programmierschnittstelle zum Entwurf graphischer Oberflächen, erstellt. Diese Schnittstelle ermöglicht die einfache Realisation von Buttons und Menus, sowie
Anzeigeelementen. Möchte man Funktionen realisieren, so werden von der ROBUilTMOberfläche aus einzelne Callback-Funktionen aufgerufen, die sich dann in Form von CFunktionen realisieren lassen [Tec99].
Das Layout der Anwenderoberfläche ist dicht an das RobcadTM-eigene Layout zur Bewegung
serieller kinematischer Strukturen angelehnt, um eine einfache Bedienung ohne umlernen zu
gewährleisten. Die Funktionen die mit Hilfe der Anwenderoberfläche der Simulation ausgelöst werden können, lassen sich in 5 Teile aufgliedern, die jeweils Bedienelementen oder
Gruppen von Bedienelementen entsprechen und werden im folgenden beschrieben:
1. Schnittstellendatei einlesen:
•
Wird der Button „Load kin. Info“ betätigt, so öffnet sich ein Dialogfenster, das die
Eingabe eines Dateinamens für eine Schnittstellendatei zuläßt. Existiert die Datei, so
wird diese auf Fehler überprüft. Wenn sie fehlerfrei ist, wird anschließend die Datei
25
eingelesen und die entsprechende Datenstruktur im Speicher abgelegt. Außerdem
werden die einzelnen CAD-Komponenten geladen und angezeigt.
2. Teach-Panel:
Hier sind eine Reihe von Buttons angebracht, die in etwa einem Teach-Panel eines realen
Roboters entsprechen. Außerdem gibt es noch 2 Anzeigen. Im einzelnen haben diese Elemente folgende Funktionen:
•
„Reset“ ermöglicht es, den zu simulierenden Roboter in seine Homeposition zu befördern. Dies kann besonders dann nützlich sein, wenn es schwierig ist aus einer festgefahren Situation, z.B. durch Kollision wieder herauszufinden.
•
„Mmove“ ermöglicht die Bewegung des Roboters mit der Maus. Wenn dieser Button
aktiviert ist, kann man mit der rechten Maustaste den Roboter in die positive Richtung
entlang der gewählten Achse im gewählten Koordinatensystem bewegen und mit der
linken Maustaste in die entgegengesetzte Richtung. Sollte keine Achse oder kein Koordinatensystem gewählt sein, so gibt die Applikation die Fehlermeldung „No Axis
selected“ bzw. „No Frame selected“ aus. Während dieser Button aktiviert ist, läßt sich
der Blickwinkel im CAD-Fenster nicht ändern.
•
„Mview“ ermöglicht es nach gewähltem „Mmove“ wieder den Blickwinkel des CADFensters zu ändern.
•
Die Buttons „x“, „y“, „z“, „rx“, „ry“ und „rz“ sind dazu da eine Bewegungsachse auszuwählen, entlang welcher sich der Roboter bewegen soll. „x“, „y“ und „z“ bezeichnen dabei translatorische Bewegungen, während „rx“, „ry“ und „rz“ Drehungen um
die jeweiligen Achsen bewirken. Die eigentliche Bewegung des Roboters erfolgt,
dann entweder durch die beiden Pfeile am unteren Rand des Teach-Panels, oder durch
die Maus mit Hilfe von „Mmove“.
•
„World“, „Tcpf“ und „Other“ lassen den Anwender das Koordinatensystem auswählen in dem sich das Toolsystem des Roboters bewegen soll. „World“ bezeichnet dabei
das Weltkoordinatensystem, „Tcpf“ läßt den Roboter sich bezüglich seines eigenen
Toolframesystems bewegen, während man mit „Other“ ein beliebiges selbst erzeugtes
Koordinatensystem wählen kann.
•
Mit „Step Size“ kann man die Schrittgröße ändern, mit der sich der Roboter bewegen
soll. Dabei lassen sich im nach der Betätigung öffnenden Fenster getrennt die Schrittgröße für translatorische Bewegungen, sowie die Schrittgröße für Rotationen festlegen. Nach Bestätigung der Eingabe werden diese Werte in den beiden Anzeigefenstern direkt unter dem Button angezeigt.
•
Die beiden Pfeile bewirken eine Bewegung des Roboters. Der Pfeil nach links ermöglicht es den Roboter entlang der gewählten Bewegungsachse im gewählten Koordinatensystem in negativer Richtung zu bewegen. Der rechte Pfeil bewegt den Roboter
entlang der gewählten Achse in positiver Richtung. Sollte keine Achse oder kein Koordinatensystem gewählt sein, so gibt die Applikation die Fehlermeldung „No Axis
selected“ bzw. „No Frame selected“ aus.
26
3. Position anfahren:
•
Nach Betätigung des Buttons „Move absolute“ öffnet sich ein Fenster in das 6 Werte
für die Lage und Orientierung des Toolframes eingegeben werden können. Anschließend bewegt sich der Roboter zu dieser in Weltkoordinaten anzugebenden Stelle, sofern dies möglich ist.
4. Kollisionsüberwachung:
•
In diesem Bereich befindet sich eine Schaltfläche mit der die Kollisionsüberwachung
an- und ausgeschaltet werden kann. Des weiteren ist hier eine Anzeige, die Auskunft
darüber gibt, ob die Kollisionsüberwachung aktiviert ist oder nicht. Die Möglichkeit
zur Deaktivierung der Kollisionsüberwachung existiert vor allem aus Gründen der
Performance. Bei eingeschalteter Kollisionsüberwachung bewegt sich der Roboter
deutlich langsamer als ohne. Würde man die RobcadTM-eigenen Funktionen durch eigene austauschen ließe sich evtl. eine schnellere Möglichkeit zur Kollisionsüberprüfung realisieren.
5. Zustandsanzeigen:
Im unteren Bereich der Anwenderoberfläche befinden sich außerdem noch einige Zustandsanzeigen, die im folgenden beschrieben werden:
4.3
•
Die Anzeige „Sel. movement“ gibt Auskunft über die derzeitig gewählte Bewegungsrichtung. „x“, „y“ und „z“ bedeuten dabei Translationen entlang der jeweiligen Achse,
während „rx“, „ry“ und „rz“ für die entsprechenden Rotationen stehen. Die Bezeichnungen für den Zustand sind dabei identisch mit den Bezeichnungen auf den Buttons
für die Wahl der Bewegungsrichtung im Teach-Panel. Eine Bewegung kann sowohl
positiv entlang der gewählten Achse als auch negativ erfolgen.
•
„Selected frame“ zeigt das gegenwärtig gewählt Koordinatensystem in dem sich der
Roboter bewegen soll. Mögliche Werte hierfür sind „World“ für das Weltkoordinatensystem, „Tcpf“ für das Toolkoordinatensystem oder jede andere Bezeichnung für
ein beliebiges Koordinatensystem, welches mit „Other“ im Teach-Panel ausgewählt
werden kann.
•
„Position“ beinhaltet 6 Anzeigeelemente für Lage und Orientierung des Toolframes
des Roboters. Diese Koordinaten sind immer relativ zum Ursprung des Weltkoordinatensystems.
Das Kinematikmodul
Das Kinematikmodul stellt verschiedene Funktionen zur Bewegung des Roboters zur Verfügung. Da derzeit noch keine allgemeine Lösung für die Inverse und Vorwärtskinematik bei
Parallelrobotern existiert, müssen diese Funktionen für jede Roboterstruktur individuell angepaßt bzw. komplett neu geschrieben werden. Das Kinematikmodul besteht im wesentlichen
aus den in der Abbildung 4.4 dargestellten Komponenten. Die einzelnen Funktionsheader
befinden sich im Anhang.
27
Eingabe
Funktion
Ausgabe
Neue Position des
Toolframes
Inverse Kinematik
Matrizen mit neuen Parametern der aktiven
und passiven Gelenke
Matrix mit neuer Stellung der aktiven Gelenke
Vorwärtskinematik
Neue Position des
Toolframes
Überprüfen des Arbeitsraums
Position des Toolframes
Position nicht erreichbar
True, falls Position nicht
erreichbar, sonst false
Überschreitung der
Stellbereiche
True bei Bereichsüberschreitung eines Gelenks,
sonst false
Kollision
True falls es zu einer
Kollision gekommen ist,
sonst false
Abbildung 4.4: Komponenten des Kinematikmoduls
4.4
Lösung der Inversen Kinematik am Beispiel des Hexa Parallelroboters
Um zu zeigen, daß die Applikation auch funktioniert, d.h. eine Schnittstellendatei eingelesen
werden und ein Roboter bewegt werden kann, wurde die Inverse Kinematik am Beispiel des
Hexa Parallelroboters gelöst. In den folgenden 2 Abschnitten wird zunächst ein Verfahren zur
Lösung der Inversen Kinematik für den Hexa Parallelroboter vorgestellt und anschließend die
Herleitung eines benötigten Gleichungsprototyps in Anlehnung an [Ries92] gezeigt.
4.4.1
Lösungsverfahren
Eine Möglichkeit zur Bestimmung der Position der Gelenke besteht darin, sich die neue Sollposition des Toolframes anzusehen und für jede kinematische Kette die Position des letzten
Gelenks zu berechnen, welche relativ zum Toolframe immer konstant bleibt, da das Gelenk
an der Arbeitsplattform befestigt ist. Um dieses Gelenk läßt sich jetzt eine Kugel mit dem
Radius des Abstandes der beiden Kugelgelenke einer Kette, also der Länge des Robotergliedes zwischen den beiden Kugelgelenken, legen, so daß sich das mittlere Gelenk theoretisch
auf einer dieser Kugeloberfläche bewegen könnte.
28
Außerdem kann man einen Kreis um das aktive Gelenk einer Kette legen. Dieser Kreis hat
genau den Radius des Robotergliedes, daß sich zwischen dem aktivem Gelenk und dem ersten passiven Kugelgelenk befindet. Das mittlere Gelenk könnte sich theoretisch auf dieser
Kreisbahn bewegen.
Bringt man den Kreis und die Kugel zum Schnitt [Bron91] so ergeben sich entweder 2
Schnittpunkte, falls zwei mögliche Lösungen für die Position des mittleren Gelenks existieren, 1 Schnittpunkt, falls sich der Roboter am Rande des Arbeitsbereichs befindet oder gar
kein Schnittpunkt für den Fall, daß der Roboter aufgrund seiner kinematischen Struktur die
entsprechende Position nicht erreichen kann. Im Falle von zwei möglichen Schnittpunkten
wählt die Applikation den, der sich näher an der vorherigen Position des mittleren Gelenks
befindet.
Dieses Verfahren wird in Abbildung 4.5 noch einmal graphisch dargestellt.
Was man nun kennt, ist die Position des letzten Gelenks, aber nicht die Orientierung dessen
Koordinatensystems. Dies wird mittels einer Gleichung berechnet, die im nachfolgenden Abschnitt hergeleitet wird.
Rotatorisches
Gelenk (aktiv)
Erstes
Kugelgelenk
(passiv)
Möglicher
Schnittpunkt
zwischen Kreis
und Kugel
Möglicher
Schnittpunkt
zwischen
Kreis und
Kugel
Kreis um
aktives, rotatorisches
Gelenk
Letztes Kugelgelenk
Kugel um
letztes Kugelgelenk in
der Kette
Abbildung 4.5: Lösungsverfahren für die Inverse Kinematik am Beispiel einer kinematischen
Kette
29
4.4.2
Gleichungsprototyp
Für die Simulation ist es wichtig, daß auch die Orientierung der Koordinatensysteme der aktiven und passiven Roboterglieder berechnet werden kann, um diese entsprechend bewegen
zu können. Wie man die Positionen der einzelnen Gelenke herausbekommt wurde bereits in
Abschnitt 4.4.1 erläutert. Auf dieser Basis kann man die Orientierung der Koordinatensysteme berechnen. Dabei sei bereits vorweg angemerkt, daß es das Kinematikmodul für den Hexa
Parallelroboter, das hier vorgestellt wird, noch nicht ermöglicht den Winkel α, also die Drehung der Schubstange um die x-Achse zu berechnen.
Zur Bestimmung der Orientierung der Schubstange kann man die Winkel θ und β berechnen.
p =( p x , p y , p z )T
Abbildung 4.6: kinematische Kette des Hexa
Abbildung 4.6 zeigt eine schematische Darstellung einer kinematischen Kette des Hexa
Parallelroboters, bestehend aus dem aktiven rotatorischen Gelenk und den zwei darauf
folgenden passiven Kugelgelenken. Da die Positionen der Gelenke bekannt sind, läßt sich
durch deren Subtraktion leicht der Vektor p berechnen. Außerdem ist noch die Gleichung für
die Transformationen zwischen den Gelenken bekannt (siehe Kapitel 2):
Ai = Rot ( zi −1 ,θ i )Trans( zi −1 ,d i ) Rot ( y 'i −1 ,β i )Trans( xi ,ai ) Rot ( xi ,α )
Den Positionsanteil aus der resultierenden Matrix kann man jetzt gleich dem Vektor p setzen, so daß man folgende drei Gleichungen erhält:
p x = cos(θ )⋅cos( β )⋅a
p y = sin(θ )⋅cos( β )⋅a
p z = −sin( β )⋅a + d
Dabei erkennt man, daß der Parameter α nicht enthalten ist und somit die Rotation um die xAchse als Freiheitsgrad erhalten bleibt. Faßt man zur Übersicht die Konstanten zu neuen
Konstanten zusammen, ergeben sich die Gleichungen:
(1) A= cos(θ )⋅cos( β )
py
px
d − pz
(2) B = sin(θ )⋅cos( β ) mit A= , B = , C =
a
a
a
(3) C =sin( β )
30
Die folgenden Schritte führen auf zwei Lösungen für β. Durch Quadrieren der Gleichungen
(1) und (2) und anschließendes Addieren erhält man zunächst die Gleichung:
cos 2 (θ )⋅cos 2 ( β ) + sin 2 (θ )⋅cos 2 ( β ) = A2 + B 2
cos 2 ( β )⋅(sin 2 (θ ) + cos 2 (θ )) = A2 + B 2
⇔
cos( β ) = ± A2 + B 2
⇔
Zusammen mit Gleichung 3 folgt:
β1, 2 = a tan2(C ,± A2 + B 2 )
bzw. nach ersetzten der Konstanten A, B und C:
β1, 2 = a tan2(
p
d − pz
p
,± ( x ) 2 + ( y ) 2 )
a
a
a
Die beiden Lösungen für β werden verglichen mit dem Wert, den der Winkel in der vorherigen Position des Roboters hatte. Die Lösung, die näher am alten Wert für den Winkel liegt,
wird für die weitere Berechnung übernommen. Liegt eine Lösung für β nicht zwischen 0°
und 180° wird sie gleich verworfen.
cos(θ ) =
sin(θ ) =
px
cos( β )⋅a
py
cos( β )⋅a
aus Gleichung
(1)
aus Gleichung
(2)
Da β jetzt bekannt ist, kann man, um θ zu berechnen, die Gleichungen (1) und (2) nach
cos(θ) bzw. sin(θ) auflösen, so daß sich ergibt:
Man erhält für θ:
θ =atan2(
py
px
)
cos( β )⋅a cos( β )⋅a
,
Für den Fall, daß β=90° sein sollte befindet sich der Roboter in einer singulären Stellung.
Damit sind die Variablen θi und βi des ersten passiven Gelenks einer kinematischen Kette
bestimmt. Das Verfahren muß auf jede kinematische Kette angewendet werden, damit man
die Lösung der inversen Kinematik für den Hexa Parallelroboter erhält.
31
5 Zusammenfassung und Ausblick
Im Rahmen dieser Studienarbeit wurde eine graphische Simulation für universelle Roboter
entwickelt. Mit einer Möglichkeit zur einheitlichen Repräsentation von Gelenken mehrerer
Freiheitsgrade und der universellen Notation für serielle, parallele und hybride Roboterstrukturen wurde die Voraussetzung geschaffen, Daten über kinematische Strukturen leicht auszutauschen [ThoWa01]. Dies ermöglichte die Entwicklung einer Schnittstelle für die graphische
Simulation, so daß die Applikation durch einfachen Austausch der Schnittstellendatei und des
Kinematikmoduls an neue Strukturen angepaßt werden kann.
In den folgenden Abschnitten wird auf mögliche Erweiterungen der Applikation eingegangen
und auf bekannte noch nicht gelöste Probleme hingewiesen.
5.1
Evaluierung mit anderen kinematischen Strukturen
Erstes Objekt zur Simulation während der Entwicklungsphase der Applikation war der Hexa
Parallelroboter. Diesen kann man bereits in der graphischen Simulation sehen. Mittlerweile
kann auch der Delta Parallelroboter mit Austausch des Kinematikmoduls und der Schnittstellendatei simuliert werden. Um die Robustheit der gefundenen Notation und der Datenstruktur
zu bestätigen, wird die Applikation mit weiteren kinematischen Strukturen getestet werden.
5.2
Einbinden der Vorwärtskinematik für Hexa und Delta
Bisher ist nur die Inverse Kinematik für die Parallelroboter Hexa und Delta implementiert.
Die für die Simulation weniger interessante und schwieriger zu lösende Vorwärtskinematik
muß noch eingebaut werden.
5.3
Berechnung des Parameters α
Wie bereits in Kapitel 4 erwähnt, ist derzeit das Problem der Orientierung der Schubstange
um die Gelenknormale noch nicht gelöst, was bedeutet, daß der Roboter bei eingeschalteter
Kollisionsüberwachung bestimmte Positionen nicht anfahren kann, obwohl er es theoretisch
könnte, wenn die Schubstange um die x-Achse rotieren könnte.
5.4
Integration eines Bahnplanungsverfahrens
Ein Bahnplanungsverfahren ist zu integrieren. Damit läßt sich das automatische Anfahren
bestimmter Positionen graphisch simulieren. Dabei ist darauf zu achten, daß der gefundene
Weg kollisionsfrei bleibt.
5.5
Verfahren zur universellen Lösung von IKP und DKP
Sobald es gelungen ist, ein Verfahren zum Generieren von universellen Lösungen für Inverse- und Vorwärtskinematik zu finden, sollte dies in die Applikation integriert werden. Der
Vorteil wäre, daß man auf den Austausch des Kinematikmoduls verzichten könnte und so die
32
Simulation durch alleinigen Austausch der Schnittstellendatei an neue Strukturen an passen
könnte.
5.6
Interaktives Definieren von kinematischen Strukturen
Eine weitere Möglichkeit zur Erweiterung der Applikation wäre das Interaktive Definieren
kinematischer Strukturen. Dabei würde man zunächst die einzelnen CAD-Komponenten der
betreffenden Struktur mit RobcadTM oder einem anderen CAD-System modellieren und sie
anschließend zu einem Modell einer kinematischen Struktur zusammensetzen. Interaktiv
könnte man dann, wie es bereits in RobcadTM für serielle Strukturen möglich ist, einzelne
Gelenke z.B. durch Festlegung der Achsen, definieren. Die Applikation würde dann auf Basis
der erstellten Struktur die Schnittstellendatei von selbst generieren. Sollte die Inverse- bzw.
Vorwärtskinematik lösbar sein, würden auch gleich die entsprechenden Gleichungen generiert.
33
A Implementierung
Dieser Teil des Anhangs verschafft einen Überblick über die Implementierung der Applikation. Im ersten Abschnitt erfolgt eine Übersicht über die einzelnen Module der Simulation und
deren Abhängigkeit untereinander. In den darauf folgenden Abschnitten sind die einzelnen
Header-Dateien der Applikation und jeweils eine kurze Beschreibung der einzelnen Funktionen aufgeführt. Die RobcadTM Programmierschnittstelle Robcad RoseTM [Tec99] läßt derzeit
nur die Implementierung in C zu, weswegen auch die Applikation in dieser Programmiersprache geschrieben ist [KeRi83]. Die graphische Anwenderoberfläche wurde mit Hilfe von
ROBUilTM, einer in RobcadTM integrierten Sprache, die auf Tcl/Tk basiert, erstellt.
A.1 Modulabhängigkeit
Die Abhängigkeit der einzelnen Module ist Abbildung A.1 zu entnehmen. Der Übersicht halber sind 3 Module weggelassen. Dies ist zum einen „parConst“, welches nur Konstanten für
u.a. Stringlängen enthält, von verschiedenen Modulen benötigt wird und nur aus einer Header-Datei besteht. Das zweite „parBool“ besteht auch nur aus einer Header-Datei und vereinfacht die Verwendung boolescher Variablen, da sie nicht explizit in C realisiert sind. Das
dritte nicht aufgeführte Modul „parTool“ wird von fast jedem anderen Modul benötigt und
beinhaltet z.B. Funktionen zur Erzeugung von Frames, oder verschiedene Zeichenkettenoperationen. Aus welchen Funktionen die Module im einzelnen bestehen, steht in Abschnitt A.2.
parMotion
parGui
parKinematics
parMath
parDisplay
parGraph
parEdge
parNode
parRead
parIndexList
Abbildung A.1: Modulabhängigkeiten der Applikation
Das Modul „parGui“ enthält die Callback-Funktionen die durch das betätigen der Buttons in
der Anwenderschnittstelle ausgelöst werden. Das Modul aktualisiert über „parDisplay“ das
34
Positionsdisplay des Roboters. Wird der Roboter bewegt, so wird eine Funktion in „parMotion“ aufgerufen, die wiederum die Inverse Kinematik von „parKinematics“ aufruft. Diese
kann durch das direkte Anfahren einer Position auch direkt aus „parGui“ aufgerufen werden.
Soll eine neue Schnittstellendatei über die Anwenderschnittstelle geladen werden, so wird
eine Funktion zum einlesen in „parGraph“ aufgerufen, die wiederum die eigentliche Funktion
zum einlesen der Datei in „parRead“ aufruft. Beide Funktionen müssen dabei auf die beiden
Module „parNode“ und „parEdge“ zugreifen, die Funktionen zum Einlesen der Elemente der
Datenstruktur enthalten.
Des Weiteren greift „parKinematics“ auf „parGraph“ zu, da sich dort u.a. die Funktion zur
Aktualisierung der Positionsdaten der CAD Entitäten befindet. „parMath“ stellt hierbei mathematische Funktionen zur Berechnung von Schnitten von Kugeln oder Kreis und Gerade
zur Verfügung, die zur Berechnung der Inversen Kinematik benötigt werden. Auch „parKinematics“ muß die Module der Graphelemente kennen.
Schließlich muß „parNode“ die Struktur der Kanten aus „parEdge“ bekannt sein. „parNode“
benutzt außerdem noch „parIndexList“ um die Indizes der einzelnen Knoten zu verwalten.
Details zu den einzelnen Funktionen können dem nächsten Abschnitt entnommen werden.
A.2 Funktionsheader
In diesem Abschnitt des Anhangs werden die Funktionsheader, sortiert nach Modulen, einzeln aufgelistet. Für jede Funktion sind die Ein- und Ausgabeparameter und eine kurze Beschreibung angegeben. Da alle Funktionen boolesche Werte zurückgeben, die anzeigen ob in
der Funktion ein Fehler aufgetreten ist, wird dies im folgenden nicht explizit erwähnt. Bei
Ausnahmen wird dies angegeben.
A.2.1
Modul „parGui“
Dieses Modul enthält die Callback-Funktionen die von der Anwenderoberfläche aufgerufen
werden, sobald einer der Buttons durch den Anwender betätigt wird. Beim Aufruf der Funktionen wird das Display der Anwenderoberfläche, z.B. für die Positionsdaten mit Hilfe von
Funktionen aus „parDisplay“ entsprechend gesetzt. Die Funktionen im Modul „parGui“ sind
im Einzelnen:
tBool FormSelectMech (tParam p);
p: Die Benutzereingaben werden im RobcadTM Datentyp tParam
gespeichert, was einer Liste von Eingabewerten entspricht. In diesem Fall ist die Bezeichnung des zu bewegenden Roboters einzugeben.
Ausgabeparameter:
Funktionsbeschreibung: Für den Fall, daß einmal mehrere Roboter gleichzeitig simuliert
werden sollen, läßt sich mit dieser Funktion und dem entsprechenden Button in der Anwenderschnittstelle der zu bewegende Roboter
auswählen. Die Verwendung von mehr als einem Roboter zur gleichen Zeit ist noch nicht implementiert.
Eingabeparameter:
35
tBool FormLoadKinInfo (tparam p);
p: Der Name der Schnittstellendatei, die Informationen über die kinematische Struktur des Roboters enthält.
Ausgabeparameter:
Funktionsbeschreibung: Diese Funktion liest die Schnittstellendatei für den Roboter ein. Dabei wird die Funktion „ReadData“ im Modul „parEdge“ aufgerufen.
Eingabeparameter:
tBool PBReset();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Wird der entsprechende Button in der Anwenderschnittstelle betätigt, so springt der Roboter zurück in seine Home-Position.
tBool PBMiddleMMove();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Diese Funktion ruft die Funktion „MoveMech“ im Modul „parMotion“ auf und übergibt, dabei die Funktion, daß sich der Roboter entlang der gewählten Achse in negativer Richtung bewegen soll.
tBool PBRightMMove();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Diese Funktion ruft die Funktion „MoveMech“ im Modul „parMotion“ auf und übergibt, dabei die Funktion, daß sich der Roboter entlang der gewählten Achse in positiver Richtung bewegen soll.
tbool PBMoveX();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Translation entlang der x-Achse
fest.
36
tbool PBMoveY();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Translation entlang der y-Achse
fest.
tbool PBMoveZ();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Translation entlang der z-Achse
fest.
tbool PBMoveRX();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Rotation um die x-Achse fest.
tbool PBMoveRY();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Rotation um die y-Achse fest.
tbool PBMoveRZ();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt die Bewegungsrichtung auf Rotation um die z-Achse fest.
tBool PBWorld();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt das Koordinatensystem in dem sich der Roboter bewegen soll
auf das Weltkoordinatensystem fest.
tBool PBTCPF();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt das Koordinatensystem in dem sich der Roboter bewegen soll
auf das Toolkoordinatensystem fest.
37
tBool FormOther();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Legt das Koordinatensystem in dem sich der Roboter bewegen soll
auf ein vom Anwender anzugebendes Koordinatensystem fest.
tBool PBLeft();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Ruft die Funktion „MoveMech“ im Modul „parMotion“ auf. Dieser
Funktion wird mitgeteilt, daß sich der Roboter entlang der gewählten Achse in negativer Richtung bewegen soll.
tBool PBRight();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Ruft die Funktion „MoveMech“ im Modul „parMotion“ auf. Dieser
Funktion wird mitgeteilt, daß sich der Roboter entlang der gewählten Achse in positiver Richtung bewegen soll.
tBool FormStepSize(tParam p);
Eingabeparameter:
p: Die Schrittweiten für translatorische und rotatorische Bewegungen als Werte im Format tParam.
Ausgabeparameter:
Funktionsbeschreibung: Diese Funktion setzt die Schrittweite in der Bewegungen des Roboters ausgeführt werden sollen auf den vom Anwender eingegebenen
Wert. Dies erfolgt getrennt für translatorische und rotatorische
Schrittweiten.
tBool FormMoveAbsolute(tParam p);
Eingabeparameter:
p: Eine Position im Weltsystem an Hand von 6 Eingabewerten für
Lage- und Orientierung des Toolframes.
Ausgabeparameter:
Funktionsbeschreibung: Der Roboter springt an die angegebene Position. Diese Funktion ruft
„InverseKinematics“ im Modul „parKinematics“ auf. An dieser
Stelle kann später ein Bahnplanungsverfahren eingesetzt werden.
38
tBool PBCollision();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Hiermit läßt sich die Kollisionsüberwachung für den Roboter entweder ein- oder ausschalten.
A.2.2
Modul „parDisplay“
Die Funktionen dieses Moduls dienen dazu die Displaydaten in der Anwenderoberfläche zu
aktualisieren.
tBool SetPosDisplay();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Diese Funktion stellt die aktuellen Werte für die Position des Roboters im Positionsdisplay der Anwenderoberfläche dar.
tBool SetStepDisplay();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Die aktuellen Werte der Schrittweite für die Bewegung des Roboters
werden im entsprechenden Display der Anwenderoberfläche dargestellt.
A.2.3
Modul „parMotion“
Die einzige Funktion dieses Modul berechnet nach Eingabe einer Bewegung die neue Position des Toolframes.
tBool MoveMech(int dir);
Eingabeparameter:
dir: Nimmt entweder den Wert –1 oder 1 an, je nachdem ob die gewünschte Bewegung des Toolframes in positiver (1) oder negativer
(-1) Richtung entlang der gewählten Achse erfolgen soll.
Ausgabeparameter:
Funktionsbeschreibung: Berechnet die neue Position des Toolframes, ruft dann die Funktion
„InverseKinematics“ aus dem Modul „parKinematics“ auf und übergibt ihr diesen Frame.
39
A.2.4
Modul „parKinematics“
Dieses Modul enthält diverse Funktionen zur Berechnung der Inversen- und
Vorwärtskinematik. Die meisten Funktionen müssen für jede Roboterstruktur neu
geschrieben werden, so lange es noch nicht möglich ist automatische Gleichungen für
Inverse- und Vorwärtskinematik zu generieren. Zu Anfang dieses Abschnitts ist der Datentyp
JMatrix angegeben, so wie er in der Header-Datei definiert ist. Dieser Datentyp stellt eine
Matrix dar und wird verwendet um die erweiterten DH-Parameter für aktive und passive
Gelenke abzuspeichern.
typedef struct JMatrix {
float matrix [MAX_JOINTS][DOF];
}JMatrix;
BOOL InverseKinematics(tFrame position, JMatrix * active, JMatrix * passive);
Eingabeparameter:
Ausgabeparameter:
position: Die neue Position des Toolframes.
active: Eine Matrix mit den neuen Werten der Gelenkvariablen der
aktiven Gelenke.
passive: Eine Matrix mit den neuen Werte der Gelenkvariablen der
passiven Gelenke.
Funktionsbeschreibung: Berechnet die neue Konfiguration des zu simulierenden Roboters
und aktualisiert die Matrizen, die die Gelenkvariablen für aktive und
passive Gelenke enthalten. Diese Funktion muß individuell an die zu
simulierende Roboterstruktur angepaßt werden.
BOOL DirectKinematics(JMatrix * active, JMatrix * passive, tFrame position);
Eingabeparameter:
active: Eine Matrix mit den neuen Werten der Gelenkvariablen der
aktiven Gelenke.
Ausgabeparameter:
passive: Eine Matrix mit den neuen Werte der Gelenkvariablen der
passiven Gelenke.
position: Die neue Position des Toolframes.
Funktionsbeschreibung: Berechnet die neue Konfiguration des Roboters und die neue Position des Toolframes auf Basis der neuen Stellung der aktiven Gelenke. Bisher wurde diese Funktion noch für keine Struktur implementiert.
BOOL OutofWorkspace(tFrame position);
Eingabeparameter:
Ausgabeparameter:
position: Die Position des Toolframes.
Ein boolescher Rückgabewert, der anzeigt ob sich der Roboter außerhalb seines Arbeitsbereichs (TRUE) befindet.
Funktionsbeschreibung: Überprüft ob sich eine anzufahrende Position außerhalb des Arbeitsbereichs des Roboters befindet. Diese Funktion muß an die zu
simulierende Roboterstruktur angepaßt sein.
40
BOOL OutOfRange();
Ein boolescher Rückgabewert, der anzeigt ob sich Gelenke außerhalb ihrer definierten Stellbereiche befinden.
Funktionsbeschreibung: Es wird überprüft, ob sich Gelenke außerhalb ihres definierten Stellbereichs befinden.
Eingabeparameter:
Ausgabeparameter:
BOOL SelfCollision(tFrame new_toolframe);
Eingabeparameter:
Ausgabeparameter:
new_toolframe: Die neue Position des Toolframes.
Ein boolescher Rückgabewert, der anzeigt, ob sich der Roboter in
Eigenkollision befindet.
Funktionsbeschreibung: Führt eine Eigenkollisionsüberprüfung durch. Dies geschieht derzeit
mit Hilfe von Funktionen die RobcadTM zur Verfügung stellt.
A.2.5
Modul „parMath“
Dieses Modul enthält mathematische Funktionen zur Berechnung der Inversen Kinematik.
Die hier beschriebenen Funktionen finden bei der Berechnung der Inversen Kinematik für
den Hexa Parallelroboter Anwendung.
BOOL GetCirclePlane(tFrame circle_fr, double circle_r, tVec3 plane_pos, tVec3
plane_dir1, tVec3 plane_dir2);
circle_fr: Lage und Orientierung des Mittelpunkts eines Kreises.
circle_r: Radius eines Kreises.
Ausgabeparameter:
plane_pos: Der Ortsvektor der zu berechnenden Ebene.
plane_dir1: Der erste Richtungsvektor der zu berechnenden Ebene.
plane_dir2: Der zweite Richtungsvektor der zu berechnenden Ebene.
Funktionsbeschreibung: Berechnet zu einer Kreisgleichung die in Mittelpunktsform gegeben
ist, eine Ebenengleichung in Parameterform, so daß der Kreis in dieser Ebene liegt.
Eingabeparameter:
BOOL SphereIntersection(tFrame mf_sphere1, double r_sphere1, tFrame mf_sphere2,
double r_sphere2, tVec3 plane_ne, double * plane_d);
Eingabeparameter:
mf_sphere1: Mittelpunkt der ersten Kugel.
r_sphere1: Radius der ersten Kugel.
mf_sphere2: Mittelpunkt der zweiten Kugel.
r_sphere2: Radius der zweiten Kugel.
plane_ne: Normaleneinheitsvektor der Schnittebene.
Ausgabeparameter:
plane_d: Abstand der Schnittebene vom Ursprung des Koordinatensystems.
Funktionsbeschreibung: Berechnet die Schnittebene zweier Kugeln. Dabei sind die Kugeln in
Mittelpunktsform und die Schnittebene in Normalenform gegeben.
41
BOOL PlaneIntersection(tVec3 p_plane_pos, tVec3 p_plane_dir1, tVec3 p_plane_dir2,
tVec3 n_plane_n, double n_plane_c, tVec3 line_pos, tVec3 line_dir);
p_plane_pos: Ortsvektor der ersten Ebene.
p_plane_dir1: Erster Richtungsvektor der ersten Ebene.
p_plane_dir2: Zweiter Richtungsvektor der ersten Ebene.
n_plane_n: Normalenvektor der zweiten Ebene.
n_plane_c: Abstand der zweiten Ebene vom Ursprung des
Koordinatensystems.
line_pos: Ortsvektor der Schnittgerade.
Ausgabeparameter:
line_dir: Richtungsvektor der Schnittgerade.
Funktionsbeschreibung: Berechnet die Schnittgerade zweier Ebenen und gibt sie in Parameterform zurück. Die erste Ebene ist in Parameterform gegeben, die
zweite in Normalenform.
Eingabeparameter:
BOOL CircleLineIntersection(tVec3 c_plane_pos, double r_circle1, tVec3 line_pos,
tVec3 line_dir, tFrame s1, tFrame s2);
Eingabeparameter:
c_plane_pos: Ortsvektor des Kreismittelpunkts.
r_circle1: Radius des Kreises.
line_pos: Ortsvektor der Geraden.
line_dir: Richtungsvektor der Geraden.
s1: Erster Schnittpunkt.
Ausgabeparameter:
s2: Zweiter Schnittpunkt.
Funktionsbeschreibung: Berechnet, falls vorhanden, die beiden Schnittpunkte einer Geraden
mit einem Kreis. Der Kreis ist in Mittelpunktsform gegeben, die Gerade in Parameterform.
BOOL CalculateTTS();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Berechnet die von der Inversen Kinematik benötigten Transformation von Toolframe zum letzten passive Kugelgelenk aller Ketten des
Hexa Parallelroboters und speichert diese in einer globalen Variable.
A.2.6
Modul „parGraph“
In diesem Modul finden sich Funktionen, die die Verwaltung des Graphen betreffen. Es
macht Gebrauch von verschiedenen Funktionen in den Modulen der einzelnen Graphelemente „parNode“ und „parEdge“ sowie Funktionen im Modul „parRead“ zum Einlesen der
Schnittstellendatei. Der Graph ist als Adjazenzliste implementiert.
42
BOOL ReadData(char filename[FILENAMESIZE]);
filename: Der Dateiname der einzulesenden Schnittstellendatei.
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Eine Schnittstellendatei mit dem angegebenen Dateinamen wird
eingelesen, auf Korrektheit überprüft und eine GraphRepräsentation des Roboters generiert.
BOOL DestroyGraph(struct node * act_node);
Eingabeparameter:
act_node: Ein Knoten des Graphen. Üblicherweise der erste Knoten.
Ausgabeparameter:
Funktionsbeschreibung: Löscht den Graphen ausgehend vom übergebenen Knoten. Dabei
werden alle folgenden Knoten und Kanten mit Hilfe der entsprechenden Funktionen in den Modulen „parNode“ und „parEdge“ gelöscht und ihr reservierter Speicher freigegeben. Üblicherweise wird
der erste Knoten angegeben um den gesamten Graph zu löschen.
BOOL UpdateRobotCAD();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Übergibt der rekursiven Funktion „UpdateRobotCADrec“ einige
Werte und ruft diese auf. Außerdem wird die Position der CADEntität aktualisiert, an der sich der Toolframe befindet.
BOOL UpdateRobotCADrec(struct node * act_node, tFrame curr_frame, tFrame
trans_frame);
Eingabeparameter:
act_node: Aktueller Knoten an dem die Rekursion fortgesetzt wird.
curr_frame: Aktuelle Position, zu der die nachfolgenden Objektpositionen relativ berechnet werden.
trans_frame: Translation der Vorgängerkante.
Ausgabeparameter:
Funktionsbeschreibung: Diese rekursive Funktion ist für die Aktualisierung der CADObjektpositionen zuständig. Um eine aktuelle Anzeige zur erhalten
muß nach dem Aufruf der Funktion noch die RobcadTM-Funktion
„apDisplayCell“ aufgerufen werden. Beim ersten Aufruf der Funktion durch „UpdateRobotCAD“ entspricht act_node dem ersten Knoten der Knotenliste, curr_frame ist der Roboterbasisframe und
trans_frame entspricht der Einheitsmatrix. Dadurch, daß die Lage
der CAD-Objekte relativ zueinander durch die erweiterten DHParameter gespeichert ist, ist es erforderlich, daß die Rekursion die
aktuelle Position (curr_frame) auf der die nachfolgenden Berechnungen beruhen, sowie den translatorischen Anteil der Vorgängerkante (trans_frame) mit übergeben bekommt.
43
A.2.7
Modul „parRead“
Dieses Modul stellt einige Funktionen bereit, die zum Einlesen der Schnittstellendatei benötigt werden. Die Funktionen werden allesamt von „ReadData“ aus dem Modul „parGraph“
aufgerufen.
BOOL ReadLine(char * line, FILE * file);
file: Ein Zeiger auf die einzulesende Schnittstellendatei.
Eingabeparameter:
Ausgabeparameter:
line: Eine Textzeile aus der Schnittstellendatei.
Funktionsbeschreibung: Liest eine Zeile aus der Schnittstellendatei ein. Zurückgegeben wird
die nächste nicht leere Zeile, die keinen Kommentar enthält.
BOOL ReadCoords(tCoords coords, char * line);
Eingabeparameter:
Ausgabeparameter:
line: Ein Teil einer Zeile der Schnittstellendatei.
coords: 6 Parameter aus denen ein Frame generiert werden kann, der
Lage und Orientierung eines Koordinatensystems beschreibt.
Funktionsbeschreibung: Liest aus einem Teil einer Zeile der Schnittstellendatei 6 Parameter
ein. Dies ist erforderlich beim einlesen der Transformationen Tfix, 1,
Tfix, 2 bzw. Tparams. Wird die Transformation Tparams eingelesen so
wird der fehlende Parameter durch den Wert Null ersetzt.
BOOL ReadFrame(tFrame frame, char * line);
line: Ein Teil einer Zeile der Schnittstellendatei.
frame: Eine Transformation, die entweder Tfix, 1, Tfix, 2 oder Tparams
entspricht.
Funktionsbeschreibung: Ruft „ReadCoords“ auf um aus einem Teil einer Zeile der Schnittstellendatei Parameter auszulesen und generiert aus diesen Parametern eine Transformation.
Eingabeparameter:
Ausgabeparameter:
A.2.8
Modul „parEdge“
Dieses Modul enthält Funktionen, die beim Arbeiten mit Kanten benötigt werden. Zu Anfang
dieses Abschnitts ist die Datenstruktur einer Kante im Graph, so wie sie in der Header-Datei
für dieses Modul definiert ist, angegeben.
struct edge {
struct edge * next_edge;
int connect;
tFrame frop1;
tCoords params;
tFrame frop2;
char joint;
// Zeiger auf die nächste Kante
// Index des Nachfolgerknotens
// Transformation Tfix, 1
// erweiterte DH-Parameter zur Berechnung von Tparams
// Transformation Tfix, 2
// Gelenktyp: R = rotatorisches Gelenk, P = prismatisches Gelenk,
//
K = Kardangelenk, S = Kugelgelenk
44
float range[3][2];
BOOL active;
};
// Stellbereiche des Gelenks
// aktives Gelenk = TRUE, passives Gelenk = FALSE
BOOL NewEdge(int connect, tFrame frop1, tCoords params, tFrame frop2, char joint,
float range[3][2], BOOL active, struct edge ** res_edge);
Eingabeparameter:
connect: Zeiger auf die nächste Kante der zu erzeugenden Kante.
frop1: Transformation Tfix, 1.
params: erweiterte DH-Parameter Tparams.
frop2: Transformation Tfix, 2.
joint: Gelenktyp der neuen Kante.
range[3][2]: Stellbereiche des Gelenks, das durch die zu erzeugende
Kante repräsentiert wird.
active: Flag, ob Gelenk aktiv oder passiv.
res_edge: Ein Zeiger auf die erzeugte neue Kante.
Ausgabeparameter:
Funktionsbeschreibung: Anhand der übergebenen Eingabewerte erzeugt diese Funktion eine
neue Kante im Graphen. Eine Einsortierung in die Adjazenzliste
wird durch diese Funktion nicht vorgenommen.
BOOL InsertEdgeInList(struct edge * new_edge, struct edge * act_edge);
Eingabeparameter:
new_edge: Die einzufügende Kante.
act_edge: Die erste Kante der Kantenliste, in die die neue Kante
eingefügt werden soll.
Ausgabeparameter:
Funktionsbeschreibung: Fügt die übergebene neue Kante in die Kantenliste ein, in der
act_edge die erste Kante ist. Diese Funktion wird von der Funktion
„InsertEdge“ im Modul „parNode“ aus aufgerufen. Ist die
Kantenliste leer, so sorgt die aufrufende Funktion dafür, daß die
Kante direkt hinter dem Knoten eingefügt wird.
BOOL DestroyEdge(struct edge * act_edge);
Die zu löschende Kante.
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Entfernt die übergebene Kante aus dem Graph und gibt den reservierten Speicher frei. Die nachfolgenden Kanten der Kantenliste
werden ans neue Ende der Liste wieder angefügt. Gibt es keine
Nachfolger wird der letzte Zeiger der Liste auf Null gesetzt.
45
BOOL ReadEdge(char * line, char * connect1_str, struct edge ** res_edge);
line: Eine Zeile der Schnittstellendatei, die eine Kante definiert.
connect1_str: Die Nummer des Knotens von der die Kante wegführt
als String.
res_edge: Die eingelesene Kante.
Funktionsbeschreibung: Liest eine Zeile, die eine Kante definiert, aus der Schnittstellendatei
ein. Hierbei wird die Funktion „new_edge“ verwendet um die Kante
zu erzeugen.
Eingabeparameter:
Ausgabeparameter:
A.2.9
Modul „parNode“
Dieses Modul enthält Funktionen, die beim Arbeiten mit Knoten benötigt werden. Zu Anfang
dieses Abschnitts ist die Datenstruktur eines Knotens im Graph, so wie sie in der HeaderDatei für dieses Modul definiert ist, angegeben.
struct node {
struct edge * next_edge; // Zeiger auf die Kantenliste des Knotens
struct node * next_node; // Zeiger auf den nächsten Knoten in der Knotenliste
int index;
// Index des Knotens
char * link;
// Typ des Links (Tool, Base, S-Link oder M-Link)
tName csg_name;
// Name der entsprechenden CAD-Entität
tFrame csg_pos;
// Position der Entität in der CAD-Welt
};
BOOL CreateFirstNode(char * link, int index, tName csg_name, tFrame csg_pos);
link: Typ des Links des ersten Knotens. Üblicherweise Base.
index: Index des ersten Knotens. Üblicherweise Eins.
csg_name: Name der CAD-Entität des ersten Knotens.
csg_pos: Position der CAD-Entität.
Ausgabeparameter:
Funktionsbeschreibung: Der erste Knoten des Graphen wird anhand der übergebenen Parameter erzeugt. Der Zeiger hierauf ist global definiert.
Eingabeparameter:
BOOL NewNode(struct node * act_node, char * link, int index, tName csg_name, tFrame csg_pos);
link: Typ des links des neuen Knotens.
index: Index des neuen Knotens.
csg_name: Name der Entität des neuen Knotens in der CADUmgebung.
csg_pos: Position der CAD-Entität.
act_node: Zeiger auf den neuen Knoten.
Ausgabeparameter:
Funktionsbeschreibung: Anhand der übergebenen Parameter wird ein neuer Knoten im Graphen erzeugt. Er wird ans Ende der Knotenliste angehängt.
Eingabeparameter:
46
BOOL InsertEdge(struct edge * new_edge, struct node * act_node);
new_edge: Die einzusortierende Kante.
act_node: Der Knoten an dem die Kante eingefügt werden soll.
Ausgabeparameter:
Funktionsbeschreibung: Fügt die übergebene Kante direkt nach dem übergebenen Knoten
ein, falls sich dort noch keiner befindet. Ist die Stelle bereits besetzt,
so wird die Kante der Funktion „InsertEdgeInList“ in „parEdge“ übergeben, wo sie ans Ende der Kantenliste eingefügt wird.
Eingabeparameter:
BOOL InsertNode(struct node * act_node);
Eingabeparameter:
act_node: Der einzusortierende Knoten.
Ausgabeparameter:
Funktionsbeschreibung: Fügt den übergebenen Knoten ans Ende der Knotenliste an.
BOOL DestroyNode(struct node * act_node);
Eingabeparameter:
act_node: Der zu löschende Knoten.
Ausgabeparameter:
Funktionsbeschreibung: Entfernt den übergebenen Knoten aus der Knotenliste des Graphen.
Dabei werden Kanten die zu diesem und von diesem Knoten weg
führen mit Hilfe der Funktion „DestroyEdge“ im Modul „parEdge“
mit gelöscht. Dabei wird sämtlicher reservierter Speicher freigegeben.
BOOL SearchPrevEdge(struct node * act_node, int connect, struct edge ** res_edge);
Eingabeparameter:
act_node: Knoten bei dem die Suche beginnen soll.
connect: Index, den der Knoten haben soll, auf den die nachfolgende Kante zeigt.
Ausgabeparameter:
res_edge: Die gefundene Kante.
Funktionsbeschreibung: Sucht die Vorgängerkante zur ersten Kante raus, deren Nachfolgerknoten den zu übergebenden Index hat. Die Suche beginnt dabei mit
der Kantenliste die dem übergebenen Knoten nachfolgt. Ist der Vorgänger ein Knoten, so wird eine Kante erzeugt deren Wert für den
Nachfolgeknoten dem negativen Index des gefundenen Knoten entspricht.
47
BOOL SearchPrevNode(struct node * act_node, int index, struct node ** return_node);
act_node: Knoten bei dem die Suche beginnen soll.
index: Index den der Knoten haben soll, auf den der Nachfolgerknoten zeigt.
Ausgabeparameter:
return_node: gefundene Knoten.
Funktionsbeschreibung: Sucht den Vorgängerknoten zum Knoten mit dem übergebenen Index. Ist der Index der des ersten Knotens in der Knotenliste, so wird
Null zurückgegeben.
Eingabeparameter:
BOOL ReadNode(char * line);
Eingabeparameter:
line: Eine Zeile aus der Schnittstellendatei, die die Definition für
einen Knoten enthält.
Ausgabeparameter:
Funktionsbeschreibung: Liest aus der übergebenen Zeile die Definition eines Knotens ein
und erzeugt diesen mit Hilfe von „NewNode“ oder „CreateFirstNode“, wenn es der erste Knoten ist. Dabei wird der Knoten mit Hilfe
von „InsertNode“ in die Liste eingefügt.
A.2.10 Modul „parIndexList“
Dieses Modul verwaltet zu vergebende Indizes für die Knoten des Graphen. Es stellt sicher,
daß kein Index doppelt vergeben wird.
BOOL InitIndexList();
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Initialisiert ein Array von booleschen Werten. Die Indizes des Arrays entsprechen dabei den Indizes der Knoten minus eins. Jedem
Element des Arrays ist dabei ein boolescher Wert zugeordnet, der
angibt ob ein Index bereits vergeben ist oder nicht.
BOOL RegisterIndex(int index);
Eingabeparameter:
Zu vergebender Index.
Ausgabeparameter:
Funktionsbeschreibung: Versucht einen Index als vergeben zu markieren. War er bereits vergeben, liefert die Funktion FALSE zurück.
48
BOOL FreeIndex(int index);
Verfügbar zu machender Index.
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Versucht einen Index als frei zu markieren. War er bereits frei, liefert die Funktion FALSE zurück.
BOOL GetFreeIndex(int * i);
Eingabeparameter:
Ausgabeparameter:
Freier Index.
Funktionsbeschreibung: Sucht den nächsten freien Index, beginnend bei 1 aus der Indexliste.
Ist die maximale Anzahl an Knoten erreicht wird FALSE zurückgegeben.
A.2.11 Modul „parTool“
Dieses Modul stellt verschiedene Werkzeuge zur Verfügung auf die fast alle Module einmal
zugreifen.
BOOL GetStrToken(char * token, char * line);
line: Eine Textzeile.
token: Ein von line abgeschnittener Teil.
line: Der Rest der Zeile.
Funktionsbeschreibung: Schneidet alle Zeichen bis zum ersten Leerzeichen von der übergebenen Zeile ab und gibt diese, sowie den abgeschnittenen Teil zurück.
Eingabeparameter:
Ausgabeparameter:
BOOL RemoveChar(char * str, char c);
str: Zu durchsuchender String.
c: Herauszufilterndes Zeichen.
str: Gefilterte Zeile.
Ausgabeparameter:
Funktionsbeschreibung: Entfernt aus dem übergebenen String alle Zeichen die dem übergebenen Zeichen entsprechen.
Eingabeparameter:
BOOL MakeIdentityFrame(tFrame frame);
Eingabeparameter:
Ausgabeparameter:
frame: Einheitsmatrix.
Funktionsbeschreibung: Erzeugt eine Einheitsmatrix und gibt diese zurück.
49
BOOL MakeFrameByCoords(tCoords coords, tFrame frame);
coords: 6 Parameter, die Translationen und Rotationen in alle 6
Richtungen definieren.
Ausgabeparameter:
frame: Resultierende Transformationsmatrix.
Funktionsbeschreibung: Auf der Basis von 6 Parametern, die im RobcadTM Datentyp tCoords
gespeichert sind, wird eine Transformationsmatrix erzeugt.
Eingabeparameter:
BOOL MakeFrameByParams(double rz, double z, double ry, double y, double rx,
double x, tFrame frame);
Eingabeparameter:
rz: Rotation um die z-Achse.
z: Translation entlang der z-Achse.
ry: Rotation um die y-Achse.
y: Translation entlang der y-Achse.
rx: Rotation um die x-Achse.
x: Translation entlang der x-Achse.
frame: Resultierende Transformationsmatrix.
Ausgabeparameter:
Funktionsbeschreibung: Auf der Basis von 6 Parametern, die alle als einzelne double Werte
vorliegen, wird eine Transformationsmatrix erzeugt.
BOOL StrToUpper(char * str);
str: Zu konvertierender String.
Eingabeparameter:
Ausgabeparameter:
str: Konvertierter String.
Funktionsbeschreibung: Wandelt einen String so um, daß alle Buchstaben zu Großbuchstaben werden.
BOOL WriteLineError(char * error_msg);
error_msg: Eine Fehlermeldung.
Eingabeparameter:
Ausgabeparameter:
Funktionsbeschreibung: Gibt im RobcadTM Textfenster eine Fehlermeldung inklusive Zeilennummer der Schnittstellendatei aus. Diese Funktion wird von
„ReadData“ aus dem Modul „parGraph“ verwendet.
BOOL IsRealNumber(char * str);
str: Zu überprüfender String.
Eingabeparameter:
Ausgabeparameter:
Ein boolescher Rückgabewert.
Funktionsbeschreibung: Überprüft einen String darauf, ob er in einen float oder double Wert
konvertiert werden kann.
50
BOOL IsPosInt(char * str);
str: Zu überprüfender String.
Eingabeparameter:
Ausgabeparameter:
Ein boolescher Rückgabewert.
Funktionsbeschreibung: Überprüft einen String darauf, ob er eine positive ganze Zahl darstellt.
BOOL Graph2JMatrix(JMatrix * active_m, JMatrix * passive_m);
active_m: Matrix mit Gelenkvariablen der aktiven Gelenke.
passive_m: Matrix mit Gelenkvariablen der passiven Gelenke.
Funktionsbeschreibung: Kopiert die Gelenkvariablen der aktiven und passiven Gelenken aus
dem Graph in zwei Matrizen vom Typ JMartrix in dem die Funktion
die rekursive Funktion „Graph2JMatrixrec“ aufruft.
Eingabeparameter:
Ausgabeparameter:
BOOL Graph2JMatrixrec(struct node * act_node, JMatrix * active_m, JMatrix *
passive_m);
Eingabeparameter:
Ausgabeparameter:
act_node: Aktuelle Position im Graphen.
active_m: Matrix mit Gelenkvariablen der aktiven Gelenke.
passive_m: Matrix mit Gelenkvariablen der passiven Gelenke.
Funktionsbeschreibung: Rekursive Funktion, die die Gelenkvariablen aus den Kanten des
Graphen in die Matrizen active_m und passive_m kopiert.
BOOL JMatrix2Graph(JMatrix * active_m, JMatrix * passive_m);
active_m: Matrix mit Gelenkvariablen der aktiven Gelenke.
passive_m: Matrix mit Gelenkvariablen der passive Gelenke.
Ausgabeparameter:
Funktionsbeschreibung: Kopiert die Gelenkvariablen der aktiven und passiven Gelenke aus
dem beiden Matrizen in die entsprechenden Kanten im Graph, in
dem die Funktion die rekursive Funktion „JMatrix2Graphrec“ aufruft.
Eingabeparameter:
BOOL JMatrix2Graphrec(struct node * active_node, JMatrix * active_m, JMatrix *
passive_m);
Eingabeparameter:
act_node: Aktuelle Position im Graphen.
active_m: Matrix mit Gelenkvariablen der aktiven Gelenke.
passive_m: Matrix mit Gelenkvariablen der passiven Gelenke.
Ausgabeparameter:
Funktionsbeschreibung: Rekursive Funktion, die die Gelenkvariablen aus den Matrizen active_m und passive_m in die entsprechenden Kanten des Graphen
kopiert.
51
B Weitere Kinematiken und deren Knotenindizierung
In diesem Teil des Anhangs finden sich zwei weitere Roboterstrukturen als Beispiele für die
Anwendung des Knotenindizierungsalgorithmus aus Kapitel 3.
B.1
Werkzeugmaschine Eclipse
In Abbildung B.1 ist die Eclipse [KiByCho01] einmal als schematische Zeichnung und mit
der entsprechenden Knotenindizierung zu sehen.
Abbildung B.1: Kinematische Struktur der Eclipse und zugehöriger Graph
B.2
Porty (unsymmetrische Parallelstruktur)
Abbildung B.2 zeigt eine einen unsymmetrischen Parallelroboter, den Porty [HeSchWa99]
mit seinem zugehörigen Graph und Knotenindizierung.
Abbildung B.2: Porty Parallelroboter und zugehöriger Graph
52
C Beispiele von Schnittstellendateien
In diesem Teil des Anhangs sind 2 Beispiele für Schnittstellendateien angeführt, wie sie von
der Applikation eingelesen werden. Die erste Datei enthält kinematische Informationen über
den Hexa Parallelroboter, die zweite über den Delta Roboter.
C.1
Schnittstellendatei des Hexa Parallelroboters
! "#$#$%###$#$#$#&$ '
()
! "#$#$+(#%,-./,0/$#$#$#&$ '
*
2
1)
3
*
-
2
3
-
4
5'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
! (16
(!
$"
$ 5#$#$#$#$#$#6&)
7! 8+4 $ "
9 $ 5+,1:-1#7:$+(..-/(.0$+7##$,#$7(#$#6&)
0! 8+4 $ "
$ 5+(1/:-.%0,$+%::-7,1($+7##$,#$7(#$+(1/-%6&)
1! * $ "
$ 5#$#$+(#%,-./,0/$#$#$#6&)
%! 8+4 $ "
9 $ 5+.(:-0,7($+/0:-7,77$+7##$+,#$(%#$#6&)
.! 8+4 $ "
$ 5+(71:-.(1/$+,:.-/(10$+7##$,#$7(#$+(1/-%6&)
/! 8+4 $ "
9 $ 5.(:-0,/%$+/0:-#:0($+7##$,#$00#$#6&)
:! 8+4 $ "
$ 5(71:-.7#7$+,:.-%#%7$+7##$,#$00#$+(1/-%6&)
,! 8+4 $ "
9 $ 5,1:-0,/%$+(..-%#.1$+7##$+,#$0#$#6&)
(#! 8+4 $ "
$ 5(1/:-.1::$+%::-#:1($+7##$,#$00#$+(1/-%6&)
((! 8+4 $ "
9 $ 500#$,#1-%:,%$+7##$,#$,#$#6&)
(7! 8+4 $ "
$ 570#-#7:.$(%/1-%:,1$+7##$,#$,#$+(1/-%6&)
(0! 8+4 $ "
9 $ 5+00#$,#1-%:,%$+7##$+,#$7/#$#6&)
(1! 8+4 $ "
$ 5+70#-#7:.$(%/1-%:,1$+7##$,#$,#$+(1/-%6&)
4
;
5
$ $ ---6
$
<= +>
5>
>
>
>
>
>
>
>
>
>
>
! (:6
!'
!'
!'
!'
!'
!'
!'
!'
!'
!'
(
(
(
(
(
(
7
0
%
.
'
'
'
'
'
'
'
'
'
'
7$ 5+,1:-1#7:$+(..-/(.0$+7##$,#$7(#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5+(:#$#6$
? )
%$ 5+.(:-0,7($+/0:-7,77$+7##$+,#$(%#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
/$ 5.(:-0,/%$+/0:-#:0($+7##$,#$00#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5+(:#$#6$
? )
,$ 5,1:-0,/%$+(..-%#.1$+7##$+,#$0#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
(($ 500#$,#1-%:,%$+7##$,#$,#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5+(:#$#6$
? )
(0$ 5+00#$,#1-%:,%$+7##$+,#$7/#$#6$ 5#$+,,-,/%$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
0$ 5+(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
.$ 5(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 5+07-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
53
>
>
>
>
>
>
>
>
!'
!'
!'
!'
!'
!'
!'
!'
C.2
/
:
,
(#
((
(7
(0
(1
'
'
'
'
'
'
'
'
:$ 5+(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
(#$ 5(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 5+07-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
(7$ 5+(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
(1$ 5(1/-%$#$#$(.##$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 5+07-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
? )
? )
Schnittstellendatei des Delta Parallelroboters
! "#$#$71##$#$#$#&$ ' ! ()
! "#$#$+(#%,-./,0/$#$#$#&$ '
*
? )
2
1)
3
*
-
2
3
-
4
5'
'
'
'
'
'
'
'
'
'
'
'
! ((6
(!
$"
9
$ 5#$#$#$#$#$#6&)
7! @+4 $ "
9
$ 5+/:0-0,/%$+1%7-7,1/$+7##$+,#$(%#$#6&)
0! 8+4 $ "
$ 5+(1/:-.0%/$+%::-(#.:$+7##$,#$7(#$+(1/-%6&)
1! * $ "
$ 5#$#$+(#%,-./,0/$#$#$#6&)
%! 8+4 $ "
$ 5+(71:-.000$+,:.-1:7:$+7##$,#$7(#$+(1/-%6&)
.! @+4 $ "
9
$ 5/:0-0,/%$+1%7-7,1/$+7##$+,#$0#$#6&)
/! 8+4 $ "
$ 5(71:-.000$+,:.-1:7/$+7##$,#$00#$+(1/-%6&)
:! 8+4 $ "
$ 5(1/:-.0%/$+%::-(#./$+7##$,#$00#$+(1/-%6&)
,! @+4 $ "
9
$ 5#$,#1-%:,%$+7##$+,#$+,#$#6&)
(#! 8+4 $ "
$ 570#-##7%$(%/1-%:,%$+7##$,#$,#$+(1/-%6&)
((! 8+4 $ "
$ 5+70#-##7%$(%/1-%:,%$+7##$,#$,#$+(1/-%6&)
4
;
5
$ $ ---6
$
<= +>
5>
>
>
>
>
>
>
>
>
>
>
>
>
>
! (%6
!'
!'
!'
!'
!'
!'
!'
!'
!'
!'
!'
!'
!'
(
(
(
7
7
0
%
.
.
/
:
,
,
'
'
'
'
'
'
'
'
'
'
'
'
'
7$ 5+/:0-0,/%$+1%7-7,1/$+7##$+,#$(%#$#6$ 5#$#$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
.$ 5/:0-0,/%$+1%7-7,1/$+7##$+,#$0#$#6$ 5#$#$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
,$ 5#$,#1-%:,%$+7##$+,#$+,#$#6$ 5#$#$#$..,-,:.,$#6$ 5#$#$#$#$#$#6$ $ 5#$(:#6$
? )
0$ 5#$#$+70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
%$ 5#$#$70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$+1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,77(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
/$ 5#$#$+70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
:$ 5#$#$70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$+1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
(#$ 5#$#$+70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
(($ 5#$#$70#-#7%$#$#$#6$ 5(1/-%$#$#$(.##$#6$ 5#$#$#$#$#$#6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
54
>
>
!'
!'
(# '
(( '
1$ 507-%$#$+1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
1$ 507-%$#$1%-.7,.$07(-/%70$+1:-7,7(6$ 8$ 5+(:#$(:#$+(:#$(:#$+(:#$(:#6$
? )
? )
55
Literaturverzeichnis
[HeSchWa99]
J. Hesselbach, W. Schuhmacher und F. Wahl. Teilprojekte A2, B2,
B3 und B4: SFB-Antrag 562: Robotersysteme für Handhabung und
Montage. Technische Universität Braunschweig, 1999
[DeHa55]
J. Denavit und R. S. Hartenberg: A Kinematic Notation for Lower
Pair Mechanisms Based on Matrices. ASME Journal of Applied Mechanics Vol. 22, 1955, pp. 215-221
[Rose00]
Andreas Rose: Einweisung in ROBCAD Version 3.7.1. Modellierung
und Simulation von Robotern. Studienarbeit, Institut für Robotik und
Prozeßinformatik, Technische Universität Braunschweig, 2000
[ThoWa01]
U. Thomas und F. Wahl: Eine universelle Schnittstelle für serielle,
parallele und hybride kinematische Strukturen. Techn. Bericht, Technische Universität Braunschweig, April 2001
[Merl00]
J. P. Merlet: Parallel Robots. Kluwer Academic Publishers,
Dordrecht, Bosten, London 2000
[BeBe00]
N. P. Belifiore und A. Di Benedetto: Connectivity and Redundancy in
Spatial Robots. The International Journal of Robotics Research Vol.
19, No. 12, Dezember 2000, pp. 1245-1261
[Cros64]
F. R. E. Crossley: A Contribution to Gruebler’s Theory in the Number
Synthesis of Plane Mechanisms. Journal of Engineering for Industry.
Transactions of the ASME, Februar 1964
[Tec99]
Tecnomatix: Reference Manuals for ROBCADTM. Firma Tecnomatix,
Juni 1999.
[Ries92]
H. Rieseler: Roboterkinematik – Grundlagen, Invertierung und Symbolische Berechnung. Dissertation. F. Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig/Wiesbaden 1992.
[Bron91]
Bronstein-Semedjajew: Taschenbuch der Mathematik. B.G. Verlag
Teubner, Stuttgart, Leipzig und Nauka, Moskau 1991
[KeRi83]
Kernighan/Ritchie: Programmieren in C. C. Hanser Verlag, München, Wien 1983.
[KiByCho01]
W. K. Kim, Y. K. Byun und H. S. Cho: Closed Forward Position
Solution for a 6-DoF 3-PPSP Parallel Mechanism and Its Implementation. The International Journal of Robotics Research Vol. 20, No. 1,
Januar 2001, pp. 85-99
[Wahl98]
F. Wahl: Vorlesung Robotik I WS 1998/1999. Institut für Robotik und
Prozeßinformatik, Technische Universität Braunschweig, 1998.
56
[Wahl99]
F. Wahl: Vorlesung Robotik II SS 1999. Institut für Robotik und Prozeßinformatik, Technische Universität Braunschweig, 1999.