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.2.3 Simulationsergebnisse 57

5.3 Riccati-Regler (LQ-Zustandsregler) 58 5.3.1 Grundlagen 58 5.3.2 Entwurf 59 5.3.3 Simulationsergebnisse 59

5.4 Feedforward-Regler 61 5.4.1 Grundlagen 61 5.4.2 Entwurf 61 5.4.3 Simulationsergebnisse 63

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 5.5.4 Simulationsergebnisse 72

6 ZUSAMMENFASSUNG 75

7 LITERATURVERZEICHNIS 76

ANHANG: SOFTWARE UND INSTALLATIONSHINWEISE 77

Markus Stark 5032520

5

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


6

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


7

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.3) [ ]))(sin()(

2

2

1 tltrt

MH s ϕ⋅+∂

∂=


8

),( uxfx =&

(2.4)

Aus dem Drehimpulssatz folgt:

(2.5)

• Differentialgleichung des Kranwagens (2. Axiom von Newton)

(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:

(2.7)

(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:

(2.9) und als Eingangssignal u=F(t) (2.10)

Gleichungen (2.7), (2.8) in die Form

(2.11)

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

(2.12)

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!

[ ] gMtlt

MV s 12

2

1 ))(cos( +⋅∂

∂−= ϕ

)())(cos())(sin()( tCtlHtlVt rsss ϕϕϕϕ &&& ⋅−⋅⋅−⋅⋅−=⋅Θ

)()()(0 trFHtFtrM r&&& −−=

=

=

4

3

2

1

)(

)(

)(

)(

x

x

x

x

t

tr

t

tr

x

ϕ

ϕ

&

&

=

=

=

=

=

0

0

0

4

3

2

1

x

x

x

rx

x

A

A

[ ] )()(sin())(())(cos()()()(

0))(cos()())(sin()()(2

1

11

tFttttlMtrFtrM

ttrlMtglMtCt

sr

ssr

=⋅−⋅⋅⋅−⋅+⋅

=⋅⋅⋅−⋅⋅⋅+⋅+⋅Θ

ϕϕϕϕ

ϕϕϕϕ

&&&&&&

&&&&&


9

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

(2.13)

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.

mit N = M1ls und N1

2 = Θ M - N

2

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:

(2.14) (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.

)()()(

)()()(

tudtxCty

tubtxAtx

⋅+⋅=

⋅+⋅=&

−−−

−Θ−−=

2

1

2

1

2

1

2

1

2

1

2

1

2

0

0

1000

0100

N

MC

N

NF

N

MNg

N

NC

N

F

N

gNA

rr

rr

=

0

0

0

0

d

Θ=

2

1

2

1

0

0

N

N

Nb

=

1000

0100

0010

0001

C

)()()(

0)()()()( 11

tFtrFtrM

trlMtglMtCt

r

ssr

=⋅+⋅

=⋅⋅−⋅⋅⋅+⋅+⋅Θ

&&&

&&&&& ϕϕϕ


10

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):

(2.16)

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:

(2.17)

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:

(2.18)

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:

(2.19)

)()()( tuKtur

iCKtF

g

g

US ⋅=⋅/

⋅⋅=

)1()()(

)(

+⋅=

+⋅=

sTs

K

FsMs

K

sU

sR

w

w

r

gKsT

s

sK

glMsCs

slM

sR

s

p

p

p

sr

s

⋅++

⋅=

⋅⋅+⋅+⋅Θ

⋅⋅=

Φ

1)(

)(

2

2

12

21

sT

sgKsT

s

sT

KK

sU

s

w

p

p

w

wp

⋅

+⋅

⋅++

⋅⋅

=Φ

11)(

)(

2

2

sgKsgKTT

sTT

s

sT

KK

pp

wpwp

w

wp

⋅⋅+⋅

⋅+

⋅+⋅

++

⋅⋅

=234

2

111


11

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:


12

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).


13

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


14

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.


15

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]


16

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.


17

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;


18

% 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}); Pol2 = str2num(answer{2,1}); Pol3 = str2num(answer{3,1}); Pol4 = str2num(answer{4,1}); P=[Pol1 Pol2 Pol3 Pol4];


19

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


20

%---------------------------------------------------------- % 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


21

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


22

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-


23

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.


24

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)...Position des Kranwagens phi(t)...Winkel des Pendels dr(t)/dt...Geschwindigkeit des Kranwagens d(phi(t)/dt...Winkelgeschwindigkeit des Pendels

Abbildung 3.8: Optionsmenü Abbildung 3.9: Teilsystemauswahl

=

)(

)(

)(

)(

)(

t

tr

t

tr

tx

ϕ

ϕ

&

&


25

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.


26

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


27

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:


28

• 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:


29

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)


