Sie sind auf Seite 1von 77

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

Markus Stark

5032520

2

Einsatz von MATLAB-Werkzeugen für einen on-line Praktikumsversuch zur Kranregelung

Diplomarbeit

on-line Praktikumsversuch zur Kranregelung Diplomarbeit Erklärung Ich versichere, dass ich diese 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

Markus Stark

5032520

3

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

Markus Stark

5032520

4

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

Markus Stark 5032520

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.

werden die Regler für jede Achse getrennt entworfen. Abbildung 2.1: Laufkatze mit Pendel Ziel der Regelung

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.

ohne Überschwingen des Pendels in die Endposition zu transportieren. Abbildung 2.2: Blockstruktur des geregelten Systems

Abbildung 2.2: Blockstruktur des geregelten Systems

Markus Stark 5032520

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.

Kräfte V und H sind in untenstehender Grafik eingezeichnet. Abbildung 2.3: Freikörperdiagramm von Kranwagen und Pendel

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 = M 0 + M 1

(2.1)

Θ = Θ s + M 1 l s 2

(Satz von Steiner)

(2.2)

Θ

Massenträgheitsm. des Pendels bei Drehung um Aufhängungspunkt [kg m 2 ]

Θ s

Massenträgheitsmoment im Bezug auf Schwerpunkt des Pendels [kg m 2 ]

C r

Reibungskonstante des Pendels [kg m 2 /s]

F r

Reibungskonstante des Kranwagens [kg/s]

M

Gesamtmasse Kranwagen und Pendel [kg]

M 0

Masse des Kranwagens [kg]

M 1

Masse des Pendels [kg]

l s

Abstand Pendelaufhängung-Pendelschwerpunkt [m]

g

Gravitationskonstante [m/s 2 ]

Differentialgleichungen des Pendel

Horizontal und vertikal wirkende Kräfte am Aufhängungspunkt des Pendles (Beschleunigung des Massenschwerpunktes):

H

=

M

2

1 t

2

[

r

(

t

)

+

l

s

sin(

ϕ

( ))]

t

(2.3)

Markus Stark 5032520

8

V

= −

M

1

2

t

2

[l s

cos(

( ))

ϕ

t

]

+

M g

1

Aus dem Drehimpulssatz folgt:

Θ s

ϕ&&

(t)

= −

V

l

s

sin(

ϕ

(t))

H

l

s

cos(

ϕ

(t))

C

r

ϕ&

(t)

(2.4)

(2.5)

Differentialgleichung des Kranwagens (2. Axiom von Newton)

M

0

&&

r t

( )

=

F ( t )

H

F r t

r

&

( )

(2.6)

Das mathematische Model des Systems 'Kran mit Pendel'

Einsetzen von Gleichungen (2.3) und (2.4) in Gleichungen (2.5) und (2.6) unter Verwendung von (2.1) u. (2.2) ergibt folgende nichtlineare Differentialgleichungen:

Θ⋅

M

&&

ϕ

( )

t

&&

r t

( )

+

+

C

r

F

r

& ( )

ϕ

t

&

r t

( )

+

M

1

M

1

l

s

l

s

g

[

&&

ϕ

( )

t

sin(

( ))

ϕ

t

M

1

cos(

( ))

ϕ

t

l

& ( ))

t

&&

r t

( )

(

s

ϕ

2

cos(

ϕ

( ))

=

t

( )]

