Gantry Control

Markus Stark 5032520 1
Einsatz von MATLAB-Werkzeugen für einen

on-line Praktikumsversuch zur
Kranregelung
Diplomarbeit D2
Lehrgebiet:
Prozesssteuerung und Regelungstechnik
Fachbereich Elektrotechnik
Fernuniversität Hagen
eingereicht von: Markus Stark

Matrikelnummer: 5032520
Fernuniversität Hagen
16. Januar 2003
Betreuer:
Dipl.-Ing. Ivan Másar
Einsatz von MATLAB-Werkzeugen für einen

on-line Praktikumsversuch zur Kranregelung
Diplomarbeit
Erklärung
Ich versichere, dass ich diese Diplomarbeit selbstständig verfasst und keine anderen als die
angegebenen Quellen und Hilfsmittel verwendet, sowie Zitate kenntlich gemacht habe.
Markus Stark
Hagen, 16. Januar 2003
Inhaltsverzeichnis
1 EINLEITUNG 5
2. DAS SYSTEM 'KRAN MIT PENDEL' 6

2.1 Mathematisches Systemmodell 7
2.2 Zustandsraumbeschreibung des linearisierten Modells 8
2.3 Übertragungsfunktionen des linearen Modells 9
3 PROGRAMMDOKUMENTATION 11
3.1 Allgemeine Programminformation 11
3.2 GUI-Implementierung 11
3.2.1 Programmaufbau 12
3.2.2 Dateiorganisation 15
3.2.3 Funktionen und Callback-Routinen 17
3.3 Anwendung Kranregelung 20

3.3.1 Systemparameter 21
3.3.2 Systemlinearisierung 22
3.3.3 Systemdarstellung 22
3.3.4 Pole und Nullstellen 23
3.3.5 Nyquist-Plot 25
3.3.6 Bode-Plot 25
3.3.7 Wurzelortskurve 26
3.3.8 Sprungantwort und Impulsantwort 26
3.3.9 Reglerentwurf 27
3.3.10 Simulation 28
3.3.11 Bahninterpolation 29
4 VRML 31
4.1 Was ist VRML? 31
4.2 VRML – Grundlagen 32

4.2.1 Beschreibung der wichtigsten Knotenarten 34
4.2.2 Wiederverwendbarkeit und Prototyping 37
4.2.3 Sensoren, Interpolatoren und Ereignisse 38
4.2.4 Skript-Knoten 40
4.3 Das VRML-Kranmodell 40

4.3.1 Aufbau des VRML-Modells 41
4.3.2 Vergleich des VRML-Modells mit dem realen Modell 42
4.4 Die Virtual Reality Toolbox 45
4.5 Implementierung mit VR-Toolbox 47

4.5.1 Funktionsbeschreibung der Simulink-Blöcke 47
4.5.2 Software-Voraussetzungen zur Animation 51
4.5.3 Bedienungsanleitung 51
5 KRANREGELUNG UND BAHNINTERPOLATION 52

5.1 PID-Regler 52
5.1.1 Grundlagen und Entwurf 52
5.1.2 Simulationsergebnisse 54
5.2 Zustandsreglerentwurf durch Polvorgabe nach Ackermann 55

5.2.1 Grundlagen 55
5.2.2 Reglerentwurf 56
5.3 Riccati-Regler (LQ-Zustandsregler) 58

5.3.1 Grundlagen 58
5.3.2 Entwurf 59
5.4 Feedforward-Regler 61
5.4.1 Grundlagen 61
5.4.2 Entwurf 61
5.5 Automatische Bahninterpolation (On-line Generator) 63

5.5.1 Planer 64
5.5.2 Parser 65
5.5.3 Implementierung On-line Generator 69
6 ZUSAMMENFASSUNG 75
7 LITERATURVERZEICHNIS 76
ANHANG: SOFTWARE UND INSTALLATIONSHINWEISE 77

1 Einleitung
Grundlage dieser Diplomarbeit ist die Aufgabenbeschreibung laut Dokument „Ausgabe der
Diplomarbeit“ vom 16.01.2002 mit dem Titel:
„Einsatz von Matlab-Werkzeugen für einen on-line Praktikumsversuch zur

Kranregelung“
Diese Arbeit verfolgt das Ziel dem Elektrotechnik-Studenten die Anwendung

regelungstechnischen Verfahren mittels einer rein virtuellen Versuchs-u. Arbeitsumgebung zu
erleichtern und vorzustellen. Das Kransystem besteht aus einem XY-Tisch mit Laufkatze und
Pendel. Die Regelung soll möglichst dynamisch sein und ein Überschwingen der Last an der
Endposition verhindern. Es wird hierzu ein mathematisches Modell der zu regelnden
Krananlage und eine virtuelle Umgebung zur Darstellung, Analyse, Modellierung und
Simulation des Kransystems erstellt. Die Anwendung wurde mittels des Programmpaketes
MATLAB / SIMULINK erzeugt. Das virtuelle 3D-Modell der Krananlage wurde in VRML
erstellt und mit Hilfe der Virtual Reality Toolbox , einer Erweiterung von Simulink,
animiert.
Schwerpunkt dieser Arbeit sind der Entwurf eines grafischen Benutzer-Interfaces, die
Programmierung regelungstechnischer Anwendungen, die über dieses GUI gestartet werden
können, sowie die Erstellung einer virtuellen Arbeitsumgebung .
Die erforderlichen Anwendungen, die über das GUI implementiert werden sollen, sind:
• Variation der Parameter-Einstellungen für die Regelstrecke und deren Linearisierung,

Simulation des Systemes (Strecke) im Zeitbereich mit der VR-Toolbox
• Darstellung und Umrechnung verschiedener Darstellungsformen für das System
(Übertragungsfunktion, Pol-Nullstellen-Diagramm, Zustandsraumbeschreibung) sowie der
grafischen Analyse (BODE-Plot, NYQUIST-Plot)
• Darstellung des Systems auch in diskreter Form mit verschiedenen Methoden ZOH (Zero
Order Hold), FOH (First Order Hold)
• Vereinfachter Reglerentwurf über das GUI (PID-Regler, Zustandsregler); Visualisierung
des geregelten Systems mit der VR-Toolbox
• Automatische Bahninterpolation für Fahrten des Krans
2. Das System 'Kran mit Pendel'

Das System besteht aus einer Laufkatze (linear verfahrbarer Portalwagen) mit angehängter
Last (s. Abb. 2.1). Die Last stellt ein Gewicht am Ende eines starren freischwingenden
Metallstabes dar. Der Portalwagen wird über ein Getriebe von einem Gleichstrommotor
angetrieben. Der Motor stellt einen Drehmomentgenerator dar, da er über einen Stromregler
angesteuert wird, d.h. die Eingangsspannung des Stromreglers ist proportional zum erzeugten
Motordrehmoment. Die Positon der Laufkatze und die Pendelauslenkung wird über
Inkrementalgeber gemessen. Die Blockstruktur ist in Abbildung 2.2 zu erkennen. Die
Kopplung der senkrecht zueinander stehenden Kran-Achsen ist vernachlässigbar, folglich
werden die Regler für jede Achse getrennt entworfen.
Abbildung 2.1: Laufkatze mit Pendel
Ziel der Regelung ist es, die Last in möglichst kurzer Zeit ohne Überschwingen des Pendels in
die Endposition zu transportieren.
Abbildung 2.2: Blockstruktur des geregelten Systems

2.1 Mathematisches Systemmodell
In diesen Abschnitten erfolgt die Herleitung des mathematischen Modells der Kran-x-Achse
(nichtlineares gekoppeltes Differentialgleichungsystem). Hierzu wird das System in seine
zwei Teilsysteme 'Kranwagen' und 'Pendel' zerlegt, d.h. freigeschnitten (s. Abb. 2.3). Die
horizontal und vertikal wirkenden Kräfte (rote Vektoren) und die durch die Freischneidung
entstehenden Kräfte V und H sind in untenstehender Grafik eingezeichnet.
Abbildung 2.3: Freikörperdiagramm von Kranwagen und Pendel
• Systemzustandsgrößen
ϕ(t) Pendelauslenkung von der Ruhestellung [rad] (im Uhrzeigersinn positiv)

r(t) Kranwagenposition in [m]
• Systemeingangsgröße
F(t) Kraft auf Kranwagen [N]
• Systemparameter und Definitionen
M = M0 + M1 (2.1)
Θ = Θs + M1 ls2 (Satz von Steiner) (2.2)
Θ Massenträgheitsm. des Pendels bei Drehung um Aufhängungspunkt [kg m2]

Θs Massenträgheitsmoment im Bezug auf Schwerpunkt des Pendels [kg m2]
Cr Reibungskonstante des Pendels [kg m2/s]
Fr Reibungskonstante des Kranwagens [kg/s]
M Gesamtmasse Kranwagen und Pendel [kg]
M0 Masse des Kranwagens [kg]
M1 Masse des Pendels [kg]
ls Abstand Pendelaufhängung-Pendelschwerpunkt [m]
g Gravitationskonstante [m/s2]
• Differentialgleichungen des Pendel
Horizontal und vertikal wirkende Kräfte am Aufhängungspunkt des Pendles

(Beschleunigung des Massenschwerpunktes):
∂2
H = M 1 2 [r (t ) + l s ⋅ sin( ϕ (t )) ] (2.3)
∂t
∂2
V = −M 1 [l s ⋅ cos(ϕ (t ))] + M 1 g (2.4)
∂t 2
Aus dem Drehimpulssatz folgt:
&(t ) = −V ⋅ l s ⋅ sin(ϕ (t )) − H ⋅ l s ⋅ cos(ϕ (t )) − C r ⋅ ϕ&(t )

Θ s ⋅ ϕ& (2.5)
• Differentialgleichung des Kranwagens (2. Axiom von Newton)
M 0&(t ) = F (t ) − H − Fr r&(t )
r& (2.6)
• Das mathematische Model des Systems 'Kran mit Pendel'
Einsetzen von Gleichungen (2.3) und (2.4) in Gleichungen (2.5) und (2.6) unter
Verwendung von (2.1) u. (2.2) ergibt folgende nichtlineare Differentialgleichungen:
&(t ) + C r ⋅ ϕ&(t ) + M 1 ⋅ l s ⋅ g ⋅ sin(ϕ (t )) − M 1 ⋅ l s ⋅ &