30

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: • 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.


31

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.


32

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:


33

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).


34

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)


35

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 } appearance Appearance {

material Material { diffuseColor 1 0 0 }


36

} }

] } # 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} appearance Appearance {

material Material { diffuseColor 0 1 0 } }

} ]

}

• 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 {


37

url "http://www.fernuni-hagen.de/" description "Link zur Fernuni-Homepage" children [

Shape { appearance Appearance {

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}

appearance Appearance { material Material { diffuseColor 0 1 0 }

} } Transform {

rotation 0 0 1 1.0472 children USE ACHSE


38

} 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


39

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) aktualisiert. Um Ereignisse 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


40

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.


41

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:


42

• 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


43

Abbildung 4.7: VRML-Laufschiene mit Zahnriemen


44

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


45

• 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


46

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


47

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)


48

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'

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:

[ ]

⋅=⋅=

)(

)(

)(

)(

)( 4321

t

tr

t

tr

KKKKtxKr

ϕ

ϕ

&

&


49

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)]


50

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:


51

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: • 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. 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.


52

• 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.


53

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.

Gesamtverstärkung k < 2 wählen (Wurzelortskurve) -> kR=2/3

Das geregelte System hat folgende Struktur:

Abbildung 5.3: PID-Regelung

)1()(

3)(

+=

=Φ

wRR sTksG

sG


54

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).


55

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 y(t) - x(t)

Abbildung 5.6: Regelung des Zustandsvektors

(5.1) (5.2) (5.3) (5.4)

dx/dt=A*x+b*u

r

M

( )

[ ]( )[ ]

[ ]4321111100

01

1

01