sin(

ϕ

t

=

F

0

( )

t

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

x =

r t

(

&

(

t

( )

)

ϕ

)

r t

& ( )

ϕ

t

=

x

x

x

x

1

2

3

4

(2.9)

Gleichungen (2.7), (2.8) in die Form

x&= f (x,u)

(2.11)

und als Eingangssignal u=F(t)

(2.10)

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

x

A

=

x

1

x

x

x

2

3

4

=

=

=

=

r

A

0

0

0

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

Markus Stark 5032520

9

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

x & ( ) t = x t A ⋅ ( ) y ( )
x
& ( )
t
= x t
A
( )
y
( )
t
= x t
C
( )

+

+

b

d

( )

u t

( )

u t

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

A =

0



0

0

0

0

0

N

1

0

1

C

r

N

2


1


 

0

0

Θ

2


1


1

0

− Θ

2

g

F r

2

1

2

F N

b =

N 1 N

MNg

N 1

2

r

N N

C

r

M

2

N

N

2

N

2 1

N

1

mit N = M 1 l s und N 1 2 = Θ M - N 2

C =

1

0

0

0

0

1

0

0

0

0

1

0

0

0

0

1

d =

0

 

0

0

0

 

Das lineare zeitinvariante System ermöglicht nun die Anwendung der üblichen Reglerentwurfs-Techniken (und auch Beobachterentwurf falls zur Regelung nur ein Teil des Zustandsvektors zur Verfügung steht).

2.3 Übertragungsfunktionen des linearen Modells

Die Übertragungsfunktionen des linearen Modells werden für den PID-Reglerentwurf benötigt.

Das reale System verhält sich bei kleinen Pendelausschlägen nahezu linear. Es gilt also cos(ϕ(t)) 1 und sin(ϕ(t)) ϕ . Wenn man zusätzlich noch die Beeinflußung der Laufkatze durch die kleine Pendelmasse vernachlässigt, vereinfachen sich Gleichung (2.7) und (2.8) zu:

Θ⋅

M

ϕ&&

(

t

&&

r t

( )

)

+

+

C

r

F

r

ϕ&

( t )

&

r t

( )

+

=

l

s

M

F

1

( t )

g

( t )

ϕ

M

1

l

s

&&

r t

( )

=

0

(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: M 1 /M 0 = 7/0.06. Die Vereinfachung ist also absolut zulässig.

Markus Stark 5032520

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

F

t

( )

u(t)

=

K

S

C

U

i /

g

r g

u(t)

=

K u(t)

(2.16)

Eingangsspannung des Umwandlers [V]

K s Verstärkung des Umwandlers [A/V] C u elektromagnetische Konstante des Gleichstrommotors [Vs] i g /r g Getriebeübersetzung

Um die Zustandsmatizen an die neue Eingröße Spannung u(t) anzupassen, muß nur der b- Vektor mit K (s. Gl. 2.16) multipliziert werden.Gleichung (2.16) in (2.15) eingesetzt und laplacetransformiert, ergibt die Übertragungsfunktion der Wagenposition:

R

(

s

)

=

K

=

K

w

U

(

s

)

(

s M

s

+

F

r

)

(

s T

w

s

+

1)

(2.17)

Die Gesamtverstärkung beträgt also K w =K s C u i g /(r g Fr) und die Wagenzeitkonstante T w =(M 0 +M 1 )/F r.

Aus Gleichung (2.14) läßt sich die Übertragungsfunktion der Pendelauslenkung in Abhängigkeit der Wagenposition ableiten:

Φ (

s

)

(

R s

)

=

M

1

l

s

s

2

 

Θ⋅

s

2

+

C

r

s

+

M

1

l

s

g

=

K

p

s

2

s

2

+

1

T

p

s

+

K

p

g

(2.18)

Mit Verstärkung K p = M 1 l s /Θ und Zeitkonstante T p = Θ /C r.

Übertragungsfunktion (2.17) mit (2.18) multipliziert ergibt die Übertragungsfunktion der Pendelauslenkung in Abhängigkeit der Spannung:

=

 

K

p

K

w

2

Φ (

s

)

=

T

w

 

s

U

(

s

)

s

2

+

1

T

p

s

+

K

p

K

p

g

K

w

s

+

2

1

T

w

s

 

T

w

s

 

4

+

1

+

1

3

+

1

+

K

2

+

K

s

T

p

T

w

 

s

T

p

T

w

p

g

s

p

g

s

(2.19)

Markus Stark 5032520

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:

Markus Stark 5032520

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:

Das folgende Diagramm verdeutlicht die Zusammenhänge: Abbildung 3.1: Zusammenhang GUI figure und

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

Markus Stark 5032520

13

Markus Stark 5032520 1 3 Abbildung 3.2: Programmablaufplan des Anwendungs-M-Files • GUI-Initialisierung Der

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

Markus Stark 5032520

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

end

GUI-Theorie

end

disp(lasterr);

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.

Markus Stark 5032520

15

Das folgende Code steht im Initialisierungsteil des M-files und verdeutlicht diese Technik:

fig = openfig(mfilename,'reuse'); handles = guihandles(fig);

handles.System.Cr = 0.00035

guidata(fig,handles);

% Öffnet GUI falls nicht schon geöffnet % Erzeugt handles-Datenstruktur der GUI- Komponenten % Fügt die globalen Anwenderdaten hinzu

% 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, sys=SS(A,B,C,D);

handles.System.Cont=sys;

,handles.System.g);

% fügt der handles-Struktur weitere Anwenderdaten hinzu % Sichert die aktualisierte Struktur

guidata(fig,handles);

return

3.2.2 Dateiorganisation

a) Programmdateien