Θ ⋅ ϕ& (t ) ⋅ cos(ϕ (t )) = 0
r& (2.7)
M ⋅ r&
& [
(t ) + Fr ⋅ r&(t ) − M 1 ⋅ l s ⋅ ϕ& ]
&(t ) ⋅ cos(ϕ (t )) − (ϕ&(t )) 2 ⋅ sin(ϕ (t ) = F (t ) (2.8)
Gleichungen (2.7) und (2.8) beschreiben das mathematische Systemmodell in Form eines
nichtlinearen gekoppelten Differentialgleichungssystems.
2.2 Zustandsraumbeschreibung des linearisierten Modells
Für den klassischen Reglerentwurf ist ein nichtlineares Differentialgleichungsystem

ungeeignet, also wird das System um einen passenden Arbeitspunkt linearisiert. Als erstes
wird der Zustandsvektor eingeführt:
 r (t )   x1 
ϕ (t )  x 
 =  2 (2.9) und als Eingangssignal u=F(t) (2.10)
x=
 r&(t )   x3 
   
ϕ&(t )  x 4 
Gleichungen (2.7), (2.8) in die Form
x&= f (x, u) (2.11)
transformieren und im zweiten Schritt Gleichung (2.11) um den Arbeitspunkt

 x1 = rA 
x = 0
(2.12)
xA =  2 
 x3 = 0 
 
 x4 = 0 
linearisieren. Die Linearsierung erfolgt also um die untere Pendelstellung ϕ=0 rad bei
beliebiger Position des Kranwagens. Die Abweichung des linearisierten Systems vom realen
Modell ist nur für kleine Pendelauschläge (sinϕ ≈ ϕ) vernachlässigbar!
Als Ergebnis der Linearisierung erhält man die lineare Zustandsraumbeschreibung:
x&(t ) = A ⋅ x(t ) + b ⋅ u (t ) (2.13)

y (t ) = C ⋅ x(t ) + d ⋅ u (t )
mit der Systemmatrix A und dem Eingangsvektor b. Wenn der Zustandsvektor als Ausgang
gewünscht wird, ist die Ausgangsmatrix C eine Einheitsmatrix. Es handelt sich um konstante,
d.h. zeitinvariante Matrizen.
0 0 1 0   0 
0 0 0 1   0 
  Θ 
− N 2g − ΘFr − Cr N 
A = 0 b= 2
 N1
2
N1
2
N1 
2
 N1 
 − MNg − Fr N − Cr M   N 
0 2 2 2
  2
 N1 N1 N 1   N 1 
mit N = M1ls und N12 = Θ M - N2
1 0 0 0 0 
0 1 0 0 0 
C= d= 
0 0 1 0 0 
   
0 0 0 1 0 
Das lineare zeitinvariante System ermöglicht nun die Anwendung der üblichen
Reglerentwurfs-Techniken (und auch Beobachterentwurf falls zur Regelung nur ein Teil des
Zustandsvektors zur Verfügung steht).
2.3 Übertragungsfunktionen des linearen Modells
Die Übertragungsfunktionen des linearen Modells werden für den PID-Reglerentwurf

benötigt.
Das reale System verhält sich bei kleinen Pendelausschlägen nahezu linear. Es gilt also
cos(ϕ(t)) ≈ 1 und sin(ϕ(t)) ≈ ϕ .
Wenn man zusätzlich noch die Beeinflußung der Laufkatze durch die kleine Pendelmasse
vernachlässigt, vereinfachen sich Gleichung (2.7) und (2.8) zu:
&(t ) + C r ⋅ ϕ&(t ) + M 1 ⋅ l s ⋅ g ⋅ ϕ (t ) − M 1 ⋅ l s ⋅ &

Θ ⋅ ϕ& (t ) = 0
r& (2.14)
M ⋅& (t ) + Fr ⋅ r&(t ) = F (t )
r& (2.15)
Dies gilt natürlich nur solange das Massenverhältnis der Laufkatze zum Pendel viel größer als
1 und die Pendellagerreibung sehr klein ist. Für das Laborsystem gilt beispielsweise folgendes
Massenverhältnis: M1/M0 = 7/0.06. Die Vereinfachung ist also absolut zulässig.
Die Systemdynamiken von Gleichstrommotor, Leistungselektronik und Getriebe sind

bedeutend schneller als die Dynamik des Portalkranes und können als konstant angesehen
werden. Daraus folgt (s. Abb. 2.2):
i/ g
F (t ) = K S ⋅ CU ⋅ ⋅ u (t ) = K ⋅ u (t ) (2.16)
rg
u(t) Eingangsspannung des Umwandlers [V]

Ks Verstärkung des Umwandlers [A/V]
Cu elektromagnetische Konstante des Gleichstrommotors [Vs]
ig/rg Getriebeübersetzung
Um die Zustandsmatizen an die neue Eingröße Spannung u(t) anzupassen, muß nur der b-
Vektor mit K (s. Gl. 2.16) multipliziert werden.Gleichung (2.16) in (2.15) eingesetzt und
laplacetransformiert, ergibt die Übertragungsfunktion der Wagenposition:
R( s) K Kw
= = (2.17)
U ( s ) s ( M ⋅ s + Fr ) s (Tw ⋅ s + 1)
Die Gesamtverstärkung beträgt also Kw=KsCuig/(rgFr) und die Wagenzeitkonstante

Tw=(M0+M1)/Fr.
Aus Gleichung (2.14) läßt sich die Übertragungsfunktion der Pendelauslenkung in

Abhängigkeit der Wagenposition ableiten:
Φ(s) M 1 ⋅ ls ⋅ s 2 K p ⋅ s2
= = (2.18)
R( s) Θ ⋅ s 2 + C r ⋅ s + M 1 ⋅ l s ⋅ g 1
s2 + s+ Kp ⋅g
Tp
Mit Verstärkung Kp = M1 ls /Θ und Zeitkonstante Tp= Θ /Cr.
Übertragungsfunktion (2.17) mit (2.18) multipliziert ergibt die Übertragungsfunktion der

Pendelauslenkung in Abhängigkeit der Spannung:
K p ⋅ Kw
⋅ s2
Φ(s) Tw (2.19)
=
U (s)  2 1   1 
s + s + K p ⋅ g  ⋅  s +  ⋅ s
 Tp  Tw 
  
K p ⋅ Kw
⋅ s2
Tw
=
 1 1   1 
s 4 +  +  ⋅ s3 +  + K p ⋅ g  ⋅ s2 + K p ⋅ g ⋅ s
T   T ⋅T 
 p Tw   p w 
3 Programmdokumentation
3.1 Allgemeine Programminformation
Die Anwendung wurde mittels des Programmpaketes MATLAB / SIMULINK erstellt. Die
Programmgrundstruktur und die GUI-Ressourcen wurden mittels Matlabs GUIDE, eines
GUI-Entwicklungstools, implementiert. Das virtuelle 3D-Modell der Krananlage wurde in
VRML modelliert und mittels der Virtual Reality Toolbox , einer Erweiterung von Simulink,
animiert.
Auflistung der Funktionen der Anwendung:
• Systemparameter: Variation der Parameter-Einstellungen für die Regelstrecke

• Systemlinearisierung: Linearisierung der Strecke
• Systemdarstellung: numerische Darstellung und Umrechnung verschiedener
Darstellungsformen für das System (Übertragungsfunktion, Pol-Nullstellen-Diagramm,
Zustandsraumbeschreibung). Darstellung des Systems auch in diskreter Form mit
verschiedenen Methoden ZOH (Zero Order Hold), FOH (First Order Hold)
• Grafische Systemanalyse: BODE-Plot, NYQUIST-Plot, Wurzelortskurve,
Sprung- u. Impulsantwort
• Reglerentwurf: Entwurf verschiedener Reglertypen:
PID-Regler, Zustandsreglerentwurf mittles Polvorgabe und Optimierung eines
quadratischen Gütemaßes (LQ-Regler)
• Simulation: Visualisierung des geregelten Systems mit der VR-Toolbox:
Simulation der offenen und geschlossenen Strecke
• Automatische Bahninterpolation für Fahrten des Krans
Die beiden folgenden Kapitel behandeln die Anwendung. In Kapitel 3.2 wird die technische
Implementierung, d.h Programmstruktur, der Anwendung vorgestellt. In Kapitel 3.3 stehen
die Funktionen der Anwendung 'Kranregelung' selbst im Vordergrund.
3.2 GUI-Implementierung [8]
Die Entwicklung einer Grafischen Benutzeroberfläche (GUI) wird durch MATLAB's Tool
GUIDE (graphical user interface development environment) vereinfacht und beschleunigt.
Der GUI-Implementierungsprozeß besteht aus zwei wesentlichen Aufgaben:

• Layout der GUI-Komponenten (Uicontrols z.B. Buttons, Texte, Bilder, ...)
• Programmierung der GUI-Komponenten (dem jeweiligen Ereignis eine Aktion zuweisen)
GUIDE ist hauptsächlich eine Sammlung von Layout-Tools. Jedoch generiert GUIDE auch
ein M-file, das den Initialisierungscode enthält. Dieses M-file (s. Abb. 3.2) stellt ein Gerüst
für die Implementierung der callbacks (die Funktion, die ausgeführt wird, wenn eine GUI-
Komponente aktiviert wird) zur Verfügung.
GUI-Implementierung:
Matlab ermöglicht zwar die GUI-Erstellung per Hand; es ist aber bedeutend einfacher die
GUI-Komponenten interaktiv mit GUIDE zu erstellen und die Dateien zu erzeugen, die dieses
GUI sichern und starten:
• FIG-file – enthält die komplette Beschreibung des GUI und seiner children (Uicontrols),
als auch aller Objekteigenschaften.
• M-file – enthält die Funktionen zum Starten und Kontrollieren des GUI und die callbacks,
die als Subfunktionen definiert sind.
Das M-file enthält nicht den Code, der die GUI-Komponenten definiert; diese Information ist
im FIG-file, d.h. gespeichert..
Das folgende Diagramm verdeutlicht die Zusammenhänge:
Abbildung 3.1: Zusammenhang GUI figure und Code/Resource-file
3.2.1 Programmaufbau
MATLAB generiert ein Programmgerüst und eine Datenstrukur (handles) zur GUI-Steuerung,
d.h. es müssen 'nur noch' die callback-Routinen der GUI-Komponenten programmiert
werden. Dieses Programmgerüst unterstützt eine robuste und effiziente Programmierung, z.B.
wird die handles-Datenstruktur automatisch jeder Funktion übergeben. Der vollständige Code
inklusive der callbacks ist im M-file der Anwendung enthalten.
• Programmablaufplan des Anwendungs-M-Files (s.Abb 3.2)
Das M-file ohne Argumente aufgerufen, startet das GUI; wird es hingegen mit dem
Namen einer Subfunktion als erstes Argument aufgerufen, wird die entsprechende
Subfunktion ausgeführt (z.B. eine callback-Routine eines GUI-Objektes).
Abbildung 3.2: Programmablaufplan des Anwendungs-M-Files
• GUI-Initialisierung
Der Initialisierungsteil des M-files enthält einige nützliche Techniken zur GUI-
Handhabung:
• öffnet das FIG-file (enthält GUI-Objekte)
• prüft ob GUI bereits geöffnet
• positioniert das GUI auf dem Bildschirm unabhängig von der Auflösung
• erzeugt automatisch eine handles-Datenstruktur der GUI-Komponeten (ermöglicht
den Zugriff auf die GUI-Objekte)
Der folgende Code ist der Initialisierungsteil des Anwendungs-M-files. Dieser Code wird
durch GUIDE erzeugt.
function varargout = Kranregelung(varargin)

if nargin == 0 % If no input arguments, launch the GUI
fig = openfig(mfilename,'reuse');
% Use system color scheme for figure:
set(fig,'Color',get(0,'defaultUicontrolBackgroundColor'));
% Generate a structure of handles to pass to callbacks, and store it.
handles = guihandles(fig);
guidata(fig, handles);
% ------------------------------------------
% Add any necessary initialization code here
% -------------------------------------------
if nargout > 0
varargout{1} = fig;
end
elseif ischar(varargin{1}) % INVOKE NAMED SUBFUNCTION OR CALLBACK

try
if (nargout)
[varargout{1:nargout}] = feval(varargin{:});
else
feval(varargin{:}); % FEVAL switchyard
end
catch
disp(lasterr);
end
end
• GUI-Theorie
Jedes grafische Objekt eines GUI hat eineListe von Objekteigenschaften (property), die
das Objektverhalten definieren. So können für die meisten grafischen Objekte
verschiedene Typen von callbacks definiert werden, die festlegen wie auf ein bestimmtes
Userverhalten reagiert wird. Die Erstellung intuitiver interaktiver grafischer
Anwendungen wird durch Verwendung der callbacks bedeutend vereinfacht.
• Auflistung von callback-Typen:
Callback: Callback-Routine wird ausgeführt, wenn sich Maus über GUI-

Objekt befindet und die linke Maustaste gedrückt wird. Dieser
callback-Typ wird fast ausschließlich in dieser Anwendung
benutzt und hat z.B. folgende Syntax:
Kranregelung('BodePlot_Callback',gcbo,[],guidata(gcbo))
Das GUI-Objekt 'pushbutton_BodePlot' hat als ButtonDownFcn

den String 'Kranregelung ('BodePlot_Callback',gcbo
,[],guidata(gcbo))' zugewiesen bekommen. Bei Aktivierung
der Objekteigenschaft wird dieser String ausgeführt, d.h.das
Anwendungs-M-file und die entsprechende callback-Routine
werden ausgeführt.
DeleteFcn: Funktion wird vor dem Löschen des Objekts ausgeführt. Wird
z.B. beim Schließen eines Fenster oder der ganzen Anwendung
benutzt um noch die Anwenderdaten zu retten!
CreateFcn: Funktion wird beim Erzeugen des Objekts ausgeführt –

kann zur Initialisierung verwendet werden.
KeyPressFcn: Funktion wird beim Drücken einer Taste (Tastatur) aufgerufen.
weitere callbacks: ResizeFcn, ButtonDownFcn, WindowButtonMotionFcn, ...
• Managen der GUI-Daten mit der handles-Datenstruktur
GUIDE stellt einen Mechanismus zum Speichern und Laden globaler Daten zur
Verfügung, indem sie die gleiche Datenstruktur benutzt. Dieser handles-Struct enthält alle
Zeiger auf benannte GUI-Komponenten. Dieser Datenstruktur können die Anwenderdaten
hinzugefügt und somit automatisch jeder Funktion, die durch einen callback aufgerufen
wird, übergeben werden.
Das folgende Code steht im Initialisierungsteil des M-files und verdeutlicht diese
Technik:
...
fig = openfig(mfilename,'reuse'); % Öffnet GUI falls nicht schon geöffnet
handles = guihandles(fig); % Erzeugt handles-Datenstruktur der GUI-
Komponenten
handles.System.Cr = 0.00035 % Fügt die globalen Anwenderdaten hinzu
...
guidata(fig,handles); % Sichert die aktualisierte Datenstruktur
...
Jede callback-Routine hat Zugriff auf die aktualisierte handles-Datenstruktur

Hier z.B. wird durch Mausklick auf den Button 'Systemparameter' die zugeordnete
callback-Routine aufgerufen und handles-Datenstruktur übergeben.
function varargout = Systemparameter_Callback(h, eventdata, handles, varargin)
...
[A,B,C,D] = Linearisierung(handles.System.Cr,...,handles.System.g);
sys=SS(A,B,C,D);
handles.System.Cont=sys; % fügt der handles-Struktur weitere
Anwenderdaten hinzu
guidata(fig,handles); % Sichert die aktualisierte Struktur
...
return
3.2.2 Dateiorganisation
a) Programmdateien
Kranregelung.M Anwendungs-M-file (enthält den Code)

Kranregelung.FIG Anwendungs-FIG-file (enthält die GUI-Ressourcen)
b) vom Programm erzeugte Dateien und Datenstrukturen
Kranparameter.MAT Sicherungsdatei der Anwenderdaten; wird bei Programmstart

geladen und beim Beenden gesichert.
Falls noch nicht vorhanden, wird diese Datei generiert
handles-Datenstruktur enthält wärend der Laufzeit des Programmes, die
Anwenderdaten und die Zeiger (handles) auf die GUI-
Komponenten
• Organisation der handles-Datenstruktur (Auswahl)
handles =
figure1: 99.0002 % pointer auf das GUI-Window
pushbutton_laden: 137.0002 % pointer auf pushbutton 'Laden'
menu_Beenden: 121.0002 % pointer auf Menü 'Beenden'
menu_Hilfe: 120.0002 % usw...
...
System: [1x1 struct] % Anwenderdaten
• vollständige Struktur der Anwenderdaten
handles.System =
Cr: 0.00035 % Reibungskonstante des Pendels in [kgm^2/s]
Fr: 36.5000 % Reibungskonstante des Wagens in [kg/s]
M0: 7 % Masse des Wagens in [kg]

M1: 0.0610 % Masse des Pendels in [kg]
ls: 0.2200 % Länge des Massenschwerpunktes des Pendels in [m]
O: 0.0039 % Trägheitsm. des Pendels bezüglich Schwerpunkt in [kgm^2]
g: 9.8100 % Gravitationskonstante in [m/s^2]
Ts: 0.0100 % Abtastintervall in [s]
Cont: [4x1 ss] % Zeitkont. lin. Zustandsraummodell der Kran-X-Achse
DigZOH: [4x1 ss] % Zeitdiskretes lin. Modell der X-Achse (Zero Order Hold)
DigFOH: [4x1 ss] % Zeitkont. lin. Modell der X-Achse (First Order Hold)
fmin = 0.1; % Frequenzbereich [Hz]
fmax = 10;
tmin = 0 % Zeitbereich [s]
tmax = 10;
M = 12; % Masse der gesamten x-Achse [kg]
Fry = 27.46; % Reibungskoef. der y-Achse
Ks = 1.7; % Umwandler [A/V]
Cu = 0.057; % Motorkonstante [Vs]
ig = 100/21; % Übersetzungsverhältnis [1/m]
rg = 0.019719; % Längenkonstante [m]
ContY: [2x1 ss] % Zeitkont. lin. Zustandsraummodell des Kranes-Y-Achse
Polvorgabe=[...];% Regler-Parameter
Zustandsregler=[...];
PID_Regler=[...];
LQ_Regler=[...]
Die Anwenderdaten werden dem handles-Strukt bei Bedarf hinzugefügt und stehen
somit jeder weiteren Funktion zur Verfügung. Es besteht also keine Notwendigkeit,
einzelne Parameter explizit anzugeben. Es kann z.B. auf die Daten des
zeitkontinuierlichen linearisierten Kranmodells mit handles.System.Cont oder auf die
Systemmatrix mit handles.System.Cont.a zugegriffen werden.
handles.System.Cont =
a =
x1 x2 x3 x4
x1 0 0 1 0
x2 0 0 0 1
x3 0 -0.06374 -5.136 -0.0001695
x4 0 -33.54 -17.67 -0.08916
b =
F(t)
x1 0
x2 0
x3 0.1407
x4 0.4842
c =
x1 x2 x3 x4
r(t) 1 0 0 0
phi(t) 0 1 0 0
d/dt(r(t)) 0 0 1 0
d/dt(phi(t)) 0 0 0 1
d =
F(t)
r(t) 0
phi(t) 0
d/dt(r(t)) 0
d/dt(phi(t)) 0
Continuous-time model.
c) Simulink-Modelle
KranZustandsreglerVR.MDL enthält System Kran mit Zustandsregler und VRML-

Model. Ist Startpunkt zur Simulation mit VR-Toolbox
KranPIDreglerVR.MDL enthält System Kran mit PID-Regler und VRML-Modell
KranSteuerungVR.MDL enthält offene Kranstrecke und VRML-Modell
OnlineGenerator.MDL Zero Order Error Tracking Controller mit online
erzeugter Trajektorie
Planer.M Interaktive Trajektoriedefinition (wird im
OnlineGenerator verwendet)
Parser.M On-line Trajektoriegeneration
d) VRML-Modelle
Kranstrecke.WRL Interaktion mit Kranstrecke (offen) mittels virtuellen Joysticks

KranVR.WRL VR-Modell der Krananlage mit Berührungssensor
Wird Sensor aktiviert (Mauszeiger auf Sensorfläche) wird neuer
Sollwert generiert und an Matlab übergeben.
3.2.3 Funktionen und Callback-Routinen
Es werden nur einige wesentliche Funktionen und nur ein paar exemplarische callback-
Routinen vorgestellt, da der Programmablauf der Funktionen sich sehr gleicht.
a) Funktion 'Linearsierung'
function sys = Linearisierung(handles)
%--------------------------------------------------------------------
% Linearisierung der nichtlin. Diffgl. des Kranes um den Arbeitspunkt
% phi...Winkel (pos. im Uhrzeigersinn)
% r...Position
% Eingabe: Systemparameter des Kranes, Naturkonstanten
% Ausgabe: Zustandsraumdarstellung des linear. Kranmodells
%--------------------------------------------------------------------
if (nargin~=1)
Cr=0.00035;Fr=36.5;M0=7;M1=0.061;
ls=0.22;O=0.0039;g=9.81;...
end
% Anwenderdaten des handles-Strukt auslesen
...
% Gesamtmasse von Wagen und Pendel

M=M0+M1;
N=M1*ls;
N012=O*M+N^2;
% Koeffizienten der lin. Systemmatrix des Kranes

a32=-N^2*g/N012;
a33=-O*Fr/N012;
a34=-N*Cr/N012;
a42=-M*N*g/N012;
a43=-N*Fr/N012;
a44=-Cr*M/N012;
% Koeff. der lin. Eingangsvektors b

b3=O/N012*Kw;
b4=N/N012*Kw;
% Systemmatrizen A,B,C,D wenn Zustandsvektor x=[r phi dr/dt d(phi)/dt]'

A=[0 0 1 0;
0 0 0 1;
0 a32 a33 a34;
0 a42 a43 a44];
B=[0;
0;
b3;
b4];
% d.h. Zustandsvektor ist Ausgang
C=[1 0 0 0;
0 1 0 0;
0 0 1 0;
0 0 0 1];
D=[0;
0;
0;
0];
% Matlab-Statespace-System erzeugen
sys=SS(A,B,C,D);
...
return
b) Funktion 'Polplazierung'
function [K] = Poleplacement(A,B)
%------------------------------------------------------
% Zustandsreglerdesign mit Full-State-Feedback für Kran
% Entwurf mittels Polvorgabe (Poleplacement)
% Eingabe (Systemmatrixen A,B)
% Ausgabe (Konstante Reglermatrix K)
%------------------------------------------------------
prompt={'1. Pol des geschlossenen Regelkreises','2. Pol','3. Pol','4. Pol'};