1

],...,,[

...det

...det

)()(

)()(

)()()(

rrrrapapapr

pspsrbAIs

asasAIs

txrbAtx

txrtu

tubtxAtx

nn

T

n

n

n

n

n

n

=−−−=

+++=⋅−−⋅

+++=−⋅

⋅⋅−=

⋅−=

⋅+⋅=

−−

−−

−−

&

&


56

(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, S.467]. Es gilt:

(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:

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

1

11

1

0

rM

wxy

xrwMu

=

==

=−⋅=

∞∞∞

∞∞∞

=

0.08916- 17.67-33.54-0

0.0001695- 5.136- 0.06374-0

1000

0100

A

=

3.11

2.3

0

0

b


57

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: r

T=[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.


58

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:

(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

( )∫∞

+=02

1dtuSuxQxJ

TT


59

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:

(5.9)

Der optimale Regler R ist dann:

(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:

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: r

T=[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


01=−−⋅−⋅⋅

−QPAAPPBSBP

TT

xRxPBSuT

⋅−=⋅−=−1

=

=

0000

0000

001000

000150

,10

Q

S


60

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.


61

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


62

Eg(s) Geschwindigkeitsfehler Rp(s) Positionsregler Rg(s) Geschwindigkeitsregler B=Fr

• Herleitung Positionsfehler Ep(s):

daraus folgt:

(5.11)

• 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 s2

X(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:

Es bietet sich hier als Geschwindigkeitsregler Rg ein PI-Regler an, der den Pol von Gg_red

kürzt - zumindest theoretisch. Daraus folgt:

sRsXREE

XMssXBREF

GFR

RXE

ppg

gg

p

p

−+=

++=

⋅=

−=

2

))((1

))((1

)(

)( 2

gpp

pp

RsRsG

MssBsG

sX

sE

++

+−=

s

K

IsK

s

IKsR

sF

sF

sRsGsF

sssGsG

sssG

g

g

g

g

gg

go

gg

gredggo

redpredgredp

)(

)(

1)(

11

)(

)()()(

117.5

1407.0)()(

)117.5(

1407.0)(

_

_

__

___

+

=+=

+

=

⋅=

+=⋅=→

+=

g

g

gg

g

go

g

g

Ks

KsF

s

KsF

K

I

⋅+

⋅=

⋅=

=

1407.0

1407.0)(

1407.0)(

117.5

_

_


63

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.


(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.

2

2

1

1

)(

)(

+

=

gTs

sX

sR


64

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


65

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:

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):

55

44

33

2210)( tbtbtbtbtbbtq +++++=

=

2

2

2

1

1

1

5

4

3

2

1

0

3

2

2

22

4

2

3

2

2

22

5

2

4

2

3

2

2

22

3

1

2

11

4

1

3

1

2

11

5

1

4

1

3

1

2

11

20126200

543210

1

20126200

543210

1

a

s

p

a

s

p

b

b

b

b

b

b

ttt

tttt

ttttt

ttt

tttt

ttttt

)()(

)(

)()( k

SE

SE

S

ky

kx

k tqpp

ppp

tp

tptp ρρ

ρρρρ

−

−+=

=


66

Geschwindigkeitsvektor s(t):

Beschleunigungsvektor a(t):

wobei gilt:

∆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.

)()(

)(

)()( k

SE

SE

ky

kx

k tqpp

pp

ts

tsts &ρρ

ρρρ

−

−=

=

)()(

)(

)()( k

SE

SE

ky

kx

k tqpp

pp

ta

tata &&ρρ

ρρρ

−

−=

=

,tktk ∆= t

tk

∆≤≤ 20


67

,)())()()(()()( 121 dkkkkkk vxxxxρρρρρ

σκβσσσασσ −−+=

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 ):

wobei: Nach Rückskalierung mit σ=t/(2τ) des Geschwindigkeits– u. Beschleunigungsvektors v(σ )

und a(σ ) gilt:

,2τ

σ k

k

t= ,

20

tk

∆≤≤

τ,tktk ∆=

,)( 111 kk mbx σσρρρ

+=

,)( 222 kk mbx σσρρρ

+=

,10156)( 345

kkkk σσσσα +−=

,33)( 3456

kkkkk σσσσσβ −+−=

,12 mmvd

ρρρ−=

.2/15=κ

,2

,

11

11

a

a

vm

pbρρ

ρρ

τ=

=

,2

,2

12

112

b

bb

vm

vpbρρ

ρρρ

τ

τ

=

−=

( ),)(

11

111

a

a

app

ppstv ρρ

ρρρ

−

−=

( ),)(

11

111

pp

ppstv

b

b

b ρρ

ρρρ

−

−=


68

).(2

1)()(

),(2

1)()(

),()2

()(

στ

σ

στ

σ

στ

avdt

dta

vxdt

dtv

xt

xtx

ρρρ

ρρρ

ρρρ

==

==

==

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.


69

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. Wegpunkt-Struct:

Position, Geschwindigkeit, Genauigkeit

Kontrollpunkt-Matrix: Polynom- u. Splineparameter, Zeitpunkte

Trajektorie-Vektor: p(tk), v(tk), a(tk)

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;

Scheduler

Planer

Parser

System Kran


70

• 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.

Abbildung 5.10: Flußdiagramm Planer

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


71

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. N J J N J N

Abbildung 5.11: Flußdiagramm-Parser

Ende der Teiltrajek-torie ?

aktueller Kontroll- punkt, Zeit t

Trajektoriesegment aus Splineparametern berechen.

Augenblickswert des Trajektoriesegemnt aus Polynomparametern berechen.

Polynom

Kontrollpunkt löschen; auf nächsten zugreifen

Ende der Trajektorie ?

auf nächsten Aufruf zum Zeitpunkt t+∆t warten

auf nächste Trajektorie warten


72


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.


73

• 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


74

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.


75

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.


76

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


77

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

Gantry Control

Documents

Transcript of Gantry Control