Kranregelung.M

Kranregelung.FIG

Anwendungs-M-file (enthält den Code) Anwendungs-FIG-file (enthält die GUI-Ressourcen)

b) vom Programm erzeugte Dateien und Datenstrukturen

Kranparameter.MAT

handles-Datenstruktur

Sicherungsdatei der Anwenderdaten; wird bei Programmstart geladen und beim Beenden gesichert. Falls noch nicht vorhanden, wird diese Datei generiert 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 pushbutton_laden: 137.0002 menu_Beenden: 121.0002 menu_Hilfe: 120.0002

System: [1x1 struct]

% pointer auf das GUI-Window % pointer auf pushbutton 'Laden' % pointer auf Menü 'Beenden' % usw

% Anwenderdaten

vollständige Struktur der Anwenderdaten

handles.System = Cr: 0.00035 Fr: 36.5000

% Reibungskonstante des Pendels in [kgm^2/s] % Reibungskonstante des Wagens in [kg/s]

Markus Stark 5032520

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]

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;

Fry = 27.46;

Ks = 1.7; % Umwandler [A/V]

Cu = 0.057; % Motorkonstante [Vs]

ig = 100/21; rg = 0.019719;

ContY: [2x1 ss] % Zeitkont. lin. Zustandsraummodell des Kranes-Y-Achse

Polvorgabe=[

Zustandsregler=[ ]; PID_Regler=[ ]; LQ_Regler=[ ]

% Zeitkont. lin. Zustandsraummodell der Kran-X-Achse

% Masse der gesamten x-Achse [kg] % Reibungskoef. der y-Achse

% Übersetzungsverhältnis [1/m] % Längenkonstante [m]

Regler-Parameter

];%

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.

Markus Stark 5032520

17

c) Simulink-Modelle

KranZustandsreglerVR.MDL

KranPIDreglerVR.MDL

KranSteuerungVR.MDL

OnlineGenerator.MDL

Planer.M

Parser.M

d) VRML-Modelle

enthält System Kran mit Zustandsregler und VRML- Model. Ist Startpunkt zur Simulation mit VR-Toolbox enthält System Kran mit PID-Regler und VRML-Modell enthält offene Kranstrecke und VRML-Modell Zero Order Error Tracking Controller mit online erzeugter Trajektorie Interaktive Trajektoriedefinition (wird im OnlineGenerator verwendet) On-line Trajektoriegeneration

Kranstrecke.WRL

KranVR.WRL

Interaktion mit Kranstrecke (offen) mittels virtuellen Joysticks 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

%

% r Position

% Eingabe: Systemparameter des Kranes, Naturkonstanten

% Ausgabe: Zustandsraumdarstellung des linear. Kranmodells

%--------------------------------------------------------------------

phi

Winkel

(pos. im Uhrzeigersinn)

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;

Markus Stark 5032520

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

Markus Stark 5032520

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

2. gewünschte Uicontrols, z.B. Bode-Plot (axes-Objekt) berechnen und anzeigen

3. fertig – warte auf nächsten Userinput

) löschen

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

Markus Stark 5032520

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.

nicht vorhanden ist, wird sie aus Defaultwerten generiert. Abbildung 3.3: Haupt- bzw. Startfenster mit Hauptmenü 3.3.1

Abbildung 3.3: Haupt- bzw. Startfenster mit Hauptmenü

3.3.1 Systemparameter

Markus Stark 5032520

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.

wiederhergestellt werden. Eingabemaske siehe Abb. 3.4. Abbildung 3.4: Systemparameter-Eingabemaske 3.3.2

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

Markus Stark 5032520

22

Markus Stark 5032520 2 2 Abbildung 3.5: Systemlinearisierung 3.3.3 Systemdarstellung Hier hat der Anwender die

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-

Markus Stark 5032520

23

Abbildung 3.6: Systemdarstellung

Markus Stark 5032520 2 3 Abbildung 3.6: Systemdarstellung stellen. Zusätzlich besteht die Wahl zwischen der

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