def={'-5','-5.05','-5.1+i*1','-5.1-i*1'};
dlgTitle='Wählen Sie die 4 Pole des geschlossenen Regelkreises:';
fehlereingabe=1;
% Hilfe ausgeben
uiwait(msgbox('Die Pole sollten alle in der linken Halbebene liegen, sonst ist
System instabil. Bei komplexen Polen, darauf achten, auch den konjugiert
komplexen Pol mit anzugeben. Kein mehrfachen Pole
verwenden!','Achtung','modal'));
while fehlereingabe
%((str2num(answer{1,1})>=0)|(str2num(answer{2,1})>=0)|(str2num(answer{3,1})>=0)|
(str2num(answer{4,1})>=0)),
answer=inputdlg(prompt,dlgTitle,1,def);
% Komma durch Punkt ersetzen
answer=strrep(answer,',','.');
if and(iscell(answer), ~isempty(answer))
fehlereingabe=0;
else
%Fehlermeldung ausgeben, je nach Fehler
fehlereingabe=1;
end
end
Pol1 = str2num(answer{1,1});
P=[Pol1 Pol2 Pol3 Pol4];
K=place(A,B,P);
return
c) callback-Routine 'BodePlot'
Jedes grafische Objekt eines GUI hat eineListe von Objekteigenschaften (property), die
das Objektverhalten definieren. So hat jedes Objekt callbacks, die festlegen wie auf ein
bestimmtes Userverhalten reagiert wird. Die Erstellung intuitiver interaktiver grafischer
Anwendungen wird durch Verwendung der callbacks bedeutend vereinfacht.
• Auflistung von callback-Typen:
Callback: Callback-Routine wird ausgeführt, wenn sich Maus über GUI-

Objekt befindet und die linke Maustaste gedrückt wird. Dieser
callback-Typ wird fast ausschließlich in dieser Anwendung
benutzt und hat z.B. folgende Syntax:
Kranregelung('BodePlot_Callback',gcbo,[],guidata(gcbo))
Das GUI-Objekt 'pushbutton_BodePlot' hat als ButtonDownFcn

den String 'Kranregelung ('BodePlot_Callback',gcbo
,[],guidata(gcbo))' zugewiesen bekommen. Bei Aktivierung
der Objekteigenschaft wird dieser String ausgeführt, d.h.das
Anwendungs-M-file und die entsprechende callback-Routine
werden ausgeführt.
DeleteFcn: Callback-Routine wird vor dem Löschen des Objekts

ausgeführt. Wird z.B. beim Schließen eines Fenster oder der
ganzen Anwendung benutzt um noch die Anwenderdaten zu
retten!
CreateFcn: Callback-Routine wird beim Erzeugen des Objekts ausgeführt –

kann zur Initialisierung verwendet werden.
KeyPressFcn: Callback-Routine wird beim Drücken einer Taste (Tastatur)

aufgerufen.
weitere callbacks: ResizeFcn, ButtonDownFcn, WindowButtonMotionFcn, ...
• Typischer Aufbau einer callback-Routine:
1. nicht benötigte Uicontrols (axes(Grafen), pushbuttons, images usw..) löschen

2. gewünschte Uicontrols, z.B. Bode-Plot (axes-Objekt) berechnen und anzeigen
3. fertig – warte auf nächsten Userinput
Fogende callback-Routine steht exemplarisch für fast alle callbacks die im Anwendungs-
M-file durch aktivierte GUI-Objekte (Uicontrols; Uimenu, ...) ausgelöst werden:
function varargout = BodePlot_Callback(h, eventdata, handles, varargin)
%----------------------------------------------------------
% BodePlot_Callback wird durck pushbutton 'Bodeplot' ausgelöst
% Die handles-Datenstruktur wird übergeben und somit ist ein
% Zugriff auf die GUI-Objekte und Anwenderdaten möglich
%----------------------------------------------------------
% alle Axes (Grafen) ausblenden

clear_axes(handles);
% Bode-Plot einblenden
axes('Position',[0.1, 0.15, 0.6, 0.8]);
Cont=handles.System.Cont;
DigZOH=handles.System.DigZOH;
DigFOH=handles.System.DigFOH;
bode(Cont,DigZOH,DigFOH);
% Bedienfeld anpassen (Hauptmenü ausblenden - Pushbuttons einblenden)

hide_buttons(handles);
% show buttons
set(handles.text1,'String','Bodeplot');
set(handles.pushbutton_Hauptmenu,'visible','on');
return
3.3 Anwendung Kranregelung
Nach Eingabe des Befehls Kranregelung am Matlab-Prompt öffnet sich das Hauptfenster (s.
Abb. 3.3) mit dem Haupt-Menü der Anwendung. Von hier kann über die Menüleiste oder das
Bedienfeld in die Untermenüs verzweigt werden. Es wird in jedem Fenster eine
kontextabhängige Hilfe angeboten. Es kann aus jedem Untermenü zurück ins Hauptfenster
gesprungen oder das Programm beendet werden. Die System- bzw. Anwenderdaten werden
bei Programmende automatisch in der Datei 'Kranparameter.MAT' gesichert. Falls diese Datei
nicht vorhanden ist, wird sie aus Defaultwerten generiert.
Abbildung 3.3: Haupt- bzw. Startfenster mit Hauptmenü
3.3.1 Systemparameter
Im Untermenü 'Systemparameter' können die Variablen der Kranstrecke eingegeben, geladen

und gesichert werden. Bei der Datensicherung werden alle Systemdaten gesichert inklusive
der Krandaten, d.h. auch evtl. entworfene Reglerparameter usw. werden gesichert und können
bei Bedarf wiederhergestellt werden. Eingabemaske siehe Abb. 3.4.
Abbildung 3.4: Systemparameter-Eingabemaske
3.3.2 Systemlinearisierung
In diesen Untermenü wird die Linearisierung der Krananlage (s. Abb. 3.5) stufenweise
bildlich dargestellt. Es wurde eine Slideshow implementiert, in der der Linearisierungprozeß
vom realen System bis hin zu den linearen Systemmatrizen verdeutlicht wird. Durch
vor/zurück-Buttons erreicht man jeweils das nächste bzw. vorherige Bild. Im Startbild kann
durch Mausklick auf die Systemblöcke eine Zusatzinformation abgerufen werden.
Die Slideshow ist wie folgt aufgebaut.
1. Blockstruktur
2. Systemvariablen
3. Zerlegung in zwei Untersysteme: Portalwagen und Pendel
4. Aufstellen der nichtlinearen Systemgleichungen von Wagen und Pendel
5. Zustandsraumbeschreibung nach Linearisierung um Arbeitspunkt
6. Systemmatrizen
Abbildung 3.5: Systemlinearisierung
3.3.3 Systemdarstellung
Hier hat der Anwender die Möglichkeit das linearisierte System im Zustandsraum, als
Übertragungsfunktion oder als faktorisierte Übertagungsfunktion (Pole und Nullstellen)
darzu-
Abbildung 3.6: Systemdarstellung
stellen. Zusätzlich besteht die Wahl zwischen der zeitkontinuierlichen und zwei zeitdiskreten
Darstellungen. Das Kransystem kann durch Eingabe der Abtastfrequenz in [Hz] in die digitale
Form gebracht werden. Es stehen zwei Konvertierungsmethoden zur Verfügung:
ZOH (Zero Order Hold): Das Signal wird zwischen den Abtastwerten konstant gehalten
(Sample & Hold)
FOH (First Order Hold): Das Signal verläuft linear zwischen den Abtastwerten
3.3.4 Pole und Nullstellen
Im diesem Menü können die Pole und Nullstellen des Kransystemes dargestellt werden.
Abbildung 3.7: Pol / Nullstellen-Plot
Da es sich beim Kran um ein System 4. Ordnung handelt, es einen Eingang, die Spannung
U(t), und vier Ausgänge, d.h den Zustandsvektor x(t), besitzt, wird es in seine 4 Teilsysteme
zerlegt. Diese können über ein Optionsmenü ausgewählt werden. Durch Klick auf die rechte
Maustaste erhält man weitere Informationen. Klick auf die linke Maustaste öffnet ein
Optionsmenü (s. Abb. 3.8). Hier können z.B. Teilsysteme, Charakteristiken ausgewählt oder
Grafen gezoomt werden. Diese Möglichkeit besteht immer wenn Grafen dargestellt werden,
also z.B. auch bei 'Bodeplot', 'Impulsantwort' usw.
 r (t )  r(t)...Position des Kranwagens