FOH (First Order Hold):

Das Signal wird zwischen den Abtastwerten konstant gehalten (Sample & 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.

Markus Stark 5032520

24

Markus Stark 5032520 2 4 Abbildung 3.7: Pol / Nullstellen-Plot Da es sich beim Kran um

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.

( ) =

x t

r

t

t

( )

t

(

)

(

ϕ

&

r

&

ϕ

( )

t

)

r(t)

phi(t)

dr(t)/dt

d(phi(t)/dt

Position

Winkel

des Kranwagens

des Pendels

Geschwindigkeit

des Kranwagens

Winkelgeschwindigkeit

des Pendels

des Kranwagens Winkelgeschwindigkeit des Pendels Abbildung 3.8: Optionsmenü Teilsystemauswahl Abbildung 3.9:

Abbildung 3.8: Optionsmenü Teilsystemauswahl

Abbildung 3.9:

Markus Stark 5032520 2 5 Mit Hilfe des I/O-Selectors (s. Abb. 3.9) können Teilsysteme des

Markus Stark 5032520

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.

Es gelten die Optionen des Maustasten von Punkt 3.3.4. Abbildung 3.10: Nyquist-Plot Es kann hier noch

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.

Markus Stark 5032520

26

Markus Stark 5032520 2 6 Abbildung 3.11: Bode-Plot Es kann auch hier noch der darzustellende Frequenzbereich,

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.

Wurzelortskurven. Optionen des Maustasten siehe Punkt 3.3.4. Abbildung 3.12: Wurzelortskurve 3.3.8 Sprungantwort und

Abbildung 3.12: Wurzelortskurve

Markus Stark 5032520

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

auch die Optionen der Maustasten (siehe Kapitel 3.3.4). Abbildung 3.13: Sprungantwort des Systems Abbildung 3.14:

Abbildung 3.13: Sprungantwort des Systems

Kapitel 3.3.4). Abbildung 3.13: Sprungantwort des Systems Abbildung 3.14: Impulsantwort 3.3.9 Reglerentwurf Im

Abbildung 3.14: Impulsantwort

3.3.9 Reglerentwurf

Im Untermenü 'Reglerentwurf' kann zwischen drei Reglertypen gewählt werden:

Markus Stark 5032520

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.

und das veränderte Systemverhalten sofort beurteilt werden. Abbildung 3.15: Reglerentwurf 3.3.10 Simulation Nach

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:

Markus Stark 5032520

29

Markus Stark 5032520 2 9 Abbildung 3.16: Simulation: Simulink-Modell 'Kran mit Zustandsregler' Um die

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

sich hier um einen Feedforward-Regler (s. Abb. 3.17). Abbildung 3.17: Kran mit Zero Tracking Error State

Abbildung 3.17: Kran mit Zero Tracking Error State Controller (Feed Forward Controller)

Markus Stark 5032520

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

Markus Stark 5032520

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.

Markus Stark 5032520

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:

Markus Stark 5032520

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 [ werden immer in Kleinbuchstaben geschrieben!

].

Felder

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.

Markus Stark 5032520

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)

Markus Stark 5032520

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

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.

Formen und soll die VRML-Syntax zeigen (s. Abb

).

Der vierte Wert legt den Drehwinkel in Radiant, also 90°=π/2 rad=1.57

rad, fest.

Drehwinkel in Radiant, also 90°= π /2 rad=1.57 rad, fest. Abbildung 4.1: Geometrie und Transformation (Beispiel

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 }

Markus Stark 5032520

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 {

Markus Stark 5032520

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.

benannten Knotens erzeugt und dann wiederverwendet werden. Abbildung 4.2: Wiederverwendbarkeit (Beispiel 4) Beispiel 4:

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

Markus Stark 5032520

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

Markus Stark 5032520

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:

folgende Nachrichtenverbindungen zwischen den Objekten: Abbildung 4.3: Nachrichtenverbindungen Während der rtimer (

Abbildung 4.3: Nachrichtenverbindungen

Während der rtimer (TimeSensor-Knotens) ununterbrochen das Versteichen der Zeit registriert und mittels des Ereignisses fraction_changed dem rengine (OrientationInterpolation-Knoten) mitteilt, ermittelt rengine anhand der verstrichenen Zeit (set_fraction) die aktuelle Objektposition. Diese wird verändert (value_changed) und dem entsprechenden Objekt mitgeteilt und über das Ereignis set_rotation im robjekt (Transform)Um Ereignisseaktualisiert.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

Markus Stark 5032520

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.

Markus Stark 5032520

41

Markus Stark 5032520 4 1 Abbildung 4.4: VRML-Kranmodell 4.3.1 Aufbau des VRML-Modells x-Achse: • Laufkatze •

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

Sollpositionsmarkierung:

Markus Stark 5032520

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

nicht gut zu erkennen sind. • Laufkatze mit Pendel Abbildung 4.5: VRML-Laufkatze mit Pendel • Laufschiene

Abbildung 4.5: VRML-Laufkatze mit Pendel

Laufschiene mit Zahnriemen

Abbildung 4.6: reale Laufkatze

mit Pendel Abbildung 4.5: VRML-Laufkatze mit Pendel • Laufschiene mit Zahnriemen Abbildung 4.6: reale Laufkatze

Markus Stark 5032520

43

Abbildung 4.7: VRML-Laufschiene mit Zahnriemen

Markus Stark 5032520

44

Markus Stark 5032520 4 4 Abbildung 4.8: reale Laufschiene der x-Achse • Endschalter: Abbildung 4.9: VRML-Endschalter

Abbildung 4.8: reale Laufschiene der x-Achse

Endschalter:

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

Abbildung 4.9: VRML-Endschalter

Näherungssensor:

Abbildung 4.9: VRML-Endschalter • Näherungssensor: Abbildung 4.11: VRML-Näherungssensor Abbildung 4.10: realer

Abbildung 4.11: VRML-Näherungssensor

• Näherungssensor: Abbildung 4.11: VRML-Näherungssensor Abbildung 4.10: realer Endschalter Abbildung 4.12: realer

Abbildung 4.10: realer Endschalter

Abbildung 4.11: VRML-Näherungssensor Abbildung 4.10: realer Endschalter Abbildung 4.12: realer Näherungssensor

Abbildung 4.12: realer Näherungssensor

Markus Stark 5032520

45

Gleichstrommotor der x-Achse:

Stark 5032520 4 5 • Gleichstrommotor der x-Achse: Abbildung 4.13: VRML-Motor Abbildung 4.14: realer

Abbildung 4.13: VRML-Motor

Gleichstrommotor der x-Achse: Abbildung 4.13: VRML-Motor Abbildung 4.14: realer Gleichstrommotor Wie bereits

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,

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.

implementiert werden. Fügt man diese Blöcke in ein Simulink-

)

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

Markus Stark 5032520

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.

zu verbessern, bietet sich ein Fülle von Möglichkeiten an. Abb. 4.15: Baumstruktur Abb. 4.16: Sollpositionsmarkierung

Abb. 4.15: Baumstruktur

ein Fülle von Möglichkeiten an. Abb. 4.15: Baumstruktur Abb. 4.16: Sollpositionsmarkierung (grüner Kegel) Welche

Abb. 4.16: Sollpositionsmarkierung (grüner Kegel)

Welche Felder des VRML-Kranmodells können für die Regelungsanwendung sinnvollerweise benutzt werden?

Pendel.rotation:

Kran.translation:

AchseX.translation:

Marker.translation:

Wird benutzt um den Pendelauschlag zu definieren

Wird gebraucht um die x-Position der Laufkatze festzulegen

Legt die y-Position der gesamten x-Achse fest

Gibt die Sollposition an Simulink weiter

Markus Stark 5032520

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:

ZahnradGross.rotation:

Schalterhebel.rotation:

Rotation mit Winkelgeschwindigkeit des Motor Rotation mit übersetzer Winkelgeschwindigkeit 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.

für die anderen Simulink-Modelle mit PID- o. LQ-Regler. Abbildung 4.17: Simulink-Modell 'Kran mit

Abbildung 4.17: Simulink-Modell 'Kran mit Zustandsregler'

4.5.1 Funktionsbeschreibung der Simulink-Blöcke (s. Abb. 4.17):

Block 'Kran x-Achse'

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

Abbildung 4.18: Simulink-Modell der Laufkatze mit Pendel (x-Achse)

Markus Stark 5032520

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'

r

=

K

x ( t )

=

[

K

1

K

2

K

3

K