ϕ (t ) phi(t)...Winkel des Pendels
x(t ) =   dr(t)/dt...Geschwindigkeit des Kranwagens
 r&(t ) 
  d(phi(t)/dt...Winkelgeschwindigkeit des Pendels
ϕ&(t )
Abbildung 3.8: Optionsmenü Abbildung 3.9:

Teilsystemauswahl
Mit Hilfe des I/O-Selectors (s. Abb. 3.9) können Teilsysteme des SIMO-Systems genauer
dargestellt werden. Wählen Sie z.B. das Feld r(t)-U(t), so wird nur die Pole und Nullstellen
zwischen dem Eingang U(t) und dem Ausgang r(t) dargestellt. Klick auf Feld [all] stellt alle
Diagramme gleichzeitig dar. Anmerkung: Bei nur einem Systemeingang haben natürlich alle
Teilsysteme den gleichen Nenner, d.h. die gleichen Pole.
3.3.5 Nyquist-Plot
Darstellung des Nyquistplots für alle vier Teilsysteme. Es gelten die Optionen des Maustasten
von Punkt 3.3.4.
Abbildung 3.10: Nyquist-Plot
Es kann hier noch der darzustellende Frequenzbereich, d.h. die Minimal- u. Maximalfrequenz
in [Hz] eingegeben werden.
3.3.6 Bode-Plot
Darstellung des Bode-Plots für alle vier Teilsysteme. Es gelten die Optionen des Maustasten
von Punkt 3.3.4.
Abbildung 3.11: Bode-Plot

Es kann auch hier noch der darzustellende Frequenzbereich, d.h. die Minimal- u.
Maximalfrequenz in [Hz] eingegeben werden.
3.3.7 Wurzelortskurve
Darstellung der Wurzelortskurven. Optionen des Maustasten siehe Punkt 3.3.4.
Abbildung 3.12: Wurzelortskurve
3.3.8 Sprungantwort und Impulsantwort

In diesen beiden Untermenüs kann jeweils der darzustellende Zeitbereich eingestellt werden.
Es gelten auch die Optionen der Maustasten (siehe Kapitel 3.3.4).
Abbildung 3.13: Sprungantwort des Systems
Abbildung 3.14: Impulsantwort
3.3.9 Reglerentwurf
Im Untermenü 'Reglerentwurf' kann zwischen drei Reglertypen gewählt werden:

• PID-Regler: Der Anwender gibt die PID-Reglerparameter in die Eingabefelder ein und es
wird automatisch die Sprungantwort des geregelten System dargestellt.
• Zustandsreglerentwurf mittels Polvorgabe nach Ackermann: Nach Eingabe der 4 Pole
wird der Reglervektor berechnet und die Sprungantwort des Regelkreises dargestellt.
• Zustandsreglerentwurf mittels Minimierung eines quadratischen Gütemaßes:
(Linear Quadratic Regulator): Nach Eingabe der Gewichtsmatrizen Q und S wird der LQ-
Regler automatisch berechnet und die Sprungantort des Regelkreises dargestellt.
Der Reglerentwurf kann iterativ durchgeführt werden, d.h. die Reglerparameter können
jederzeit geändert und das veränderte Systemverhalten sofort beurteilt werden.
Abbildung 3.15: Reglerentwurf
3.3.10 Simulation
Nach erfolgten Reglerentwurf kann das Systemverhalten überprüft werden. Im Untermenü

'Simulation' kann das geregelte als auch das offene System getestet und mit der Virtual
Reality Toolbox von MATLAB visualisiert werden. Es stehen 4 Simulink-Modelle zur
Verfügung:
Das Simulink-Modell 'Kran mit Zustandsregler', 'Kran mit PID-Regler', 'Kran mit LQ-Regler'
und 'Kransteuerung'.Sie erhalten den Positions-Sollwert (VR Source) vom VRML-Modell des
Kranes und geben den simulierten und transformierten Zustandsvektor an das Modell (VR
Sink) zurück. Das im Browser animierte VRML-Modell verhält wie das reale System. Der
Vorteil der Simulation für den Anwender (Student) ist die bessere Veranschaulichung der
Regelung.
Es wird ein Simulink-Modell exemplarisch vorgestellt:

Abbildung 3.16: Simulation: Simulink-Modell 'Kran mit Zustandsregler'
Um die Simulation zu starten, sollte folgende Vorgehensweise eingehalten werden:
• Im Simulink-Modell auf den VR Sink o. Source Block doppelklicken -> der

Blockparameter-Dialog erscheint.
• Auf den View button klicken -> die mit Simulink verbundene virtuelle Welt wird im Web-
Browser geöffnet.
• Im Simulink Simulationsmenü den Start-Button drücken -> Die Simulation läuft und wird
mittels der Simulink-Signale animiert.
• Es ist sinnvoll das Simulink-Fenster und das VRML-Modell nebeneinander darzustellen.
3.3.11 Bahninterpolation
Im Untermenü 'Bahninterpolation' wird das Simulink-Modell 'Online-Generator' geöffnet. Es
handelt sich hier um einen Feedforward-Regler (s. Abb. 3.17).
Abbildung 3.17: Kran mit Zero Tracking Error State Controller (Feed Forward Controller)
Druch Drücken des grünen 'Bahninterpolation starten'-Buttons wird eine kleine GUI gestartet
durch die eine Krantrajektorie analytisch, d.h sie steht als Funktion der Zeit zur Verfügung
und somit können die Ableitungen nahezu fehlerfrei berechnet werden, definiert wird. Die
genaue Kenntnis ist für ein exaktes Regelverhalten wichtig.
Der Funktionsblock 'Parser' erzeugt daraus zu jedem Zeitpunkt k∆t einen Positions-,
Geschwindigkeits- u. Beschleunigungswert. Der Feedforward-Regler kann nun mittels dieser
Werte die Trägheits- u. Reibungskräft im Voraus berechnen. Dadurch wird die Regeldifferenz
beträchtlich verkleinert und es müssen nur noch die Fehler 0. Ordnung ausgeregelt werden.
Der Positionsfehler läßt sich mittels dieses Reglers in der Größenordnung 10-4 m halten.
Um die Simulation zu starten, sollte folgende Vorgehensweise eingehalten werden:

• Auf den View button klicken -> die mit Simulink verbundene virtuelle Welt wird im Web-
Browser geöffnet.
4 VRML
4.1 Was ist VRML?
VRML (Virtual Reality Modelling Language) kann als eine Erweiterung der grafischen
Fähigkeiten von HTML (HyperText Markup Language) angesehen werden.
• Zweck:
VRML ist ein Datenformat zum Beschreiben dreidimensionaler Objekte und Welten. Es
wurde speziell für den Einsatz im Internet oder Intranet entworfen (geringe Bandbreite).
Sie ist als universelles Datenformat für 3D-Grafik und Multimedia geeignet. VRML ist
durch Interaktion und Animation gekennzeichnet, so daß man aufgrund der
Berücksichtigung der Zeitkomponente von einer 3D/4D-Sprache ausgehen kann.
VRML bietet neben der Repräsentation statischer und animierter Objekte weiterhin die
Möglichkeit, Verknüpfungen (Hyperlinks) zu anderen Medien wie Sound und Video
herzustellen. Darüber hinaus enthält VRML eine Schnittstelle zur Programmiersprache
JAVA. Somit ist es nicht nur möglich interaktive 3D Repräsentationen zu schaffen,
sondern eine plattformunabhängige Programmiersprache und Netzwerkzugriffe zu nutzen.
VRML-Browser bzw. Plugins aber auch Programme zum Erstellen von VRML-Dateien
sind für alle Rechnertypen erhältlich. Andere 3D-Datenformate wie etwa OpenGL sind
aufgrund ihres hohen Bandbreitebedarfs nicht für das WWW geeignet.
• Einsatzgebiete:
VRML bietet viele Anwendungsmöglichkeiten, wie z.B: Visualisierung im technisch-
wissenschaftlichen Bereich, Präsentationen, Veranschaulichung von Lehrinhalten in der
Ausbildung oder Studium, aber auch attraktivere Gestaltung von Webseiten oder
virtuellen Welten.
• Entwicklungsgeschichte:
VRML 1.0 Spezifikation 1995
VRML 97 / 2.0 Spezifikation 1997
X3D (und Java3D) Spezifikation (noch im Entwicklungsstadium)
• Design:
Generierbarkeit
Dadurch wird die Entwicklung von Anwendungs-Generatoren und –Editoren sowie der
Import von Datenformaten anderer Industrieformate ermöglicht. Hierbei sind vor allem
Konverter aus dem Bereich CAD/CAE und 3D-Modellierer gemeint.
Komponierbarkeit
In VRML erstellte Elemente sind in Kombination zu gebrauchen und können wieder
verwendet werden.
Erweiterbarkeit
Stellt die Möglichkeit zur Verfügung neue nicht in VRML definierte Objekt-Typen, wie
z.B: Video und Audio-Objekte, hinzuzufügen.
Plattformunabhängigkeit
VRML ist auf einer breiten Palette von Systemen implementierbar und lauffähig.
Performance
Schwerpunkt liegt auf Interaktion und Plattformunabhängigkeit.
Skalierbarkeit
Es ist möglich, theoretisch unendlich große Kompositionen von 3D-Szenen zu erzeugen.
Kosten
Im Vergleich zu herkömmlichen Videodateien ist die Herstellung von VRML-
Repräsentationen um ein Vielfaches günstiger. Aber auch die spätere Nutzung durch den
Anwender, in erster Linie im Internet, erfordert wesentlich weniger Bandbreite.
• Informationsquellen
VRML Standard Organisation:

http://www.web3d.org/
VRML 2 Spezifikation:
http://www.web3d.orgtechnicalinfo/specifications/vrml97/
Bücher:
Hartman Jon, Wernecke Josie: The VRML 2.0 Handbook: building moving
worlds on the web. Addison Wesley Developers Press, August 1996, ISBN 0-
201-47944-3
Schlüter Oliver: VRML Sprachmerkmale, Anwendungen, Perspektiven.
O’Reilly Verlag, Köln, 1. Auflage 1998, ISBN 3-89721-121-1
Brutzman Don: The Virtual Modeling Language and Java.
http://www.stl.nps.navy.mil/~brutzman/vrml/vrmljava.pdf
Browser: z.B. Blaxxun Java-applet,

Plug-Ins: Cosmo Player (SGI)
http://www.web3d.org/vrml/browpi.htm
4.2 VRML – Grundlagen
• Ein VRML-File ist im wesentlichen eine Sammlung von Objekten, die Knoten (nodes)
genannt werden und sich auf physische, z.B. Quader, Zylinder, Kugeln, oder
nichtkörperliche Objekte, wie z.B. Sound, Hyperlinks und Transformationen, beziehen.
• Jeder Knoten enthält Felder (fields) mit den Daten des Knotens.
• Manche Knoten sind Container-oder Gruppierungsknoten (container, grouping)
• Die Knoten sind in hierarchischen Strukturen namens Szenegraphen (szene graph)
angeordnet. Der Szenegraph enthält und ordnet alle Knoten. Knoten die früher im
Graphen aufgelistet sind dürfen, später angeordnete Knoten ändern.
VRML ist eine Beschreibungssprache und alle Deklarationen werden in der Reihenfolge
ausgeführt, wie sie erscheinen. Sie hat statische (Objekte) und dynamische (Animationen)
Eigenschaften.
• Ein VRML (*.wrl) – File besteht aus drei Grundbausteinen:

1. Den Kopf (header), der dem Browser mitteilt um welche Version von VRML es sich
handelt. Der Header muß immer angegeben werden und hat folgende Syntax: #VRML
V2.0 utf8
2. Kommentare: Sie beginnen mit #.
3. Knoten: Der Rest der VRML-Datei besteht aus Knoten (nodes).
Die Knoten sind stets folgendermaßen aufgebaut:

(a) Angabe des Knotentyps (beginnt immer mit einem Großbuchstaben!).
(b) Darauf folgt ein Paar geschwungener Klammern {.....}
(c) Dann werden die Felder (fields) aufgelistet.
(d) Felder die mehrere Werte annehmen können, stehen in eckigen Klammern [ ...]. Felder
werden immer in Kleinbuchstaben geschrieben!
Beispiel 1:
# VRML V2.0 utf8

# Mein erstes VRML-File mit nur einem Knoten.
# Es wird eine Kugel dargestellt.
# Werden keine weiteren Parameter angegeben, gelten die Defaultwerte.
Transform {
translation 0 2 0
children [
Shape {
geometry Sphere {}
}
]
}
• Welche Knotentypen gibt es?
1. Gruppenknoten (grouping node): => Sie werden benutzt um die virtuelle Welt
hierarchisch zu strukturieren. Die Kinder (children) der Gruppenknoten sind die
Transformationen (Translation, Rotation und/oder Skalierung). Jeder Gruppenknoten
definiert ein Koordinatensystem für seine Kinder. Die Koordinatensysteme des Kindes
und der Eltern gelten relativ zueinander, d. h. die Transformationen von höherer zu
niedrigerer Hierarchie im Szenegrafen summieren sich.
2. Spezielle Gruppenknoten: Der Inline-Knoten liest die Daten seiner Kinder aus dem World
Wide Web. Der LOD-Knoten (level of detail) spezifiziert die Genauigkeit und
Komplexität der Objektdarstellung und ermöglicht somit ein schnelleres Rendern der
Szene. Der Schalter-Gruppenknoten (switch) erlaubt die Auswahl der im Auswahlfeld
(choicefield) definierten Knoten, d.h je nach Schalterstellung wird z.B. ein anderes Objekt
dargestellt.
3. Allgemeingültige Knoten: Sie werden benutzt um etwa den Hintergrund (background),
das Licht (light), Ansichtspunkte (camera, viewpoint) usw. einzustellen und beziehen sich
auf die ganze VRML-Datei.
4. Sensorknoten (sensors): Ein Sensor generiert ein Ereignis (event), falls er aktiviert wird.
Es gibt geometrische Sensorknoten (ProximitySensor, TouchSensor, PlaneSensor,
SphereSensor, CylinderSensor) die abhängig von der Eingabe des Users, z.B. einen
Mausklick oder eine Annäherung an ein Objekt, ein Ereignis generieren. Zusätzlich gibt
es noch Zeitsensoren (TimeSensor), die je nach Einstellung in regelmäßigen Zeitabständen
Ereignisse auslösen.
5. Geometrieknoten (Geometry): Sie müssen einen Formknoten (Shape) enthalten, um
sichtbar zu sein. Der Shapeknoten enthält stets einen Geometrieknoten in seinem
Geometriefeld (geometry).
6. Aussehen (Appearance): Der Appearanceknoten definiert die visuellen Eigenschaften

Material (material) und Textur (texture).
7. Interpolatoren (Interpolators): Sie ermöglichen Animationen entlang interpolierter Wege,
d.h. man legt Weg- u. Zeitpunkte fest, zwischen denen die Animation interpoliert wird.
• VRML-Koordinatensystem:
Zur Darstellung der einzelnen Objekte verwendet VRML ein dreidimensionales

kartesisches Koordinatensystem. Das Koordinatensystem ist rechtshändig orientiert,
d.h. die positive X-Achse zeigt vom Ursprung ausgehend horizontal von links nach
rechts, die positive Y-Achse vertikal von unten nach oben und die positive Z-Achse
vom Bildschirm aus in Richtung des Betrachters. Rotationen oder andere Bewegungen
von Objekten werden nicht in Grad, sondern in Radiant angegeben. Man nutzt die
Rechte-Hand-Regel, um die Rotationsrichtung von Objekten zu veranschaulichen.
Dabei zeigt der Daumen in Richtung der Achse um die die Rotation erfolgen soll, und
die Richtung der restlichen Finger gibt die Rotationsrichtung an.
4.2.1 Beschreibung der wichtigsten Knotenarten (nodes)
• Positionierung der Objekte (Transformation node):
Um Objekte innerhalb der VRML-Welt zu bewegen, wird der Transformationsknoten

gebraucht. Er hat folgende Syntax:
Transform {
translation x y z
rotation xr yr zr wr
scale s
children [
Shape {}
...
]
}
Der Transformationsknoten hat drei Felder:

• Das Feld translation =[x y z] legt die Position der untergeordneten Knoten (children)
relativ zum übergeordneten Knoten (parent) fest. Es kann
• Das Feld rotation =[xr yr zr wr] legt die Drehung der untergeordneten Knoten relativ
zum übergeordneten Knoten fest. [xr yr zr] definiert die Rotationsachse; wr den
Rotationswinkel in [rad].
• Das Feld scale =[s] stellt einen Skalierungsfaktor dar, d.h. alle untergeordneten
Objekte können damit vergrößert oder verkleinert werden.
• Der Formknoten (Shape node):
Der Shapeknoten muß angegeben werden um ein Objekt sichtbar zu machen. Er hat zwei
untergeordnete Knoten: den Geometrieknoten und den Appearance-Knoten.
Es gibt 4 Grundgeometrien:
1. Quader (Box):
2. Zylinder (Cylinder):
3. Kegel (Cone)
4. Kugel (Sphere)
Alle in VRML vordefinierten Grundformen werden per Definition um den Ursprung

gezeichnet und haben eine Standardgröße, wenn diese nicht weiter definiert wird.
Größenangaben, Materialeigenschaften usw. werden mit Floatingpoint-Zahlen, z.B. 2.0
angegeben. Rotationswinkel müssen in [rad] eingegeben werden, d.h. 180° enspricht
3.1416 rad.
Das folgende Beispiel 'Bausteine.Wrl' beschreibt eine Komposition mehrerer dieser

Formen und soll die VRML-Syntax zeigen (s. Abb...). Es wird ein oben offenen hellblauer
Zylinder mit der Höhe=1 und dem Radius=0.5. Die Zylinderfarbe (diffuseColor) ist ein
Feld des Materialknotens und wird durch den RGB-Vektor [0.1 0.5 0.9] definiert. Die
Objektfarbe entsteht durch Mischung der drei Grundfarben. Die Farbintensitäts darf
zwischen 0 und 1 liegen, d.h. [R G B]=[0 0 1] bedeutet Tiefblau oder [R G B]=[0 0.5 0.5]
bedeutet eine Mischung zwischen Blau und Grün -> Gelb mit halber Intensität. Rechts
daneben soll eine rote Kugel gezeichnet werden, also muß sie in negativer x-Richtung
verschoben werden -> [x y z]=[-1.25 0 0]. Als letztes soll ein Kegel den Zylinder von der
Seite durchdringen. Hierzu wird zuerst der grüne Kegel definiert und dann um die z-
Achse um 90° gedreht. Die wird durch Belegen des Kegel-Rotationsfeldes mit [0 0 1 1.57]
erreicht. Die ersten 3 Werte des Vektors definieren die Rotationsachse, hier die z-Achse.
Der vierte Wert legt den Drehwinkel in Radiant, also 90°=π/2 rad=1.57..rad, fest.
Abbildung 4.1: Geometrie und Transformation (Beispiel 2)
Beispiel 2: Bausteine.Wrl
#VRML V2.0 utf8
#Eimer: Oberer Zylinderdeckel wird nicht gezeichnet,
# da Zylinderfeld top=FALSE gesetzt
Shape {
geometry Cylinder{
height 1
radius 0.5
bottom TRUE
side TRUE
top FALSE}
appearance Appearance {
material Material { diffuseColor 0.1 0.5 0.9 }}
}
# Zeichne eine rote Kugel links neben dem Eimer

# Dies wird durch eine Translation in x-Richtung erreicht -> [-1.25 0 0]
Transform {
translation -1.25 0 0
children [
Shape {
geometry Sphere { radius 0.5 }
material Material { diffuseColor 1 0 0 }
}
}
]
}
# Zeichne einen um 90° um die z-Achse gedrehten grünen Kegel ohne Boden,
# d.h. das bottom-Feld des Cone-Geometrieknotens = FALSE
Transform {
rotation 0 0 1 1.57
children [
Shape {
geometry Cone {
bottom FALSE}
}
}
]
}
• Definition der Erscheinungsbildes (Appearance node, Material node, Texture node):
Um ein geometrisches Objekt darzustellen, muß auch sein Erscheinungsbild (appearance)

definiert werden. Ohne Definition erscheint es schwarz bzw. weiß.
Jedes geometrische VRML-Objekt wird durch Polygone dargestellt. Der
Appearanceknoten legt die visuellen Eigenschaften der Polygone fest. Der Appearance-
Knoten hat zwei mögliche Kind-Knoten: Erstens den Materialknoten (material), der die
Eigenschaften der Objektoberfläche festlegt und zweitens den Texturknoten (texture).
Mittels dieses Knotens können Bilder auf Oberflächen gemappt werden.
Die Felder des Materialknotens definieren die Objektfarbe und die Lichtreflektionen.
Natürlich sollten vorher auch die Position und Intensität der Lichtquelle(n) festgelegt
werden, denn ohne Licht keine Reflexion.
Die Felder des Materialknotens sind:

• Das Feld diffuseColor wird am häufigsten gebraucht. Es bestimmt die Intensität und
Farbe der Lichtreflektion in Abhängigkeit vom Oberflächenwinkel. Oberflächen die
direkt, d.h. senkrecht, beleuchtet werden, erscheinen heller.
• Das Feld emissiveColor definiert die Intensität und Farbe selbstleuchtender Objekte.
• Das Feld specularColor definiert eine zusätzliche Farbreflektion, wenn sich ein
Objekt vom Betrachter aus in der Nähe einer Lichtquelle befindet. Dadurch erhalten
die Objekte ein realistischeres Aussehen. Es wird zusammen mit dem Feld shininess
benutzt.
• Das Feld transparency legt die Lichtdurchlässigkeit der Objekte fest. Glas sollte etwa
ein hoher Transparenzwert zugeordnet werden..
• Der Anker-Knoten (Anchors):
Der Ankerknoten zählt zu den Gruppierungsknoten, d.h. er muß um das zu ankernde

Objekt gelegt werden. Sie ermöglichen Links in das WWW. Beispiel 3 öffnet die
Homepape der Fernuniversität Hagen, wenn auf das Objekt mit dem Ankerknoten geklickt
wird.
Beispiel 3: Anchor.Wrl
#VRML V2.0 utf8
#Mausklick auf Kugel öffnet Homepage der Fernuni Hagen
Anchor {
url "http://www.fernuni-hagen.de/"
description "Link zur Fernuni-Homepage"
children [
Shape {
material Material {
diffuseColor 0 0 1
}
}
geometry Sphere {}
}
]
}
Es gibt insgesamt 53 verschiedene Knotentypen, die den Umfang dieser Einführung aber
sprengen würden (s. Informationsquellen).
4.2.2 Wiederverwendbarkeit und Prototyping
• Wiederverwendbarkeit
• Eine wichtige Fähigkeit von VRML ist Wiederverwendbarkeit von bereits definierten und
mit einem Namen bezeichneten Objekten. Der DEF-Knoten ermöglicht die Benennung
von Knoten. Dies bietet zusätzlich den Vorteil einer Dokumentation der VRML-Datei.
Mit USE können dann multiple Instanzen des benannten Knotens erzeugt und dann
wiederverwendet werden.
Abbildung 4.2: Wiederverwendbarkeit (Beispiel 4)
Beispiel 4: Stern.Wrl
#VRML V2.0 utf8

# Wiederverwendung des Zylinders mittels DEF und USE
DEF ACHSE Shape {
geometry Cylinder {
radius 0.5
height 5}
}
}
Transform {
rotation 0 0 1 1.0472
children USE ACHSE
}
Transform {
rotation 0 0 1 2.0944
children USE ACHSE
}
• Ein weitere Möglichkeit Code wieder zu verwenden ist Inlining, d.h bereits existierende
VRML-Welten können in die eigene Welt eingebunden werden.
Der Inline-Knoten hat drei Felder:

• Das Feld name definiert die URL, d.h die Adresse der VRML-Datei.
• Das Feld bboxSize legt die Größe der Welt mittles der boundingbox fest. Dies ist
ein Quader indem die zu ladende Szene eingepaßt wird.
• Das Feld bboxCenter beschreibt die Position des Quaderzentrums.
• Prototyping
Je komplizierter die Welten, desto wichtiger ist es auch eigene Knotentypen kreieren und
wiederbenutzen zu können. Der PROTO-Knoten erlaubt die Definition eigener Knoten
mit beliebigen Feldtypen und Feldnamen. Anders formuliert können PROTO-Knoten die
Fähigkeiten der VRML-Sprache nahezu beliebig erweitern. Die Syntax des Proto-Knotens
stimmt mit der Syntax der anderen Knoten (s. Materialknoten) überein:
PROTO prototypename [ field fieldtypename name defaultValue
field fieldtypename name defaultValue
]
{node}
4.2.3 Sensoren, Interpolatoren und Ereignisse
Um Interaktion und Animation in die VRML-Welt einzubringen, verwendet man Ereignisse

(Events), die auf Knoten einwirken und entsprechend Feldinhalte verändern und somit auch
den Knotenzustand. Eine Szene ist eine Ansammlung von Objekten. Sämtliche Vorgänge die
geschehen stehen im Zusammenhang mit einem oder mehrerer Objekte. Durch das Anklicken
eines Sensor-Objektes mit der Maus, verändert sich daraufhin ein anderes Objekt. Dabei ist
der Mausklick das Ereignis, welches von dem Sensor-Objekt registriert wird. Dieses sendet
eine Nachricht an das Zielobjekt, das daraufhin den Inhalt eines Feldes und somit seinen
Zustand ändert. Die beiden Objekte müssen vorher durch eine Art Nachrichtenkanal, der als
Route bezeichnet wird, miteinander verbunden werden. Sensoren sind die Quellen für
Ereignisse (s. Abbildung 4.3). Nur darüber ist es möglich die Interaktion zum Benutzer
herzustellen. Durch einen TouchSensor werden Eingaben in der Art einer Schalterbetätigung
durchgeführt. Der ProximitySensor hingegen reagiert auf die Annäherung des Benutzers
innerhalb der 3D-Welt. Zusätzlich dient er der Analyse von Position und Orientierung des
Benutzers. Man faßt Sensoren, die auf Bewegungen des Mauszeigers reagieren in die Gruppe
der Drag-Sensoren zusammen. Dazu gehören der PlaneSensor, der CylinderSensor und der
SphereSensor. Objekte die mit diesen Sensoren verbunden sind, können auf bestimmte Weise
mit der Maus bewegt werden. Mit dem PlaneSensor lassen sich Objekte innerhalb der Ebene
verschieben, mit dem CylinderSensor kann ein Objekt um die Längsachse eines Zylinders
gedreht werden und der SphereSensor erlaubt eine beliebige Drehung um einen Punkt. Ein
weiterer Sensor ist der TimeSensor. Er registriert das Verstreichen der Zeit und generiert
fortlaufend Zeitsignale. Dies ist die Basis zur Erstellung von Animationen, die durch
Interpolation gesteuert sind. Interpolatoren sind Knoten, die Werte für die Zwischenphasen
von einfachen Animationen liefern. Darunter ist ein fest vorgegebener, vom Benutzer
ausgelöster aber nicht beeinflußbarer Ablauf zu verstehen. Soll ein Objekt zwischen zwei
Punkten hin und her bewegt werden, würden die Angabe von Anfangs- und Endpunkt
genügen. Die Zwischenschritte werden daraufhin interpoliert.
Am folgenden Beispiel 5 sollen die zur Animation notwendigen Schritte gezeigt werden. Es
werden dabei folgende Objekte benötigt [Schlüter Oliver, 1998, S.59]:
• Die Rotationsmaschine (OrientationInterpolator-Knoten)

• Ein TimeSensor-Knoten zur Versorgung der Rotationsmaschine mit Zeitinformationen
• Routen zwischen dem TimeSensor, der Rotationsmaschine und dem Objekt
Um die Routen verbinden zu können, müssen die Objekte mittels DEF einen Namen
erhalten.
Beispiel 5: Animation.Wrl
#VRML V2.0 utf8
#Animation mit TimeSensor: Eine Drehung um die Z-Achse in
# 20 Sekunden
DEF robjekt Transform {
children [
...
]
}
DEF rtimer TimeSensor {
loop TRUE
cycleInterval 20
}
DEF rengine OrientationInterpolator {
key [0,.25,.5,1]
keyValue [0 1 0 0, 0 1 0 2.094,0 1 0 4.188, 0 1 0 0]
}
ROUTE rtimer.fraction_changed TO rengine.set_fraction
ROUTE rengine.value_changed TO robjekt.set_rotation
Durch den TimeSensor wird ein Zeitintervall auf 20 Sekunden gesetzt und permanent
wiederholt (loop TRUE). Im OrientationInterpolation werden vier Skalenabschnitte
mittels key definiert die Bruchteilen des Zeitintervalls entsprechen. Die Skalenabschnitte
korrespondieren mit denen in keyValue vorgegebenen Positionen des Objektes. Durch die
Routeverbindungen entstehen folgende Nachrichtenverbindungen zwischen den Objekten:
Abbildung 4.3: Nachrichtenverbindungen
Während der rtimer (TimeSensor-Knotens) ununterbrochen das Versteichen der Zeit

registriert und mittels des Ereignisses fraction_changed dem rengine
(OrientationInterpolation-Knoten) mitteilt, ermittelt rengine anhand der verstrichenen Zeit
(set_fraction) die aktuelle Objektposition. Diese wird verändert (value_changed) und dem
entsprechenden Objekt mitgeteilt und über das Ereignis set_rotation im robjekt
(Transform)
Um Ereignisse
aktualisiert.
empfangen und senden zu können besitzen die Knoten sogenannte eventIn-
und eventOut-Definitionen. Mittels eventIn kann man von anderen Objekten Nachrichten
empfangen. Durch eventOut kann man nach eigenen Objektveränderungen selbst
Nachrichten an andere Objekte verschicken. Beim Herstellen von Nachrichten-

verbindungen muß zwischen den eventIn und eventOut Feldern Typkonformität vorliegen.
4.2.4 Skript-Knoten
Um komplexere und flexiblere Abläufe im Sinn einer höheren Programmierlogik gestalten

zu können, gibt es spezielle Knoten, die eine Schnittstelle zu höheren Programmier-
sprachen wie JAVA oder JavaScript zur Verfügung stellen. Dabei handelt es sich um
Knoten, die regulär in die Hierarchie eingegliedert sind. Diese können Bestandteile eines
Objektes oder eigenständige Objekte sein. Derartige Script-Knoten verfügen allerdings
über Möglichkeiten die andere Knoten nicht besitzen. Sie stellen das Bindeglied zu einer
programmierbaren Schnittstelle und somit die Verbindung zur Außenwelt dar. Das
folgende Beispiel zeigt eine mögliche Deklaration. Dabei bestimmt die Reihenfolge die
Priorität des Zugriffes:
#VRML V2.0 utf8
Script {
url ["javascript:...",
"http://inetsite.com/name.js",
"http://inetsite.com/name.class"
]
}
Der Scriptknoten besitzt die gleichen Eigenschaften wie die anderen Knoten und kann
über die Ereignisse angesprochen werden und daraufhin entsprechende Ereignis-Kaskaden
auslösen. Im URL-Feld kann anstatt einer Adresse auch Programmcode einer
Scriptsprache wie JavaScript oder VrmlScript stehen.
4.3 Das VRML-Kranmodell

Dieses Kapitel beschreibt das VRML-Modell Kran.Wrl (s. Abbildung 4.4). Das Modell wurde
mittels der Software 'V-Realm Builder 2.0' erstellt. Sollen größere Systeme in ein
wirklichkeitsgetreues VRML-Modell umgesetzt werden, wäre der Einsatz einer CAD-
Software mit VRML-Exportfilter sinnvoll.
Abbildung 4.4: VRML-Kranmodell
4.3.1 Aufbau des VRML-Modells
x-Achse:
• Laufkatze
• Pendel
• Endschalter
• Näherungsschalter
• 2 Schlitten mit darauf befestigter Laufschiene, Umlenkrollen und Zahnriemen
• x-Antrieb
y-Achse:
• Laufschiene mit Umlenkrollen und Zahnriemen (2x)
• 2 Endschalter
• 2 Näherungsschalter
• y-Antrieb
• Verbindungswelle der beiden parallelen y-Achsen
Krantisch:
• Auf dem Krantisch sind die beiden y-Achsen montiert, auf der wiederum die x-Achse
montiert ist.
Bodenplatte mit dem Berührungssensor:

• Die Bodenplatte ist mit einem 2m x 3m großen Berührungssensor ausgestattet. Dieser
definiert den maximalen Fahrbereich des Kranes. Durch Mausklick auf diese Fläche
wird die Sollpositon des Kranes festgelegt. .
Sollpositionsmarkierung:
• Der grüne Kegel auf der Bodenplatte markiert die Endposition der Laufkatze.
Alle animierten VRML-Knoten befinden sich auf der x-Achse, d.h. es wird entweder die
x-Achse selbst in y-Richtung verschoben, die Laufkatze in x-Richtung und das daran
befestigte Pendel um seine Drehachse gedreht. Die Näherungs- u. Enschalter, als auch die
Motoren und Übersetzungen werden in dieser Version noch nicht animiert. Der
Verfahrweg in x- Richtung ist 2m und in y-Richtung 3m lang. Der Koordinaten-Ursprung
befindet sich in der Mitte, d.h x∈[-100cm, 100cm] und y∈[-150cm, 150cm]. Mehrmals
vorhandene Baugruppen (Schalter, Umlenkrollen, Schienen) wurden wiederverwendet.
Alle geometrischen Objekte wurden in [cm] definiert.
4.3.2 Vergleich des VRML-Modells mit dem realen Modell
Die Komplexität der Modellierung wurde möglichst einfach gehalten, da sie sich
wesentlich auf die Geschwindigkeit der Animation auswirkt und aufgrund der Größe des
Modells kleinere Einzelheiten sowieso nicht gut zu erkennen sind.
• Laufkatze mit Pendel
Abbildung 4.5: VRML-Laufkatze mit Pendel Abbildung 4.6: reale Laufkatze
• Laufschiene mit Zahnriemen

Abbildung 4.7: VRML-Laufschiene mit Zahnriemen

Abbildung 4.8: reale Laufschiene der x-Achse
• Endschalter:
Abbildung 4.9: VRML-Endschalter Abbildung 4.10: realer Endschalter
• Näherungssensor:
Abbildung 4.11: VRML-Näherungssensor Abbildung 4.12: realer Näherungssensor

• Gleichstrommotor der x-Achse:
Abbildung 4.13: VRML-Motor Abbildung 4.14: realer Gleichstrommotor
Wie bereits erwähnt, ist für möglichst realistische Darstellungen der Einsatz eines CAD-
Programmes mit VRML-Filter unabdingbar.
4.4 Die Virtual Reality Toolbox [7]
Die Virtual Reality Toolbox ist eine Werkzeug zur Visualisierung und Interaktion mit
dynamischen Systemen in einer 3-dimensionalen virtuellen Umgebung. Diese Systeme
werden mit MATLAB und Simulink beschrieben. Mittels der VRML-Technologie können
realistisch animierte 3-dimensionale Welten erzeugt und von MATLAB und Simulink
gesteuert werden.
• Simulink Interface
Sie können eine Simulation ihres dynamischen Systems mittels eines realistischen 3D-
Modells durchführen. Ein Großteil der VR-Toolbox-features kann mit Simulink-Blöcken
(VR-Sink, VR-Source,..) implementiert werden. Fügt man diese Blöcke in ein Simulink-
Modell ein, so erhält man die Möglichkeit Signale zwischen Simulink und der virtuellen
Welt auszutauschen und diese 'zum Leben zu erwecken'.
Die VR-Toolbox durchsucht die ausgewählte virtuelle Welt nach ansteuer- bzw. lesbaren
VRML-Knoten. Diese Knoten (nodes) können hierarchisch aufgelistet werden. Durch
einfaches Anklicken wählt man die Freiheitsgrade die mit Simulink gesteuert werden
sollen aus. Nachdem die anzusteuernden (VR-Sink) bzw. zu lesenden (VR-Source)
Knoten ausgewählt wurden, verbindet man sie mit passenden Simulink-Signalen. Die
Simulation kann mittels eines Browsers mit VRML-Plugin visualisiert werden.
• MATLAB Interface
Es besteht auch unter MATLAB die Möglichkeit die VR-Toolbox und damit das VRML-
Modell direkt über Befehle anzusprechen.,
Die VR-Toolbox stellt zwei Simulink-Block-Typen zur Verfügung, die die Verbindung mit
der virtuellen Welt vereinfachen:
• VR-Source:
Dieser Block sendet Signale an das Simulink-Kranmodell, d.h. es werden die Feldinhalte
des gewünschten Knotens ausgelesen. Nur auf die Felder der mit DEF gekennzeichnete
Knoten kann ein Schreib- bzw. Lesezugriff erfolgen. Durch Doppelklick auf den VR-
Source-Block öffnet sich ein Fenster, in dem das darzustellende VRML-Modell
ausgewählt werden kann. Ist die VRML-Welt ausgewählt, öffnet sich eine Baumstruktur
(s. Abb. 4.15) der VRML-Knoten. Hier können die Knoten markiert werden, die an
Simulink Signale senden sollen. Unser Simulink-Modell benötigt als Eingangssignal die
Sollposition. Diese wird im VR-Modell als kleiner grüner Kegel symbolisert (s. Abb.
4.16). Der zu markierente VRML-Knoten der Kegelposition lautet also
Marker.translation. Der Kegel kann mit der Maus (Mausklick auf Touchsensor-
Fläche) innerhalb der X/Y-Fahrgrenzen des Kranes positioniert werden. Die Sollposition
wird automatisch an Simulink weitergeleitet.
• VR-Sink:
Dieser Block empfängt Signale aus Simulink, d.h. er beschreibt die Felder des VRML-
Modells. Mit Hilfe dieses Blocks wählt man das VRML-Modell und die Felder ,die
Signale empfangen sollen, aus (wie VR-Source).
Im VRML-Kranmodell werden nur drei Felder beschrieben und ein Feld gelesen. Um die
Animation mit dem VRML-Modell zu verbessern, bietet sich ein Fülle von Möglichkeiten an.
Abb. 4.15: Baumstruktur Abb. 4.16: Sollpositionsmarkierung (grüner Kegel)
Welche Felder des VRML-Kranmodells können für die Regelungsanwendung sinnvollerweise

benutzt werden?
• Pendel.rotation: Wird benutzt um den Pendelauschlag zu definieren
• Kran.translation: Wird gebraucht um die x-Position der Laufkatze festzulegen
• AchseX.translation: Legt die y-Position der gesamten x-Achse fest
• Marker.translation: Gibt die Sollposition an Simulink weiter
Im bestehenden VRML-Kranmodell könnten zusätzlich die Endschalter (Collisiontest),

Näherungssensoren (verwenden eines ProximitySensors) und die Motoren mit den
Übersetzungen animiert werden. Eine weitere Möglichkeit wäre es alle Objekte die
kollidieren können einer Kollisionsprüfung zu unterziehen, z.B. wenn das Pendel zu weit
ausschlägt und an die y-Achse prallt, würde dies erkannt und an Simulink weitergeleitet.
Simulink müßte dann eine Berechnung starten, das den elastischen Aufprall der Pendelmasse
mit der Aufprallwinkelgeschwindigkeit simuliert.
• ZahnradKlein.rotation: Rotation mit Winkelgeschwindigkeit des Motor

• ZahnradGross.rotation: Rotation mit übersetzer Winkelgeschwindigkeit
• Schalterhebel.rotation: Rotation bei Kontakt mit Laufkatze
4.5 Implementierung mit VR-Toolbox
In diesem Abschnitt wird die konkrete Realisierung mit Hilfe der VR-Toolbox und
Matlab/Simulink beschrieben. Das Simulink-Modell 'Kran mit Zustandsregler' (Abb.: 4.17)
steht als Beispiel für die anderen Simulink-Modelle mit PID- o. LQ-Regler.
Abbildung 4.17: Simulink-Modell 'Kran mit Zustandsregler'
4.5.1 Funktionsbeschreibung der Simulink-Blöcke (s. Abb. 4.17):

• Block 'Kran x-Achse'
Abbildung 4.18: Simulink-Modell der Laufkatze mit Pendel (x-Achse)

Diese Struktur beschreibt das Differentialgleichungssystem des Systems 'Kran mit

Pendel'. Sie stellt eine schnelle Möglichkeit dar nichtlineare Systeme mit Simulink zu
modellieren. Zuerst legt man den Ausgangsvektor, hier z.B. den Zustandsvektor, fest und
beginnt dann von rechts nach links über Integratoren die einzelnen Zustandsgrößen
aufzubauen. Diese fasst man über einen Multiplexer (Mux-Block) zu Vektoren
zusammen, die dann an den Funktionsblock (f(u)) übergeben werden. Funktionsblöcke
können beliebige mathematische Ausdrücke enthalten. Als Ausgangsgröße der
Funktionsblöcke wählt man eine Zustandsgröße (hier z.B. x'' und phi'') und verbindet
diese mit der passenden Zustandsgröße eines Integratoreingangs, und fertig ist das
Simulink-Modell.
Oberer Funktionsblock (enspricht Gl. (2.8)):

f(u) = u[1]/(M0+M1) - Fr/(M0+M1)*u[5]-M1*ls/(M0+M1)*(u[4]*(-cos(u[3]))
+power(u[2],2)*sin(u[3]))) = x''(t) = r''(t)
Unterer Funktionsblock (entspricht Gl. (2.7)):

f(u) = -C/(Os+M1*ls^2)*u[2]-M1*ls*g/(Os+M1*ls^2)*sin(u[3])+M1*ls/
(Os+M1*ls^2)*u[1]*cos(u[3]) = phi''(t)
Die Variable u ist die vektorielle Ausgangsgröße des jeweiligen Multiplexers. u[1] ist also
die Kraft F auf den Kranwagen in der oberen Funktionsgleichung, u[2] entspricht der
Zustandsgröße ϕ'(t) usw.
• Block 'Regler x'
Dieser Block ist der Zustandsregler K für die x-Achse, der mittels der Polvorgabe nach
Ackermann entworfen wurde. Er führt folgende Operation aus:
• Block 'Vorfilter x'
 r (t ) 
ϕ (t )
r = K ⋅ x(t ) = [K 1 K 2 K 3 K 4 ] ⋅  
 r&(t ) 
 
ϕ&(t )
Mit K1 bis K4 sind nun die 4 Pole (Kran mit Pendel ist System 4. Ordnung) des
geschlossenen Regelkreises festgelegt. Der stationäre Zustand entspricht aber noch nicht
dem Sollzustand (hier: Position) – zum Einstellen des Sollwertes ist also noch ein
Freiheitsgrad notwendig -> das Vorfilter! Das Vorfilter ist ein einfacher Verstärker mit
dem Wert K1.
• Block 'Kran y-Achse' (vergl. x-Achse')

Abbildung 4.19: Simulink-Modell der y-Achse des Kranes
Funktionsblock:
f(u) = (u(1)-Fr*u(2))/M = y''(t)
Hier hätte man zur Modellierung auch einen Zustandsraumblock verwenden können,
da die Differentialgleichung der y-Achse linear ist, wenn man die von Getriebe und
Reibung verursachten Nichtlinearitäten vernachlässigt.
• Block 'Regler y' (vergl. 'Regler x')
• Block 'Vorfilter y' (vergl. 'Vorfilter x')
• Blöcke 'Koordinaten-Transformation'
Matlab und VRML verwenden unterschiedliche Koordinatensysteme (s. Abb. 4.20).

Dies macht eine Hin- u. Rücktransformation der Koordinatensysteme erforderlich.
Abbildung 4.20: Unterschied zwischen den Koordinatensystemen: Matlab – VRML
Die x-Achse stimmt in beiden Koordinatensystemen überein (auch mit der Kran-x-
Achse). Das VRML-Modell wurde aber in [cm] konstruiert, d.h. die Matlabkoordinaten
müssen mit dem Faktor [m]/[cm]=100 in die VRML-Koordinaten umgerechnet werden
und umgekehrt.
VRML erwartet für Translationen einen 3D-Vektor mit folgenden Foramt: T=[x y z] in
[cm]. Mit der Kranposition (x-Achse) rx(t) in [m] folgt also für Tx (s. Abb. 4.21 oben):
Tx=100*[rx(t) 0 0]
Das Pendel rotiert im VRML-Koordinatensystem um die –z-Achse (rechte Hand-Regel,

d.h. Daumen in Richtung –z; Finger zeigen in Richtung positiver Ausschläge). Die
VRML-Syntax für Rotationen lautet: R=[ex ey ez ϕ] wobei der Vektor e die
Rotationsachse und ϕ(t) den Rotationswinkel in [rad] definiert, hiermit folgt für R (s. Abb.
4.21 unten):
R=[0 0 –1 ϕ(t)]
Abbildung 4.21: x-Achsen-Koordinaten-Transformation: Matlab –> VRML
Die y-Achse des Kranes stimmt mit der –z-Achse im VRML-Modell überein. Mit rx(t) in
[m] folgt also für den VRML-Translationsvektor Ty (s. Abb. 4.22):
Ty=-100*[0 0 ry(t)]
Abbildung 4.22: y-Achsen-Koordinaten-Transformation: Matlab –> VRML
• Block VR Source
Dieser Block gibt die aktuelle Sollposition des Kranes in der VRML-Syntax für
Translationen, d.h. als 3-dim. Vektor T=[x y z]/[cm], an Matlab weiter.
• Block VR Sink
Dieser VR-Block empfängt die in das VRML-Koordinatensystem transformierten Kran-

Zustandsgrößen rx(t), ry(t) und ϕ(t), d.h. die Translation Tx für die x-Achse, Ty für die y-
Achse und R für die Pendeldrehung.
Die Felder der VRML-Knoten für diese Größen sind:

Tx: Kran.translation, Ty: AchseX.translation und R: Pendel.rotation.
4.5.2 Software-Voraussetzungen zur Animation:

• Ein VRML-fähiger Browser, z.B mit Plugin 'Blaxxun Contakt'
• Im Browser 'Java' und 'Javascript' aktivieren
• Matlab / Simulink & VR-Toolbox
4.5.3 Bedienungsanleitung:
Um die virtuelle Welt animieren zu können, müssen im Simulink- bzw. VRML-Modell
folgende Schritte ausgeführt werden:
Simulink:
• Auf den View button klicken -> die mit Simulink verbundene virtuelle Welt wird im
Web-Browser geöffnet.
VRML-Browser:
• Durch Mausklick auf die Touchsensorfläche wird die neue Kran-Sollposition definiert und
durch einen kleinen grünen Kegel markiert. Der virtuelle Kran nimmt die neue
Sollposition ein.
• Rechter Mausklick öffnet ein Menü. Hier können Navigationsmodi, Viewpoints und die
Qualtiät und Geschwindigkeit der Grafik eingestellt werden.
Kontrolle desVRML-Browsers (s. Abb. 4.23):

• Mit Hilfe des Kontrollfeldes kann durch die virtuelle Welt navigiert werden. Verschiedene
Navigationsarten, wie z.B. fly (Fliegen), walk (Gehen) oder examine (Untersuchen)
stehen zur Verfügung.
• Druch Drücken der linken Buttons (s. Abb. 4.23: Rechteck, Dreieck) können die
verschieden voreingestellten viewpoints (Ansichten) des Modells eingestellt werden.
Sollte man sich in einer virtuellen Welt 'verirren', findet man mittels dieser Knöpfe wieder
zurück.
Es gibt fünf vordefinierte Ansichten:
1. Pseudo Orthografic View (s. Abb. 4.4)
2. Nahaufnahme (Kranwagen und Pendel in Grundstellung, d.h Ursprung des xy-
Koordinatensystems)
3. Draufsicht
4. Frontansicht x-Achse
5. Seitenansicht y-Achse
• Der mittlere Knopf und die beiden rechten Buttons dienen zur Navigation.
• Der kleine kreisförmige Button blendet das Kontrollfeld aus bzw .ein.
Abbildung 4.23: VRML Navigator
5 Kranregelung und Bahninterpolation

Es werden dem Anwender 4 verschiedene Regler zur Verfügung gestellt:
• PID-Regler
• Zustandsreglerentwurf durch Polvorgabe
• Zustandsreglerentwurf durch Minimieren eines quadratischen Gütemaßes
• Feedforward-Regler (Bahninterpolation)
5.1 PID-Regler
Entwurfskrierien: Die Regelung soll möglichst geringes Überschwingen des Pendels in der
Endstellung erreichen und nicht zu langsam sein.
5.1.1 Grundlagen und Entwurf
Die Regler werden mittels der Wurzelortskurve entwickelt, da der Entwurf nach dem
Betragsoptimum nicht das gewünschte Ergebnis gebracht hat. Positions- u. Winkelkreis lassen
sich nicht entkoppeln, da das System nur einen Eingang hat. Als Winkelregler wird ein P-
Regler verwendet.
Abbildung 5.1: Wurzelortskurve Winkel
Aus der Wurzelortskurve des Winkelkreises ist im Verstärkungsbereich von etwa k=2 bis
k=10 maximale Dämpfung der Pendelschwingung zu erwarten. Es wird GPHI(s)=3 gewählt.

Abbildung 5.1: Wurzelortskurve Winkel
Die Wurzelortskurve des Positionskreises neigt für k-Werte >2 zum Schwingen. Da die
Strecke schon einen I-Anteil enthält wird ein PD-Regler gewählt der die
Streckenzeitkonstante kürzt. Hiermit erhält das Gesamtsystem annähernd PT1-Verhalten.
GΦ ( s ) = 3 Gesamtverstärkung k < 2 wählen (Wurzelortskurve)

-> kR=2/3
G R ( s ) = k R ( sTw + 1)
Das geregelte System hat folgende Struktur:
Abbildung 5.3: PID-Regelung

5.1.2 Simulationsergebnisse
Abbildung 5.4: Sprungantwort des Krans mit PID-Regler
Die Regelung ist trotz der Kopplung zufriedenstellend. Der maximale Pendelausschlag
beträgt 0.25 rad schwingt aber im Vergleich zu den Zustandsreglern länger nach (s 5.2.3 und
–5.3.3).
Abbildung 5.5: Stellgröße u(t) des Krans mit PID-Regler
5.2 Zustandsreglerentwurf durch Polvorgabe nach Ackermann
5.2.1 Grundlagen
Das dynamische Verhalten eines Systems wird durch seine Eigenwerte definiert. Diese
Eigenwerte sind die Nullstellen des charakteristischen Polynomes der Systemmatrix A.
Grundgedanke dieser Entwurfsmethode ist also: Um die Dynamik eines Systems im Sinne des
Anwenders zu verbessern, müßte man die Eigenwerte und damit die Systemmatrix vorgeben.
Die Eigenwertvorgabe (Polvorgabe) erreicht man durch negative Rückkopplung (s. Abb. 5.6)
des Zustandsvektors x(t) mit einem konstanten Reglervektor r. Voraussetzung ist natürlich die
Steuerbarkeit des Systems. Falls das System nur eine Steuergröße hat, vereinfacht sich der
Reglerentwurf beträchtig und es gilt nach Ackermann [6]:
x0
w(t) u dx/dt=A*x+b*u y(t)

M
- x(t)
Abbildung 5.6: Regelung des Zustandsvektors
(5.1)
x&(t ) = A ⋅ x(t ) + b ⋅ u (t )
(5.2)
u (t ) = −r ⋅ x(t ) (5.3)
x&(t ) = ( A − b ⋅ r ) ⋅ x(t )
(5.4)
det[s ⋅ I − A] = s n + a n −1 s n −1 + ... + a 0
det[s ⋅ I − ( A − b ⋅ r )] = s n + p n −1 s n −1 + ... + p 0
r = [ p 0 − a 0 , p1 − a1 ,..., p n −1 − a n −1 ] = [r1 r4 ]
T
r2 r3
(5.5)
(5.6)
Wird das System (Gleichung 5.1) über den Reglervektor r (Gleichung 5.2) rückgekoppelt, so
erhält man die neue Systemgleichung (5.3). Die Koeffizienten der charakteristischen
Gleichungen (5.4) und (5.5) legen dann den Reglervektor r (5.6) fest (es gilt w=0).
Oder anders formuliert:

Man gibt n Systempole vor (n ist die Systemordnung) und berechnet daraus die Koeffizienten
pn. Davon zieht man die Koeffizienten an des Ausgangssystems ab und erhält den
Reglervektor r. Um ein stabiles System zu erhalten, müssen alle Pole in der linken Halbebene
liegen.
Da beim Zustandsreglerentwurf kein Soll/Istwertvergleich stattfindet, ist nicht garantiert das

die Ausgangsgröße y(t) mit dem Sollwert übereinstimmt, es muß also noch ein konstanes
Vorfilter M (hier Skalar M, das nur eine Eingangsgröße) bestimmt werden, der die
Eingangsgröße transfomiert. Die Ausgangsgröße soll y(t)=x1(t), d.h der erste Wert des
Zustandsvektors (bei dem Kransystem wäre es die Laufkatzposition r(t)).
Im stationären Zustand (t→∞) des Kransystemes sind alle Zustände bis auf x1 = y gleich Null.
Die allgemeine Herleitung des Vorfilters findet man z.B. in [6,
u ∞ = M ⋅ w∞ − r1 x1∞ = 0 S.467]. Es gilt:
y ∞ = x1∞ = w∞
M = r1
(5.7)
Das Vorfilter M ist bei einem Eingrößensystem und y(t)=x1(t) gleich r1.
Hiermit ist der Zustandsreglerentwurf nach Ackermann abgeschlossen.
5.2.2 Reglerentwurf
In diesem Abschnitt wird der Reglerentwurf für das Kransystem mit seinen Defaultwerten
durchgeführt.
Die Systemmatrix A und die Eingangsmatrix b lauten:

0 0 1 0   0 
0 0 0 1   0 
A=  b= 
0 - 0.06374 - 5.136 - 0.0001695  3 .2 
   
0 - 33.54 - 17.67 - 0.08916  11.3
Wie zu erkennen ist, handelt es sich um System 4.Ordnung. Die charakteristische Gleichung
des Ursprungsystems (Gl. 5.4) s^4 + 5.225 s^3 + 33.99 s^2 + 171.1 s hat also die
Koeffizienten: a3=5.225; a2=33.99; a1=171.1; a0=0
Die Pole des neuen Systems sollen alle in der negativen Halbebene, nicht komplex und etwa
gleich sein, d.h. die Dynamik des neuen Systems enthält keine Schwingungen und alle
Zustandsgrößen nehmen nach ungefähr gleicher Zeit den Endzustand an. Diese Endverhalten
ist gerade bei der Laufkatze mit Pendel wünschenswert, da ein Überschwingen des Pendels in
der Endposition somit vermieden wird.
Polvorgabe: Es werden 4 Pole in der Nähe der negativen, reellen Achse bei λi=-4 gewählt.
Zu beachten ist, das kein mehrfacher Pol gewählt wird. Daraus folgt für die Koeffizienten pi
dem Reglervektor r und dem Vorfilter M:
Polvorgabe: P=[-4 –4.01 –4.02 –4.03]
Man kann r mittels des Matlabbefehls r=PLACE(A,b,P)oder mit (Gl. 5.6) bestimmen:
rT=[2.3688 4.8279 0.7939 0.7257] und M = r1 = 2.3688.
Es kann durch geschickte Polwahl bereits auf Anhieb ein gutes Resultat erzielt werden.Wenn
das Systemverhalten den Erfordernissen noch nicht genügt, wird man die Polplazierung
solange variieren bis ein zufriedenstellendes Ergebnis erreicht wird.
Abbildung 5.7: Sprungantwort des Krans mit Zustandsregler nach Ackermann
Wie zu erkennen, wird ein sehr gutes Übergangsverhalten, d.h. kein Überschwingen des
Pendels an der Endposition, erreicht. Das Pendel hat einen Maximalausschlag von 0.25 rad =
14°. Alle Systemzustände haben nach ca. 3 Sekunden ihren stationären Zustand erreicht.
Durch Linksverschieben der Pole könnte auf Kosten des Pendelausschlags das Zeitverhalten
verbessert werden.
Abbildung 5.8: Stellgröße u(t) des Krans mit Zustandsregler nach Ackermann
5.3 Riccati-Regler (LQ-Zustandsregler)
5.3.1 Grundlagen
Entwurfskriterium des Riccati-Regler ist die Minimierung eines quadratischen Gütemaßes.

Grundgedanke dieser Reglerentwurfsmethode ist aber auch hier die Steuerbarkeit eines
Systems, d.h. das ein System von Anfangszustand in einen beliebigen Endzustand in
endlicher Zeit überführt werden kann (der Riccati-Regler ist auch ein Zustandsregler) wenn es
steuerbar ist.
Das Gütemaß besteht aus zwei Forderungen und ist folgendermaßen definiert:
• Minimierung der erforderlichen Steuerenergie
• Optimieren des zeitlichen Übergangs (nicht zu langsam und ohne starke Schwingungen)
Diese beiden Forderungen kann man mathematisch durch ein quadratisches Gütemaß
ausdrücken:
∞
1
20
T
(
J = ∫ x Q x + u S u dt
T
) (5.8)
Die Gewichtsmatrizen Q und S sind im Normalfall Diagonalmatrizen, zudem müssen sie um

eine Minimierung von J zu ermöglichen positiv definit sein. Sie gewichten die einzelnen
Zustände x bzw. den Eingang u. Je größer die Gewichtung, desto kleiner wird die zu
gewichtende Größe nach der Minimierung sein. In anderen Worten: Möchte man z.B. wenig
Steuerenergie verbrauchen, so muß die zugeordnete Gewichtung in des Matrix S (beim
System Kran handelt es sich um einen Skalar S, da nur eine Eingangsgröße) nur groß genug
gewählt werden.
Die Minimierung der Gleichung (5.8) unter der Nebenbedingung dx=Ax+Bu

führt auf die Riccati-Gleichung (5.9). Herleitung s. [6 S. 480 ff].
Um den Regler R zu bstimmen. muß die Riccati-Gleichung nach P aufgelöst werden:

−1 T T
P⋅B⋅S B P− P⋅ A− A P−Q = 0 (5.9)
Der optimale Regler R ist dann:
−1 T
u = −S B P ⋅ x = − R ⋅ x (5.10)
5.3.2 Entwurf
Der Kran soll ein möglichst schwingungsarmes Übergangsverhalten und nicht zu langsam
sein. Dies widerspricht aber gleichzetig Forderung zwei nach einem geringen
Energieverbrauch. Ein schnelles, schwingsarmes Übergangsverhalten soll in dieser
Anwendung wichtiger als der Energieverbrauch sein. Daraus folgt für die Gewichtsmatrizen
Q und S:
Nach mehrmaligen Testen, wurde für die Gewichtsmatrizen gewählt:

S = 10,
150 0 0 0
 0 100 0 0
Q= 
 0 0 0 0
 
 0 0 0 0
Matlab bietet ein numerisches Lösungsverfahren der Riccati-Gleichung unter dem Befehl LQR
an. Durch Eingabe von [r,S,E] = LQR(A,b,Q,S,[0;0;0;0]) wird r bestimmt.
Q und S müssen positiv definit sein. Systemmatrix A und Eingangsvektor b wie bei
Polvorgabe. Es ergibt sich für den Reglervektor r:
rT=[3.873 2.8904 1.1073 0.1797]
Da auch hier kein Soll/Istwertvergleich stattfindet (s. Polvorgabe), muß noch ein konstanes
Vorfilter M = r1 bestimmt werden (s. Abb. 5.6).
M = r1 = 3.873
Abbildung 5.9: Sprungantwort des Krans mit Linear-Quadratic-Regler
Das Übergangsverhalten ist im Vergleich zum ersten Zustandsregler (Abb. 5.8) etwa um den
Faktor 1.5 schneller. Das Pendel hat dafür einen höheren Maximalausschlag von 0.5 rad. Die
Entwurfskriterien, d.h. kein Überschwingen in Endstellung und dynamisches Verhalten,
werden erreicht.
Abbildung 5.10: Stellgröße u(t) des Krans mit Linear-Quadratic-Regler
Alle Stellgrößen der drei vorgenannten Reglertypen haben ähnliche Struktur. Das lokale
Minimum zu Beginn verhindert zu starken Pendelausschlag.
5.4 Feedforward-Regler
5.4.1 Grundlagen
Das Modell 'Kran mit Zero Tracking Error State Controller' wird im Menüpunkt
Automatische Bahninterpolation verwendet.
Abbildung 5.11: Kran mit Zero Tracking Error State Controller
Der Zero Tracking Error State Controllers bietet folgende Vorteile:
Bei analytisch bekannter Trajektorie x(t) (wird vorher bzw. on-line berechnet) können die
Trägheitskräfte FT = m*x"(t) = m*a(t) und Reibungskräfte FR = Fr*x'(t) = Fr*v(t) berechnet
werden. Die Regler müssen nur noch die Fehler 0. Ordnung ausregeln. Die Positionsfehler
(Tracking Error) und Geschwindigkeitsfehler können falls das Systemmodell genau bekannt
sind, sehr klein gehalten werden.
5.4.2 Entwurf
Herleitungen der Regler und Übertragungsfunktionen des Positionsfehlers und

Geschwindigkeitsfehlers. Index p und g beziehen sich jeweils auf Positionsregler oder
Geschwindigkeitsregler (Kreis):
• Definitionen (s. Abb. 5.11):
X(s) Laplace-Transf. der x-Sollposition (Trajektorie)

R(s) x-Istposition (Ausgangsgröße: Position Kran)
F(s) Kraft (Eingangsgröße: Kran)
Gp(s)=R(s)/F(s) Übertragungsfunktion Kran (Kraft/Position)
Gg(s)=Gps Übertragungsfunktion Kran (Kraft/Geschwindigkeit)
Ep(s) Positionsfehler
Eg(s) Geschwindigkeitsfehler
Rp(s) Positionsregler
Rg(s) Geschwindigkeitsregler
B=Fr
• Herleitung Positionsfehler Ep(s):

Ep = X − R
R = F ⋅Gp
F = E g R g + sXB + s 2 XM
E g = E p R p + sX − sR
daraus folgt:
E p (s) 1 − G p ( s )( sB + s 2 M ) (5.11)
=
X (s) 1 + G p ( s )( R p + s ) R g
• Herleitung Geschwindigkeitsfehler Eg(s):
Eg(s)=EpRp+sX-sR=Ep(Rp+s) (5.12)
• Entwurf des Geschwindigkeitsreglers Rg(s):
Anmerkung: zuerst wird der Geschwindigkeits-Regelkreis (der Innere der

Kaskadenregelung) entworfen, wobei s2X(s)M+sX(s)B als Störung betrachtet wird.
Weiterhin wird zum Entwurf ein reduziertes Modell (s. Modellreduktion Kap. 2.3) des
Kranes verwendet, das aber dem wirklichen System Kran sehr gut entspricht (bis auf die
fehlende Resonanzstelle, die durch das Pendel verursacht wird)
Definition: Mit den Kran-Defaultwerten gilt:
0.1407 0.1407
G p _ red ( s ) =  → G g _ red ( s ) = G p _ red ( s ) ⋅ s =
s ( s + 5.117) s + 5.117
Fo _ g ( s ) = G g _ red ( s ) ⋅ R g ( s )
1
Fg _ g ( s ) =
1
+1
Fo _ g ( s )
Ig
K g (s + )
Ig Kg
Rg ( s) = K g + =
s s
Es bietet sich hier als Geschwindigkeitsregler Rg ein PI-Regler an, der den Pol von Gg_red
kürzt - zumindest theoretisch. Daraus folgt:
Ig
= 5.117
Kg
0.1407 ⋅ K g
Fo _ g ( s ) =
s
0.1407 ⋅ K g
Fg _ g ( s ) =
s + 0.1407 ⋅ K g
Regelkreis hat PT1-Verhalten mit der Zeitkonstante Tg=1/(Kg*0,1407), d.h:
Je größer Kg , desto schneller wird Sollgeschwindigkeit erreicht und desto kleiner werden
die Fehler von Position und Geschwindigkeit (näturlich Kg nicht zu groß wählen, da sonst
evtl. Reglerausgang an seine Grenzen fährt). Mit Ig=Kg*5,117 sind die beiden Parameter
von Rg bestimmt!
• Entwurf des Positionsreglers Rp(s)=Kp:
Bei der Wahl eines P-Reglers erhält der geschlossene Regelkreis PT2-Verhalten.
Durch Wahl von z.B. Kp=1/(4*Tg) bekommt die Übertragungsfunktion R(s)/X(s)
aperiodisches PT2-Verhalten mit der Zeitkonstanten Tg.
R( s) 1
= 2
X ( s)  
s + 1 
 2Tg 
 
(s. Punkt 5.5.4 Bahninterpolation)
5.5 Automatische Bahninterpolation (On-line Generator)
Bahninterpolationsverfahren können grob in zwei Gruppen eingeteilt werden: Einerseits

Strategien, die auf dem dynamischen Systemmodell basieren und andererseits Methoden, die
die kinematischen und meist empirisch festgelegten Grenzwerte für Geschwindigkeit,
Beschleunigung usw. einhalten. Aufgrund des relativ geringen Rechenzeitbedarfs eignet sich
letztere Methode zur On-line-Trajektorie-Generierung. Ein sanfter Trajektorieverlauf
erleichtert die Einhaltung der kinematischen Grenzwerte, vermeidet Reglersättigung und
verkleinert den Positionsfehler, zudem wird die Beanspruchung bzw. Abnutzung der
Systemkomponenten vermindert.
Die On-line-Trajektorie-Generierung erleichtert und beschleunigt die Programmierung des

Kransystems und erhöht somit die Produktivität eines Automatisierungssystems.
Die hier aufgeführte Methode zur Trajektorie-Generierung basiert auf einer Arbeit von Sonja
Mcfarlane [4]. Maximalwerte für Beschleunigung, Geschwindigkeit und Beschleunigungsrate
(jerk) werden entlang der ganzen Trajektorie eingehalten. Die Trajektorie wird durch eine
sequentielle Folge von Wegpunkten definiert. Sie besteht somit aus einer Folge von linearen
Teilstücken, die durch Splines (Übergangsfunktionen) an den Wegpunkten verbunden sind.
Um einen sanften sinusförmigen Trajektorieverlauf zu ermöglichen, wird jede Teiltrajektorie
zwischen zwei Wegpunkten durch Kontrollpunkte unterteilt. Für jeden Kontrollpunkt wird
durch einen Planer die Zeit, Position, Geschwindigkeit und die Beschleunigung bestimmt.
Aus diesen Werten können dann die Polynomparameter bzw. Splineparameter bestimmt und
an den Parser übergeben werden. Der Parser arbeitet die Liste der Kontrollpunkte ab, neue
können on-line hinzugefügt werden.
Dieser hier implementierte Algorithmus ist nur zeitsuboptimal, da die

Maximalgeschwindigkeit smax immer gleich der Endgeschwindigkeit des nächsten
Trajektorieteilstückes s2 gesetzt wird, d.h. auch bei erreichbarer Maximalgeschwindigkeit smax
wird nur auf s2<smax beschleunigt.
In Abbildung 5.11 wird ein ein typischer Trajektorieverlauf gezeigt. Die Einhaltung der
Maximalwerte für die Geschwindigkeit smax=s2, die Beschleunigung amax und die
Beschleunigungsrate jmax ist deutlich zu erkennen.
Abbildung 5.11: Trajektorieausschnitt
5.5.1 Planer
Der Planer entscheidet ob die vom Scheduler (Definition des Trajektorieverlauf durch den
User, z.B. mittels GUI oder als Wegpunkte-Strukt) übergebenen Wegpunkte mit der
angegebenen Geschwindigkeit und Genauigkeit angefahren werden können, ohne die
kinematischen Grenzwerte zu überschreiten. Gegebenfalls werden die Geschwindigkeiten
angepaßt oder auch sich deckende bzw. benachbarte Wegpunkte gelöscht. Daraufhin werden
die Kontrollpunkte (sie enthalten Zeitpunkt, Position, Geschwindigkeit und Beschleunigung)
der Teiltrajektorien berechnet und an den Parser übergeben.
On-line Trajektorie-Generation ist die Berechnung des nächsten Trajektoriesegments (wird
durch zwei Kontrollpunkte definiert) während das Kransystem das aktuelle Segment ausführt
[2]. Folgen mehrere Segmente sehr kurz hintereinander, ist es dem Planer evtl. nicht möglich
in der kurzen Zeitspanne, die gewünschten Kontrollpunkte zu berechnen. Es ist also sinnvoll,
je nach Schnelligkeit des Planers, eine Anzahl N von zukünftigen Kontrollpunkten im voraus
zu planen. Zusätzlich ist es notwendig, daß der letzte Wegpunkt immer ein Stopppunkt mit
Endgeschwindigkeit v=0 ist. Neue Wegpunkte können nach der Planung an die
Kontrollpunkt-Datenstruktur mit angepaßter Endpunktgeschwindigkeit angehängt werden.
Der Parser arbeitet die Kontrollpunkte nacheinander bis zum letzten Trajektoriesegment ab
und wartet auf neue Kontrollpunkte.
5.5.2 Parser
Um eine Trajektorie zwischen zwei Punkten zu berechnen, die die Start-u. Endpunkt-
bedingungen, d.h. Position, Geschwindigkeit und Beschleunigung für den Start- u. Endpunkt;
einhalten, sind 6 Freiheitsgrade notwendig. Es ist also mindestens ein Polynom 5. Ordnung
nötig, um allen Nebenbedingungen zu genügen. Ein Polynom 5. Ordnung bietet zusätzlich
den Vorteil einer ruckarmen Bewegung. Indem man den Polynomen passende Start- u.
Endbedingungen zuweist, ist es möglich einen sanften Trajektorieverlauf zu garantieren.
Für die Übergangsfunktionen von einem linearen Teilstück der Trajektorie zum nächsten wird
ein Spline 6. Ordnung [3] verwendet. Durch geeignete Parameterwahl können auch hier die
kinematischen Grenzwerte eingehalten werden.
5.5.2.1 Bestimmung der Polynom-Funktion q(t) für eine Teiltrajektorie:
Sind die kinematischen Größen (p,s,a) für alle Kontrollpunkte durch den Planer festgelegt,
können für alle linearen Teiltrajektorien die Polynomparameter durch den Parser berechnet
werden:
q (t ) = b0 + b1t + b2 t 2 + b3t 3 + b4 t 4 + b5 t 5
1 t1 t1
2
t1
3
t1
4
t1
5
 b0   p1 
 2 3 4    
0 1 2t1 3t1 4t1 5t1   b1   s1 
0 0 2 6t1 12t1
2
20t1  b2   a1 
3
 2 3 4 5  = 
1 t 2 t2 t2 t2 t 2  b3   p 2 
0 1 2t 2 3t 2
2
4t 2
3
5t 2  b4   s 2 
4
 2 3
   
0 0 2 6t 2 12t 2 20t 2  b5   a 2 
Die Parameter p1, s1 , a1 sind die Anfangswerte zum Startzeitpunkt t1 für Position,
Geschwindigkeit und Beschleunigung entlang der Trajektorie. Entsprechend handelt es sich
bei p2, s2 , a2 um die Endwerte zum Endzeitpunkt t2. Die Werte gelten entlang der Trajektorie
und sind folglich skalare Größen.
Das lineare Gleichungsystem 6. Ordnung läßt sich durch Nullsetzen von t1 in ein System 3.
Ordnung vereinfachen und somit die Lösung beträchtlich beschleunigen.
Mit pS als Startpunktvektor und pE als Endpunktvektor der Teiltrajektorie und q(t) als
Polynom 5. Ordnung, gilt somit zum Zeitpunkt tk in einem orthogonalen zweidimensionalen
Koordinatensystem für den Positions-, Geschwindigkeits- u. Beschleunigungsvektor:
Positionsvektor p(t):
ρ ρ
ρ  p x (t k )  ρ ( p E − pS )
p(t k ) =   = pS + ρ ρ q(t k )
 p y (t k ) pE − pS
Geschwindigkeitsvektor s(t):
ρ ρ
ρ  s x (t k )  ( p E − p S )
s (t k ) =  = ρ ρ q&(t k )
 s y (t k )  p E − p S
Beschleunigungsvektor a(t):
ρ ρ
ρ  a x (t k )  ( p E − p S )
a (t k ) =  = ρ ρ q& &(t k )
 a y (t k )  p E − p S
wobei gilt:
t2
t k = k∆t , 0≤k ≤
∆t
∆t ist das Samplingintervall.
Die Teiltrajektorie beginnt also für t=0 im Startpunkt und endet füt t=t2 imEndpunkt. An den
Parser müssen also pro linearer Teiltrajektorie nur folgende Parameter übergeben werden: pE ,
pS, b0 bis b5 und t2.
5.5.2.2 Splinefunktion x(σ k) zwischen zwei linearen Teiltrajektorien qi(t) und qi+1(t):
Es wird eine Übergangsfunktion 6. Ordnung nach Hayward und Lloyd [3] verwendet. Sie
bietet wie das Polynom 5 .Ordnung den Vorteil alle kinematischen Grenzwerte entlang der
Trajektorie einzuhalten und garantiert deshalb ein sanftes Übergangsverhalten von einem
Teilstück zum nächsten.
5.5.2.3 Splinefunktion x(σ k) zwischen zwei linearen Teiltrajektorien qi(t) und qi+1(t):
Es wird eine Übergangsfunktion 6. Ordnung nach Hayward und Lloyd [3] verwendet. Sie
bietet wie das Polynom 5 .Ordnung den Vorteil alle kinematischen Grenzwerte entlang der
Trajektorie einzuhalten und garantiert deshalb ein sanftes Übergangsverhalten von einem
Teilstück zum nächsten.
Abbildung 5.8: Splinefunktion mit Näherungsradius
Der Näherungsradius (tightness) legt fest, wie genau ein Wegpunkt angefahren werden muß.
Je größer er ist, desto schneller kann der Übergang gefahren werden, ohne die kinematischen
Grenzwerte zu überschreiten.
Die Schnittpunkte des tightness-Kreises mit der Trajektorie, bestimmen die Anfangs- u.
Endpunkte p1a, p1b der Übergangsfunktion. Die Punke p1a, p1b sind somit auch die neuen
Start- u. Endpunkte der linearen Trajektoriesegmente.
p0, p1 und p2 sind Wegpunkte der Trajektorie. Die Beschleunigung in den Anfangs- u.
Endpunkten der Trajektoire soll 0 und die Anfangs- u. Endeschwindigkeiten gleich sein. Die
Übergangszeit von p1a nach p1b ist 2τ. Die Übergangsfunktion ist zeitskaliert und muß nach
Berechnung rückskaliert werden.
Es gilt für den zeitskalierten Positionsvektor x(σ k ):

ρ ρ ρ ρ ρ
x (σ k ) = x1 (σ k ) + α (σ k )( x 2 (σ k ) − x1 (σ k )) − κβ (σ k )v d ,
tk 2τ
σk = , t k = k∆t , 0≤k ≤ ,
2τ ∆t
ρ ρ ρ
x1 (σ k ) = b1 + m1σ k ,
ρ ρ ρ
x 2 (σ k ) = b2 + m2σ k ,
α (σ k ) = 6σ k 5 − 15σ k 4 + 10σ k 3 ,
β (σ k ) = σ k 6 − 3σ k 5 + 3σ k 4 − σ k 3 ,
ρ ρ ρ ρ ρ
b1 = p1a , b2 = p1b − 2τv1b ,
ρ ρ ρ ρ
m1 = 2τv1a , m2 = 2τv1b ,
ρ ( pρ1 − ρ
p1a )
v1a (t ) = s ρ ρ , vρ = m ρ ρ
p1 − p1a d 2 − m1 ,
ρ ( pρ1b − pρ1 )
v1b (t ) = s ρ ρ , κ = 15 / 2.
p1b − p1
wobei:
Nach Rückskalierung mit σ=t/(2τ) des Geschwindigkeits– u. Beschleunigungsvektors v(σ )

und a(σ ) gilt:
ρ ρ t ρ
x (t ) = x ( ) = x (σ ),
2τ
ρ d ρ 1 ρ
v (t ) = x (σ ) = v (σ ),
dt 2τ
ρ d ρ 1 ρ
a (t ) = v (σ ) = a (σ ).
dt 2τ
An den Parser müssen also pro Übergangsfunktion nur die Parameter b1, b2, m1, m2 und τ
übergeben werden, um zum Zeitpunkt tk die Vektoren x, v und a zu bestimmen.
5.5.3 Implementierung On-line Generator

In diesen Abschnitt werden die wesentlichen Programmabschnitte der Funktionsblöcke des
On-line-Generators (s. Abb. 5.9) und die verwendeten Datenstrukturen erklärt.
Scheduler
Wegpunkt-Struct:
Position, Geschwindigkeit, Genauigkeit
Planer
Kontrollpunkt-Matrix:
Polynom- u. Splineparameter, Zeitpunkte
Parser
Trajektorie-Vektor:
p(tk), v(tk), a(tk)
System Kran
5.9: Informationsfluß Online-Generator
5.5.3.1 Datenstrukturen
• Wegpunkt-Struktur bei N Wegpunkten:
Die Wegpunkte werden vom User vorgegeben, vom Planer auf Machbarkeit geprüft, evtl.
angepaßt und an den Parser mittels der Kontrollpunktmatrix übergeben. Sie enthält die
Koordinaten der Wegpunkte mit der zugeordneten Geschwindigkeit und dem jeweiligen
Näherungsradius (tightness). Start- .u Endgeschwindigkeit werden immer auf s1=sN=0
gesetzt. Ebenso Start- .u Endtightness r1=rN=0, da diese Punkte exakt angefahren werden.
p1x p2x p3x p4x ... pNx

p1y p2y p3y p4y ... pNy
0 s2 s3 s4 ... 0
0 r2 r3 r4 ... 0
In Matlab werden die Wegpunktdaten in einen Strukt p zusammengefaßt:

% p enthält Wegpunkte
p.p;
% enthält die Geschwindigkeiten
p.speed;
% enthält die Näherungsradien
p.tightness;
• Kontrollpunkt-Matrix:
Die Kontrollpunktmatrix c enthält pro Zeile die Polynom-Koeffizienten bzw. Spline-

Koeffizienten, die zur Berechnung der Trajektorie notwendig sind. In der ersten Spalte
steht jeweils die Zeitdauer des jeweiligen Trajektoriesegments. Im Falle eines Splines hat
eine Matrixzeile folgenden Aufbau:
2τ 2τ b1x b1y b2x b2y m1x m1y m2x m2y 0
Im Falle eines Polynomes diese Struktur:
t b0 b1 b2 b3 b4 b5 pSx pSy pEx pEy
Um z.B. in Matlab auf die Polynom-Koeffizienten bi zuzugreifen, muß man beachten, daß
in Matlab der Index mit 1 startet. Wenn c die Kontrollpunkt-Matrix ist, folgt: b=c(1,2:7).
Es wird also auf die aktuelle, d.h. die erste Zeile der Matrix zugegriffen und der 2. bis 7.
Wert der Variablen b zugewiesen.
• Trajektorie:
Die Position-, Geschwindigkeits- und Beschleunigungs-Sollwert der x- u. y-Achse des

Kranes wird alle ∆t Sekunden berechnet und hat folgenden Aufbau:
rx ry vx vy ax ay
5.5.3.2 Funktion 'PLANER.M'
Der Planer entscheidet, ob die benutzerdefinierten Wegpunkte mit der gewünschten

Geschwindigkeit und Genauigkeit gefahren werden können und paßt die Werte entsprechend
an.
SCHEDULER:
Wegpunkte definieren und
zeichnen
PLANER:
Wegpunkte prüfen und
evtl. anpassen
geprüfte Wegpunkt-
Trajektorie zeichnen
Trajektorie berechnen,
d.h. Kontrollpunkt-matrix
erzeugen
Kontrollpunkt-
matrix
Abbildung 5.10: Flußdiagramm Planer

5.5.3.3 Funktion 'PARSER.M'
Die Funktion 'Parser.M' greift im Matlab-Workspace auf die vom Planer erzeugte
Kontrollpunkt-Matrix zu, und erzeugt die Trajektoriewerte zum Zeitpunkt t für das System
Kran. Die Zeilen der Kontrollpunkt-Matrix enthalten die Polynomparameter und
Splineparameter in der abzuarbeitenden Sequenz (s. Datenstruktur). Je nach Aufbau der
Kontrollpunktparameter wird entschieden, ob es sich um ein Polynom oder einen Spline
handelt. Ist der Kontrollpunkt abgearbeitet, wird er gelöscht und auf den nächsten
zugegriffen.
Diese Funktion wird alle ∆t Sekunden aufgerufen, sollte also in Assembler oder C
implementiert sein. Das hier realisierte M-File ist zur Simulation gut, unter Realtime-
Bedingungen aber nur bedingt geeignet.
aktueller Kontroll-
punkt, Zeit t
N
Polynom
Augenblickswert des Trajektoriesegment aus

Trajektoriesegemnt aus Splineparametern
Polynomparametern berechen.
berechen.
Ende der J
Teiltrajek-
torie ?
Kontrollpunkt löschen;
auf nächsten zugreifen
N
Ende der J
Trajektorie ?
N
auf nächsten Aufruf auf nächste
zum Zeitpunkt t+∆t Trajektorie warten
warten
Abbildung 5.11: Flußdiagramm-Parser

Dieses Beispiel wird die Genauigkeit der Regelung mit On-line-Generator verdeutlicht.
• Trajektorie-Definition:
Abbildung 5.17: Vergleich der benutzerdefinierten (a) mit der erzeugten Trajektorie (b)
Die Trajektorie wird mittels einer kleinen GUI definiert. In Abb. 5.17a sind die
Näherungsradien (tightness) eingezeichnet. Wegpunkt 1 ist Startpunkt und Wegpunkt 5 ist
Stopppunkt. Wegpunkte mit tightness=0 bzw Geschwindigkeit=0 werden exakt
angefahren. In Abbildung 5.17b ist der durch die Näherungsradien ermöglichte sanfte
Trajektorieverlauf zu erkennen. Die Radien wurden zu 0.1m, die Maximalgeschwindigkeit
zu 0.5m/s gewählt.
• Simulationergebnisse der x-Achse:
Abbildung 5.18: Zustandsvektor bei o.Trajektoriedefinition
In Abb. 5.18 ist das Einhalten der Anfangs-u. Endbedingung am Punkt 1 bzw. 5 (v=0) zu
erkennen. Durch den sanften Trajektorieverlauf wird der Pendelauschlag in Grenzen
gehalten
Abbildung 5.19: Stellgröße bei obiger Trajektoriedefinition

Abbildung 5.20: Positionsfehler des Feedforward-Reglers
Abbildung 5.21: Geschwindigkeitsfehler des Feedforward-Reglers
Positionsfehler (s. Abb. 5.20) und Geschwindigkeitsfehler (s. Abb. 5.21) liegen in der
Größenordnung 10-4 m bzw. 10-3 m. In Trajektoriesegmenten mit a = 0 gehen beide Fehler
gegen Null. Der vom On-line-Generator erzeugte sanfte Trajektorieverlauf ist also
verfolgbar (trackable). Die Genauigkeit der Regelung könnte durch Vergrößern der
Verstärkung bzw. durch verbesserte Übergangsfunktionen der Trajektorie noch verbessert
werden.
6 Zusammenfassung
In dieser Diplomarbeit wurde für einen regelungstechnischen Praktikumsversuch eine
virtuelle Versuchs- u. Arbeitsumgebung geschaffen. Der Praktikant erhält die Möglichkeit
über eine intuitiv und leicht zu bedienende Software einfache und komplexere Verfahren und
Methoden der Regelungstechnik kennenzulernen und anzuwenden. Hierzu wurde ein reales
System 'XY-Tisch mit Laufkatze und Pendel' grafisch und mathematisch modelliert. Das
virtuelle 3D-Modell der Krananlage wurde in VRML erstellt und mit Hilfe der Virtual Reality
Toolbox , einer Erweiterung von Simulink, animiert. Die regelungstechnischen
Anwendungen wurden mit Hilfe des Software MATLAB umgesetzt.
7 Literaturverzeichnis
[1] Sciavicco L., Siciliano B., “Modeling and Control of Robot Manipulators”, 1996: S. 167-256
[2] Bazaz, S., Tondu, B., “3-Cubic Spline for On-Line Cartesian Space Trajectory Planning of an
Industrial Manipulator”, International Workshop on Advanced Motion Control, 1998: S. 493-498.
[3] Lloyd, J., Hayward, V., “Trajectory Generation for Sensor-Driven and Time-Varying Tasks”,
International Journal of Robotics Research, Vol. 12, No. 4, 1993: S. 380-393.
[4] Macfarlane, S., “On-Line Smooth Trajectory Planning for Manipulators”, University of New
Brunswick, 2001.
[5] Schlüter Oliver, “VRML Sprachmerkmale, Anwendungen, Perspektiven.”, O’Reilly Verlag, Köln,
1. Auflage 1998.
[6] Otto Föllinger “Regelungstechnik”, Hüthig Verlag, Heidelberg, 7. Auflage 1992.
[7] Matlab Virtual Reality Toolbox Handbook 2001
[8] Matlab Build GUI Handbook 2001

Anhang: Software und Installationshinweise

Die Anwendungsdateien ins Arbeitsverzeichnis von Matlab kopieren und mit 'Kranparameter'
starten.
1. Anwendung:
Kranparameter.M Anwendungs-M-File (enthält Callback-Routinen und

Funktionen)
Kranparameter.Fig Anwendungs-Fig-File (enthält GUI)
Kranparameter.Mat enthält Anwender- u. Systemdaten
Planer.M Trajektorieplaner (für On-line-Generator)
Parser.M Trajektoriegenerator (für On-line-Generator)
2. Bild-Dateien (sollten sich im Order der Anwendung befinden, da keine Möglichkeit

zur GUI-Einbindung):
Blockstruktur.Jpg
Systemvariablen.Jpg
Untersysteme.Jpg
nichtlineare Gleichungen.Jpg
Zustandsraumbeschreibung.Jpg
Systemmatrix.Jpg
PRT-Logo.Jpg
Pendulum.Jpg
Pendel.Jpg
Reglerentwurf.Jpg
Simulation.Jpg
Bahninterpolation.Jpg
3. SIMULINK-Modelle:
Kran_PIDRegler_VR.Mdl
Kran_Zustandsregler_VR.Mdl
Kran_Steuerung_VR.Mdl
Online_Generator.Mdl
4. VRML-Modelle:
Kran.Wrl enthält Gesamtsystem mit Touchsensor

Kransteuerung.Wrl enthält virtuelle Kran-x-Achse und virtuellen Joystick

Sprache

Gantry Control

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Gantry Control

Hochgeladen von

Copyright:

Verfügbare Formate

Markus Stark 5032520 1

Einsatz von MATLAB-Werkzeugen für einen

eingereicht von: Markus Stark

Einsatz von MATLAB-Werkzeugen für einen

2. DAS SYSTEM 'KRAN MIT PENDEL' 6

2.2 Zustandsraumbeschreibung des linearisierten Modells 8

2.3 Übertragungsfunktionen des linearen Modells 9

3.1 Allgemeine Programminformation 11

3.3 Anwendung Kranregelung 20

4.1 Was ist VRML? 31

4.2 VRML – Grundlagen 32

4.3 Das VRML-Kranmodell 40

4.4 Die Virtual Reality Toolbox 45

4.5 Implementierung mit VR-Toolbox 47

5 KRANREGELUNG UND BAHNINTERPOLATION 52

5.2 Zustandsreglerentwurf durch Polvorgabe nach Ackermann 55

5.3 Riccati-Regler (LQ-Zustandsregler) 58

5.5 Automatische Bahninterpolation (On-line Generator) 63

ANHANG: SOFTWARE UND INSTALLATIONSHINWEISE 77

„Einsatz von Matlab-Werkzeugen für einen on-line Praktikumsversuch zur

Diese Arbeit verfolgt das Ziel dem Elektrotechnik-Studenten die Anwendung

• Variation der Parameter-Einstellungen für die Regelstrecke und deren Linearisierung,

2. Das System 'Kran mit Pendel'

Abbildung 2.1: Laufkatze mit Pendel

Abbildung 2.2: Blockstruktur des geregelten Systems

2.1 Mathematisches Systemmodell

Abbildung 2.3: Freikörperdiagramm von Kranwagen und Pendel

ϕ(t) Pendelauslenkung von der Ruhestellung [rad] (im Uhrzeigersinn positiv)

F(t) Kraft auf Kranwagen [N]

• Systemparameter und Definitionen

Θ Massenträgheitsm. des Pendels bei Drehung um Aufhängungspunkt [kg m2]

• Differentialgleichungen des Pendel

Horizontal und vertikal wirkende Kräfte am Aufhängungspunkt des Pendles

&(t ) = −V ⋅ l s ⋅ sin(ϕ (t )) − H ⋅ l s ⋅ cos(ϕ (t )) − C r ⋅ ϕ&(t )

• Differentialgleichung des Kranwagens (2. Axiom von Newton)

• Das mathematische Model des Systems 'Kran mit Pendel'

&(t ) + C r ⋅ ϕ&(t ) + M 1 ⋅ l s ⋅ g ⋅ sin(ϕ (t )) − M 1 ⋅ l s ⋅ &

2.2 Zustandsraumbeschreibung des linearisierten Modells

Für den klassischen Reglerentwurf ist ein nichtlineares Differentialgleichungsystem

Gleichungen (2.7), (2.8) in die Form

x&= f (x, u) (2.11)

transformieren und im zweiten Schritt Gleichung (2.11) um den Arbeitspunkt

Als Ergebnis der Linearisierung erhält man die lineare Zustandsraumbeschreibung:

x&(t ) = A ⋅ x(t ) + b ⋅ u (t ) (2.13)

mit N = M1ls und N12 = Θ M - N2

2.3 Übertragungsfunktionen des linearen Modells

Die Übertragungsfunktionen des linearen Modells werden für den PID-Reglerentwurf

&(t ) + C r ⋅ ϕ&(t ) + M 1 ⋅ l s ⋅ g ⋅ ϕ (t ) − M 1 ⋅ l s ⋅ &

Die Systemdynamiken von Gleichstrommotor, Leistungselektronik und Getriebe sind

u(t) Eingangsspannung des Umwandlers [V]

Die Gesamtverstärkung beträgt also Kw=KsCuig/(rgFr) und die Wagenzeitkonstante

Aus Gleichung (2.14) läßt sich die Übertragungsfunktion der Pendelauslenkung in

Mit Verstärkung Kp = M1 ls /Θ und Zeitkonstante Tp= Θ /Cr.

Übertragungsfunktion (2.17) mit (2.18) multipliziert ergibt die Übertragungsfunktion der

Auflistung der Funktionen der Anwendung:

• Systemparameter: Variation der Parameter-Einstellungen für die Regelstrecke

3.2 GUI-Implementierung [8]

Der GUI-Implementierungsprozeß besteht aus zwei wesentlichen Aufgaben:

Das folgende Diagramm verdeutlicht die Zusammenhänge:

Abbildung 3.1: Zusammenhang GUI figure und Code/Resource-file

• Programmablaufplan des Anwendungs-M-Files (s.Abb 3.2)

Abbildung 3.2: Programmablaufplan des Anwendungs-M-Files

function varargout = Kranregelung(varargin)