Einführung in MATLAB und Simulink - Hochschule Heilbronn · PDF fileEinführung in...

MSc. Dipl.-Ing. (FH) U. Ingelfinger

Automotive

Systems

Engineering (ASE)

Elektronik

und

Informationstechnik (EL)

Einführung

in

MATLAB und Simulink

V 3.0

Labor Signalverarbeitung, Regelungstechnik


Inhalt

1 DAS MATLAB PAKET ......................................................................................... 1

1.1 Grundlagen der Befehlskonsole ............................................................................................................... 3

1.2 Vordefinierte Konstanten ......................................................................................................................... 5

1.3 Datentypen ................................................................................................................................................. 6 1.3.1 Einfache Datentypen und Variablen(typen)deklaration ...................................................................... 6 1.3.2 Konvertieren von Datentypen ............................................................................................................. 8 1.3.3 Zusammengesetzte Datentypen: Strukturen ........................................................................................ 9 1.3.4 Übersicht über Funktionen im Zusammenhang mit Datentypen und Variablen ............................... 10

1.4 Funktionshandles, anonyme Funktionen .............................................................................................. 11

1.5 MATLAB Hilfe ........................................................................................................................................ 14 1.5.1 help-Funktion .................................................................................................................................... 14 1.5.2 lookfor-Funktion ............................................................................................................................... 14 1.5.3 Hilfe zu häufig benötigten Themengebieten ..................................................................................... 15

1.6 Matrizen und Vektoren .......................................................................................................................... 16 1.6.1 Matrizendefinition und Matrizenelemente ........................................................................................ 16

1.6.1.1 Matrizendefinition ......................................................................................................................... 16 1.6.1.2 Zugriff auf Matrixelemente bzw. eine Untermatrix ...................................................................... 17 1.6.1.3 Bilden einer Matrix aus mehreren Matrizen .................................................................................. 18 1.6.1.4 Umgang mit mehrdimensionalen Matrizen .................................................................................. 18

1.6.2 Spezielle Matrizen und Vektoren ...................................................................................................... 19 1.6.3 Matrizenmanipulationen .................................................................................................................... 21

1.6.3.1 Ändern von Werten ....................................................................................................................... 21 1.6.3.2 Löschen von Elementen und erweitern um Elemente ................................................................... 21

1.6.4 Rechnen mit Matrizen ....................................................................................................................... 22 1.6.4.1 Matrizenoperationen ...................................................................................................................... 22 1.6.4.2 By Element Operationen ............................................................................................................... 23

1.6.5 Allgemeine Matrizen Funktionen ...................................................................................................... 24

1.7 Cell Arrays ............................................................................................................................................... 25

1.8 MATLAB Befehlsskripte (m-Files) ........................................................................................................ 28 1.8.1 Skriptdateien ..................................................................................................................................... 28

1.8.1.1 Funktionsfiles ................................................................................................................................ 28 1.8.1.2 Kommandofiles ............................................................................................................................. 30

1.8.2 Sprachgrundkonstrukte...................................................................................................................... 31 1.8.2.1 Boolesche Operatoren und Ausdrücke .......................................................................................... 31 1.8.2.2 Ablaufsteuerung ............................................................................................................................ 31 1.8.2.3 Exceptions ..................................................................................................................................... 31

1.9 Ein- und Ausgabe .................................................................................................................................... 32 1.9.1 Text, Konsole .................................................................................................................................... 32 1.9.2 Grafikausgabe ................................................................................................................................... 34

1.9.2.1 Ausgabe numerischer Daten .......................................................................................................... 34 1.9.2.2 Funktionenplotter .......................................................................................................................... 35 1.9.2.3 Anpassung, Beschriftung des Koordinatensystems ....................................................................... 39

1.9.3 Übersicht zum Dateihandling und zu Datendateien .......................................................................... 39

1.10 Eval ........................................................................................................................................................... 40

1.11 Lösung von expliziten Differentialgleichungssystemen ........................................................................ 41


1.12 Regelungstechnik-Toolbox ..................................................................................................................... 45 1.12.1 Überladen von Operatoren und Funktionen ...................................................................................... 45 1.12.2 Definition von LTI Systemen ohne Totzeit ....................................................................................... 46

1.12.2.1 Übertragungsfunktion (TF-Modell) ........................................................................................... 46 1.12.2.1.1 Tf SISO – Systeme................................................................................................................ 46 1.12.2.1.2 TF MIMO – Systeme, Übertragungsmatrix .......................................................................... 47

1.12.2.2 Definition über Pole, Nullstellen und Verstärkung (ZPK-Modell) ........................................... 50 1.12.2.2.1 ZPK SISO-Systeme .............................................................................................................. 50 1.12.2.2.2 ZPK MIMO-Systeme ............................................................................................................ 51

1.12.2.3 Zustandsraummodell (ss-Modell) .............................................................................................. 51 1.12.3 Anzeigen und ändern von Eigenschaften (Properties) eines LTI-Systems ........................................ 53

1.12.3.1 Allgemeine Eigenschaften von LTI-Systemen ......................................................................... 54 1.12.3.2 tf-Modell spezifische Eigenschaften ......................................................................................... 55 1.12.3.3 zpk-Modell spezifische Eigenschaften ...................................................................................... 55 1.12.3.4 ss-Modell spezifische Eigenschaften ......................................................................................... 56

1.12.4 Modellkonvertierung ......................................................................................................................... 57 1.12.4.1 Konvertierung zwischen den Modellarten ................................................................................. 57 1.12.4.2 Konvertierung zeitdiskret kontinuierlich ............................................................................. 58 1.12.4.3 Ändern der Abtastzeit bei zeitdiskreten Systemen (model resampling) .................................... 59 1.12.4.4 Koordinatentransformation von Zustandsraumssystemen ......................................................... 59 1.12.4.5 Reduktion der Ordnung eines LTI-Systems, kürzen von Pol- und Nullstellen ......................... 60 1.12.4.6 Berechnung des inversen Systems ............................................................................................. 60

1.12.5 Verschaltung von LTI-Systemen....................................................................................................... 61 1.12.6 LTI-Systeme mit Totzeit ................................................................................................................... 61 1.12.7 Simulation und Eigenschaften von LTI-Systemen ............................................................................ 63

1.12.7.1 Systemeigenschaften und Untersuchungen im Zeit- und Frequenzbereich ............................... 63 1.12.7.2 Untersuchungen im Zustandsraum: Steuerbarkeit, Beobachtbarkeit, Rang .............................. 65

1.12.8 Befehle für den Regler- und Beobachterentwurf ............................................................................... 65

2 SIMULINK .......................................................................................................... 66

2.1 Erstellen eines neuen Simulinkmodells ................................................................................................. 67

2.2 Library Browser ...................................................................................................................................... 68

2.3 Modelleditor ............................................................................................................................................ 72

2.4 Modellierungsrichtlinien ........................................................................................................................ 77

2.5 Grundlagen der Grafikausgabe ............................................................................................................. 77 2.5.1 Signalaufzeichnung mit Simulation Data Inspector .......................................................................... 77 2.5.2 Grafikausgabe über ein Scope ........................................................................................................... 79 2.5.3 Grafikausgabe über ScopeViewer ..................................................................................................... 82

2.6 Zeitlich kontinuierliche Systeme in Zustandsraumdarstellung .......................................................... 84 2.6.1 Zustandsraumdarstellung .................................................................................................................. 84 2.6.2 Beispiel PT1-Glied ............................................................................................................................ 86 2.6.3 Beispiel Stabpendel ........................................................................................................................... 86

2.7 Zeitlich kontinuierliche Systeme als Integratorketten ......................................................................... 87 2.7.1 Lineare Systeme ................................................................................................................................ 87

2.7.1.1 Beispiel: Analoger aktiver Tiefpass erster Ordnung ..................................................................... 89 2.7.1.2 Beispiel: Einfacher analoger Notchfilter (Bandsperre zweiter Ordnung)...................................... 91

2.7.2 Nichtlineare Systeme......................................................................................................................... 95 2.7.2.1 Beispiel Einfaches Fahrzeugmodell .............................................................................................. 95

2.7.3 Simulation mit Anfangswerten .......................................................................................................... 97 2.7.3.1 Beispiel: Pendel I .......................................................................................................................... 98 2.7.3.2 Beispiel: Pendel II ....................................................................................................................... 101

2.7.4 Untersysteme (Subsystems) ............................................................................................................ 106 2.7.5 Vereinfachung der Implementierung von Modellen über MATLABskripte ................................... 109


2.8 Zeitdiskrete Systeme ............................................................................................................................. 114 2.8.1 Lineare Systeme .............................................................................................................................. 114

2.8.1.1 Beispiel: Tiefpass erster Ordnung ............................................................................................... 114 2.8.2 Zeitdiskretisierter PI-Regler ............................................................................................................ 117

3 REGLERENTWURF ......................................................................................... 120

3.1 Kontinuierlicher Zustandsraum .......................................................................................................... 120 3.1.1 Steuerbarkeit und Beobachtbarkeit ................................................................................................. 126

3.1.1.1 Steuerbarkeit ............................................................................................................................... 126 3.1.1.2 Beobachtbarkeit ........................................................................................................................... 126

3.1.2 Zustandsraumregler: Regelung mit Zustandsrückführung .............................................................. 127 3.1.2.1 Berechnung des Vorfilters ........................................................................................................... 128 3.1.2.2 Reglerauslegung durch Polvorgabe ............................................................................................. 130 3.1.2.3 Reglerauslegung durch linear-quadratische (LQ) Optimierung .................................................. 138

3.1.3 Luenberger Zustandsgrößenbeobachter........................................................................................... 144 3.1.3.1 Zustandsraumregler mit vollständigem Luenberger Zustandsgrößenbeobachter ........................ 144

4 ANHANG .......................................................................................................... 154

4.1 Gradient, Jacobimatrix und Rechenregeln ......................................................................................... 154

4.2 Methoden ............................................................................................................................................... 157 4.2.1 Nullstellensuche mittels Newton-Verfahren ................................................................................... 157 4.2.2 Minimieren von Gütekriterien, Minimumsuche .............................................................................. 159

4.2.2.1 Methode des steilsten Abstiegs (steepest descent, gradient descent) .......................................... 159 4.2.2.1.1 Beispiel: Minimumsuche Polynom (eindimensional) ........................................................... 161 4.2.2.1.2 Beispiel: Minimumsuche Polynom (zweidimensional) ........................................................ 162 4.2.2.1.3 Änderung der Abtastzeit ....................................................................................................... 164

Einführung in MATLAB und Simulink

MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 1

1 Das MATLAB Paket

Bei MATLAB handelte es sich ursprünglich um ein konsolenorientiertes Mathematik Programmpaket, das

mathematische Probleme durch numerische Algorithmen löst. Eine Ausnahme bildet dabei die Symbolic-Toolbox,

die dem MuPAD (bis R2008 Maple) Kern entspricht. MuPAD und Maple verwendet im Gegensatz zu MATLAB

symbolische Algorithmen zur Lösung von Problemen (Computeralgebrasysteme). Damit Befehlsfolgen nicht immer

wieder neu „per Hand“ eingegeben werden müssen ist MATLAB in der Lage Befehlsskripte, die als m-Files

bezeichnet werden, auszuführen. Erweiterungen von MATLAB, die sogenannte Toolboxen, werden oft mit Hilfe

von m-Files realisiert. Die folgenden Abbildungen zeigen die graphischen Benutzeroberflächen (GUI) von

MATLAB in der alten und der neuen Form:

Abbildung 1.1 : Alte MATLAB Oberfläche

Abbildung 1.2 : Neue Matlab Oberfläche



In den oben stehenden Abbildungen der GUIs von MATLAB wurden einige Teilbereiche der GUI

nummeriert.

Die mit 4) und 9) in der neuen GUI Version gekennzeichten tab-controls in der Toolbar werden fortan als

„Reiter“ HOME, PLOTS, APPS bezeichnet.

Diesen Bereichen sind folgende Funktionalitäten zugeordnet:

1) Befehlskonsole: In diesem Eingabefenster werden die MATLAB Befehle eingegeben. Mit einem click

auf das Symbol kann die Kurzhilfe aufgerufen werden.

2) Zeigt den Inhalt des aktuellen Dateipfades an. In diesem Verzeichnis wird gesucht wenn m-Files

ausgeführt werden sollen. Das Verzeichnis wird in dem mit einer 6 markierten Bereich aufgelistet. Da

MATLAB auch DOS/Win32 Konsolenbefehle kennt ist auch eine Ausgabe des aktuellen

Verzeichnisinhalts durch die Eingabe des Befehls dir im Konsolenfenster möglich.

3) Befehlshistorie (als tree view): Es werden bereits ausgeführte Befehle angezeigt. Durch einen doppel-

click auf einen Befehl in diesem Fenster kann dieser Befehl erneut ausgeführt werden. Es besteht auch

die Möglichkeit im Konsolenfenster in dieser Liste über die Cursortasten zu blättern. Eine ähnliche

Funktionalität bietet der Befehl diary.

4) Hilfsprogramme zur Automatisierung immer wiederkehrender Standardaufgaben.

Alte GUI:

Startbutton zum Ausführen bzw. Anzeigen von Demo- und Hilfsprogrammen bzw. Hilfen zu den

verschiedenen Toolboxen.

Aktuelle GUI:

Aufruf von Hilfsprogrammen. Es erfolgt eine Untergliederung in „plot tools“ (Reiter PLOTS) zur

grafischen Ausgabe von Daten(vektoren) und sonstigen Hilfsprogrammen genannt „apps“ (Reiter

APPS).

5) Zeigt die verwendeten Variablen an. Über einen doppel-click auf eine Variable kann der Inhalt einer

Variablen via Data-Grid-Control angezeigt und verändert werden. Mit einem rechts-click auf eine

Variable stehen dem Benutzer noch weitere Optionen zur Verfügung (speichern, als Graph ausgeben

usw.). Im Konsolenfenster ist ein Abruf der Variabelenliste über die Befehle who bzw. whos möglich.

Wobei whos zusätzliche Informationen über die Datentypen und die Speichergrößen der aufgelisteten

Variablen anzeigt. Über die Toolbar dieses Fensters können auch Daten importiert, neue Variablen

erzeugt, gelöscht und bearbeitet werden.

6) Einstellung des aktuellen Dateipfades (siehe auch Punkt 2). Dies ist auch über den Befehl cd möglich.

7) Bereitschaftsflag (Ready/Busy)

8) Hilfes via GUI

9) Alte GUI:

Menusystem

Aktuelle GUI (Reiter HOME):

Standardbedienelemente, die in alten Versionen im Menu hinterlegt worden waren.



1.1 Grundlagen der Befehlskonsole

In diesem Eingabefenster werden die MATLAB Befehle eingegeben. Die „>>“ Zeichen repräsentieren das

Eingabeprompt. Ein „;“ hinter einem Befehl unterdrückt die Ausgabe der Rückgabewerte des Befehls im

Konsolenfenster (Echo Off). Wie in vielen Programmiersprachen üblich kann über ein „=“ Zeichen einer Variablen

(hier die Variablen a und b) ein Wert zugeordnet werden. Das „%“ Symbol kennzeichnet einen Kommentar, der sich

ab diesem Zeichen über die komplette Zeile erstreckt (identisch zu dem C++ Kommentartoken „//“).

>> a=2 % Initialisiere Variable a mit dem Wert 2 a = 2 >> b=3; % Initialisiere Variable b mit dem Wert 3 % Da die Anweisung b=3 mit einem „;“ versehen wurde % unterbleibt die Rückgabe des Zuweisungsergebnisses >> c=1.3e-3 % Zahlenformat: c=1,3*10

-3

c = 0.0013 >> c=2; >> d = c + c^2 + c^3 + c^4 ... % Fortsetzung des Ausdrucks in der folgenden Zeile + c^5 + c^6 d = 126 >> a+b % Addiere a und b ans =

5

Da das Ergebnis der Addition nicht zugeordnet wird, wird das Ergebnis in der von MATLAB fest definierten

Variablen ans abgelegt. Die Variable ans kann für weitere Berechnungen verwendet werden:

>> ans + 1 ans = 6

bzw. vom Nutzer geändert werden:

>> ans=0

ans = 0



Bei den oben definierten Variablen handelt es sich um globale Variablen (vergleiche dazu Kap. 1.8.1). Mit dem

Befehl who lassen sich alle Variablen im aktuellen Workspace (Stack) auflisten. Mit dem Befehl whos werden

ebenfalls die Variablen im aktuellen Workspace aufgelistet. Allerdings enthält diese Auflistung noch Arraygröße,

Bytezahl und Datentyp (Klasse). Die Befehle lassen sich noch weiter parametrieren. Siehe dazu:

>>help who >>help whos

Mit den Befehlen clear, clearvars (läßt sich vielseitig parametrieren) lassen sich eine, mehrere oder alle Variablen

löschen. Im Folgenden sind einige Beispiele des Befehls clear dargestellt:

Befehl Funktion

clear a Löscht Variable a

clear a b Löscht Variable a und Variable b

clear global Löscht alle globalen Variablen

clear Löscht alle Variablen des Workspaces

clear variables Löscht alle Variablen des Workspaces

clear all Löscht alle Variablen

Da der Befehl clear nicht nur Variablen löscht, können side effects auftreten. Siehe dazu die Hilfe zu den Befehlen

clear und clearvars. Weitere grundlegende Befehle sind in der folgenden Tabelle zusammengefasst:

Befehl Funktion

exist Prüft die Existenz einer Variablen, MATLAB Funktion, Datei,

Pfad oder Java Klasse

clc Löscht den Inhalt des Konsolenfensters

help Hilfe zu einem Befehl, Toolbox usw.

disp Ausgabe eines Strings im Konsolenfenster (siehe Kap. 1.9.1)

input Eingabe eines Strings im Konsolefenster über die Tastatur

(siehe Kap. 1.9.1)

who Auflisten der Variablen im aktuellen Workspace (Stack) ,

mittels der option –file läßt sich der Befehl auf .mat Dateien

erweitern. (siehe auch Kap. 1.9.3)

whos Auflisten der Variablen im aktuellen Workspace (Stack) mit

zusätzlichen Informationen zu Arraygröße, Bytezahl und

Datentyp (Klasse). Mittels der option –file läßt sich der Befehl

auf .mat Dateien erweitern. (siehe auch Kap. 1.9.3)

which Ermittelt den Pfad einer Datei / Funktion.

dir, what Verzeichnis im Konsolenfenster ausgeben. Mit what werden

nur MATLAB spezifische Dateien ausgegeben.

cd Verzeichnis wechseln

delete Datei löschen

dos Führe den angegebenen DOS-Befehl aus

format Steuert die Formatierung der Konsolenausgabe. Der Befehl

verändert aber nicht die Rechengenauigkeit. Der Befehl ist

vergleichbar mit dem Formatierungsstring der printf Funktion in

C

diary Steuert die Ausgabe der Befehlshistorie in eine ASCII-Datei

load Lade Variablen von Datenträger (siehe auch Kap. 1.9.3), siehe

auch uiimport.

save Speichere Variablen auf Datenträger (siehe auch Kap. 1.9.3)

uiimport Startet den Import Wizzard zum Importieren von Daten aus

einer Datei oder der Zwischenablage (siehe auch Kap. 1.9.3)

class Ermittelt den Datentyp / Klassennamen einer Variablen



1.2 Vordefinierte Konstanten

In MATLAB sind einige Konstanten vordefiniert worden. Einige dieser Konstanten sind abhängig vom verwendeten

Datentyp. Daher existieren neben den Konstanten Schreibweisen auch Funktionen zum Abrufen dieser Konstanten.

Den Konstanten können ohne weiteres neue Werte zugewiesen werden (Falls dies überhaupt einen Sinn macht). Der

default Wert einer Konstante kann allerdings wieder über den clear Befehl wiederhergestellt werden.

>> eps ans = 2.2204e-016 >> eps('double') ans = 2.2204e-016 >> eps('single') ans = 1.1921e-007 >> eps=0.1 eps = 0.1000 >> clear eps >> eps ans = 2.2204e-016

In der folgenden Tabelle sind die wichtigsten Konstanten dargestellt:

Konstante Beschreibung

pi

i bzw. j Imaginäre Einheit: 1

eps (*) oder

eps(’Genauigkeit’)

Relativer Gleitpunktfehler nach IEEE Norm

Inf (*) oder

Inf(’Genauigkeit’)

nach IEEE Norm. Mit dem Befehl isinf kann eine Variable

auf unendlich geprüft werden.

NaN (*) oder NaN(’Genauigkeit’)

Not a Number Flag nach IEEE Norm. Mit dem Befehl isnan

kann eine Variable auf dieses Flag geprüft werden.

realmin (*) oder realmin(’Genauigkeit’)

Kleinste positive Gleitpunktzahl

realmax (*) oder realmax(’Genauigkeit’)

Größte positive Gleitpunktzahl

Verfügbare Genauigkeiten: double, single

(*) Genauigkeit double wird angenommen.



1.3 Datentypen

1.3.1 Einfache Datentypen und Variablen(typen)deklaration

Aus den vorangegangenen Beispielen geht hervor, dass MATLAB keine Typendeklaration vorsieht wie es z.B. in

C/C++ dringend erforderlich ist. Mit der Erstverwendung einer Variablen wird die Variable deklariert und

initialisiert. Der Datentyp der Variable wird durch den Datentyp der zugewiesenen Daten festgelegt. Standardmäßig

erhalten Variablen mit numerischen Inhalten den Datentyp double. Bei dem Datentyp double handelt es sich um

eine komplexwertige Fließkommazahl mit der Genauigkeit double nach IEEE. Arrays (Vektoren und Matrizen)

können zur Laufzeit in ihrer Größe geändert werden (siehe Kap. 1.6.3.2). Dies ist allerdings nicht zu empfehlen, da

z.B. bei der Erweiterung an einer großen Matrix längere Verzögerungszeiten entstehen, die durch eine Garbage

Collection (neuen größeren Speicherbereich anfordern, Matrixdaten kopieren, Erweiterung durchführen, alten

Speicherbereich freigeben) verursacht werden. Es ist daher immer empfehlenswert Arrays in der später tatsächlich

benötigten Größe zu initialisieren. Folgendes Beispiel demonstriert die Definition von numerischen Variablen und

Strings:

>> a=1; % Definiere numerische Variable vom Typ double >> b='Hallo Welt'; % Definiere einen String >> disp(b); % Gebe String in der Konsole aus Hallo Welt >> who % Liste definierte Variablen auf Your variables are: a b >> whos % Liste definierte Variablen mit Datentyp auf Name Size Bytes Class Attributes a 1x1 8 double b 1x10 20 char

Strings werden in MATLAB im Gegensatz zu C/C++ nicht von “-Zeichen sondern von ‘-Zeichen eingeschlossen.

Eine kleine Übersicht zur Stringverarbeitung erhält man über:

>>help strfun

Beispiel komplexe Zahlen:

>> a=2+j*3 % oder a=2+i*3 % Alternativ: complex(2, 3) a = 2.0000 + 3.0000i >> real(a) % Realteil ans = 2 >> imag(a) % Imaginärteil ans = 3



>> whos Name Size Bytes Class Attributes a 1x1 16 double complex ans 1x1 8 double

Durch die Definition einer komplexen Zahl hat sich der Speicherbedarf auf 16 Bytes verdoppelt und das Attribut

complex wurde gesetzt.

In MATLAB ist aber nicht nur der Datentyp double verfügbar. Die folgenden einfachen numerischen Datentypen

stehen zur Verfügung:

Datentyp

(class) (***) Integer Floating-point (FLO)

signed unsigned Bitbreite

int8 X 8 -

int16 X 16 -

int32 X 32 -

int64 (*) X 64 -

uint8 X 8 -

uint16 X 16 -

uint32 X 32 -

uint64 (*) X 64 -

double - Double Genauigkeit nach IEEE

single - Single Genauigkeit nach IEEE

logical (**) X 1 -

(*) Für diese Datentypen gelten Einschränkungen.

(**) Booldatentyp, der die Werte 0 und 1 annehmen kann.

(***) In MATLAB werden Datentypen als Klassen (classes) bezeichnet.

Beispiel Variablendeklaration:

>> a=int8(5); b=int32(-5); c=single(0.001); d=double(0.003); % ist identisch zu d = 0.003 >> whos Name Size Bytes Class Attributes a 1x1 1 int8 b 1x1 4 int32 c 1x1 4 single d 1x1 8 double

Weitere Informationen finden sich unter:

>>help datatypes



1.3.2 Konvertieren von Datentypen

Die Konvertierung von Datentypen erfolgt mit denselben Funktionen wie in Kap. 1.3.1 z.B. Konvertierung von

double nach int8 bzw. uint8:

>> a=5; b=2.1; c=-5; d=500; >> whos Name Size Bytes Class Attributes a 1x1 8 double ans 1x1 8 double b 1x1 8 double c 1x1 8 double d 1x1 8 double >> a=int8(a) a = 5 >> b=int8(b) % Nicht verlustlos konvertierbar ! b = 2 >> c=uint8(c) % Fehler: Konvertierung einer negativen Zahl nach unsigned int c = 0 >> d=int8(d) % d im double Format > 2^7 - 1 d = 127 >> whos Name Size Bytes Class Attributes a 1x1 1 int8 ans 1x1 8 double b 1x1 1 int8 c 1x1 1 uint8 d 1x1 1 int8

Die obigen Beispiele zeigen, dass eine Konvertierung wie in C/C++ zu Fehlern führen kann. Eine

Verallgemeinerung der Konvertierung ist mittels des Befehls cast möglich (weiterer Befehl: typecast).

>> a=3; >> b=cast(a,'uint8'); >> whos Name Size Bytes Class Attributes a 1x1 8 double b 1x1 1 uint8



Weitere Informationen finden sich unter:

>>help datatypes

1.3.3 Zusammengesetzte Datentypen: Strukturen

In MATLAB sind wie in C/C++ Strukturen (neuerdings auch Klassen) vorgesehen. Die Definition einer Struktur

erfolgt über den Befehl struct oder direkt über den von C/C++ bekannten „.“-Operator zum Zugriff auf einen

Member. Leider existiert kein MATLAB typedef Äquivalent, so dass eine definierte Struktur nicht als neuer

Datentyp definiert werden kann.

Beispiel:

>> a=struct('Member1',2,'Member2','Hallo')

a = Member1: 2 Member2: 'Hallo' >> a.Member2 ans = Hallo >> b.c=3; b.d=-50; % Alternative Definition >> b b = c: 3 d: -50 >> whos Name Size Bytes Class Attributes a 1x1 266 struct ans 1x5 10 char b 1x1 264 struct

Zugriff auf einen Member mittels des Membernamens:

>> g=struct('Member1',2,'Member2','Hallo'); >> h='Member1'; >> g.(h) ans = 2 >> g.('Member1') ans = 2



1.3.4 Übersicht über Funktionen im Zusammenhang mit Datentypen und Variablen

Befehl Funktion Anmerkung

exist Prüft die Existenz einer Variablen,

MATLAB Funktion, Datei, Pfad oder

Java Klasse.

aus

Kap. 0 Grundlagen der

Befehlskonsole

clear a Löscht Variable a.

clear a b Löscht Variable a und Variable b.

clear global Löscht alle globalen Variablen.

clear Löscht alle Variablen des Workspaces.

clear variables Löscht alle Variablen des Workspaces.

clear all Löscht alle Variablen.

load Lade Variablen von Datenträger. (siehe

auch Kap. 1.9.3)

save Speichere Variablen auf Datenträger.

(siehe auch Kap. 1.9.3)

class Ermittelt den Datentyp / Klassennamen

einer Variablen.

isa Prüft Variable auf eine bestimmte Klasse

ab.

-

isequal Testet ob Variablen den gleichen Inhalt

haben. Dies ist interessant bei

komplexeren Datentypen. Versagt bei

Variablen, die NaN enthalten.

-

isequalwithequalnans Wie isequal schließt jedoch NaN als

Inhalt mit ein.

-

isreal Testet ab, ob es sich um eine reelle

Variable handelt.

-

isprime Ermittelt, ob Arrayinhalte eine Primzahl

repräsentieren.

-

isinf, isfinite, isnan Ermittelt, ob Arrayinhalte unendliche,

finite, NaN Zahlen enthalten.

-



1.4 Funktionshandles, anonyme Funktionen

MATLAB verfügt über sogenannte Funktionshandles, die den Functionpointers (Zeiger auf Funktionen) in C/C++

ähneln. Für alle Funktionen ist im Gegensatz zu C/C++ ein einziger Datentyp mit dem Namen function_handle

(siehe doc function_handle) vorgesehen. Das Handle einer m-File Funktion (siehe Kap. 1.8.1.1) kann über den

Operator @ ermittelt werden (BASIC: @-Operator ist Variablenadressoperator) bzw. eine anonyme Funktion

(Anonymous Functions) über den Operator @ definiert werden. Anonyme Funktion sind vergleichbar mit den

BASIC Funktionen, die über den BASIC-Befehl DEF FN definiert werden. Die Funktionen werden als anonym

bezeichnet, da sie keinen Funktionsnamen besitzen und nur über einen Zeiger / Handle referenziert werden können.

Eine anonyme Funktion wird wie folgt definiert:

Funktionshandle = @(Argumentenliste) Ausdruck;

Die Funktionsvariablen in der Argumentenliste werden über Kommas separiert. Referenziert wird die Funktion über

das Funktionshandle. Der Ausdruck definiert die Funktion. Der Ausdruck muss nicht rein mathematisch sein.

Beispiel: 22 yx)y,x(square_p

>> p_square=@(x, y) x^2 + y^2; >> p_square(2, 4)

ans = 20

Die obige Funktion kann nur skalare Variablen x und y aufnehmen. Soll die Funktion auf Datenvektoren x und y

erweitert werden, so empfiehlt sich hierfür folgende Definition (dies setzt aber Kap. 1.6 voraus).

>> p_squarem=@(x, y) x.^2 + y.^2; >> ezsurf(p_squarem,[-10,10,-5,5]); % Ausgabe als 3D-Graph (siehe Kap. 1.9.2.2)

-10

-5

0

5

10

-5

0

5

0

20

40

60

80

100

120

x

x2+y2

y



Anonyme Funktionen können per load und save geladen und abgespeichert werden. Im Folgenden sind einige

Operationen im Zusammenhang mit anonymen Funktionen und Fuktionshandles dargestellt.

Funktion definieren.

>> p_squarem=@(x, y) x.^2 + y.^2;

Eigenschaften der Funktion ermitteln.

>> functions(p_squarem) ans = function: '@(x,y)x.^2+y.^2' type: 'anonymous' file: '' workspace: {[1x1 struct]}

Datentyp / class ermitteln.

>> class(p_squarem) ans = function_handle

Funktion als String ermitteln.

>> func2str(p_squarem) ans = @(x,y)x.^2+y.^2

Ein Funktionshandle aus einem String ermitteln, das einen gültigen Funktionsnamen enthält.

>> str2func('exp')

ans = @exp

Im Folgenden soll das Funktionshandle der Funktion parabel2.m (Beispiel aus Kap. 1.8.1.1) ermittelt und die

Funktion grafisch dargestellt werden.

Datei parabel2.m

% Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c

function [y] = parabel2(x, a, b, c) y =a*x.^2 + b*x +c; end



>> p_p=@parabel2; >> ezplot(@(x)p_p(x,1,2,3),[0:0.1:10]); grid on;

0 1 2 3 4 5 6 7 8 9 10

0

20

40

60

80

100

120

x

pp(x,1,2,3)



1.5 MATLAB Hilfe

Die MATLAB Hilfe gliedert sich in zwei getrennte Bereiche:

1) Aufruf der Hilfe im Konsolenfenster über die Befehle help und lookfor bzw. die Kurzhilfe über das Symbol

.

2) Neue GUI: via Symbol.

Alte GUI:

Aufruf der ausführlicheren Dokumentation über den Helpbrowser mittels Hauptmenü über:

MenüHelpProduct Help. Ist der Befehl bekannt kann direkt über die Konsole mit dem Befehl doc der

Helpbrowser zu einem bestimmten Befehl geöffnet werden.

Beispiel: >>doc bode

Im Folgenden werden die wichtigsten Hilfebefehle der Konsole aufgelistet.

1.5.1 help-Funktion

Für sämtliche Funktionen von MATLAB steht eine sehr ausführliche Hilfe zur Verfügung, auf die im Folgenden des

Öfteren verwiesen wird. Durch die Eingabe von

ver

in der Kommandozeile erhält man eine Auflistung der installierten Toolboxen. Über

help

wird eine Übersicht über alle wichtigen Hilfsthemen ausgegeben. Durch die Eingabe von

help Toolboxname z.B.: help control

erhält man eine Auflistung und Kurzbeschreibung der in der Toolbox vorhandenen Funktionen. Durch die Eingabe

von

help Funktionsname z.B.: help bode

erhält man eine Beschreibung der Funktion. Häufig werden auch Beispiele zum Einsatz der Funktion gegeben. Am

Ende des Hilfetextes werden verwandte Befehle bzw. Überladungen von Funktionen aufgelistet. Die aufgelisteten

Funktionen sind meist verlinkt, so das relativ schnell auf ihren Hilfstext zugegriffen werden kann. Zusätzlich

existieren noch Verlinkungen zu der Dokumentation im Helpbrowser.

1.5.2 lookfor-Funktion

Mit dieser Funktion können sämtliche Konsolenhilfetexte nach einem Schlüsselwort durchsucht werden. Als

Ergebnis erscheint eine Liste aller Hilfetexte, in denen das gesuchte Schlüsselwort auftaucht.

lookfor Schlüsselwort z.B.: lookfor kalman



1.5.3 Hilfe zu häufig benötigten Themengebieten

In der folgenden Tabelle sind elementare Hilfeaufrufe dargestellt:

Aufruf Hilfe zu(r)

help Hilfeübersicht

help arith Arithmetische Operatoren

help ops In MATLAB verfügbaren Operatoren

help elfun Elementare mathematische Funktionen

help specfun Spezielle Funktionen

help elmat Elementare Matrixfunktionen (siehe Kap. 1.6)

help strfun Stringverarbeitung

help control Regelungstechniktoolbox (siehe Kap. 1.12)

help signal Signalverarbeitungstoolbox

help datatypes Datentypen

help funfun Funktionenplotter (siehe Kap. 1.9.2.2),

numerische Integration,

Lösung von Anfangswertproblemen (solver für

Differentialgleichungen, Lösung durch numerische

Integration, siehe Kap. 1.11)

help polyfun Polynome und Interpolationen



1.6 Matrizen und Vektoren

Jede Variable in MATLAB repräsentiert eine Matrix mit komplexwertigen Matrixelementen. Wobei die

Matrixelemente wie in der Mathematik adressiert werden d.h. die Indices beginnen mit 1 (In C beginnen sie mit 0).

Mit den Befehlen size(Matrixname) kann die Dimension einer Matrix ermittelt werden. Handelt es sich um einen

Vektor also um den Sonderfall einer Matrix kann auch length(Vektorname) zur Längenermittlung verwendet

werden. Eine Übersicht zu Matrixoperationen erhält man über:

help elmat

1.6.1 Matrizendefinition und Matrizenelemente

1.6.1.1 Matrizendefinition

Die Eingabe einer Matrix erfolgt zeilenweise. Die eckige Klammern „[ ]“ begrenzen die Matrizendefinition.

nitionMatrixdefiiablevarMatrix

.....A

Für die Definition einer Matrix sind folgende Trennzeichen vorgesehen.

Zeichen Funktion

, oder Leerzeichen Trennzeichen zwischen einzelnen Werten (Spalten)

innerhalb einer Matrixzeile

; Trennzeichen zwischen zwei Zeilen einer Matrix

Beispiel: Definition der Matrix

987

654

321

A

>> A = [1,2,3;4,-5,6;7,8,9]

oder

>>A = [1 2 3; 4 -5 6; 7 8 9]

Die Anweisung

>>A = [ ];

definiert eine leere Matrix, d.h. die Matrix enthält keine Elemente (empty matrix). Eine leere Matrix wird von

manchen MATLAB Funktionen zurückgegeben, wenn z.B. die Rückgabe eines numerischen Ergebnisses nicht

möglich ist. Ermittelt man z.B. die Nullstellen einer Übertragungsfunktion ohne Nullstellen, so scheidet ein

numerischer Wert als Rückgabewert aus. Eine Matrix kann mittels isempty(Variablenname) auf eine leere Matrix

hin untersucht werden.

>> A=[ ]; >> isempty(A)

ans =

1



1.6.1.2 Zugriff auf Matrixelemente bzw. eine Untermatrix

Die folgenden Beispiele zum Zugriff auf Matrixelemente beziehen sich auf die A-Matrix aus Kapitel 1.6.1.1. Aus

einer definierten Matrix kann eine Untermatrix mit folgender Syntax gebildet werden:

Untermatrix = Matrix(Zeilenausdruck, Spaltenausdruck)

wobei der Zeilen- bzw. Spaltenausdruck folgende Form aufweisen kann:

Zeilen-

bzw.

Spaltenausdruck

Beschreibung Beispiel

n Es handelt sich um eine

einzelne Zeile oder

Spalte

>> B = A(2,3) % Zugriff auf ein Element >> B = 6

n:m Von Zeile/Spalte n bis

Zeile/Spalte m. Es

muss gelten n < m.

>> B = A(1:2,2:3) % Zeile 1 bis 2, Spalte 2 bis 3 B =

2 3 -5 6

n:end Von Zeile/Spalte n bis

zur letzten Zeile/Spalte.

Damit wird der length

Befehl siehe Kapitel

1.6.5 vermieden.

>>B=A(2:end,3:end) % Alle Zeilen ab 2, alle Spalten ab 3 B =

6 9

: Komplette Spalte oder

Zeile >> B = A(1,:) % Komplette Zeile 1 (alle Spalten in Zeile 1) B = 1 2 3

[n1:n2,n3] value-based indexing:

Von Zeile/Spalte n1 bis

Zeile/Spalte n2 und

zusätzlich Zeile/Spalte

n3, wobei hier die

Elemente beliebig

(sinnvoll, durch

Komma getrennt)

kombiniert werden

dürfen.

>> A A = 1 2 3 4 -5 6 7 8 9 >> B = A([1],[1:2,2:3,2]) B = 1 2 2 3 2 >> B = A([3],[1:2,2:3,2]) B = 7 8 8 9 8 >> B = A([1:2],[1:2,2:3,2]) B = 1 2 2 3 2 4 -5 -5 6 -5 >> B = A([1,3,1:2],[1:2,2:3,2]) B =

1 2 2 3 2 7 8 8 9 8 1 2 2 3 2 4 -5 -5 6 -5



Handelt es sich um einen Spalten- oder Zeilenvektor, so kann (muss aber nicht) nur eine Dimension angeben

werden:

>> V = [7 3 8] >> V(3) = 8

ansonsten gilt die gleiche Syntax wie für Matrizen.

Wird auf ein Matrixelement(e) zugegriffen, die nicht existieren, wird eine Fehlermeldung ausgegeben:

>> A = [1,2,3;4,-5,6;7,8,9]; >> A(4,4) ??? Attempted to access A(4,4); index out of bounds because size(A)=[3,3].

Ältere MATLAB Versionen geben folgenden Fehler aus: ??? Index exceeds matrix dimensions.

1.6.1.3 Bilden einer Matrix aus mehreren Matrizen

Die Syntax ist identisch, wie bei der Eingabe einer Matrix aus einzelnen Werten. Der einzige Unterschied besteht

darin, dass statt den Werten nun Matrizen eingegeben werden. Ist A = [1 2;3 4], B = [5 6;7 8] so kann eine neue

Matrix C folgendermaßen gebildet werden:

>>C = [A B; B*2 A+B] C =

1 2 5 6 3 4 7 8 10 12 6 8 14 16 10 12

1.6.1.4 Umgang mit mehrdimensionalen Matrizen

Über die Eingabesyntax von MATLAB können nur 2-dimensionale Matrizen gebildet werden. Jedoch kann durch

mehrfaches Eingeben einer 2-dimensionalen Matrix eine mehrdimensionale erzeugt werden.

A(:,:,1,1)=[1 2;3 4] A(:,:,1,2)=[5 6;7 8] A(:,:,2,1)=[11 22; 33 44] A(:,:,2,2)=[55 66; 77 88]

Auf diese Weise ist eine 2 x 2 x 2 x 2-Matrix erzeugt worden

Löschen von singleton Dimensionen:

>> size(A) ans = 1 1 50001 >> A=squeeze(A); >> size(A) ans = 50001 1



1.6.2 Spezielle Matrizen und Vektoren

Matrix mit Nullen und mit Einsen in der Hauptdiagonalen

>> Z = eye(2,3) >> Z = 1 0 0 0 1 0

Identitätsmatrix

>> Z = eye(2) identisch mit eye(2,2) >> Z = 1 0 0 1

Matrix mit Nullen

quadratische Nullmatrix

>> Z = zeros (4)

nichtquadratische Nullmatrix

>> Z = zeros (2,3)

mehrdimensionale Nullmatrix

>> Z = zeros (2,2,3)

Matrix mit Einsen

quadratische Einsermatrix

>> Z = ones(4)

nichtquadratische Einsermatrix

>> Z = ones(4,2)

mehrdimensionale Einsermatrix

>> Z = ones(3,2,3)

Matrix mit gleichverteilten Zufallszahlen

rand(...)

Matrix mit normalverteilten Zufallszahlen

randn(...)

„Linearly spaced vector“ bzw. „:“-Operator:

Erzeugt einen Zeilenvektors V dessen Elemente eine Gerade durch den Ursprung ergeben:

linspace(a,b,c) oder die Kurzform a:b:c.

linspace(a,c) oder die Kurzform a:c



wobei a dem Startwert, c dem Endwert und b der Differenz zweier Nachbarelemente b = V(i+1) – V(i)

entspricht. Ist b nicht angegeben worden, so wird b zu 1 gesetzt und a muss kleiner b sein.

V = 1:4 Erzeugt einen Zeilenvektor [1 2 3 4]

V = 1:0.5:4 Erzeugt einen Zeilenvektor [1 1.5 2 2.5 3 3.5 4]

„Logarithmically spaced vector“:

Erzeugt einen Zeilenvektors V dessen Elemente wie folgt definiert sind:

bi

n

aba

aV 10...10...10 1 mit i = 0 ... n-1 und i ist Element von N.

V = logspace(a,b,n)

Wird n nicht angegeben, so wird n = 50 gesetzt.

Den Funktionen eye, ones kann als zweiter oder dritter Parameter bzw. der Funktion zeros als zweiter, dritter oder

vierter Parameter der Datentyp (class) übergeben werden (sie dazu Kap. 1.3.1):

>> zeros(2,'int8') ans = 0 0 0 0 >> zeros(2,2,'int8') ans = 0 0 0 0 >> zeros(2,2,2,'int8') ans(:,:,1) = 0 0 0 0 ans(:,:,2) = 0 0 0 0

Diagonalmatrix (Befehl bietet weitere Optionen)

>> diag([1,2,3]) ans = 1 0 0 0 2 0 0 0 3



1.6.3 Matrizenmanipulationen

1.6.3.1 Ändern von Werten

A(2,3) = 3 ändert den Wert in der 2. Zeile und 3. Spalte in 3 um.

A (2,:) = [1 2 3] ändert eine ganze Zeile

A (:,1) = [1 2 3] ändert eine ganze Spalte

A (1:2,2:3) = [2 4;6 7] ändert den angegebenen Bereich der Matrix

1.6.3.2 Löschen von Elementen und erweitern um Elemente

Das Löschen von Elementen erfolgt durch das Zugordnen einer leeren Matrix / Vektor in dem zu löschenden

Bereich. Es müssen immer komplette Zeilen und Spalten gelöscht werden, so dass eine neue Matrix entstehen kann.

Löschungen von Elementen, die keine neue Matrix ergeben werden mit einem Fehler quittiert.

A(1,:) = [ ] Löscht die angegebene Zeile in der Matrix

A (:,2) = [ ] Löscht die angegebene Spalte in der Matrix

Beispiel:

>> A = [1,2,3;4,-5,6;7,8,9] A = 1 2 3 4 -5 6 7 8 9 >> A(1,:)=[ ] % Erfolgreiches Löschen der ersten Zeile A = 4 -5 6 7 8 9 >> A(1,2:3)=[ ] % Gescheiterter Versuch einer Löschung der Elemente (1,2) und (1,3) ??? Subscripted assignment dimension mismatch.

Ähnlich erfolgt auch das Erweitern einer Matrix. Hier z.B. eine Erweiterung um eine Zeile:

>> A = [1,2,3;4,-5,6;7,8,9] A = 1 2 3 4 -5 6 7 8 9 >> A(4,:)=[10 11 12] A = 1 2 3 4 -5 6 7 8 9 10 11 12

Siehe dazu auch Kap. 1.6.1.3.



1.6.4 Rechnen mit Matrizen

Da jede Variable in MATLAB eine Matrix darstellt gelten für alle Rechenoperationen die Matrizen Rechenregeln

sofern für die Operation eine Matrizenoperation existiert. Skalare (Dimension 1, 1) und Vektoren (Dimension 1, n

bzw. n, 1) sind als Sonderfälle von Matrizen anzusehen.

Matrixoperationen sind in 2 Gruppen unterteilt:

1) „Mathematische“ Matrizen Operationen.

2) „By Element“ Matrizen Operationen. Bei diesen Operationen wird die mathematische Operation auf jedes

Matrixelement einzeln angewendet. So ist z.B. die sin Funktion nicht für Matrizen definiert also wird die

Funktion auf jedes Element (daher der Name „by Element“) der Matrix angewendet. Um dieses Feature

auch für mathematischen Operatoren wie z.B. „* / ^“ nutzen zu können, die schon als Matrizenoperatoren

definiert sind, wurde der „by Element“ Operator eingeführt.

Eine Übersicht zu elementaren Matrixfunktionen erhält man über:

help elmat

1.6.4.1 Matrizenoperationen

Multiplikation / Division

C = A * B C = B / A entspricht C = B*A^-1 (siehe weiter unten)

Addition / Subtraktion

C = A + B C = A - C

Addition / Subtraktion / Multiplikation / Division einer ganzen Matrix mit einem Skalar

C = A + 4 Zu jedem Element der Matrix A wird die Zahl 4 addiert (*) C = A – 5 Von jedem Element der Matrix A wird die Zahl 5 subtrahiert (*)

C = A * 4 C = A / 3

Transponieren einer Matrix

C = A' oder C = transpose(A) (siehe auch rot90 Funktion)

Determinante einer Matrix

B = det(A)

Inverse einer Matrix

B = inv(A) oder B = A^-1

(*) Ist bereits eine „by Element“ Operation

Es sind noch weitere Operationen definiert. Siehe dazu:

help ops



1.6.4.2 By Element Operationen

Wie bereits beschrieben werden solche Operationen immer auf jedes Element einer Matrix angewendet. Dem

eigentlichen Operator wie z.B. „* “ wird ein „.“ vorangestellt (also „.*“). Zwischen den beiden Zeichen darf kein

Leerzeichen stehen, da beide Zeichen zusammen einen neuen Operator bilden.

Elementweise

C = A .* B Multiplikation C(i,j) = A(i,j) * B(i,j)

C = A ./ B Division C(i,j) = A(i,j) / B(i,j)

C = A .^ B Exponentialrechnung:

Wenn B eine skalare Variable ist C(i,j) = A(i,j) ^ B

Wenn B eine Matrix Variable ist: C(i,j) = A(i,j) ^ B(i,j)

Beispiele:

Quadrieren aller Elemente in A

>> A = [1 2 3; 4 5 6] A = 1 2 3 4 5 6 >> A .^2 ans = 1 4 9 16 25 36

Berechne die Sinuswerte der Winkel – bis im Abstand von /4

>> phi = -pi:pi/4:pi % Generiere Vektor mit Winkeln –pi bis +pi in pi/4 Schritten phi = Columns 1 through 7 -3.1416 -2.3562 -1.5708 -0.7854 0 0.7854 1.5708 Columns 8 through 9 2.3562 3.1416 % Da für eine Matrix/Vektor die Operation sin nicht

% definiert ist wird der sinus eines jeden Elements berechnet >> sin(phi) ans = Columns 1 through 7 -0.0000 -0.7071 -1.0000 -0.7071 0 0.7071 1.0000 Columns 8 through 9 0.7071 0.0000



1.6.5 Allgemeine Matrizen Funktionen

Ermittelung der Größe einer Matrix

B = size(A)

Bei dem Rückgabewert B handelt es sich um einen Vektor. Das erste Element B(1) beinhaltet die Anzahl der Zeilen,

das zweite Element B(2) die Anzahl der Spalten der Matrix A. Bei Vektoren kann auch der Befehl length verwendet

werden. Wendet man den Befehl length auf eine Matrix A an, so liefert length den Wert max(size(A)). Über den

Befehl isempty kann überprüft werden, ob es sich um eine(n) leere(n) Matrix / Vektor / Skalar handelt.

Beispiel:

>> A = [1 2 3; 4 -5 6; 7 8 9] A = 1 2 3 4 -5 6 7 8 9 >> B=size(A) B = 3 3 >> isempty(A) ans = 0 >> whos Name Size Bytes Class Attributes A 3x3 72 double B 1x2 16 double ans 4x4 128 double >> A=[ ] A = [ ] >> size(A) ans = 0 0 >> whos Name Size Bytes Class Attributes A 0x0 0 double B 1x2 16 double ans 1x2 16 double >> isempty(A) ans = 1

Löschen einer Matrix

clear(A) (siehe auch Kap. 0)

Anzeigen aller vorhandenen Matrizen

who oder whos (siehe auch Kap. 0)



1.7 Cell Arrays

Normalerweise enthalten Matrizen und Arrays in MATLAB / C / C++ usw. Elemente gleicher Größe vom selben

Datentyp. Benötigt man aber Matrizen deren Elemente im Datentyp oder in ihrer Größe variieren, so wird z.B. in C

eine Matrix erzeugt, die auf void gecastete pointer enthält, d.h. der Zeiger auf die Daten eines Matrixelementes

werden auf void gecastet und in dieser void pointer Matrix abgelegt. Beim Zugriff auf ein Datenelement wird dieser

Zeiger wieder auf den richtigen Datentyp gecastet. Die Daten selbst sind also nicht in der Matrix gespeichert. Es

muss also eine Zuordnung existieren in der definiert ist welches Element einer Matrix welchem Datentyp

zugeordnet ist. Um Matrizen zur Verfügung stellen zu können (ohne diesen Overhead selbst implementieren zu

müssen), die verschiedene Datentypen mit variablen Größen enthalten können wurden die cell arrays eingeführt.

Die Definition eines cell arrays erfolgt analog zu der einer Matrix. Jedoch werden zur Definition keine „[ ]“-

Klammern sondern „{ }“-Klammern verwendet. Der Zugriff auf das Element i, j erfolgt am einfachsten über {i, j}

anstatt (i, j). Die Unterschiede zwischen den beiden Zugriffsarten werden später in Form von Beispielen erläutert.

Beispiel: Definition eines cell arrays

>> A={'Hallo','Welt'; 1 2} A = 'Hallo' 'Welt' [ 1] [ 2] >> A{1,1} ans = Hallo

Ein leeres cell array mit der Dimension n1 x n2 x ... nn wird über den Befehl cell(n1,n2,...,nn) ( alternative

Schreibweise: cell([n1 n2 ... nn]) ) definiert:

>> A=cell(2) A = [ ] [ ] [ ] [ ] >> B=cell(2,3) B = [ ] [ ] [ ] [ ] [ ] [ ] >> B{1,1}='Hallo'; B{1,2}='Welt'; B{1,3}=3; B{3,3}=int8(2); >> B B = 'Hallo' 'Welt' [3] [ ] [ ] [ ] [ ] [ ] [2] >> whos Name Size Bytes Class Attributes A 2x2 16 cell B 3x3 287 cell



Ein cell array kann wie eine Matrix schrittweise erweitert werden:

>> C{1,1}='Hallo' C = 'Hallo' >> C{1,2}='Welt' C = 'Hallo' 'Welt' >> C{2,2}=1 C = 'Hallo' 'Welt' [ ] [ 1] >> C{2,1}=[1 2; 3 4] C = 'Hallo' 'Welt' [2x2 double] [ 1]

Ein Schreibzugriff auf das cell array mittels „( )“-Klammern kann nur erfolgen, wenn die Datenquelle vom Datentyp

(class) cell array ist. Bei einem Lesezugriff mittels „( )“-Klammern erhält man die Daten in Form des Datentyps cell

array:

>> A={'Hallo','Welt'; 1, 2} A = 'Hallo' 'Welt' [ 1] [ 2] >> A(1,1)='Hello'; % Der zugewiesene Datentyp ist nicht vom Typ cell array ??? Conversion to cell from char is not possible. >> A(1,1)={'Hello'} % Der zugewiesene Datentyp vom Typ cell array A = 'Hello' 'Welt' [ 1] [ 2] >> B=A(1,1); C=A{1,1}; % Beachten Sie unten den Datentyp von B und C >> whos Name Size Bytes Class Attributes A 2x2 274 cell B 1x1 70 cell C 1x5 10 char ans 1x4 8 char



Der direkte Zugriff auf Matrixelemente bzw. Member einer Struktur innerhalb eines cell array Elements ist in dem

folgenden Beispiel dargestellt:

>> a=struct('c',1,'d',[1 2; 3 4]); >> e=[5 6; 7 8]; >> f={a,e} f = [1x1 struct] [2x2 double] >> f{1,1}.c ans = 1 >> f{1,1}.d ans = 1 2 3 4 >> f{1,1}.d(2,2) ans = 4 >> f{1,2}(2,2) ans = 8



1.8 MATLAB Befehlsskripte (m-Files)

1.8.1 Skriptdateien

Besonders effektiv wird der Einsatz von MATLAB durch die Verwendung von Befehlsskripten, sogenannter m-

Files. m-Files müssen, damit sie als solches erkannt werden, die Dateiendung „m“ besitzen. Das „%“ Zeichen

beginnt einen Kommentar (in C++ „//“). m-Files sind reine ASCII-Textdateien, die z.B. mit dem Windows

Texteditor erstellt und bearbeitet werden können. MATLAB stellt für die Bearbeitung einen eigenen Text Editor zur

Verfügung, der über edit aufgerufen werden kann.

edit Öffnet den Editor mit einem leeren m-File ohne Namen edit fname Öffnet im Editor das m-File fname.m zur Bearbeitung

Über den MATLAB m-File Editor können m-Files im Debug Modus gestartet werden. Ein neues m-File kann auch

über das MATLAB Menu: FileNewBlank M-File oder FileNewFunction M-File erstellt werden.

1.8.1.1 Funktionsfiles

Ein Funktionsfile ist eine Datei, die aus einem Funktionskopf und einer Liste von MATLAB-Anweisungen besteht.

Im Funktionskopf werden die Ein- (in1, in2, ...) und die Ausgangsgrößen (out1, out2, ...) sowie der Funktionsname

(fname) der Funktion definiert. Die Syntax des Funktionskopfes lautet:

function [out1, out2, ...] = fname(in1, in2, ...)

Der Name des m-Files muss „fname.m“ lauten. Ein m-File kann auch mehre Funktionen enthalten. Aber nur die

Funktion, die den gleichen Namen besitzt wie das m-File ist außerhalb des m-Files aufrufbar. d.h. der

Funktionsname ist global definiert. Variablen, die innerhalb einer Funktion definiert worden sind, besitzen die

Speicherklasse lokal und sind somit außerhalb der Funktion nicht bekannt. Lokale Variablen können aber über das

Schlüsselwort global exportiert und importiert werden. Das Schlüsselwort persistent ist das MATLAB Äquivalent

zu der Speicherklasse static in C/C++, d.h. beim Verlassen der Funktion bleiben die Inhalte der lokalen Variablen

erhalten und stehen beim nächsten Aufruf der Funktion wieder zur Verfügung. Über den Befehl nargin kann

festgestellt werden mit wie vielen Parametern die Funktion aufgerufen worden ist. Damit lässt sich ein flexiblerer

Aufruf einer Funktion erreichen (variable Anzahl der Eingangsgrößen). Analog dazu steht für die Rückgabewerte

auch noch der Befehl nargout zur Verfügung. Kommentarzeile werden über das % Zeichen eingeleitet (Äquivalent

zu // in C/C++).

Beispiel:

Datei parabel.m

function [y] = parabel(x, a, b, c) % Hilfetext: Ausgabe über help parabel % % Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c y =a*x.^2 + b*x +c; end



Die grafische Ausgabe der Parabel 3x2xy 2 im Bereich 10,10x (grafische Ausgabe siehe Kap.

1.9.2) erfolgt via Konsole über.

>> x=-10:0.1:10; y=parabel(x, -1, 2, 3); plot(x,y); grid on; % Vergleiche Kap. 1.4

Kommentare nach der Funktionsdeklaration bis zum ersten Befehl können als Hilfetext eingesetzt werden sofern vor

der Funktionsdeklaration kein Kommentar steht.

>> help parabel Hilfetext: Ausgabe über help parabel Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c

Kommentare von Beginn an bis zur Funktionsdeklarartion können ebenso als Hilfetext definiert werden.

Datei parabel2.m

% Hilfetext: Ausgabe über help parabel2 % % Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c function [y] = parabel2(x, a, b, c) % dies wird ignoriert y =a*x.^2 + b*x +c; end

>> help parabel2 Hilfetext: Ausgabe über help parabel2 Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c

Da die Variablen a, b, c lokal sind, tauchen sie nicht im globalen Workspace der Konsole auf.

>> whos Name Size Bytes Class Attributes x 1x201 1608 double y 1x201 1608 double

-10 -8 -6 -4 -2 0 2 4 6 8 10-120

-100

-80

-60

-40

-20

0

20



anders sieht das im lokalen Workspace aus ändert man testweise parabel.m wie folgt ab,

Datei parabel.m

function [y] = parabel(x, a, b, c) % Hilfetext: Ausgabe über help parabel % % Berechnet die Funktionswerte der Parabel: y = a*x^2 + b*x + c whos; y =a*x.^2 + b*x +c; end

so erhält man beim Aufruf der Funktion die lokale Variablenliste mit den lokalen Variablen a, b, c und x. Wobei die

Variable x zweimal existiert, einmal als lokale und einmal als globale Variable. Beide Variablen sind unabhängig

voneinander, da wie in C/C++ nur eine Kopie der Variablen übergeben wird.

>> x=-10:0.1:10; y=parabel(x, -1, 2, 3); plot(x,y); grid on; Name Size Bytes Class Attributes a 1x1 8 double b 1x1 8 double c 1x1 8 double x 1x201 1608 double

1.8.1.2 Kommandofiles

Ein Kommandofile ist eine Datei in der eine Liste mit MATLAB-Anweisungen steht. Der Unterschied zum

Funktionsfile besteht darin, dass ein Kommandofile keinen eigenen Variabelenraum (Workspace: Stack) erzeugt

und den Variabelenraum des Eingabefensters bzw. den der aufrufenden Funktion verwendet, d.h. alle im

Kommandofile erzeugten Variablen sind global. Ein Kommandofile besitzt keinen Funktionskopf. Alle

Kommentare bis zum ersten Befehl können als Hilfetext abgerufen werden.



1.8.2 Sprachgrundkonstrukte

1.8.2.1 Boolesche Operatoren und Ausdrücke

Operator Funktion Beispiele für boolesche Ausdrücke:

A <= 5 : Wahr wenn A kleiner gleich 5

b ~= c – 3 : Wahr wenn b nicht gleich c-3

1 == 1 : 1 ist gleich 1, ist immer wahr

1 ~= 1 : 1 nicht gleich 1, ist immer falsch

A > 4 && A < 10 : Wahr wenn A größer 4 und A kleiner 10 ist (Intervallabfrage).

Bei Operatoren, die aus mehr als einem Zeichen bestehen z.B. &&, darf zwischen den Zeichen

kein Leerzeichen sein.

= = gleich

< kleiner als

> größer als

<= kleiner gleich

>= größer gleich

~ Not

~= ungleich

&& Und

|| Oder

1.8.2.2 Ablaufsteuerung

For Schleife for i=n1:n2

Anweisungen ... end

Hierbei wird die Schleife von i = n1 bis i = n2, also

n2-n1+1 mal durchlaufen. Mit der Angabe:

for i=n1:step:n2 ... end lässt sich zusätzlich eine Schrittweite step einstellen.

While Schleife

(Kopf gesteuert)

Eine while-Schleife besitzt folgenden Syntax:

while boolescher Ausdruck

Anweisungen ... end

wobei die Schleife so lange durchlaufen wird bis der

boolesche Ausdruck wahr (ungleich 0) ist. Siehe (*).

If-Bedingung

(mit elseif, else)

Eine if-Bedingung kann mit folgendem Syntax

eingefügt werden:

if boolescher Ausdruck 1 Anweisung(en) elseif boolescher Ausdruck 2 Anweisung(en) else Anweisung(en) end

Für Ausdruck gelten die im Abschnitt while

getroffenen Aussagen. Siehe (*).

switch, case switch Ausdruck % Kann Skalar oder String sein case value1 Anweisungen case {value2, value3} Anweisungen . otherwise % entspricht default in C Anweisungen end

Wie in C/C++ besitzt MATLAB auch ein switch

case Konstrukt. Mit den Unterschieden:

Es wird kein break verwendet um ein case

abzuschließen. Der nächste case oder otherwise

wirkt wie ein break. Ein „fall through“ über

mehrere case ohne break wie in C/C++ ist für

Mehrfachvergleiche ist daher nicht möglich. Aus

diesem Grund muss für Mehrfachvergleiche case

{value2, value3} (cell arrays) verwendet werden (in

C case value2: case value3:). otherwise entspricht

default in C/C++. Die Variable die verglichen wird

kann auch einen String enthalten. Dies ist in C/C++

nicht möglich.

continue,

break

- Wie in C definiert.

return - Wie in C definiert, es werden aber keine

Rückgabewerte angegeben.

(*) Siehe dazu Kapitel 1.8.2.1

1.8.2.3 Exceptions

Ähnlich wie in C++ können über try und catch Exeptions verwendet werden.



1.9 Ein- und Ausgabe

Wie in vielen Programmiersprachen besteht auch in MATLAB die Möglichkeit Daten über die Tastatur, aus

Dateien einzulesen (auch formatiert) bzw. Daten über das Konsolenfenster auszugeben oder in Dateien (auch

formatiert) abzuspeichern. Ergebnisse und Daten können grafisch dargestellt werden. MATLAB stellt auch

Funktionen zur Erstellung von grafischen Benutzeroberflächen (GUI) zur Verfügung (siehe guide), die aber im

Rahmen dieser Einführung nicht beschrieben werden. Die im Folgenden aufgelisteten Funktionen repräsentieren nur

die Basisfunktionen. Eine ausführlichere Beschreibung der Befehle kann über den help-Befehl abgefragt werden.

In Matlab ist auch ein Teil der C-Library stdio implementiert, die zur Datei/ String Ein- und Ausgabe verwendet

werden kann:

fprintf, sprintf, fscanf, sscanf, fclose, fopen, ……

Allerdings ist der Befehl printf zur Ausgabe auf der Konsole nicht implementiert.

1.9.1 Text, Konsole

Befehlsbeschreibung Befehl

Eingabe eines Wertes in das MATLAB-

Konsolenfenster M = input (‚Ausgabetext’)

Eingabe eines Strings in das MATLAB-

Konsolenfenster string = input (‚Ausgabetext’,’s’)

Ausgabe eines Textes, einer Variablen oder eines

Objekts im Konsolenfenster disp(Variable), disp('Ausgabetext'), display(Variable), display('Ausgabetext') disp gibt im Gegensatz zu display nicht den

Namen der Variablen aus. Des Weiteren

verhalten sich beide Befehle unterschiedlich

in Bezug auf spezielle Klassen wie z.B. LTI-

Systeme (siehe Kap. 1.12.2).

>> a=1; >> disp(a) 1 >> display(a) a = 1 >> s=tf('s'); >> G=1/(s+1); >> display(G) Transfer function: 1 ----- s + 1 >> disp(G) tf object: 1-by-1



Zur Ausgabe von Text auf der Konsole kann der Datei Ein-/Ausgabe Befehl fprintf unterAuslassung des filepointer

Parameters verwendet werden:

>> x=5; >> fprintf('Wert : %f\n', x); Wert : 5.000000 >>

Das Auslassen des filepointer Parameter entspricht dem Setzten des filepointer parameters auf 1 dem Standard

stream: Ausgabe auf der Konsole.

>> x=5; >> fprintf(1, 'Wert : %f\n', x); Wert : 5.000000

Der Befehl kann im Unterschied zu C auch vektorielle Größen verarbeiten:

>> x=1:5; >> fprintf('Wert : %f\n', x); Wert : 1.000000 Wert : 2.000000 Wert : 3.000000 Wert : 4.000000 Wert : 5.000000 >>



1.9.2 Grafikausgabe

Die Grafikausgabe in MATLAB kann in zwei Bereiche unterteilt werden.

Ausgabe Numerischer Daten, die in Datenvektoren oder Datenmatrizen gespeichert sind.

Grafische Darstellung von Funktionen mittels Funktionsplotter.

1.9.2.1 Ausgabe numerischer Daten

Die Ausgabe numerischer Daten ist mit den folgenden Befehlen möglich.

Befehlsbeschreibung Befehl(e)

Ausgabe von Zahlenreihen in einer Grafik in einem

zweidimensionalen Koordinatensystem

plot(Vektor, Optionen) bzw.

plot(xVektor, yVektor, Optionen)

Entspricht plot aber mit zwei unabhängigen y-Achsen. plotyy

Logarithmische zweidimensionaler Graph loglog, semilogx, semilogy

Ausgabe in Polarkooardinaten. polar

Ausgabe von Zahlenreihen in einer Grafik in einem

dreidimensionalen Koordinatensystem

plot3, mesh, surf, waterfall, fill3, contour3 usw.

Ausgabe als Höhenlinien / Kontur. contour, contourf

Ausgabe als Treppenstufe (z.B. zur Darstellung eines

zeitdiskreten Signals, zero order hold)

stairs(Vektor, Optionen) bzw.

stairs(xVektor, yVektor, Optionen)

Darstellung einer diskreten Folge stem

Balkendiagramm bar

Die Grafikausgabe kann über eine Vielzahl von Parametern angepasst werden. Siehe auch help graph2d und help graph3d.

Beispiel:

Im Folgenden sollen die beiden Funktionen y1 und y2 im Wertebereich x = -10 ... +10 in 0,1 Schritten diskret

berechnet und in einem zwei-dimensionalen Graphen ausgegeben werden. Die Funktionen sind wie folgt definiert.

1x2x1,0xy

1xxy

232

21

Dazu muss zuerst der Vektor x definiert werden, der die Werte von -10 bis +10 in 0,1 Schritten als Vektorelemente

beinhaltet 109,99.910 x .

>> x=-10:0.1:10;

Danach wird für jedes Vektorelement in x der Funktionswert der Funktionen y1 und y2 berechnet und in den

Vektoren y1 und y2 abgelegt.

>> y1=x.^2+1; >> y2=0.1*x.^3-2*x.^2+1;

Danach erfolgt die eigentliche grafische Ausgabe der Datenvektoren.

>> plot(x,y1,'r',x,y2,'b--');

Hinzufügen eines Rasters (grid).

>> grid on; % siehe Kap. 1.9.2.3



Beschriften des Koordinatensystems.

>> xlabel('x'); % siehe Kap. 1.9.2.3 >> ylabel('y'); >> title('Beispiel'); >> legend('y_1','y_2');

Grafikausgabe

1.9.2.2 Funktionenplotter

MATLAB stellt einige Funktionsplotter zur Verfügung mit deren Hilfe mathematische Funktionen in Form eines

Strings, anonyme Funktionen (siehe Kap. 1.4) oder m-Funktionfiles (siehe Kap. 1.8.1.1) grafisch dargestellt werden

können. Die Funktionen können implizit oder explizit angeben werden bzw. werden als implizit oder explizit

interpretiert je nachdem welcher Funktionsplotter verwendet wird.


Zweidimensionale Kurvenplotter. ezplot, fplot

Dreidimensionaler Kurvenplotter für

Vektorfunktionen, die von einem

Parameter abhängen z.B.Trajektorie.

ezplot3

Polarkoordinaten Funktionsplotter. ezpolar

Konturen Funktionsplotter. ezcontour, ezcontourf

Dreidimensionale Kurvenplotter. ezmesh, ezmeshc, ezsurf, ezsurfc

Siehe help funfun

-10 -8 -6 -4 -2 0 2 4 6 8 10-300

-250

-200

-150

-100

-50

0

50

100

150

x

y

Beispiel

y1

y2



Beispiel: Explizite Funktion als String oder anonyme Funktion

Ausgabe der expliziten Zeitfunktion tetsin)t(f im Bereich 10,0t .

>> ezplot('sin(t)*exp(-t)',[0 10]); grid on; % 'sin(t)*exp(-t)' wird als 'sin(t).*exp(-t)' % interpretiert

Oder über die anonyme Funktionsvariante.

>> p_f=@(t) sin(t)*exp(-t); % In diesem Fall wäre die Definition >> ezplot(p_f,[0 10]); grid on; % p_f=@(t) sin(t).*exp(-t); die bessere Alternative Anmerkung:

Hier wäre die Definition p_f=@(t) sin(t)*exp(-t); die bessere Alternative um die Funktion

auch vektoriell auswerten zu können.

Funktion mit Parametern (Parametern und : t

2 etsin)t(f .

Mit = 0,5 und = 2.

>> p_f2=@(t,a,w) sin(w*t)*exp(-a*t); >> ezplot(@(t)p_f2(t, 0.5, 2), [0 10]); >> grid on; >> axis auto; % siehe Kap. 1.9.2.3

Wobei der Ausdruck @(t)p_f2(t, 0.5, 2) wieder eine anonyme Funktion repräsentiert, die die anonyme Funktion mit

dem Handle p_f2 referenziert.

0 1 2 3 4 5 6 7 8 9 10

0

0.05

0.1

0.15

0.2

0.25

0.3

t

sin(t) exp(-t)



Beispiel: dreidimensionale grafische Darstellung expliziter Funktionen

>> ezmesh('sin(x)*cos(y)');

0 1 2 3 4 5 6 7 8 9 10-0.4

-0.2

0

0.2

0.4

0.6

t

pf2

(t,0.5,2)

-6-4

-20

24

6

-6

-4

-2

0

2

4

6

-1

-0.5

0

0.5

1

x

sin(x) cos(y)

y



Beispiel: Implizite Funktionen

Bei der zweidimensionalen Ausgabe der Funktion 2yx)y,x(circ_p 22 wird der Ausdruck als implizite

Funktion 2yx0 22 interpretiert. Nach Auflösung nach y ergibt sich2x4y .

>> p_circ=@(x, y) sqrt(x.^2 + y.^2)-2; ezplot(p_circ,[-2.5,2.5]); grid on;

Bei einer dreidimensionalen Ausgabe wird die Funktion als explizite Funktion interpretiert.

>> ezmesh(p_circ,[-2.5,2.5,-2.5,2.5]); grid on;

-2.5 -2 -1.5 -1 -0.5 0 0.5 1 1.5 2 2.5-2.5

-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

2.5

x

y

sqrt(x2+y2)-2 = 0

-2

-1

0

1

2

-2

-1

0

1

2

-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

x

sqrt(x2+y2)-2

y



1.9.2.3 Anpassung, Beschriftung des Koordinatensystems

Befehlsübersicht


Überschrift eines Grafikfensters title(Überschrift’)

Achsenbeschriftung x-Achse xlabel ('Beschriftung der X-Achse')

Achsenbeschriftung y-Achse ylabel ('Beschriftung der Y-Achse')

Beeinflussung des Erscheinungsbildes

des Koordinatensystems axis

Erstellung eines neuen

Koordinatensystems axes

Erstellen einer Legende legend('Kurve1', 'Kurve2', ....)

Raster ein und ausschalten grid on, grid off

Löscht aktuelles Grafikfenster clf

Ein Grafikfenster schließen close

Alle Grafikfenster schließen close all

Handle des aktuellen Grafikfensters (get

current figure) ermitteln gcf

Ein neues Grafikfenster öffnen bzw. ein

bestehendes Grafikfenster in den

Vordergrund bringen, es zum aktuellen

Grafikfenster machen (current figure).

figure

Nachtäglich z.B. einen plot in einen

bestehenden plot einfügen ohne den alten

plot zu löschen.

hold on, hold off

Siehe auch help graphics

1.9.3 Übersicht zum Dateihandling und zu Datendateien

Das Speichern von Variablen aus dem Workspace im mat-Format erfolgt über den save Befehl, das Laden von

Variablen in den Workspace im mat-Format erfolgt über den load Befehl. Beide Befehle können sehr flexibel z.B.

im Format der Datei, der zu speichernde / zu ladende Daten parametriert werden. Über den Befehl whos oder who

mit der Option –file lassen sich informationen über in .mat Dateien abgespeicherten Variablen ermitteln und über

uigetfile / uiputfile wird ein (Common)filebrowserdialog (wie „Öffen“ / „Speichern“ Dialoge) geöffnet mithilfe

dessen Dateien ausgewählt werden können. Zum browsen nach Pfaden steht uigetdir zur Verfügung.

Eine weitere Möglichkeit Daten zu importieren besteht darin den Data Import Wizzard über uiimport aufzurufen.

uiimport ist in der Lage in MATLAB bekannte Datenformate aus Dateien und aus der Zwischenablage zu

importieren. Neben dem mat-Format können auch Datendateien wie Bilder (gängige Formate und Windows

Imageresourcedateien), Audiodateien (.au, .snd, .wav), Videodateien (.avi) sowie Tabellen (.csv, .xls, .xlsx, .wk1)

und Textdateien importiert werden.

Des Weiteren existieren, wie eingangs erwähnt, Implementierungen von C-Funktionen aus der stdio.h (fopen, fclose,

fprintf, fread usw.) Bibliothek, Funktionen zum lesen / schreiben von formatierten Datenfiles z.B. auch Excel und

csv Dateien (textscan, dlmread, dlmwrite, csvread, csvwrite, xlsread, xlswrite) und zum lesen von Sound-Dateien

(wavread, wavwrite, auread, auwrite) und Bilddateien (imread, imwrite). Voraussetzung für das Lesen und

Schreiben von Bilddateien ist die Image Toolbox.



1.10 Eval

Die Funktion eval führt den übergebenen String als Befehl aus.

Beispiel:

string = input('Dateiname','s') eval (['load ',Dateiname,'.asc'])



1.11 Lösung von expliziten Differentialgleichungssystemen

Zur Lösung von Differentialgleichungssystemen stellt MATLAB einen reichen Befehlssatz zur Verfügung. Die

Parametrierung der Befehle lassen auf den ersten Blick nur die Lösung eines Anfangswertproblems (initial value

problem) durch numerische Integration (Simulation) der Differentialgleichungen / des

Differentialgleichungssystems zu. Es werden sogenannte solver eingesetzt (Eine Übersicht ist über help funfun oder

doc funfun abrufbar). Die Befehle lassen sich aber auch für Systeme mit Eingangssignalen einsetzen.

Mittels MATLAB lassen sich Anfangswertprobleme (siehe auch Kap. 2.7.3) gewöhnlicher expliziter

Differentialgleichungen (ordinary differential equations, ode) / Differentialgleichungssystemen erster Ordnung der

Form

yfy ,t oder yfyyM ,t,t

lösen (siehe auch help funfun oder doc funfun). Wobei yM ,t die Massenmatrix, f die Vektorfunktion und y(t)

den Zustandsgrößenvektor repräsentieren. Die Verschiedenen solver unterliegen bestimmten Einschränkungen bzw.

sind für bestimmte Problemtypen entwickelt worden. Näheres dazu z.B. über help ode23 oder besser doc ode23.

[T,Y] = solver(odefun,tspan,y0,options) oder

ergstruct = solver(odefun,tspan,y0,options) solver: Integrationsverfahren: ode23, ode45, ode113, ode15s, ode23s, ode23t,

ode23tb

odefun: Ein Funktionshandle (oder Funktionszeiger) auf das

Differentialgleichungssystem implementiert als m-function

tspan: Vektor des Integrationszeitintervalls (Simulationszeitintervall) [tstart, tende]

y0: Vektor mit den Anfangswerten von y(0)

options: Zusätzlich einstellbare Option. Diese Optionen können auch über odeset gesetzt

werden. Hilfe zu den Optionen und odeset über help odeset oder doc odeset

(optionaler Parameter)

T: Rückgabe Zeitvektor

ergstruct: Ergebnisstruktur (siehe auch help deval, doc deval)

Anmerkung: Es stehen noch weitere Rückgabeparameter zur Verfügung siehe help ode23, doc ode23

Die Anwendung dieser solver erfolgt anhand des Beispiel: Pendel I aus Kap. 2.7.3.1. Es soll ein Pendel mit

geschwindigkeitsproportionaler Reibung (Reibmoment µR kM , Reibmomentkoeffizient kµ) simuliert werden.

Der Stab der Länge l sei masselos und die Luftreibung werde vernachlässigt.

0sing

k

mit 2

µ

m

kk

Schwerkraft FG: gmFG

k = 0,3 und g / l = 9,81 / 0,5 (ohne Einheiten)

MR

m

l



In einem ersten Schritt muss die Differentialgleichung (DGL) in ein Differentialgleichungssystem überführt werden.

0sing

k

122

21

1

ysing

kyy

yy

y

yf

y,t

12

2

2

1

ysing

ky

y

y

y

DGL-System implementiert als m-function (siehe Kap. 1.8.1.1) pendelf (Datei pendelf.m).

Datei pendelf.m

function dydt = pendelf(t,y) % Parameter k = 0.3; g = 9.81; l = 0.5; % DGL-System: pendelf dydt= [y(2); -y(2)*k-g/l*sin(y(1))];

Simulationsaufruf und grafische Ausgabe.

>> [t,y]=ode23(@pendelf, [0, 10], [0.8 0]); plot(t,y(:,1),t,y(:,2)); legend('y_1', 'y_2'); grid on; Der Operator „@“ ermittelt das Funktionshandle bzw. den Funtionszeiger der Funktion pendelf

(siehe Kap. 1.4).

Simulationsergebnis.

0 1 2 3 4 5 6 7 8 9 10 -4

-3

-2

-1

0

1

2

3

y 1

y 2



Simulation eines PT-1 mit einem Sprung nach 2 sec.

)t(uT

1)t(y

T

1)t(y

1Ts

1

)s(U

)s(Y

mit u(t) = h(t-2)

DGL als m-function implementiert.

Datei PT1f.m

function dydt = PT1f(t,y) % Parameter T = 2; % Zeitkonstante % DGL-PT1: Sprung nach 2 sec if(t < 2) dydt= -y(1)/T; else dydt= -y(1)/T + 1/T; end

Simulationsaufruf und grafische Ausgabe.

>> [t,y]=ode23(@PT1f, [0, 14], [0]); plot(t,y); legend('y'); grid on;

0 2 4 6 8 10 12 140

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

y



Es existieren noch weitere Solver und Funktionen zur Lösung folgender Problemstellungen (siehe help funfun oder

doc funfun):

Anfangswertproblem für implizite Differentialgleichungssysteme: 0yyf ,,t

Anfangswertproblem für Differentialgleichungssysteme mit Totzeiten

Randwertproblem (boundary value problem, bvp)



1.12 Regelungstechnik-Toolbox

Zur Lösung regelungstechnischer Probleme steht die Control Toolbox zur Verfügung. Zur Untersuchung von

dynamischen linearen zeitinvariant Systemen (Linear Time Invariant - LTI) stehen 4 Modelle zur Verfügung:

1) Übertragungsfunktion (transfer function) tf

2) Zustandsraum (state space) ss

3) Pole, Nullstellen und Verstärkung zpk

4) Frequenzmodell frd (dieses Modell wird nicht beschrieben)

Diese Modelle können sowohl in kontinuierlicher (Laplace-Transformation) als auch in zeitdiskreter (Z-

Transformation) Form definiert werden (siehe auch help ltimodels). Des Weiteren unterscheidet man zwischen

Systemen mit einem Eingangs – und Ausgangssignal (single-input/single-output SISO) und Systemen mit mehreren

Eingangs- und Ausgangssignalen (multiple-input/multiple-output MIMO). Eine Übersicht über die von der Toolbox

zur Verfügung gestellten Befehle erhält man über:

help control

1.12.1 Überladen von Operatoren und Funktionen

Da im Fall der Control-Toolbox jedem LTI-System Modell ein Datentyp zugeordnet wurde existiert häufig (aber nur

wenn dies Sinn macht) für die verschiedenen Datentypen (LTI-Systeme) eine separate Implementierung eines

Befehls/Operators bzw. eine datentypabhängige (LTI-System) Ausführung des Befehls/Operators. Dies wird wie in

C++ als überladen (overloading) von Methoden und Operatoren bezeichnet.

Beispiel:

>> help step STEP Step response of LTI models. ... ... See also IMPULSE, INITIAL, LSIM, LTIVIEW, LTIMODELS. Overloaded methods Diese Methode wurde überladen, ist also für verschiedene Datentypen

definiert worden. help lti/step.m Datentyp lti Modell (also für alle Modelle). help idmodel/step.m help iddata/step.m >> help lti/step Hilfe zur überladenen Methode STEP Step response of LTI models. STEP(SYS) plots the step response of the LTI model SYS (created with either TF, ZPK, or SS). ... ... >> help zero --- help for zpk/zero.m --- ZERO Transmission zeros of LTI systems. ... ... There is more than one zero available. See also also definiert für tf, ss und frd Systeme help tf/zero.m überladen für tf Modell help ss/zero.m überladen für ss Modell help frd/zero.m überladen für frd Modell >> help tf/zero liefert die Hilfe zum tf-System

(überladen für tf Modell)



1.12.2 Definition von LTI Systemen ohne Totzeit

1.12.2.1 Übertragungsfunktion (TF-Modell)

1.12.2.1.1 Tf SISO – Systeme

Die Eingabe von Übertragungsfunktionen ist seit MATLAB 5.0 auch in symbolischer Form möglich. Beide

Definitionsformen sind gleichwertig.

Definition über Polynomkoeffizienten Symbolische Definition

Kontinuierlich

(Laplace Transformation)

fes2ds

cbs2as)s(1G

mit

Zähler (Numerator):

a = 1, b = 2, c = 10,

Nenner (Denominator):

d = 7, e = 1, f = 2

Durch Angabe der Zähler- und Nenner-

polynomkoeffizienten

G1 = tf(Zähler,Nenner)

mit

Zähler = [a b c] = [1 2 10]

Nenner = [d e f] = [7 1 2]

Beispiel:

>> G1 = tf( [1 2 10] , [7 1 2] ) Transfer function: s^2 + 2 s + 10 ----------------- 7 s^2 + s + 2

Über die Funktion s = tf(’s’) wird s (Teilausdruck

s =) als Laplace Variable (Teilausdruck ’s’) zugeordnet. Dies ist nötig um

Übertragungsfunktionen symbolisch eingeben zu

können.

Beispiel:

>> s = tf(’s’); >> G1=(s^2+2*s+10)/(7*s^2+s+2) Transfer function: s^2 + 2 s + 10 -------------------- 7 s^2 + s + 2

Zeitdiskret

(Z-Transformation)

dcz

baz)z(1G

mit

Zähler (Numerator):

a = 0.2, b = 0.1,

Nenner (Denominator):

c = 1, d = 0.3

Abtastzeit TA = 1 sec.

(*)

Durch Angabe der Zähler- und Nenner-

polynomkoeffizienten und der Abtastzeit TA.

G1 = tf(Zähler, Nenner, TA)

mit

Zähler = [a b] = [0.2 0.1]

Nenner = [c d] = [1 0.3]

TA = 1

>> G1 = tf( [ 0.2 0.1] , [1 0.3] , 1) Transfer function: 0.2 z + 0.1 ------------- z + 0.3

Über die Funktion z = tf(’z’,TA) wird z

(Teilausdruck z =) als Z-Transformationsvariable

(Teilausdruck ’z’) zugeordnet. Mit TA wird die

Abtastzeit festgelegt. Dies ist nötig um

Übertragungsfunktionen symbolisch eingeben zu

können.

Beispiel:

>> z = tf('z',1); >> G1=(0.2*z + 0.1)/(z + 0.3) Transfer function: 0.2 z + 0.1 ------------- z + 0.3

Anmerkung (*):

Im Gegensatz zur Signalverarbeitungs-Toolbox bzw. Literatur sind Übertragungsfunktionen im Z-Bereich in der

Control-Toolbox mit positiven Exponenten dargestellt. Diese Darstellung lässt sich auch umstellen:

>> z=tf('z', 0.001);

>> H=1/(z-0.1)

Transfer function:

1

-------

z - 0.1

>> H.Variable = 'z^-1' siehe dazu Kapitel 0

Transfer function:

z^-1

------------

1 - 0.1 z^-1



1.12.2.1.2 TF MIMO – Systeme, Übertragungsmatrix

Um ein System mit mehreren Ein- und Ausgängen definieren zu können wird eine Übertragungsmatrix G

(kontinuierlich oder diskret) definiert, deren Elemente Übertragungsfunktionen Gij enthalten. Wobei die

Zeilennummer i der Ausgangsnummer entspricht auf den das Ausgangssignal von Gij wirkt. Die Spaltennummer j

definiert den Eingang mit dem die Übertragungsfunktion Gij angeregt wird. Alle Ausgangssignale der

Übertragungsfunktionen Gij, die auf den gleichen Ausgang wirken werden addiert. Im Folgenden wurde ein System

mit drei Eingängen und zwei Ausgängen dargestellt:

Matrixschreibweise

)s(G)s(U)s(G)s(U

)s(G)s(U)s(G)s(U

)s(G)s(U)s(G)s(U

)s(U

)s(U

)s(G)s(G

)s(G)s(G

)s(G)s(G

)s(Y

)s(Y

)s(Y

322311

222211

122111

2

1

)s(

3231

2221

1211

2

2

1

G

Blockschaltbild

Beispiel: Wird jeder Eingang des links definierten Systems separat durch einen

Sprung angeregt ergibt sich folgendes Bild. >> s=tf('s'); >> g11 = 1/(s+1); >> g12 = 1/(2*s^2 + s + 1); >> g21 = 1/(s+3); >> g22 = 3; >> G =[g11 g12; g21 g22] Transfer function from input 1 to output... 1 #1: ----- s + 1 1 #2: ----- s + 3 Transfer function from input 2 to output... 1 #1: ------------- 2 s^2 + s + 1 #2: 3

0

0.5

1

1.5

To: O

ut(

1)

From: In(1)

0 5 10 15 200

1

2

3

4

To: O

ut(

2)

From: In(2)

0 5 10 15 20

Step Response

Time (sec)

Am

plit

ude

G11(s)

G12(s)

G21(s)

G22(s)

U1(s)

U2(s)

G31(s)

G32(s)

Y1(s)

Y2(s)

Y3(s)

+

a

+



Der Zugriff auf Übertragungsfunktionen innerhalb der Übertragungsmatrix erfolgt analog zu den Elementzugriffen

auf ein „normales“ Matrixelement (i, j) G(i, j).

Beispiel:

>> g11 = G(1,1) oder >> g11 = tf(G.num{1,1}, G.den{1,1}) (siehe unten)

Transfer function: 1 ----- s + 1

Es besteht auch die Möglichkeit MIMO Systeme in Form von Übertragungsmatrizen (hier Übertragungsmatrix

G(s)) mittels cell arrays (siehe Kap. 1.7) und der Funktion tf zu definieren. Zur Definition des MIMO-Systems

benötigt man zwei cell arrays (Matrix) num und den. Wobei num die Zählerpolynomkoeffizientenvektoren enthält

und den die Nennerpolynomkoeffizientenvektoren enthält. Genauer:

num{i,j} Ist ein Vektor, der die Zählerpolynomkoeffizienten der

Übertragungsfunktion Gij, von Eingang j auf Ausgang i enthält.

den{i,j} Ist ein Vektor, der die Nennerpolynomkoeffizienten der

Übertragungsfunktion Gij, von Eingang j auf Ausgang i enthält.

Erneute Eingabe des vorherigen Beispiels mit Hilfe von cell arrays und der Funktion tf:

>> num = {1,1; 1,3}; >> den ={[1 1], [2 1 1]; [1 3],[1]}; >> G=tf(num,den) Transfer function from input 1 to output... 1 #1: ----- s + 1 1 #2: ----- s + 3 Transfer function from input 2 to output... 1 #1: ------------- 2 s^2 + s + 1 #2: 3

Die Übertragungsmatrix G eines Zustandsraumsystems (siehe Kap. 0) kann auch direkt Mithilfe der

Zustandsraummatrizen A, B, C und D berechnet werden.

)t()t()t(

)t()t()t(

uDxCy

uBxAx

)s(

)s(

)t()t()t(L

)t()t()t(L

uDxCy

uBxAx

)s(s)s(

)s()s()s(

)s(s)s(

)s(

1

1

UDBAICY

UDXCY

UBAIX

G



Übertragungsmatrix: DBAICG 1

s)s(

Das Zustandsraummodell wurde dem Beispiel Permanentmagnetgleichstrommotor aus Kap. 3.1 entnommen.

>> R=2; L=500e-6; k=68e-3; J=10e-6; ku=5e-5; >> A=[-R/L -k/L; k/J -ku/J]; B=[1/L; 0]; C=[1 0; 0 1]; D=[0; 0]; >> G=C*((s*eye(2)-A)^-1)*B+D Transfer function from input to output... 2000 s + 1e004 #1: ---------------------------------- s^2 + 4005 s + 9.448e005 1.36e007 #2: ---------------------------------- s^2 + 4005 s + 9.448e005

Alternative: Konvertierung

>> G2=tf(ss(A,B,C,D)) % Vergleich über Konvertierung % siehe dazu Kap. 1.12.4.1 Transfer function from input to output... 2000 s + 10000 #1: ------------------------------ s^2 + 4005 s + 944800 1.36e007 #2: ------------------------------ s^2 + 4005 s + 944800

Die vorgestellten Vorgehensweisen lassen sich auch auf diskrete Systeme (Z-Transformation) anwenden.



1.12.2.2 Definition über Pole, Nullstellen und Verstärkung (ZPK-Modell)

1.12.2.2.1 ZPK SISO-Systeme

Zur Definition des Systems werden Pole, Nullstellen und die Verstärkung angegeben. Das System G(s) ist dann wie

folgt definiert:

n1

m1

ps...ps

zs...zsk)s(G

Die Definition des Systems ist in der folgenden Tabelle beschrieben:

Laplace-Transformation G2 = zpk(z,p,k) mit

z:

p:

Vektor mit Nullstellen [z1 z2 ... zm]

Vektor mit Polen [p1 p2 ... pn]

Z- Transformation G2 = zpk(z,p,k,TA) k:

TA:

Verstärkung

Abtastzeit für zeitdiskrete Systeme

Beispiel:

>> G2 = zpk(1,[-2 -3],4) Nullstelle bei 1, Pole bei -2 und -3 sowie eine Verstärkung von 4.

Zero/pole/gain: 4 (s-1) --------------- (s+2) (s+3)

Eine „symbolische Eingabe “ von Übertragungsfunktion dises Typs ist ebenso wie beim tf Modell (siehe Kap.

1.12.2.1.1) möglich:

>> s=zpk('s'); >> G=1/(s+1)/(s+2) G = 1 ----------- (s+1) (s+2) Continuous-time zero/pole/gain model. >> G2=1/(s^2+4*s+4) G2 = 1 ------- (s+2)^2 Continuous-time zero/pole/gain model.



1.12.2.2.2 ZPK MIMO-Systeme

Die Eingabe erfolgt wie in Kapitel 1.12.2.1.2 beschrieben, jedoch wird die zpk Funktion verwendet und es werden

anstatt Vektoren mit Polynomkoeffizienten Vektoren mit Polen und Nullstellen sowie eine Verstärkungsmatrix

angegeben.

1.12.2.3 Zustandsraummodell (ss-Modell)

Das folgende Modell ist ein kontinuierliches Zustandsraummodell (state-space model, ss-Modell) der Ordnung n mit

p Eingangsgrößen und q Ausgangsgrößen.

Blockschaltbild eines kontinuierlichen Zustandsraumsystems.

Analog dazu das zeitdiskrete Zustandsraummodell.

Blockschaltbild eines zeitdiskreten Zustandsraumsystems.

x(t) Zustandsvektor mit den Anfangswerten x(0) (n,1)

u(t) Steuervektor (p,1)

y(t) Ausgangsvektor (q,1)

A Systemmatrix (n, n)

B Steuermatrix (n, p)

C Ausgangsmatrix (q, n)

D Durchgangsmatrix (q, p)

x(n) Zustandsvektor mit den Anfangswerten x(0) (n,1)

u(n) Steuervektor (p,1)

y(n) Ausgangsvektor (q,1)

F Systemmatrix (n, n)

H Steuermatrix (n, p)



H

F

+

+

C

D

+

+

)t()t()t(

)t()t()t(

uDxCy

uBxAx

)n()n()n(

)n()n()1n(

uDxCy

uHxFx

B

A

+

+

C

D

+

+



Definition des Zustandsraumsystems mit MATLAB.

Laplace-Transformation G3 = ss(A,B,C,D)

Z-Transformation G3 = ss(A,B,C,D,TA)

wobei A, B, C und D die Matrizen A, B, C und D des Zustandsraums darstellen und TA die Abtastzeit bei

zeitdiskreten Systemen repräsentiert.

Beispiel:

G3=ss([-2 -1.5;2 0],[1;0],[1 1],0)

a = x1 x2 x1 -2 -1.5 x2 2 0 b = u1 x1 1 x2 0

c = x1 x2 y1 1 1

d =

u1 y1 0



1.12.3 Anzeigen und ändern von Eigenschaften (Properties) eines LTI-Systems

Den verschiedenen Systemmodellen (tf, ss, zpk, ...) sind verschiedene Datentypen (classes: tf, ss, zpk, ...) zugeordnet

in denen die Daten des Systems abgelegt werden. Diese Datentypen wurden ähnlich wie in C über einen

strukturierten Datentyp „struct“ definiert (siehe Kap. 1.3.3). Aus diesem Grund sind die Datamember einer Instanz

über den „.“ Operator wie in C adressierbar. Des Weiteren existieren noch Befehle um Systemeigenschaften

anzuzeigen und zu verändern.

tf ss zpk

Anzeige aller verfügbaren LTI Systeme

ltimodels

Hilfe zu verschiedenen Modellen ltimodels(’tf’) help tf

ltimodels(’ss’) help ss

ltimodels(’zpk’) help zpk

Ermitteln der Systemeigenschaften [Zaehler,Nenner] = tfdata(sys) [Zaehler,Nenner,TA] = tfdata(sys) (*)

[A,B,C,D] = ssdata(sys) [A,B,C,D,TA] = ssdata(sys)

[Z,P,K] = zpkdata(sys) [Z,P,K,TA] = zpkdata(sys) (*)

Anzeigen der Systemeigenschaften get(sys)

Anzeigen (bzw. abspeichern) einer

speziellen Systemeigenschaft

get(sys,’TS’) oder sys.TS In diesem Fall Abtastzeit TA (sampling time TS)

Ändern einer Systemeigenschaft set(sys,’TS’,1) oder sys.TS = 1 In diesem Fall Abtastzeit TA auf 1 sec setzen (sampling time TS)

Gleichzeitiges Ändern mehrerer Systemeigenschaften

set(sys, ’PropertyName1’, Wert1, ’PropertyName2’, Wert2, ’PropertyName3’, Wert3, ...)

Mit:

Zaehler Nenner : Vektoren mit Zähler- und Nennerpolynomkoeffizienten der Übertragungsfunktion.

A B C D : Matrizen des Zustandsraummodells.

Z P K : Nullstellen (Z), Pole (P) und Verstärkung (K) des ZPK-Modells.

TA : Abtastzeit bei diskreten Systemen.

Anmerkung zu (*):

Da MIMO-Systeme wie in Kapitel 1.12.2.1.2 beschrieben über cell arrays und über Funktion wie z.B. die tf

Funktion definiert werden können, muss die Struktur vom Typ (class) tf neben einer einzelnen

Übertragungsfunktionen auch eine Übertragungsmatrix beherbergen können. Aus diesem Grund sind einige

Properties (Datamembers) der Struktur tf vom Typ cell array, auch wenn es sich um ein SISO-System handelt.

Daher können bei SISO-Systemen folgende alternative Befehle verwendet werden um die Properties als normale

Vektoren oder Matrizen zu erhalten:

[Zaehler,Nenner] = tfdata(sys,’v’) oder z.B. Zaehler = sys.num{1} [Z,P,K] = zpkdata(sys,’v’) oder z.B. Z = sys.z{1}

Beispiel:

>> s=tf('s'); >> H=(s+2)/(s+1)/(s+3); % Zähler auf 1 setzen >> set(H,'num',{1}) % oder alternativ H.num = {1} >> H Transfer function: 1 ----------------- s^2 + 4 s + 3 >> class(H) ans = tf



Des weiteren können allen Ein- und Ausgängen Namen zugewiesen sowie Ein- und Ausgänge zu Gruppen

zusammengefasst (Input/Output Groups) werden. Im Folgenden Beispiel werden dem Ein- und Ausgang Namen

zugewiesen:

>> H.InputName{1} = 'Eingang'; >> H.OutputName{1} = 'Ausgang'; >> H Transfer function from input "Eingang" to output "Ausgang": 1 ----------------- s^2 + 4 s + 3

Die Eigenschaften (Datamembers) lassen sich auch bereits während der Definition festlegen:

G1 = tf( [1 2 10] , [7 1 2] , 'PropertyName1', PropertyValue1, 'PropertyName2', PropertyValue2, …..)

Beispiel:

>> G1 = tf( [1 2 10] , [7 1 2],'InputName','Eingang','OutputName','Ausgang') Transfer function from input "Eingang" to output "Ausgang": s^2 + 2 s + 10 ------------------- 7 s^2 + s + 2 % Genauer wäre: G1 = tf( [1 2 10] , [7 1 2],'InputName',{'Eingang'},'OutputName',{'Ausgang'})

1.12.3.1 Allgemeine Eigenschaften von LTI-Systemen

Die folgenden Eigenschaften (Datamembers) sind in allen LTI-Systemen (classes: tf, ss, zpk, ...) enthalten.

Membername Datentyp Aufgabe

Ts double Abtastzeit des diskreten Systems. 0 bei kontinuierlichen

Systemen.

InputDelay double Vektor Totzeiten der Eingänge (siehe Kap. 1.12.6)

OutputDelay double Vektor Totzeiten der Ausgänge (siehe Kap. 1.12.6)

InputName cell array

Vektor

Namen der Eingänge, Vektorelement ist ein String

OutputName cell array

Vektor

Namen der Ausgänge, Vektorelement ist ein String

InputGroup struct Gruppierung von Systemeingängen, siehe

MATLABdokumentation.

OutputGroup struct Gruppierung von Systemausgängen, siehe

MATLABdokumentation.

Name string Modellname

Notes string Dokumentation

UserData cell array Beliebige Benutzerdaten

Diese Informationen sind abrufbar über den Befehl ltiprops.



1.12.3.2 tf-Modell spezifische Eigenschaften

Die folgenden Eigenschaften (bis auf die Member Variable, ioDelay) sind rein tf-Modell spezifisch.


num cell array Matrix cell array mit den Zählerpolynomkoeffizientenvektoren (*)

den cell array Matrix cell array mit den Nennerpolynomkoeffizientenvektoren (*)

Variable string Systemtyp: kontinuierliches ‘s’, diskret ‘z’

ioDelay double Matrix Matrix enthält die Totzeiten jeder Teilübertragungsfunktion G(i, j)

der Übertragungsmatrix G (siehe Kap. 1.12.6)

(*) jedes Element des cell arrays (siehe Kap. 1.7) enthält einen Vektor mit

Polynomkoeffizienten (Zähler oder Nenner) siehe Kap. 1.12.2.1.2.

Diese Informationen sind abrufbar über den Befehl ltiprops('tf').

Beispiel:

>> den ={[1 1], [2 1 1]; [1 3],[1]}; >> num = {1,1; 1,3}; >> G=tf(num,den); >> get(G) num: {2x2 cell} den: {2x2 cell} ioDelay: [2x2 double] Variable: 's' Ts: 0 InputDelay: [2x1 double] OutputDelay: [2x1 double] InputName: {2x1 cell} OutputName: {2x1 cell} InputGroup: [1x1 struct] OutputGroup: [1x1 struct] Name: '' Notes: {} UserData: []

1.12.3.3 zpk-Modell spezifische Eigenschaften

Die folgenden Eigenschaften (bis auf die Member Variable, ioDelay) sind rein zpk-Modell spezifisch.


z cell array Matrix cell array mit den Nullstellenvektoren (*)

p cell array Matrix cell array mit den Polvektoren (*)

k double Matrix Matrix mit den Verstärkungen zu jeder

Teilübertragungsfunktion G(i, j) der Übertragungsmatrix G

Variable string Systemtyp: kontinuierliches ‘s’, diskret ‘z’

ioDelay double Matrix Matrix enthält die Totzeiten jeder Teilübertragungsfunktion

G(i, j) der Übertragungsmatrix G (siehe Kap. 1.12.6)

DisplayFormat string Anzeige als zpk Modell: 'roots'

(*) jedes Element des cell arrays (siehe Kap. 1.7) enthält einen Vektor mit

Nullstellen und Polen siehe Kap. 0.

Diese Informationen sind abrufbar über den Befehl ltiprops('zpk').



1.12.3.4 ss-Modell spezifische Eigenschaften

Die folgenden Eigenschaften sind rein ss-Modell spezifisch.


a double

Matrix

Zustandsraummatrix: A

b double

Matrix

Zustandsraummatrix: B

c double

Matrix

Zustandsraummatrix: C

d double

Matrix

Zustandsraummatrix: D

e double

Matrix

E Matrix für Modelle in descriptor Form (siehe

MATLABdokumentation)

StateName cell array

Vektor

Vektorelement ist ein String, der der Zustandsgröße einen

Namen zuordnet

InternalDelay double Matrix Interne Totzeiten, siehe MATLABdokumentation

z.B. help getdelaymodel (siehe auch Kap. 1.12.6)

Scaled logical undokumentiert

Diese Informationen sind abrufbar über den Befehl ltiprops('ss').



1.12.4 Modellkonvertierung

In vielen Fällen z.B. beim Reglerentwurf ist es notwendig ein Modell in ein anderes zu konvertieren, da sich z.B. ein

Reglerentwurf leichter mit einer bestimmten Modellart durchführen lässt. Allerdings sollte man bedenken, dass

einige Konvertierungen verlustbehaftet sind, d.h. eine Rückkonvertierung ergibt nicht mehr das ursprüngliche

System.

1.12.4.1 Konvertierung zwischen den Modellarten

Soll ein Modell (tf, zpk, ss) in ein Anderes umgewandelt werden, so wird die Funktion des Zielmodells mit dem zu

konvertierenden Modell als Parameter aufgerufen:

Ziel_Modell = Funktion_des_Ziel_Modells(zu_konvertierendes_Modell)

Funktion_des_Ziel_Modells ist ein Platzhalter für die Funktionen: tf, zpk und ss

Es existieren noch weitere Konvertierungsbefehle der Form x2y:

Konvertiere System x nach System y: tf2ss, tf2zpk, ss2tf, …

Allerdings mit der Einschränkung, dass diesen Befehlen keine Systeme direkt übergeben werden können sondern

nur Matrizen, Vektoren und Skalare, die diese Systeme definieren:

- Vektoren für Zähler- und Nennerpolynomkoeffizienten (tf).

- Vektoren mit Polen und Nullstellen und der skalaren Verstärkung (zpk).

- Matrizen und Vektoren (ss).

Aus diesem Grund sind diese Befehle nur für SISO Systeme geeignet.

Beispiel:

>> G1 = tf(1,[1 1]); % Erstellt tf Model G1 >> G2 = zpk(G1); % Wandelt tf Model G1 nach zpk Modell G2 >> G3 = ss(G1) ; % Wandelt tf Model G1 nach ss Modell G3 usw. >> G4 = ss(G2); >> G5 = ss(G);

Anmerkungen:

- Bei G (in Kap. 1.12.2.1.2 definiert) handelt es sich um eine Übertragungsmatrix G, die

Übertragungsfunktionen enthält (siehe MIMO-Systeme z.B. Kap. 1.12.2.1.2).

- Die Konvertierung gilt sowohl für kontinuierliche, wie auch für zeitdiskrete Systeme.

- Bei der Konvertierung können noch weitere Parameter angegeben werden.

- Siehe auch Kap. 1.12.4.5: Sys2 =ss(Sys1,’min’)



1.12.4.2 Konvertierung zeitdiskret kontinuierlich

Eine Umwandlung eines kontinuierlichen Systems G1k in ein zeitdiskretes System G1d geschieht mit folgendem

Aufruf (siehe auch Beispiel Kap. 0):

G1d = c2d(G1k,Ts,Methode, W0)

mit:

Parameter Funktion

G1k Zu Konvertierendes kontinuierliches Modell

Ts Abtastzeit

Methode Diskretisierungsmethode (optionaler Parameter)

'zoh' Halteglied 0. Ordnung am Eingang (zero order hold), ist der Defaultwert.

Diskretisierung mittels Impulsinvarianz mit Halteglied 0. Ordnung.

'foh' Lineare Interpolation des Eingangs. Diskretisierung mittels

Impulsinvarianz mit Halteglied erster Ordnung.

'imp' Diskretisierung mittels Impulsinvarianz ohne Halteglied.

'tustin' Bilineare Transformation (Tustin).

'prewarp' Bilineare Transformation (Tustin) mit Frequenzprewarping. Zusätzlicher

Parameter Prewarpingkreisfrequenz Wc in rad/sec.

G1d = c2d(G1k,Ts,'prewarp',Wc)

'matched' Matched pole-zero Methode (nur für SISO-Systeme).

Die umgekehrte Umwandlung (zeitdiskret kontinuierlich) erfolgt mit der Funktion d2c

G1k = d2c(G1d,Methode) mit:

Parameter Funktion

G1d Zu Konvertierendes diskretes Modell

Methode Diskretisierungsmethode (optionaler Parameter)

'zoh' Es wird von einem diskreten System mit Halteglied 0. Ordnung

ausgegangen (default Wert).


'prewarp' Bilineare Transformation (Tustin) mit Frequenzprewarping. Zusätzlicher

Parameter Prewarpingkreisfrequenz Wc in rad/sec.

G1k = d2c(G1d, 'prewarp',Wc)

'matched' Matched pole-zero Methode (nur für SISO-Systeme).



1.12.4.3 Ändern der Abtastzeit bei zeitdiskreten Systemen (model resampling)

Die Änderung der Abtastzeit in einem zeitdiskreten System lässt sich mit der Funktion d2d durchführen:

G2d = d2d(G1d,Ts_neu, Methode)

mit:

G1d: Zeitdiskretes Model

G2d: Zeitdiskretes Modell mit der neuen Abtastzeit Ts_neu

Ts_neu: neue Abtastzeit

Methode Funktion

'zoh' Es wird von einem diskreten System mit Halteglied 0. Ordnung ausgegangen

(default Wert).


'prewarp' Bilineare Transformation (Tustin) mit Frequenzprewarping. Zusätzlicher Parameter

Prewarpingkreisfrequenz Wc in rad/sec.

G2d = d2d(G1d, Ts_neu, 'prewarp',Wc)

1.12.4.4 Koordinatentransformation von Zustandsraumssystemen

Sys2 = ss2ss(Sys1,T) Transformiere Sys1 über Transformationsmatrix T nach Sys2.

csys = canon(Sys1,'modal')

Kanonische Darstellung: Die Realteile der Eigenwerte (Pole) der Matrix A

von Sys1 tauchen in der transformierten Matrix A von csys in ihrer

Diagonalen auf und die Imaginäranteile der Eigenwerte diagonal dazu.

Hat die Matrix A von Sys1 folgende Eigenwerte: 21 ,j , ,

so ergibt das dann nach der Transformation folgende A Matrix:

2

1

000

00

00

000

csys = canon(Sys1,'companion') Kanonische Darstellung: Hat ein System folgende charakteristische Gleichung:

n1n

1n

1

n asa...sas)s(p

so sieht die A Matrix des transformierten Systems csys wie folgt aus:

1

2

1n

n

a100

a010

0

010

a0001

a000

A

Sys2 = Sys.’ Transponiere System Sys nach Sys2

Weitere Transformationen: ssbal, balreal, ctrbf (controllability staircase form), obsvf (observability staircase form)

Anmerkung: Für die Transformationen gelten Einschränkungen siehe dazu MATLAB Hilfesystem



1.12.4.5 Reduktion der Ordnung eines LTI-Systems, kürzen von Pol- und Nullstellen

In manchen Fällen besteht die Notwendigkeit die Ordnung eines Systems nach bestimmten Kriterien gezielt zu

reduzieren. Aus diesem Grund stellt die Control-Toolbox Befehle zur Reduktion der Modellordnung zur Verfügung.

Befehl Funktion

modred Reduktion der Anzahl von Zustandsgrößen in Zustandsraummodellen.

minreal Kürzen von Polen und Nullstellen in tf und zpk Systemen auslösen. Eliminiert

nicht steuerbare und beobachtbare Zustandsgrößen in Zustandsraumsystemen.

siehe auch Sys2 = ss(Sys1, 'minimal')

Sys2 =ss(Sys1,’min’) Konvertieren eines Modells (auch ss-Modell) in ein ss-Modell mit minimaler

Anzahl von Zustandsgrößen (siehe doc ss). Entfernt nicht unabhängige

Zustandsgrößen.

sminreal Entfernt alle Zustandsgrößen eines Zustandsraumsystems, die keinen Einfluss auf

das Eingangs- und Ausgangsverhalten haben. Entfernen eines LTI-Teilsystems

aus einem LTI-Gesamtsystem.

1.12.4.6 Berechnung des inversen Systems

Mit dem Befehl inv oder mit „^-1“ kann das inverse Modell eines Systems berechnet werden. Voraussetzung für die

Berechnung ist, dass das System die gleiche Anzahl an Ein- und Ausgänge besitzt.

Beispiel:

>> s=tf('s'); >> G=1/(s^2+2*s+1) Transfer function: 1 ----------------- s^2 + 2 s + 1 >> GI=G^-1 Transfer function: s^2 + 2 s + 1 >> G*GI % Es findet keine Kürzung statt! Transfer function: s^2 + 2 s + 1 ----------------- s^2 + 2 s + 1 >> minreal(G*GI) % Noch mal mit Kürzen Transfer function: 1



1.12.5 Verschaltung von LTI-Systemen

Es existieren folgende Befehle für einfache Verschaltungen von LTI-Systemen:

Verschaltung Anweisung alternativ Befehl (*)

Reihenschaltung G3 = G1 * G2 series

Parallelschaltung G3 = G1 + G2 bzw. G3 = G1 – G2 parallel

Rückkopplung G3 = G1/(1+sign*G1*G2) G3 = feedback (G1,G2,sign)

(*) Es stehen mehr Optionen zur Verfügung siehe dazu MATLAB Hilfesystem.

Mit sign:

pos. Rückkopplung = +1

neg. Rückkopplung = -1 (default)

Anmerkung:

MATLAB kürzt Pole und Nullstellen an der gleichen Stelle nicht. Dazu kann aber der Befehl

minreal verwendet werden (siehe Kap. 1.12.4.5) .

Beispiel:

>> s=tf('s'); >> G1=(s-1)/(s+1)/(s+2)/(s+3); >> G2=(s+1)/(s-1); >> G3=zpk(G1*G2) % G3 = G1*G2 als ZPK – Modell Zero/pole/gain: % Es findet kein „kürzen“ statt. (s+1) (s-1) ----------------------------- (s+3) (s+2) (s+1) (s-1) >> G3 = minreal(G3) % Kürzen auslösen. Zero/pole/gain: 1 --------------- (s+3) (s+2)

Möchte man aus mehreren SISO oder MIMO Systeme ein MIMO System erstellen kann dazu der Befehl append verwendet

werden (vergleiche dazu auch Kap. 1.12.2.1.2). Eine Übersicht zu diesem Thema findet sich unter help control Abschnitt „System

interconnections“.

1.12.6 LTI-Systeme mit Totzeit

Für MIMO-LTI-Systeme kennt MATLAB mehrere Arten von Totzeiten die Spaltenvektoren InputDelay bzw.

OutputDelay, die Totzeiten enthalten, die direkt den Eingängen bzw. den Ausgängen des Systems (*) zugeordnet

sind und die Matrix ioDelay deren Elemente die Totzeiten der Übertragungsfunktionen des Systems (*) enthalten.

IoDelay(i,j) Totzeit der Übertragungsfunktion Gij (bei tf (siehe Kap. 1.12.3.2) und zpk (siehe Kap.

1.12.3.3) Modellen, bei ss Modellen InternalDelay siehe auch Kap. 1.12.3.4 )

InputDelay(i) Totzeit von Eingang i (ist allen Gij zugeordnet, siehe Kap. 1.12.3.1).

OutputDelay(i) Totzeit von Ausgang i (ist allen Gij zugeordnet, siehe Kap. 1.12.3.1).

(*) Bei SISO-Systemen handelt es sich um einen Skalar.



Die gesamte Totzeit von Eingang i nach Ausgang j setzt sich also aus den Totzeiten InputDelay(i), IoDelay(i,j) und

OutputDelay(j) zusammen. Die gesamte Totzeit kann über den Befehl totaldelay ermittelt werden. Um

herauszufinden ob ein System überhaupt eine Totzeit besitzt stellt die MATLAB Control-Toolbox den Befehl

hasdelay zur Verfügung. Bei zeitdiskreten Systemen können über den Befehl delay2z die Totzeiten in Pole bei z = 1

umgewandelt werden.

Beispiel: Definiere eine Übertragungsfunktion und setze die Totzeit auf 1 sec.

>> s=tf('s'); >> G=1/(s+1); >> G.ioDelay =1 % oder set(G,’ ioDelay’,1) Transfer function: 1 exp(-1*s) *----- s + 1 >> % oder kurz (Vorsicht nicht ALLE MATLABversionen erlauben diese Schreibweise!) >> G2=1/(s+1)*exp(-1*s) Transfer function: 1 exp(-1*s) * ----- s + 1

Wichtig:

LTI-Systeme unterschiedlicher Totzeiten können nicht addiert bzw. subtrahiert werden. Eine

Rückkopplung eines LTI-Systems mit Totzeit ist auch nicht möglich, da dabei z.B. eine

Übertragungsfunktion mit Totzeit im Nenner stehen würde. Um solche System wenigstens

näherungsweise simulieren zu können kann die Padé Approximation verwendet werden, die über

den Befehl pade (help pade) zur Verfügung gestellt wird.



1.12.7 Simulation und Eigenschaften von LTI-Systemen

Die MATLAB Control-Toolbox bietet für die Untersuchung und Simulationen von LTI-Systemen einen

umfangreichen Befehlsschatz an. Für die Befehle gelten Einschränkungen bzw. erweiterte Optionen sind verfügbar.

So sind z.B. nicht alle Befehle für alle Modellformen zugelassen. Bitte entnehmen Sie der Hilfe die genaue

Parametrierung der Befehle. Im Folgenden sind nur die grundlegenden Befehle und ihre Parametrierungen

aufgelistet. Ausführlichere Informationen erhalten Sie über:

help control

1.12.7.1 Systemeigenschaften und Untersuchungen im Zeit- und Frequenzbereich

Für die Parametrierung werden die SISO Systeme G (tf-Modell) und sys (ss-Modell) verwendet. Die Befehle können

aber meistens auch für MIMO Systeme eingesetzt werden:

>> s=tf('s'); >> G=(s+1/10)/(s+1)/(s+2) Transfer function: s + 0.1 ----------------- s^2 + 3 s + 2 >> sys=ss(G);

Mit dem GUI-Tool ltiview können einige der untenstehenden Analysen auch interaktiv durchgeführt werden.

Systemeigenschaften

Systemeigenschaft Bemerkung Befehl

Modelltyp class

Prüfen auf Modelltyp Liefert true, falls G oder sys den angegebenen

Klassennamen classname (z.B. tf, zpk, ss) aufweist. isa(G,’classnanme’) isa(sys,’classnanme’)

Prüfen auf Modellart Liefert true, falls G oder sys ein kontinuierliches Modell

ist. isct(G) isct(sys)

Liefert true, falls G oder sys ein diskretes Modell ist. isdt(G) isdt(sys)

Gleichstromverstärkung dcgain(G) dcgain(sys)

Systempole, Eigenwerte Für tf und zpk Systeme (kann auch für ss Systeme

verwendet werden) pole(G) pole(sys)

Für ss Systeme (kann auch für zpk und tf Systeme

verwendet werden) eig(sys) eig(sys.a)

Nullstellen eines

Systems

Berechnet die Nullstellen eines Systems zero(G) zero(sys)

Dämpfung und

Natürliche Frequenz des

Systems

Dämpfung und Natürliche Frequenz der Systempole damp(G) damp(sys)

Linien gleicher Dämpfung

und natürlicher Frequenzen

kontinuierlich sgrid

diskret zgrid

Sortieren von Polen Bei kontinuierliche Systemen nach dem Realteil der

Pole in Vektor P, der die Pole enthält esort(P)

Bei diskreten Systemen nach dem Betrag der Pole in

Vektor P, der die Pole enthält dsort(P)

Grafische Ausgabe von

Polen und Nullstellen

pzmap(G) pzmap(sys)

Ordnung des Systems order(G) order(sys)

Anzahl der Eingänge

und Ausgänge

Bei ss Systemen wird noch zusätzlich die Anzahl der

Zustandsgrößen ausgegeben size(G) size(sys)



Pol jbapi

Natürliche Frequenz 22

N ba

Dämpfung 22 ba

aD

Beispiel:

>> pole(G)

ans =

-2

-1

>> zero(G)

ans =

-0.1000

>> dcgain(G)

ans =

0.0500

Zeitbereich

Untersuchung im Zeitbereich Befehl

Sprungantwort step(G) step(sys)

Kennwerte der Sprungantwort: Anstiegszeit, Peak, .... stepinfo(G) stepinfo(sys)

Impulsantwort impulse(G) impulse(sys)

Anregen des Systems mit einem Eingangssignal(en) u (siehe dazu auch lsiminfo).

Mit u dem Vektor(Matrix) der Eingangsignale(n) und t dem Vektor mit den zugehörigen

äquidistanten Abtastzeitpunkten.

lsim(G,u,t) lsim(sys,u,t)

Generiere Signale für lsim (help gensig). gensig

Simulation eines Zustandsraumsystems ohne Anregung unter Vorgabe der Anfangswerte

über den Vektor x0.

initial(sys,x0)

Frequenzbereich

Untersuchung im

Frequenzbereich

Bemerkung Befehl

Ortskurve bei der grafischen Ausgabe wird auch der Kurvenanteil für

negative Frequenzen mit ausgegeben. Abschaltbar über einen

rechten Mausclick in die Grafikausgabe (nicht direkt auf die

Kurve) ShowNegative Frequencies.

nyquist(G) nyquist(sys)

Bodediagramm Siehe auch bodeplot, bodeoptions, sigma, bodemag bode(G) bode(sys)

Bandbreite eines Systems Bandbreite ist die erste –3dB Stelle die von 0 Hz an gefunden

wird (anwendbar auf SISO Modelle). bandwidth(G) bandwidth(sys)



1.12.7.2 Untersuchungen im Zustandsraum: Steuerbarkeit, Beobachtbarkeit, Rang

QB = obsv(A,C) QB = obsv(sys) (siehe Kap. 3.1.1.2)

Beobachtbarkeitsmatrix:

1n

2

B

CA

CA

CA

C

Q

n: Anzahl der Zustandsgrößen

QS = ctrb(A,B) QS = ctrb(sys) (siehe Kap. 3.1.1.1)

Steuerbarkeitsmatrix:

BA,BA,AB,BQ 1n2

S

n: Anzahl der Zustandsgrößen

rank Rang einer Matrix (Zeilen oder Spaltenrang)

Siehe auch gram.

1.12.8 Befehle für den Regler- und Beobachterentwurf

In der Folgenden Tabelle sind die gebräuchlichsten Befehle für den Regler- und Beobachterentwurf aufgelistet.

Regler- und Beobachterentwurf Befehl

Wurzelortskurve rlocus

Polvorgabe für Zustandsraumregler bzw. Beobachterentwurf (siehe Kap.

3.1.2.2) place

Linear-quadratische Regleroptimierung im Zustandsraum für

kontinuierliche Systeme bezogen auf die Zustandsgrößen bzw.

Stellgrößen (siehe Kap. 3.1.2.3)

lqr

Linear-quadratische Regleroptimierung im Zustandsraum für

kontinuierliche Systeme bezogen auf die Systemausgänge und

Stellgrößen anstatt auf die Zustandsgrößen und Stellgrößen (siehe Kap.

3.1.2.3)

lqry

Linear-quadratische Regleroptimierung im Zustandsraum für diskrete

Systeme bezogen auf die Zustandsgrößen bzw. Stellgrößen dlqr

Linear-quadratische Regleroptimierung im Zustandsraum für diskrete

Systeme bezogen auf die Systemausgänge und Stellgrößen anstatt auf die

Zustandsgrößen und Stellgrößen

dlqry

Diskreter Zustandsraumregler für kontinuierlichen Prozess mittels linear-

quadratischer Optimierung bezogen auf die Zustandsgrößen bzw.

Stellgrößen

lqrd

Linear-quadratisch optimierter I-Zustandsraumregler für diskrete und

kontinuierliche Systeme lqi

GUI für den Reglerentwurf sisotool

Amplitudenrand und Phasenrand (siehe auch allmargin) margin Zustandsraummodell eines Beobachters erstellen estim

Zustandsraummodell eines Reglers mit Beobachter erstellen reg

Lösung der kontinuierlichen algebraischen Riccati Gleichung care

Lösung der diskreten algebraischen Riccati Gleichung dare



2 Simulink

Mit der Control-Toolbox (Kap. 1.12) lassen sich LTI-Systeme simulieren und untersuchen. Möchte man aber

nichtlineare oder zeitinvariante Systeme modellieren und simulieren (vergleiche dazu Anfangswertprobleme aus

Kap. 1.11) so bietet MATLAB die Toolbox Simulink an (help simulink). Mit deren Hilfe lassen sich Modelle in

Form eines Signalflussplans (Blockschaltbilds) grafisch eingeben. Simulink stellt Bibliotheken mit

Funktionsblöcken zu verschiedenen technischen Problemen zur Verfügung. Diese Bibliotheken werden Blocksets

genannt.

Weiterhin wird Simulink zur modellgetriebenen Softwareentwicklung für elektronische Steuergeräte eingesetzt.

Auch in diesem Fall wird Simulink als grafischer Editor für Signalflusspläne eingesetzt. Diese Signalflusspläne sind

Modelle für Steuer- und Regelungsfunktionen. Neben Signalflussplänen werden für die Modellierung von

Embedded Software Zustandsautomaten eingesetzt, die in Stateflow – einer Simulink-Erweiterung – implementiert

werden. Mit Hilfe von Autocodegeneratoren wird aus diesen Modellen Embedded C-Code für elektronische

Steuergeräte generiert.

Bei Simulink handelt es sich nicht um ein Bondgraph-Simulationssystem. Simulinkblöcke arbeiten

rückwirkungsfrei, d.h. ein Eingang eines Blocks beeinflusst nicht den Ausgang eines Blocks mit dem er verbunden

ist. Die Kopplung von Komponenten erfolgt nicht über Energien sondern auf Signalebene, d.h. wenn die

Teilsysteme von einander abhängig sind, so müssen die Differentialgleichungen der Einzelkomponenten eines

Systems zu einer Differentialgleichung bzw. Differentialgleichungssystem zusammengefasst und anschließend

modelliert werden. Dies ist bei Bondgraph-Simulatoren nicht der Fall. Bei Bondgraph-Simulationssystemen können

Teilsysteme bestehend aus Basisbauelemente wie z.B. Widerständen, Spulen, Kondensatoren usw. separat

modelliert und später verkoppelt werden. Meist enthalten die Bibliotheken dieser Simulatoren auch relativ komplexe

Modelle wie z.B. Verbrennungsmotoren. Mit den Simulink-Blocksets zur physikalischen Modellierung wie z.B.

SimPowerBlockset, SimMechanics, SimElectronics, SimHydraulics usw. (mit Simscape als Basisbibliothek) ist eine

solche Modellierung ebenso möglich.

Bei der Modellierung ist stets darauf zu achten, dass alle Ein- bzw. Ausgänge mit Signalquellen (Signalquelle oder

Ausgang eines anderen Blocks) versorgt bzw. Signalsenken verbunden oder über einen Terminator abgeschlossen

werden. Unbelegte Ein- und Ausgänge können falsche Simulationsergebnissen verursachen und scheinbar

unabhängige Teilsysteme negativ beeinflussen. Klassisches Beispiel hierfür ist ein nicht angeschlossenes

Bauteil/Funktionsblock.

Die Simulinkblöcke werden über Signalleitungen verbunden. Den Signalleitungen können Namen, Datentypen und

Abtastrate (bzw. kontinuierliches Signal) zugeordnet werden. Eine Signalleitung kann die Dimensionen Skalar,

Vektor, Matrix und Bus annehmen.



2.1 Erstellen eines neuen Simulinkmodells

Eine neues Simulinkmodells kann bei der alten GUI über das MATLAB Menü NewSimulink Model bzw. bei der

neuen GUI unter Reiter HOME über „New+“ Button Simulink Model oder über den Simulink Library Browser

erstellt werden (im Library Browser: Toolbarbutton (alte GUI) bzw. (neue GUI) oder FileNewModel):

Im Anschluss werden die Funktionsblöcke/Bauteile im Zeichnungsbereich platziert und verbunden. Die

Funktionsblöcke werden über den Library Browser verwaltet. Gestartet / angehalten werden kann die Simulation

über die Play / Stopp Tasten in der Toolbar oder über das Menu SimulationRun / SimulationStop. Die

Simulationsdauer kann in dem Editfeld neben den Start- und Stopptasten eingegeben werden.

Im Folgenden ist ein bereits erstelltes Simulationsmodell dargestellt:



2.2 Library Browser

Der Simulink Library Browser stellt die einzelnen Bibliotheken zur Verfügung (dargestellt als tree view). Jede

Bibliothek enthält wiederum Funktionsblöcke, die die Grundbausteine einer Simulation darstellen und per drag and

drop auf das Simulationsfenster gezogen werden. Gestartet wird der Simulink Library Browser über die Konsole

mit:

>> simulink

oder über den Toolbarbutton (alte GUI) bzw. (neue GUI, Reiter HOME) unter MATLAB.

Die Bibliotheken „Simulink“ und „Simulink Extras“ enthalten die wichtigsten Grundbausteine für Simulationen.

Die Funktionsblöcke einer Bibliothek sind nach Blockeigenschaften in Unterbibliotheken einsortiert (tree view).



Bibliothek: Simulink

Die gebräuchlichsten Unterbibliotheken der Bibliothek Simulink wurden im vorherigen Bild gekennzeichnet.

Teilbibliothek der

Bibliothek Simulink

Funktion

Continuous Kontinuierliche Bauelemente:

Integratoren, Differenzierer, Übertragungsfunktion (als zpk, tf),

Zustandsraummodelle, Totzeit usw.

Discontinuities Statische und dynamische Nichtlinearitäten



Teilbibliothek der

Bibliothek Simulink

Funktion

Discrete Diskrete Bauelemente:

Integratoren, Differenzierer, Übertragungsfunktion (als zpk, tf),

Zustandsraummodelle, Totzeit, Delayelemente usw.

Math Operations Mathematische Operation wie Summe, Differenz, Produkt, Division,

Verstärker, Betrag, Sinus usw.

Sinks Signalsenken z.B. Grafikausgabe, MATLABvariable usw.



Teilbibliothek der

Bibliothek Simulink

Funktion

Sources Signalquellen wie Sprünge, Rampen, Sinus, MATLABvariablen usw.

Lookup Tables Selbstdefinierbare Nichtlinearitäten

Signal and Routing Schalter, Busse usw.

Ports & Subsystems Untersysteme mit Ein- und Ausgängen usw. (siehe Kap. 2.7.4)

Commonly Used

Blocks

Häufig verwendete Blöcke



2.3 Modelleditor

Nachdem wie in Kap. 0 beschrieben ein neues Simulationsmodell geöffnet wurde, kann damit begonnen werden die

Bauteile zu platzieren und zu verbinden. Im Anschluss daran werden die Blöcke parametriert. Im Folgenden sind

einige grundlegende Operationen im Umgang mit Blöcken und Signalleitungen dargestellt. Die Operationen an

Blöcken gelten meist auch für Signalleitungen.

Positionieren und Verschieben von Blöcken

Platziert werden die Bauteile per drag & drop oder der rechten Maustaste vom Library Browser auf den

Zeichnungsbereich der Simulation. Positioniert man den Mauszeiger über einem Block und drückt die linke

Maustaste (Block ist nun selektiert) und hält sie weiter gedrückt, so kann der Block mittels Maus verschoben werden

(ziehen mit der Maus). Ist ein Block selektiert, so lässt er sich auch über die Cursortasten verschieben.

Selektieren eines Blocks / von Blöcken

Mit einem einfachen Click auf einen Block wird ein Block selektiert. Positioniert man den Mauszeiger über einer

freien Fläche und drückt die linke Maustaste und hält sie weiter gedrückt, so kann über die Maus ein rechteckiger

Bereich definiert werden in dem alle darin enthaltenen Bauteile selektiert werden sobald die Maustaste wieder

losgelassen wird. Alle Bauteile können über Str + A selektiert werden. Des Weiteren können wie im

Windowsexplorer Blöcke via Shift + linke Maustaste selektiert / deselektiert werden.

Verbinden von Blöcken, Löschen von Verbindungen / Signalleitungen

Das Verbinden der Blöcke über Signalleitungen beginnt mit dem Plazieren des Mauszeigers auf einen Ein- oder

Ausgang. Befindet sich der Mauszeiger über einem Ein- oder Ausgang, so verwandelt sich der Mauszeiger in ein

Kreuz. Durch drücken und halten der linken Maustaste kann nun eine Verbindung zu einem Aus- oder Eingang

gezeichnet werden. Es kann immer nur ein Eingang mit einem Ausgang verbunden werden, d.h. eine direkte

Verbindung Eingang mit Eingang oder grundsätzlich eine Verbindung Ausgang mit Ausgang ist nicht möglich.

Selektiert man einen Block 1 dessen Ausgang man mit einem Eingang von z.B. Block 2 verbinden möchte, so muss

der Block 2 mittels Str + linke Maustaste angewählt werden. Die Signalleitung wird nun automatisch erstellt.

Verbindungen / Signalleitungen können selektiert und mittels Entf gelöscht werden. Dies ist auch über einen rechten

Mausclick auf die Signalleitung möglich.

Weitere Operationen

Aktion Funktion

Str + R Str + Shift +R

Die selektierten Bauteile werden im Uhrzeigersinn gedreht.

Die selektierten Bauteile werden gegen den Uhrzeigersinn gedreht.

Ctr + I Die selektierten Bauteile werden an der vertikalen Achse gespiegelt (Flip).

Ctr + A Alle Bauteile werden selektiert.

Str + C Die selektierten Bauteile werden in die Zwischenablage kopiert.

Str + X Die selektierten Bauteile werden ausgeschnitten und in die Zwischenablage

kopiert.

Str + V Die Bauteile aus der Zwischenablage werden in den Zeichnungsbereich

kopiert und sind selektiert, so dass sie auch gleich verschoben werden können.

Rechte Maustaste auf

einen Block und „ziehen“ Dies kopiert einen Block analog zu Str + C und Str + V.

Das Erstellen einer Simulation soll anhand des folgenden Beispiels gezeigt werden.

)s(G1

)s(G)s(G

0

0

mit

2s3s

2

1s

3)2s()1s(

2

1s

3)s(G20



Mittels Simulation soll von G(s) die Sprungantwort ermittelt werden. Dazu werden folgende Bauteile aus der

Bibliothek Simulink benötigt:

Sprung als Signalquelle (Block Step aus der Teilbibliothek Sources)

Grafikausgabe zur Visualisierung der Sprungantwort (Block Scope aus der Teilbibliothek Sinks)

Differenz (Block Sum aus der Teilbibliothek Math Operations)

Produkt mit einer Konstanten / Verstärker (Block Gain aus der Teilbibliothek Math Operations)

Laplaceübertragungsfunktion als tf Modell (Block Transfer Fcn aus der Teilbibliothek Continuous)

Platzierung der Bauteile mittels drag & drop vom Library Browser auf den Zeichnungsbereich der Simulation

Verbinden der Blöcke über Signalleitungen

Die Einstellung der Parameter der einzelnen Blöcke erfolgt über einen doppelclick auf den Block oder über einen

rechtsclick auf den Block XXX Parameters (XXX steht für den Namen des Blocks).



Zum Zeitpunkt Step Time springt die Quelle

vom Wert Initial Value auf den Wert Final

Value

Die Anzahl der Vorzeichen in List of signs

bestimmt die Anzahl der Eingänge. Eingang 2

wird von ‚+’ auf ‚-’ umgestellt.



Multiplikation mit der Konstanten Gain (

hier mit 3).

Eingabe der Zähler- und

Nennerkoeffizienten der

Laplaceübertragungs-funktion, siehe Kap.

1.12.2.1.1.

Die Grafikausgabe (Scope) wird ebenfalls über einen doppelclick geöffnet.



Das Modell sieht nun wie folgt aus

Die Namen der Blöcke lassen sich über einen doppelclick auf den Blocknamen ändern / editieren. Nach der

Simulation über die Play Taste kann über einen doppelclick auf das Scope die Grafikausgabe geöffnet werden

Das Modell kann nun über Menu->File->Save oder Save As oder über das Diskettensymbol gespeichert werden.

In der neuen GUI tragen die Simulinkmodelle die Extension slx in der alten GUI die Extension mdl.



2.4 Modellierungsrichtlinien

Die Richtlinien geben einheitlich vor, wie Simulink zur Modellerstellung eingesetzt werden soll. Durch Einhalten

dieser Richtlinien sind Simulink-Modelle für Teamkollegen leichter zu verstehen. Dies vereinfacht einen Austausch

von Simulink-Modellen und die Zusammenarbeit in Teams.

Signallinien immer von links nach rechts, von oben nach unten, außer Rückkopplungen

Blöcke immer nach rechts ausgerichtet

Inports

o grün

o alle links im Signalflussplan

Outports

o rot

o alle rechts im Signalflussplan

Signalnamen

o gültige C-Bezeichner

o Eingabe der physikalischen Einheiten über Properties

Parameternamen

o gültige C-Bezeichner

o mit vorangestelltem P_ zur Unterscheidung von Signalen

Parameter in MATLAB-Skript definieren mit Kommentar für Bedeutung und physikalische Einheit

Dieses MATLAB-Skript in Modell-Callback „Init“ aufrufen. Dadurch werden alle Parameter beim Modell-

Start oder Modell-Update neu gesetzt.

Keine Goto- / From-Blöcke

Jedes Teilsystems des Gesamtsystem jeweils in einem virtuellen oder atomaren Subsystem kapseln oder

alternativ Modellreferenzen verwenden

Auf der obersten Modellebene nur diese Teilsysteme verschalten oder Tests implementieren

Auf oberster Modellebene nie Funktionen / dynamische Modelle implementieren. Dies erleichtert die

Wiederverwendung von Subsystemen oder referenzierten Modellen.

Die folgenden zusätzlichen Richtlinien sind zwingend einzuhalten, damit die numerischen Lösungsverfahren von

Simulink gute Ergebnisse erzielen.

Keine algebraischen Schleifen

Grundsätzlich keine d/dt-Blöcke

Ausnahme: d/dt-Blöcke nur für die Signalverarbeitung von Eingangssignalen verwenden, falls notwendig

Möglichst elementare Blöcke verwenden

o z.B. 1/s, Gain, Sum anstelle von Transfer-Function

2.5 Grundlagen der Grafikausgabe

In Simulink gibt es eine Vielzahl von Methoden, um Signale aufzuzeichnen bzw. während der Simulation grafisch

darzustellen. Das neueste und bevorzugte Werkzeug ist der „Simulation Data Inspector“. Der Einsatz des

„Simulation Data Inspector“ ermöglicht eine Signalaufzeichnung ohne Manipulation des Signalflussplanes im

Gegensatz zu den anderen Methoden.

2.5.1 Signalaufzeichnung mit Simulation Data Inspector

Signale, die mit dem Simulation Data Inspector grafisch dargestellt werden sollen, müssen vor der Simulation zur

Aufzeichnung konfiguriert werden. Dazu klickt man mit der rechten Maustaste auf die entsprechende Signallinie in

Simulink und öffnet den „Signal Properties Editor“:



In diesem Editor sind zwei Einstellungen vorzunehmen:

Definition eines Signalnamens im Eingabefeld „Signal name“

Aktivierung der Signalaufzeichnung durch Setzen des Hakens bei „Log signal data“.

Im Signalflussplan erscheint nach Bestätigung der Einstellungen mit „OK“ das Symbol auf der Signallinie:

Diese Einstellung kann für beliebig viele Signale im Signalflussplan erfolgen.

Weiterhin muss die Signalaufzeichnung durch Anklicken des Record-Buttons in der Simulink-Toolbar vor dem

Simulationsstart aktiviert werden.

Beim Simulationslauf werden dann die konfigurierten Signale aufgezeichnet.

Die grafische Darstellung erfolgt durch Öffnen des Simulation Data Inspectors

durch Anklicken des Hyperlinks oben im Signalflussplan

durch Öffnen des Pulldown-Menüs des Record-Buttons und Selektieren des Menüeintrags „Simulation

Data Inspector …“

oder durch das Simulink-Menü „SimulationOutputSimulation Data Inspector …”.



Der Simulation Data Inspector speichert jeden Simulationslauf. In einer Baumdarstellung können einzelne oder

mehrere Signale von verschiedenen Simulationsverläufen zur grafischen Darstellung ausgewählt warden.

Durch Wechsel auf die Ansicht „Compare Signals“ können darüber hinaus jeweils 2 Signale miteinander verglichen

werden. Das ist beispielsweise sehr nützlich zum Vergleich desselben Signals bei mehreren Simulationsläufen.

Damit können Auswirkungen von Modellveränderungen untersucht werden.

2.5.2 Grafikausgabe über ein Scope

Simulink bietet einige Blöcke zur Grafikausgabe an (Bibliothek Simulink, Teilbibliothek Sinks). Am häufigsten

wird der Block Scope verwendet. Leider verfügt das Scope unter Simulink bei weitem nicht über den Umfang an

Möglichkeiten wie z.B. der plot Befehl unter MATLAB. Für eine professionellere Dokumentation empfiehlt es sich

daher die Simulationsdaten in eine MATLAB-Variable (Sink, To Workspace) oder MATLAB-Datendatei (Sink, To

File) zu speichern und automatisch via Callbacks über ein m-File oder manuell auszuwerten. Im Folgenden sind die

wichtigsten Scope Operationen dargestellt.

Häufig benötigte Buttons in der Scope Toolbar

Toolbarbutton Funktion

Ansichtswerkzeuge

(alten GUI)

(neue GUI)

Lupe Zoomen in definierbarem rechteckigen Bereich

Lupe mit X Zoom X-Achse (Zeitachse)

Lupe mit Y Zoom Y-Achse (Signalamplitude)

Fernglas Autoscale

Scopeeinstellungen

(alte GUI)

(neue GUI)

Einstellung der Scope Parameter

Über die Scopeeinstellungen kann die Anzahl der dargestellten Zeitachsen eingestellt werden (Tab General, Number

of axes).

Pro Achse erhält das Scope einen Eingang. Möchte man mehrere Signale in einer Zeitachse darstellen, so müssen

mehrere Signale über einen Mux (Bibliothek Simulink, Teilbibliothek Signal and Routing) Block zu einem Vektor

(Bus) zusammengefasst werden. Mit einen doppelclick auf die Signalleitungen können diese beschriftet werden.

Diese Beschriftungen werden als Y-Achsen Beschriftungen im Scope verwendet.



Im Folgenden Beispiel sind beide Scope Varianten dargestellt:

Scope

Scope1

Werden mehrere Signale in einer Zeitachse mittels eines Busses (Vektorsignal) dargestellt, so sind die dargestellten

Farben folgenden Elementnummern des Vektorsignals zugeordnet:

Vektorelement

Nr.

Farbe

1 Yellow

2 Magenta

3 Cyan

4 Red

5 Green

6 Dark Blue

Ab ca. Matlab R12b ist es auch möglich Legenden in ein Scope einzublenden.

Eine Legende kann wie folgt eingeblendet werde:

Plot Toolbar Button Einstellungen , unter „General“ Tab Haken „Legends“ setzen.



Danach erneut simulieren und plot öffnen. Zur Beschriftung eines Signals in der Legende wird der Signalname des

Busses mit der Leitungsnummer verwendet.

In der Scopeeinstellung Tab Data History, Checkbox Limit data points to last: ist per default aktiviert, d.h. umfasst

eine Simulation mehr als die hier angegebenen 5000 Simulationszeitpunkte, so stehen nur die letzten 5000

Simulationszeitpunkte für die grafische Ausgabe zur Verfügung. Es empfiehlt sich daher diesen per default

gesetzten Haken zu entfernen.



2.5.3 Grafikausgabe über ScopeViewer

Eine weitere Möglichkeit zur Grafikausgabe bieten die Viewer. In diesem Fall ein Scope Viewer. Ausgegeben

werden sollen zwei Signale in einer Zeitachse. Dazu wird über einen Mux ein Vektorsignal erzeugt und über einen

Terminator abgeschlossen, da das Vektorsignal nicht weiterverarbeitet werden soll.

Über einen Rechtsclick auf die Signalleitung und im Kontextmenü: Create & Connect Viewer Simulink Scope

erhält man einen Scope Viewer auf dieser Signalleitung, was durch eine Brille (alte GUI) bzw. Scope Block (neue

GUI) angezeigt wird.

Alte GUI

Neue GUI

Parallel dazu öffnet sich ein Scope Viewer Fenster.



Über den Signalselection Toolbarbutton oder einem rechten Mausclick in das Grafikausgabefenster im

Kontextmenü „Signal Selection“ können Signale vom Scope entfernen bzw. neue hinzufügt werden.

Mit einem rechten Mausclick in das Grafikausgabefenster im Kontextmenü „Legends“ selektieren.



2.6 Zeitlich kontinuierliche Systeme in Zustandsraumdarstellung

Zur Modellierung zeitlich kontinuierlicher Systeme oder Teilsysteme in Simulink werden zwei Ansätze favorisiert.

Entweder muss das Modell vorliegen in Zustandsraumdarstellung oder als Integratorkette. In diesem Abschnitt wird

die Modellerstellung auf Basis der Zustandsraumdarstellung behandelt.

2.6.1 Zustandsraumdarstellung

Die Zustandsraumdarstellung eines nichtlinearen Systems hat allgemein die folgende explizite Form:

( )

( )

( ) ( )

Zustandssignal-Vektor ( ) ( )

Eingangssignal-Vektor ( ) ( )

Ausgangssignal-Vektor ( ) ( )

Vektorielle Systemfunktion ( ) ( )

Vektorielle Ausgangsfunktion ( ) ( )

Vektorieller Anfangswert der Zustände ( )

Die Zustandsraumdarstellung in expliziter Form ist nicht für jedes System vorhanden. Insbesondere bei Systemen,

bei welchen nichtlineare algebraische Beziehungen zwischen einzelnen Zustandssignalen bestehen, kann nicht in

jedem Fall die explizite Zustandsraumdarstellung hergeleitet werden. Dies ist insbesondere der Fall bei Differential-

Algebra-Gleichungssystemen mit relativem Grad größer gleich 1, bei welchen der relative Grad nicht reduziert

werden kann. Beispiele für Systeme, die mit Differential-Algebra-Gleichungssystemen beschrieben werden, sind:

Mechanische Systeme mit holonomen oder nicht holonomen Zwangsbedingungen

Thermodynamische Systeme mit nichtlinearen Phasengleichgewichtsbeziehungen

Diese Systeme werden in impliziten Zustandsraumdarstellungen formuliert. Simulink ohne Erweiterungen kann

jedoch diese impliziten Zustandsraumdarstellungen numerisch nicht lösen. Dazu bietet Mathworks weitere

Simulink-Toolboxen an. Beispielsweise können mit SimMechanics mechanische Systeme mit Zwangsbedingungen

modelliert und simuliert werden.

Abbildung 2.1: Signalübertragungsglied für Zustandsraumdarstellung.

𝑢 (𝑡)

𝑢 (𝑡)

𝑢𝑚(𝑡)

…

𝑦 (𝑡)

𝑦 (𝑡)

𝑦𝑝(𝑡)

…

Signalübertragungsglied

Zustandssignalvektor 𝒙(𝑡)

Parametervektor 𝒑

Anfangsbedingungen 𝒙𝟎



Die oben definierte nichtlineare, explizite Zustandsraumdarstellung kann als Signalflussplan dargestellt werden.

Dieser Signalflussplan ist Grundlage für die Modellimplementierung in Simulink.

In diesem Signalflussplan wird die rechte Seite ( ) der Differentialgleichung als nichtlineares

Übertragungsglied beschrieben. Die Eingangssignale sind das vektorielle Eingangssignal ( ) und das vektorielle

Zustandssignal ( ). Das Ausgangssignal ist die Zeitabbleitung ( ) des Zustandssignals.

Die vektorielle Differentialgleichung wird durch das I-Glied

definiert. Dieses Übertragungsglied hat als

Eingangssignal die Zeitableitung ( ). Das I-Glied integriert das Eingangssignal unter Berücksichtigung der

Anfangsbedingung . Daraus ergibt sich das vektorielle Zustandssignal ( ) als Ausgangssignal des I-Glieds.

Nachgeschaltet ist ein nichtlineares Übertragungsglied für die nichtlineare Ausgangsfunktion ( ). Dieses

Übertragungsglied hat die Eingangssignale ( ) und ( ). Es liefert das vektorielle Ausgangssignal ( ).

In Simulink werden beide nichtlinearen Übertragungsglieder

entweder als virtuelle Subsysteme, die Signalflusspläne erhalten,

oder durch MATLAB-Functions modelliert.

Die Verwendung von MATLAB-Functions hat meist den Vorteil einer kompakten, gleichungsbasierten

Formulierung der Funktionen ( ) und ( ). Der Nachteil liegt darin, dass Hilfssignale in den MATLAB-

Functions nicht direkt gemessen werden können. Für eine Messung ist eine Definition von zusätzlichen Outports

nötig.

Die Verwendung von virtuellen Subsystemen mit Signalflussplänen kennt diesen Nachteil nicht. Ein Nachteil kann

sein, dass die Darstellung der Funktionen ( ) und ( ) als Signalflusspläne sehr aufwändig und

unübersichtlich wird.

Der Integrator

in Simulink definiert die vektorielle Differentialgleichung. Für das Verständnis der internen

Funktion von Simulink ist es wichtig zu verstehen, dass Simulink nicht etwa das I-Übertragungsglied

im

Bildbereich der Laplace-Transformation betrachtet. Viel mehr wird in Simulink der Integrator

zur Definition von

expliziten Differentialgleichungssystemen verwendet, wobei das Eingangssignal die rechte Seite der vektoriellen

Differentialgleichung darstellt.

Simulink löst diese Differentialgleichungssysteme mit Hilfer numerischer Diffentialgleichungslöser. Das Ergebnis

dieser numerischen Lösung ist das vektorielle Zustandssignal ( ).

𝒖

𝒙 𝒇(𝒙 𝒖 𝑡)

1

𝑠 𝒉(𝒙 𝒖 𝑡) 𝒚

��

𝒙𝟎



2.6.2 Beispiel PT1-Glied

Lineare Systeme sind Spezialfälle nichtlinearer Systeme. Also kann ein lineares PT1-Glied mit Hilfe des obigen

Signalflussplans in Simulink modelliert werden.

Explizite Zustandsraumdarstellung für PT1-Glied:

( )

1

( )

( )

( )⏟

( )

( )

( ) ( )⏟

( )

Simulink-Modell: modelle\pt1\pt1_blockdiagram.slx

2.6.3 Beispiel Stabpendel

Das Stabpendel wird durch eine nichtlineare Zustandraumdarstellung 2. Ordnung beschrieben:

( )

⏟

(

)⏟

( )

( ( ) ( )

)⏟ ( )

( )

⏟

⏟

( )

Simulink-Modell mit Signalflussplan für rechte Seite: modelle\stabpendel\pend_blockdiagram.slx

Alternatives Simulink-Modell mit MATLAB-Funktion für rechte Seite: modelle\stabpendel\pend_matlabfun.slx



2.7 Zeitlich kontinuierliche Systeme als Integratorketten

2.7.1 Lineare Systeme

Für LTI-Systeme existieren bereits fertige Blöcke. In der folgenden Tabelle werden den MATLAB LTI-Modellen

die entsprechenden Simulink LTI-Modelle aus der Simulink Bibliothek gegenüber gestellt.

MATLAB

LTI-Modell

kontinuierlich diskret Simulink Block aus der Unterbibliothek

continuous discrete

ss X X State Space Discrete State Space

tf X X Transfer Fcn Discrete Transfer Fcn

zpk X X Zero-Pole Discrete Zero-Pole

Lineare Differentialgleichungen z.B. mit konstanten Koeffizienten ( LTI-Systeme) der Form

N

0i

)i(

i )t(ya)t(u mit

können mittels einer Integratorenkette der Zustandsgrößen modelliert und simuliert werden. Im Folgenden ist eine

Zustandsgrößen Integratorenkette dargestellt:

Im nächsten Schritte muss die lineare Differentialgleichung wie folgt umgeformt werden:

N

1N

0i

)i(

i)N(

1N

0i

)i(

i

)N(

N

N

0i

)i(

i

a

)t(ya)t(u

)t(y

)t(ya)t(ya)t(ya)t(u

Daraus ergibt sich die „Beschaltung“ der Zustandsgrößen Integratorenkette:

y(t)(i)

der i’ten Ableitung der Zustandsgröße y(t)

u(t) Eingangsgröße des Systems

y(t) y(t)

(1)

y(t)

(N) y(t)

(N-1) y(t)

(N-2) y(t)

(2)

y(t) y(t)

(1)

y(t)

(N) y(t)

(N-1) y(t)

(N-2) y(t)

(2) u(t) +

-

1

aN

a1 a0 a2 aN-2 aN-1

+ + +

+ + + +

+

1N

0i

)i(

i )t(ya



Wobei das Symbol

ein Produkt mit einem konstanten Koeffizienten repräsentiert (idealer Verstärker mit der Verstärkung ai, Gain

Block).

Eine Implementierung mittels einer Differentiatorkette wäre ebenso möglich, jedoch aus numerischen Gründen nicht

sinnvoll, da z.B. ein differenzierter Rundungsfehler falsche Simulationsergebnisse produzieren würde.

Rundungsfehler produzieren z.B. Sprünge in einem Signal, differenzierte Sprünge haben Impulsantworten zur

Folge, die in der Realität nicht enthalten sind.

Liegt eine Differentialgleichung mit nicht voneinander abhängigen Zustandsgrößen vor wie z.B.

)i(

i

N

0i

)i(

i )t(xb)t(ya)t(u

,

so sind mehrere (im obigen Fall zwei) unabhängige Integratorenketten zu implementieren.

Enthält die Differentialgleichung Ableitungen der Eingangssignale,

N

0i

)i(

i

M

0k

)k(

k )t(ya)t(uc

so muss eine Differentiatorkette für den Eingangsteil der Differentialgleichung implementiert werden. Dies ist

numerisch ebenso wenig wünschenswert aber unumgänglich. Die numerischen Auswirkungen der

Eingangsdifferentiatorkette bei Fehlern sind aber nicht so stark wie bei einer Zustandsgrößen Differentiatorkette, da

keine Rückkopplung auf den Eingang der Kette erfolgt.

Bei den bisher gezeigten Beispielen linearer Differentialgleichungen waren die Koeffizienten konstant, es handelte

sich um LTI-Systeme. Wie bereits zuvor beschrieben können für die Simulation von LTI-Systemen die in der

Bibliothek vorhandenen Blöcke verwendet werden. Sind die Koeffizienten dagegen zeitlichen Änderungen

unterworfen, so können diese Blöcke nicht eingesetzt werden. Sind die Koeffizienten zeitabhängig wie z.B. in der

folgenden Differentialgleichung dargestellt

1N

0i

)i(

i

)N( )t(y)t(a)t(u)t(y mit 1)t(a N ,

ai

y(t) y(t)

(1)

y(t)

(N) y(t)

(N-1)

u(t)

+

-

1

aN

a1 a0 aN-1

+ +

+ +

c0

c1

cM

u(t)(1)

u(t)(M)

+ +

+ +



so müssen die Produkte mit konstanten Koeffizienten

Durch Produkte mit Signalen ersetzt werden:

2.7.1.1 Beispiel: Analoger aktiver Tiefpass erster Ordnung

Aufstellen der Differentialgleichung (Grenzfrequenz G)

Stromknoten

Geaa

G

G

e

a

eaa

i

e

i

aa

12

uuu

s

CR

1s

CR

1

)s(G)s(U

)s(U

uuuCR

uR

1u

R

1uC

ii

G

12

+

-

ue ua

uR

i1

C

idealer

OP

R

≈ua

≈ 0V

R i2

ai

ai

y(t)(i)



Berechnung unter MATLAB

>> R=10e3; C=1e-6; wg=1/R/C wg = 100.0000 >> s=tf('s'); G=-wg/(s+wg) Transfer function: -100 ---------- s + 100 >> bodemag(G)

Eingabe des Modells in Simulink

100

101

102

103

104

-40

-35

-30

-25

-20

-15

-10

-5

0

Magnitu

de (

dB

)

Bode Diagram

Frequency (rad/sec)



Simulationsergebnisse

2.7.1.2 Beispiel: Einfacher analoger Notchfilter (Bandsperre zweiter Ordnung)

Ein idealer Notchfilter mit der Grenzkreisfrequenz (Notchkreisfrequenz) 0 sperrt ein sinusförmiges Signal mit der

Kreisfrequenz 0 und lässt alle anderen Frequenzen unverändert durch. In der Realität lässt sich eine solche ideale

Schaltung nicht realisieren. Sie kann aber z.B. durch die folgende Schaltung angenähert werden.

Der OP wurde als Impedanzwandler eingesetzt damit der Eingangswiderstand der Signalsenke (die Senke ist hier

nicht eingezeichnet) keinen Einfluss auf die Schaltung hat. Die Signalquelle mit der die Schaltung gespeist wird

sollte über einen niederohmigen Innenwiderstand verfügen damit die Güte der Schaltung nicht all zu sehr

verschlechtert wird.

Aufstellen der Differentialgleichung

Maschengleichung

dt

diLuuuu cLca

+

-

ue ≈ua

ua

uR i

uC

uL

R

C

L

iOP≈0 idealer

OP



Strom i durch R, L und C (iOP = 0 angenommen)

CaeR uCuu

R

1

R

ui

Aus dem Strom abgeleitete Gleichungen zum Einsetzen in die Maschengleichung

ae

aeC

uuR

1

dt

di

uuCR

1u

Einsetzen der zeitlichen Ableitung des Stroms in die Maschengleichung ergibt

aeca uuR

Luu

Maschengleichung zeitlich ableiten

aeca uuR

Luu

mit

aeC uuCR

1u

ergibt sich

ee

2

0a

2

0aa

eeaaa

eeaaa

aeaea

uuuuL

Ru

uuCL

1u

CL

1u

L

Ru

uR

Lu

CR

1u

CR

1uu

R

L

uuR

Luu

CR

1u

20

20

Schaltungsparameter

R = 200

L = 1 mH

C = 10 µF

CL

10

0 = 10

4 rad / s f0 ≈ 1,592 kHz

s

1 102

L

R 5



Frequenzgang der Schaltung

Eingabe des Modells in Simulink

101

102

103

104

105

106

107

-200

-180

-160

-140

-120

-100

-80

-60

-40

-20

0M

agnitu

de (

dB

)

Bode Diagram

Frequency (rad/sec)



Bei diesem Beispiel kann die Differentialgleichung nicht mit den Standardsimulatoreinstellungen simuliert werden.

Die Schrittweite muss von variable step auf fixed step umgeschaltet werden. Änderungen an den

Simulationseinstellungen erfolgen über MenuSimulationConfiguration Parameters ... (alte GUI) bzw.

MenuSimulationModel Configuration Parameters oder den Button in der Toolbar (neue GUI).

in Solver Options

Type: Fixed-step

Fixed-step size: 1e-5

Simulationsergebnisse mit ue = sin(100*t) und einer Simulationsdauer von 0,5 s.

Simulationsergebnisse mit ue = sin(104*t) und einer Simulationsdauer von 0,003 s.



2.7.2 Nichtlineare Systeme

Die Simulation nichtlinearer kontinuierlicher Systeme erfolgt analog zur Simulation linearer Systeme über

Integratorenketten, Differentiatorenketten bei kontinuierlichen Systemen und Delayketten bei diskreten Systemen.

Wegen der Verschiedenartigkeit nichtlinearer Gleichungen lässt sich eine Implementierung nicht wie im linearen

Fall (gewichtete Summen) generalisieren. Es ist jedoch von Vorteil, wenn z.B. ein kontinuierliches SISO-System

auf folgende Form gebracht werden kann:

t),t(u,)t(u,,)t(u,)t(u),t(x,)t(x,,)t(x,)t(xf)t(x )1()1M()M()1()2N()1N()N(

x(t): Zustandsgröße bzw. Ausgangsgröße

u(t): Eingangsgröße

f(…): Skalare Funktion

2.7.2.1 Beispiel Einfaches Fahrzeugmodell

Im folgenden Beispiel soll ein sehr einfaches Fahrzeugmodell erstellt werden. Das Fahrzeug bewegt sich auf einer

ebenen Fahrbahn eindimensional auf der Koordinate x. An dem Fahrzeug wirken folgende Kräfte:

- Luftwiderstand FL mit 22w

L xkx2

AcF

- Antriebskraft FA mit FA,max=5250 N

- Bremskraft FB mit FB,max = m·g

Folgendes wird z.B. vernachlässigt:

- Das Fahrzeug verfügt über kein Getriebe

- Die Reifen werden nicht modelliert

- Der Motor wird nicht modelliert

- Die Bremsen werden nicht modelliert

- usw.

Dichte der Luft 1,2 kg / m3

Projektionsfläche des PKW A 2 m2

cw-Wert PKW cw 0,3

Masse Fahrzeug m 1500 kg

Faktor k 0,36 kg / m

Erdbeschleunigung g 9,81 kg m / s2

FL

FA

FB

x

x(t) x(t)

(1)

x(t)

(N) x(t)

(N-1)

u(t)

u(t)(1)

u(t)(M)



Aufstellen der Differentialgleichung

LF

2

k

w

F

BABLA

i

i x2

AcFFFFFFxm

t,F,xf

2xkFm

1x

Simulinkmodell

Maximale Geschwindigkeit v bei konstantem F

2xkFm

1x

s

m4,105

m

kg36,0

s

mkg4000

k

Fv vkF

m

1v

20v2

Simulationsergebnisse mit F = 4000 N

Weitere Beispiele finden sich in Kap. 2.7.3.



2.7.3 Simulation mit Anfangswerten

Häufig besteht die Notwendigkeit den Zustandsgrößen Anfangswerte zu zuordnen (siehe auch Kap. 1.11). Die

Anfangswerte werden über den Integrator bzw. das Delayelement festgelegt. Der Anfangswert legt den Startwert des

Integratorausgangs bzw. den Startwert des Delayelementeausgangs fest. Hierfür sieht Simulink zwei

Vorgehensweisen vor.

Definition des Anfangswerts (Initial condition) über einen Parameter im Blockparameterdialog

oder als zusätzlicher Port. Hierfür muss die Listbox Initial condition source von internal auf external umgestellt

werden. Der Integrator erhält nun den Anfangswerteingangsport X0 mit dessen Hilfe der Anfangswert (hier phi(0))

festgelegt werden kann.



2.7.3.1 Beispiel: Pendel I

Im Folgenden soll ein Pendel mit geschwindigkeitsproportionaler Reibung (Reibmoment MR) modelliert werden.

Der Stab der Länge l sei masselos und die Luftreibung werde vernachlässigt (siehe auch Kap. 1.11).

Trägheitsmoment des Pendels:

2

i

2

ii mrmJ

mi: Masseelement i

ri: Senkrechter Abstand von mi zur Rotationsachse

Reibmoment MR und Reibkraft FR, Reibmomentkoeffizient kµ:

µ

RRµR

kFFkM

Schwerkraft FG:

gmFG

Tangentialer Anteil der Schwerkraft FT bzw. MT:

singmsinFF GT bzw. singmFM TT

Momentenansatz:

sing

m

k

singmkm

singmkMMMJ

2

µ

µ

2

µ

F

T

k

R

i

i

mT

2

Ansatz mittels Bewegungsgleichung der Masse m auf der Bahn :

sing

m

k

singmk

m

singmk

FFFm

2

µ

µ

µ

TR

i

i

Vereinfachung: t,,fsing

k

mit 2

µ

m

kk

Linearisierung im Arbeitspunkt s :

0t,,,gsing

k

Arbeitspunkt:

n0sing

k0t,,,g n,ss

0

s

0

sAP

mit ,...,2,1,0,1,2,...,n , nur stabil für 2nn,s

MR

FT

FO

FG

m

l



ss 00n

0t,,,gt,,,gt,,,g

t,,,gt,,,g

0t,,,gsing

k

gcos

g

AP

k

APAP0

sss

0

s

mit erhält man die linearisierte Differentialgleichung

g

k

Aus der nichtlinearen Differentialgleichung sing

k

erhält man mit x

x

2

1

x das

nichtlineare Zustandsraumsystem

2

µ

212

21

m

kxxsin

gx

xx

t,

21

2

kxxsing

x

xf

x



Mit k = 0,3 und g / l = 9,81 / 0,5 (ohne Einheiten) und den Solvereinstellungen

Simulation mit Anfangswerten 1,0)0( ,0)0(

Simulation mit Anfangswerten 8,0)0( ,0)0(



yb

xb mb

-Fs

FR

FGb

2.7.3.2 Beispiel: Pendel II

Das vorherige Beispiel: Pendel I wird nun wie folgt um einen Schlitten erweitert, der über ein Feder- und

Dämpfersystem mit dem „Gebäude“ verbunden ist. Es werden zwei Koordinatensysteme (xa, ya) und (xb, yb) für die

beiden Massen ma (Schlitten) und mb (Pendelmasse) eingeführt. Die beiden Koordinatensysteme sind über l und φ

gekoppelt. Der Schlitten kann sich nur in xa-Richtung (Zwangsbedingung) bewegen. Diese Bewegung erfolgt ohne

Reibung. Die Pendelstange sei wieder masselos, die Bahnbewegung des Pendels wieder reibungsbehaftet. Da der

Bahnbewegung der Masse mb eine Translationsbewegung in Richtung xb überlagert ist werden die

Bewegungsgleichungen im kartesischen Koordinatensystem angesetzt.

Freischneiden der beiden Massen

Aufstellen der Bewegungsgleichungen für (xa, ya)

saasDFaa FsinxdxcsinFFFxm

Wegen der Zwangsbedingung ergibt sich für 0yy aa

0cosFFFym

0

sGaAaa

Aufstellen der Bewegungsgleichungen für (xb, yb)

cosFsinFFym

sinFcosFxm

sR

gm

Gbbb

sRbb

b

ma

l

xa

ya

yb

xb mb

MR

c

d

FF

ma

xa

ya

FD

FS

FGa

FA



Verbindung der beiden Koordinatensystemen über l und

sincosy

sinsinyy

cosyy

cossinxx

cosxx

sinxx

2

b

0

ab

ab

2

ab

ab

ab

Einsetzen in die Bewegungsgleichungen der Masse mb ergibt

cosFsinFgmsinmcosm

sinFcosFcosmsinmxm

sRbb

2

b

sRb

2

bab

Mit der x-Bewegungsgleichung der Masse ma saaaa Fsinxdxcxm erhält man

sin

xdxcxmF aaaa

s

durch Einsetzen in die x-Bewegungsgleichungen der Masse mb die erste Differentialgleichung

0cosFcosmsinmxcxdxmm Rb

2

baaaba

Durch Auflösen nach Fs und Gleichsetzen der Bewegungsgleichungen der Masse mb erhält man die zweite

Differentialgleichung

cos

sinFgmsinmcosmF

sin

cosFcosmsinmxm Rbb

2

bs

Rb

2

bab

0cosx

m

Fsin

g a

b

R

mit

µ

R

kF erhält man

0cosx

ksing

0cosx

m

ksin

g

a

a

k

2

b

µ

Ergebnis: zwei Differentialgleichungen

0cosmkcosmsinmxcxdxmm bb

2

baaaba

0cosx

ksing a

I Pendel ausleichunglgPende



Da beide Differentialgleichungen jeweils ax und enthalten müssen sie noch so umgeformt werden, dass

entweder nur ax oder nur in einer Differentialgleichung enthalten sind. Daher wird die Differentialgleichung

0cosx

ksing a

einmal nach ax und einmal nach aufgelöst und jeweils in die

Differentialgleichung


2

baaaba

eingesetzt.

Einsetzen von

cosxksin

g a in


2

baaaba

ergibt

2

b

a

b

aa2

a

sinm

m

m

xcxdcosgsin

x

Einsetzen von

cos

ksingxa

in


2

baaaba

ergibt

2

b

a

b

a

b

aaa

b

sinm

m

m

kmsinkcos

g1

m

msinxcxd

m

cos

Das System wird nun durch die beiden folgenden Differentialgleichungen beschrieben:

2

b

a

b

aa2

a

sinm

m

m

xcxdcosgsin

x

2

b

a

b

a

b

aaa

b

sinm

m

m

kmsinkcos

g1

m

msinxcxd

m

cos



Für die Simulation wurden folgende Parameter ohne Einheiten zugrunde gelegt. Es werden die gleichen

Solvereinstellungen wie in Beispiel: Pendel I verwendet.

k 0,3

mb 1

l 0,5

g / l 9,81 / 0,5

ma / mb 10

d 2

c 1000

Simulationsmodell



Simulation mit Anfangswerten 05,0)0( x,0)0(x ,8,0)0( ,0)0( aa

Simulation mit Anfangswerten 05,0)0( x,0)0(x ,0)0( ,0)0( aa

Simulation mit Anfangswerten 0)0( x,0)0(x ,8,0)0( ,0)0( aa



2.7.4 Untersysteme (Subsystems)

Das Beispiel: Pendel II aus Kap. 2.7.3.2 hat gezeigt, dass ein Modell schnell sehr unübersichtlich werden kann

daher besteht in Simulink die Möglichkeit Modelle in eigene Blöcke zu „verpacken“ in sogenannte Subsysteme.

Unterstützt wird dies durch die Bibliothek Simulink, Unterbibliothek Ports & Subsystems. Die Erstellung eines

Subsystems kann auf zwei Arten erfolgen, z.B. über den Block Subsystem (einfachste Blockvariante) und die Blöcke

in und out, die die Ein- und Ausgänge definieren.

Aus der Bibliothek Simulink,

Unterbibliothek Ports & Subsystems

Über einen doppelclick auf den Block Subsystem wird das Subsystem geöffnet und das Modell kann wie gewohnt in

dem Subsystem erstellt oder hineinkopiert werden. Signalleitungen die nach außen geführt werden sollen werden

mit einem out Block verbunden. Signale von außen können dem Subsystem über einen in Block zugeführt werden.

Die Namen des Subsystems, sowie die Namen der Ein- und Ausgänge können geändert werden. Es stehen noch

weitere komplexere Varianten von Subsystemen zur Verfügung (z.B. enabled Subsystems, masked Subsystems,

usw.), die nicht in dieser Einführung beschrieben werden.



Eine weitere Möglichkeit besteht darin die Modellteile, die in ein Subsystem verschoben werden sollen zu

selektieren und über

MenüEditCreate Subsystem das Subsystem (alte GUI) bzw.

MenüDiagramSubsystem & Model Reference Create Subsystem from Selection (neue

GUI) oder

rechtsclick auf einen selektierten Block und im Kontextmenü „Create Subsystem from Selection“

auswählen

zu erstellen.

Create Subsystem, Änderung der Blocknamen / Portnamen, abspeichern unter pendel2a



Subsystem Pendel II



2.7.5 Vereinfachung der Implementierung von Modellen über MATLABskripte

Das Beispiel: Pendel II aus Kap. 2.7.3.2 hat gezeigt, dass ein Modell schnell sehr unübersichtlich werden kann. Eine

Möglichkeit der Vereinfachung des Implementierungsaufwands eines Modells mit dem

Differentialgleichungssystem (hier Zustandsraumdarstellung)

t,,)t( uxfx

besteht darin f anstatt mit Blöcken mittels Skriptfile zu implementieren. Verwendet werden kann hierfür der Block

Embedded MATLAB Function (alte GUI) bzw. MATLAB Function (neue GUI) aus der Bibliothek Simulink,

Teilbibliothek User-Defined Functions.

(alte GUI)

(neue GUI)

Mittels doppelclick auf den Block öffnet sich der MATLABeditor mit dem dem Block zugeordneten Skriptfile mit

der Funktion fcn. Der Name der Funktion kann geändert werden.

Möchte man einen Eingang u2 und einen Ausgang y2 hinzufügen, so muss die Funktionsdeklaration wie folgt

geändert werden:

function [y,y1] = fcn(u,u1)



Mit y = u + u1 und y1=u*u1ergibt sich folgendes Skriptfile:

function [y,y1] = fcn(u,u1) y = u + u1; y1=u*u1;

Mit dem Modell

Diese Vorgehensweise wird anhand des folgenden Modells pendel2b gezeigt. Wobei es sich beim Subsystem Pendel

II a um das Beispiel aus Kap. 2.7.4 handelt und das Subsystem Pendel II b die zuvor erwähnte Implementierung von

f mittels Skriptfile repräsentiert.

Die Implementierung erfolt über zwei Integratorenketten, wobei f in zwei Funktionen f1 und f2 aufgeteilt wird.

Beide Funktionen werden mithilfe des Skriptfiles berechnet.

2b

a

b

aa2

aa1a

sinm

m

m

xcxdcosgsin

t,,,x,xfx

2b

a

b

a

b

aaa

baa2

sinm

m

m

kmsinkcos

g1

m

msinxcxd

m

cos

t,,,x,xf

Das dazugehörige Blockschaltbild ist im Folgenden dargestellt:



Implementierung in Simulink (Subsystem Pendel II b)

Öffnen des Subsystems Pendel II b durch doppelclick oder Selektion im Modelbrowser



Eingabe des Skriptfiles

Eine weitere Vereinfachungsmöglichkeit besteht im Einsatz eines Zustandsraumsystems:

22

b

a

4b

a2424

b

a213

b

2

22

b

a

b

132

242

4

3

xsinm

m

xm

kmxsinkxxcosx

g1

m

mxsinxcxd

m

xcos

xsinm

m

m

xcxdxcosgxxsin

x

x

t,

xfx

mit

4

3

2

1

a

a

x

x

x

x

x

x

x

Das dazugehörige Blockschaltbild ist im Folgenden dargestellt:



Implementierung in Simulink (Subsystem Pendel II c)

Subsystems Pendel II c

Quelltext Matlab Function



2.8 Zeitdiskrete Systeme

2.8.1 Lineare Systeme

Zur Implementierung diskreter Systeme werden für Ein- und Ausgangsgrößen Delayketten gebildet. Für die

Implementierung solcher Ketten existieren verschiedene Ansätze, die z.B. der Literatur digitaler Filter entnommen

werden können. Im Folgenden wird die einfachste Realisierung vorgestellt. Liegt ein diskretes LTI-System mit der

Differenzengleichung

M

1k

knk

N

0i

inin ybxay

vor, so kann dieses System als Direct Form I wie folgt implementiert werden:

2.8.1.1 Beispiel: Tiefpass erster Ordnung

Der „analoge“ Tiefpass

0

0

s)s(G

mit 0 = 100 rad / s wird zuerst via Impulsinvarianzverfahren diskretisiert.

Im Folgenden wird die Diskretisierung (siehe auch Kap. 1.12.4.2) mit MATLAB berechnet.

>> w0=100; >> 2*pi/w0 ans = 0.0628 >> Ta=5e-3; % Abtastzeit >> s=tf('s'); G=w0/(s+w0); >> Gz=c2d(G,Ta,'zoh') % Diskretisierung

z-1

z-1

z-1

z-1

z-1

z-1

z-1

z-1

x(n-1)

x(n-2)

x(n-N+1)

x(n-N)

y(n-1)

y(n-2)

y(n-M+1)

y(n-M)

y(n) x(n)

a1

a0

a2

aN-1

aN

-b1

-b2

-bM-1

-bM

+ +

+

+ +

+

+ +

+

+ +

+

+



Transfer function: 0.3935 ---------- z - 0.6065 Sampling time: 0.005

Aus Gz(z) erhält man die Differenzengleichung y(n) = y(n-1)*0,6065 + 0,3935*x(n-1).

Vergleich von G(s) und Gz(z)

Wie bereits erläutert sind einer Leitung nicht nur der aktuelle Simulationswert, sondern auch der Datentyp und die

Abtastzeit zugeordnet. Jedem Delay Element lässt sich eine Abtastzeit zuordnen. Steht die Abtastzeit der

Delayelemente wie im obigen Beispiel auf -1, so arbeitet das Delayelement mit der Abtastzeit des Eingangssignals.

Die Abtastzeit wird über den Block Step definiert. Es empfiehlt sich aber den Delayelementen auch die vorgesehene

Diskreter Sprung Kontinuierlicher Sprung



Abtastzeit zuzuordnen. In Simulink können Teilsysteme mit unterschiedlichen Abtastzeiten arbeiten. Müssen

Signale dieser Teilsysteme mit unterschiedlichen Abtastzeiten verknüpft werden (Berechnungen usw.), so müssen

alle Teilsignale auf die kleinste in der Verarbeitung vorkommende Abtastzeit gewandelt werden (z.B. über den

Block Rate Transition), wenn keine Informationen verloren gehen sollen.


Simuliert man ein rein diskretes System mit einem kontinuierlichen Solver (variable step)

So erhält man folgende Warning im MATLAB Konsolenfenster:

Warning: The model 'digtp' does not have continuous states, hence Simulink is using the solver 'VariableStepDiscrete' instead of solver 'ode45'. ......



Dies bedeutet, dass der Solver auf diskret umgestellt werden sollte (es sind keine kontinuierlichen Teilsysteme

vorhanden) um die Simulationsgeschwindigkeit zu erhöhen. Durch diese Umstellung erfolgt keine numerische

Integration mehr, sondern alle Berechnungen lassen sich auf Differenzengleichungen reduzieren.

Änderung an den Simulationseinstellungen erfolgen wieder über

Alte GUI: MenuSimulationConfiguration Parameters ...

Neue GUI: Menu SimulationModel Configuration Parameters

Durch diese Einstellung muss an der Step Quelle auch nicht mehr die Abtastzeit angegeben werden. Die oben

eingestellte Abtastzeit ist die kleinste in der Simulation verwendbare Abtastzeit.

Das obige Beispiel könnte auch über einen diskreten LTI-Block realisiert werden. Möchte man aber z.B. die

Grenzfrequenz variabel gestalten, so muss wie oben gezeigt vorgegangen werden.

2.8.2 Zeitdiskretisierter PI-Regler

Als zweites Beispiel wird nun das Simulink-Modell eines zeitdiskreten PI-Reglers betrachtet. Zeitdiskrete PI-Regler

werden als Funktionen auf elektronischen Steuergeräten implementiert. Die Funktionen werden zyklisch mit einer

Abtastzeit vom Betriebssystem oder durch Timer-Interrupts aufgerufen.

Der zeitdiskrete PI-Regler tastet die Regelabweichung ( ) mit einer Abtastzeit ab. Der PI-Regler verarbeitet

daher die zeidiskrete Regelabweichung ( ) 1 . Zu jedem Abtastzeitpunkt generiert der PI-

Regler ein zeitdiskretes Stellsignal ( ), das über ein Halteglied H das Stellglied im Regelkreis und damit

die Regelstrecke ansteuert.

Stellglied + Strecke

Regler

𝑤(𝑡) 𝑒 𝑘 𝑢(𝑡) 𝑦(𝑡)

D/A

A/D

H A/D

𝑤𝑘 𝑤 𝑘 𝑢 𝑘 𝑢𝑘

𝑦𝑘 𝑦 𝑘



Zunächst wird die Übertragungsfunktion des zeitdiskreten PI-Reglers aus der Übertragungsfunktion eines

zeitkontinuierlichen PI-Reglers hergeleitet. Die Übertragungsfunktion des zeitkontinuierlichen PI-Reglers lautet:

( )

Zur Zeitdiskretisierung des Reglers wird hier das Rückwärtsdifferenzenverfahren angewendet. Die

Übertragungsfunktion für den zeitdiskreten Regler ergibt sich durch ein Ersetzen der komplexen Frequenz durch

1

Die Herleitung dieses Ansatzes ist im Vorlesungsskript „Regelungstechnik“ beschrieben.

Daraus ergibt sich die folgende Übertragungsfunktion für den zeitdiskreten Regler im Bildbereich der z-

Transformation:

( ) (

1

)

1

1

1 (

)

Damit wird im Bildbereich der z-Transformation das Stellsignal aus der Regelabweichung wie folgt berechnet:

( ) ( ) ( )

Nun gibt es zwei Alternativen zur Implementierung des zeitdiskreten PI-Reglers. Die erste Alternative basiert auf

der Übertragungsfunktion

( ) 1

1 (

)

Die z-Rücktransformation liefert folgende Berechnungsvorschrift für das zeitdiskrete Stellsignal:

( )

Der Nachteil dieser Darstellung ist, dass der P- und der I-Anteil des Reglers nicht mehr getrennt ersichtlich sind. Zur

Laufzeit ist daher auch keine getrennte Analyse der P- und I-Anteile des Reglers mehr möglich. Weiterhin wird die

Realisierung eines Anti-Windups erschwert.

Daher wird der zeitdiskrete PI-Regler in eine zweite alternative Darstellungsform überführt, die auf der

Übertragungsfunktion

( ) 1

basiert. Der P- und der I-Anteil werden zunächst parallel berechnet und dann aufsummiert:

( ) ( ) ( )

Die z-Rücktransformation liefert für den P-Anteil

und für den I-Anteil

Das Stellsignal ergibt sich als Summensignal



Die zweite Alternative ist im Simulink-Modell modelle\discrete\pi_diskret.slx implementiert.

modelle/discrete/pi_diskret.slx



3 Reglerentwurf

3.1 Kontinuierlicher Zustandsraum

Das folgende Zustandsraumprozessmodell, ein System der Ordnung n mit p Eingangsgrößen und q

Ausgangsgrößen, wird für die Regelung im Zustandsraum verwendet.

Beispiel: Permanentmagnetgleichstrommotor

Im Folgenden ist das elektrische Ersatzschaltbild des Permanentmagnetgleichstrommotors mit seinen

Motorparametern dargestellt.

x(t) Zustandsvektor mit den Anfangswerten x(0) (n,1)

u(t) Steuervektor (p,1)

y(t) Ausgangsvektor (q,1)

z(t) Störvektor (r, 1)

A Systemmatrix (n, n)

B Steuermatrix (n, p)



L Störmatrix (n, r)

k Motorkonstante 68·10 -3

Nm / A

bzw. V / sec-1

kµ Reibmomentkonstante zur

geschwindigkeitsproportionalen

Reibung oder viskosen Reibung

5·10 -5

Nm s / rad

R Ankerwiderstand 2 Ω

L Ankerinduktivität 500·10 - 6

H

J Rotorträgheitsmoment 10·10 - 6

kg m2

UN Nennspannung 40 V Motorkreisfrequenz rad / s

i Motorstrom A

u Motorspannung V

mL Lastmoment N

)t()t()t(

)t()t()t()t(

uDxCy

zLuBxAx

u R L

kµ·

B

A

+

+

C

D

+

+

L

+



Zustandsraumsystem

L

µ

Lµ mJ

1

J

ki

J

k

dt

d mkik

dt

dJ

uL

1

L

ki

L

R

dt

di

dt

diLiRku

L

A

µ

m

J

10

u

0L

1i

J

k

J

kL

k

L

R

dt

ddt

di

LBx

x

xy

xx

10

01

m

J

10

u

0L

1

J

k

J

kL

k

L

R

Lµ

System „mot“ ohne mL

xy

xx

10

01

u

0L

1

J

k

J

kL

k

L

R

µ

xy

xx

10

01

u0

2000

56800

136-4000-

Erstellen des Modells „mot“ in MATLAB

>> R=2; L=500e-6; k=68e-3; J=10e-6; ku=5e-5; >> A=[-R/L -k/L; k/J -ku/J]; B=[1/L; 0]; C=[1 0; 0 1]; D=[0; 0]; >> mot=ss(A,B,C,D) a = x1 x2 x1 -4000 -136 x2 6800 -5 b = u1 x1 2000 x2 0



c = x1 x2 y1 1 0 y2 0 1 d = u1 y1 0 y2 0 >> dcgain(mot) ans = 0.0106 14.3946 >> pole(mot) ans = 1.0e+003 * -3.7533 -0.2517 >> step(mot)

0

0.1

0.2

0.3

0.4

0.5

To: O

ut(

1)

0 0.005 0.01 0.015 0.02 0.0250

5

10

15

To: O

ut(

2)

Step Response

Time (sec)

Am

plit

ude



Simulinkmodell Variante I



Simulinkmodell Variante II

Charakteristische Gleichung

LJ

kkR

LJ

JRLksssdet

JL

kkR

L

R

J

kss

LJ

k

J

ks

L

Rs

J

ks

J

kL

k

L

Rs

detsdet

2

µµ2

2

µµ22

µ

µ

AI

AI

Pole

2

µ

2

µµ

2,1

2

µ

2

µµ

2,1

JRLk

LJkkR

4

1

2

1

LJ

JRLkp

2LJ

LJ4kkRJRLkJRLkp

Für JRLkµ ergibt sich

JR

LkkR

4

1

2

1

L

Rp

2

2

µ

2,1



Weitere Umformung und Näherung

2

µ

2µ

µ

2,1

L

R

J

k

LJ

k

LJ

kR

4

1

2

1

L

R

J

kp mit

LJ

k

R

L 2

el

2

el

µ

µ

el

el

µ

2,1

1J

k

J

k

4112

11

J

kp

1J

kJ

k1

J

k

p

1J

kJ

k

p

1J

kJ

k

2

111J

k

p

1

1J

k

J

k

4wenn1x1

1

2

11x

el

µ

µ

el

el

µ

2

el

µ

µ

1

el

µ

µ

el

el

µ

2,1

2

el

µ

µ

el

Mit kµ = 0

el

2

1

1p

p



3.1.1 Steuerbarkeit und Beobachtbarkeit

Anhand des Beispiels Permanentmagnetgleichstrommotor aus Kap. 3.1 wird gezeigt, wie mittels MATLAB die

Steuerbarkeit und die Beobachtbarkeit eines Systems ermittelt werden kann. Ist das System vollständig beobachtbar

und vollständig steuerbar, so ist es auch vollständig regelbar (dies ist für das Beispiel

Permanentmagnetgleichstrommotor gegeben).

3.1.1.1 Steuerbarkeit

QS = ctrb(A,B) QS = ctrb(sys)

Steuerbarkeitsmatrix:

BA,BA,AB,BQ 1n2

S

Beispiel: Permanentmagnetgleichstrommotor aus Kap. 3.1

>> rank(ctrb(mot)) ans = 2 % System voll steuerbar

3.1.1.2 Beobachtbarkeit

Ob = obsv(A,C) Ob = obsv(sys)

Beobachtbarkeitsmatrix:

1n

2

B

CA

CA

CA

C

Q

Beispiel: Permanentmagnetgleichstrommotor aus Kap. 3.1

>> rank(obsv(mot)) ans = 2 % System voll beobachtbar



3.1.2 Zustandsraumregler: Regelung mit Zustandsrückführung

Die Zustandsraumregelung mit Zustandsrückführung des Systems aus Kap. 3.1 ohne Störgrößen ist im folgenden

Bild dargestellt.

Für den geschlossenen Regelkreis gilt.

)t()t()t(

)t()t()t(

)t()t()t()t(

)t()t()t(

)t()t()t(

w

w

w

wSBxRBAx

uBxRBAx

xRuBxAx

xRuu

uBxAx

Für die Ausgangsgleichung gilt.

)t()t()t(

)t()t()t()t(

)t()t()t()t(

)t()t()t(

w

wSDxRDCy

xRwSDxCy

xRuDxCy

uDxCy

Zusammengefasst erhält man das Zustandsraumsystem des geschlossenen Regelkreises.

)t()t()t(

)t()t()t(

wSDxRDCy

wSBxRBAx

Wobei RBA die „Systemmatrix des geschlossenen Regelkreises“ repräsentiert.

B

A

+

+

C

D

+

+

-R

+

+

S

Prozess

Vorfilter

Führungsgröße

Reglermatrix



Über die Laplacetransformation des Zustandsraumsystems des geschlossenen Regelkreises erhält man die

Führungsübertragungsmatrix )s(wG .

SDBRBAIRDCG

WSDBRBAIRDCY

WSDXRDCY

XRWSDXCY

WSBRBAIX

WSBXRBAX

wSBxRBAx

G

1

w

)s(

1

1

)s()s(

s)s(

)s(s)s(

)s()s()s(

)s()s()s()s(

)s(s)s(

)s()s()s(s

)t()t(L)t(L

w

Bevor mit dem Entwurf der Regelung begonnen werden kann ist die Regelbarkeit des Systems zu überprüfen. Für

das Beispiel Permanentmagnetgleichstrommotor wurde dies in Kap. 3.1.1 geprüft (vollständig regelbar). Die

Reglerauslegung erfolgt am Beispiel Permanentmagnetgleichstrommotor aus Kap. 3.1. Geregelt werden soll die

Zustandsgröße x2 = (Motorkreisfrequenz). Befehle zur Reglerauslegung finden sich in Kap. 1.12.8.

3.1.2.1 Berechnung des Vorfilters

Die Verstärkungsmatrix wK der Führungsübertragungsmatrix )s(wG erhält man wie im skalaren Fall aus dem

Endwertsatz mit

q

1

w

w

)t(h)t( w . h(t) ist die Sprungfunktion.

)t(y lim w

)t(y

)t(y

lim

w

w

)s( lim

)t(y

)t(y

lim

w

w

)s( lim

w

w

s

1)s(s lim)s()s(s limy(t) lim

)s()s()s(

wit

i

q

1

t

q

1

w

w0s

w

q

1

t

q

1

w0s

q

1

w0s

w0st

w

w

IKK

GK

GGWG

WGY

K

Der Vorfilter S muss so festgelegt werden, dass IK w wird.

11

1w

DBARBRDCS

ISDBARBRDCK



Alternativer Ansatz

)t()t()t(

)t()t()t(

wSDxRDCy

wSBxRBAx

mit

q

1

w

w

)t(h)t( w

Bei einem stabilen System gilt im eingeschwungenen Zustand 0)t( x , s)t( xx ,

q

1

s

w

w

)t( yy und

damit

q

1

1

s

q

1

s

w

w

w

w

SBARBx

SBxRBA0

q

1

q

1

1

s

w

w

w

w

SDBARBRDCy

ergibt die Forderung

ISDBARBRDC 1

Aus dieser Forderung erhält man wieder

11 DBARBRDCS



3.1.2.2 Reglerauslegung durch Polvorgabe

Das zu regelnde System habe die Ordnung n und nur eine Stellgröße: T

rR . Bei der Reglerauslegung durch

Polvorgabe wird das charakteristische Polynom des geschlossenen Regelkreises benötigt, das aus der „Systemmatrix

des geschlossenen Regelkreises“ RBA (siehe Kap. 3.1.2) ermittelt werden kann.

Tsdet rBAI

Mit der Festlegung der Pole des geschlossenen Regelkreises pR i mit i = 1 ... n erhält man über

n

1i

i Rps

ein gewünschtes charakteristisches Polynom. Mittels Koeffizientenvergleich der beiden charakteristischen

Gleichungen können dann die Vektorelemente des Reglervektors T

r bestimmt werden.

n

1i

i R

T pssdet rBAI

Bei einem System der Ordnung n ergeben sich n vorzugebende Pole und n Koeffizienten der charakteristischen

Gleichung. Aus n Koeffizienten erhält man n Gleichungen durch Koeffizientenvergleich. Mit diesen n Gleichungen

können die n Vektorelemente des Reglervektors T

r bestimmt werden. Bei einer Mehrgrößenregelung von z.B. k

mit k = 1 ... p Eingängen wird eine Reglermatrix R (k, n) benötigt und man erhält folgende Gleichung.

n

1i

i Rpssdet RBAI

Da aber wie zuvor nur n Gleichungen zur Verfügung stehen aber k·n Gleichungen zur Bestimmung der

Matrixelemente der Reglermatrix erforderlich sind existiert nicht nur eine Lösung für R.

Die Reglerauslegung durch Polvorgabe erfolgt nun am Beispiel des Permanentmagnetgleichstrommotors aus

Kap. 3.1. In einem ersten Schritt werden die Pole des offenen Regelkreises

>> eig(mot) ans = 1.0e+003 * -3.7533 -0.2517

bzw. die zugehörigen Zeitkonstanten (auch wenn die Pole in diesem Beispiel rein reell sind wird der Befehl real zur

Extraktion des Realteils verwendet)

>> T=abs(real(eig(mot)).^-1) T = 0.0003 0.0040 >> T(1) ans = 2.6643e-004



bestimmt um ein „Gefühl“ für das System zu bekommen. Der „schnellere“ Pol entspricht näherungsweise der

elektrischen Zeitkonstante L / R (siehe Kap. 3.1, Beispiel Permanentmagnetgleichstrommotor,

Näherungsgleichung der Systempole p1, 2),

>> L/R ans = 2.5000e-004

die kaum ins Gewicht fällt. Die Summe der Zeitkonstanten ergibt sich zu.

>> TS=sum( abs( real( eig(mot) ) ).^-1 ) TS = 0.0042

Die Summe der Zeitkonstanten TSR des geschlossenen Regelkreises soll 400 ms betragen. Bei einem System zweiter

Ordnung (n = 2) erhält man für die zwei identischen reellen Pole pR 1,2 des geschlossenen Regelkreises folgende

Gleichung für die Summe der Zeitkonstanten.

SR

2,1 R

2,1 R2,1 R2,1 R

SR

T

2p

p

2

p

1

p

1T

>> TSR = 400e-3 TSR = 0.4000 >> pR12=-2/TSR pR12 = -5

Die Begründung für diese Vorgehensweise kann anhand des Vergleichs eines PT-1 Gliedes mit einer Zeitkonstante

von 400 ms mit einem PT-2 Glied (reeller Doppelpol) mit einer Summe der Zeitkonstanten von ebenfalls 400 ms

erfolgen.

>> 1/400e-3 ans = 2.5000 >> s=tf('s'); >> G1=2.5/(s+2.5); >> G2=25/(s+5)/(s+5); >> step(G1,G2) >> grid on



Für die Polvorgabe stehen die beiden Befehle place (empfohlen) und acker zur Verfügung. Verwendet wird wie

empfohlen der Befehl place. Dieser Befehl hat die Einschränkung, dass Mehrfachpole nur in der Häufigkeit von

rang(B) festgelegt werden dürfen.

>> rank(B) ans =

1

Im Beispiel dürfen also nicht wie vorgesehen zwei gleiche Pole für den geschlossenen Regelkreis festgelegt werden.

Daher wird ein Pol um den Faktor 1,0001 leicht verändert übergeben, was die Summe der Zeitkonstanten leicht

verringert (Alternativ wäre es möglich von vorneherein zwei unterschiedliche Pole festzulegen).

>> pR = [pR12 pR12*1.0001]; % Vektor pR mit Polen erzeugen >> R1=place(A,B,pR) % Polvorgabe R1 = -1.9975 -0.0680

Im nächsten Schritt wird wie in Kap. 3.1.2.1 beschrieben der Vorfilter berechnet. Da allerdings nur = x2 geregelt

werden soll, muss eine reduzierte Ausgangsgleichung angesetzt werden.

xCxy

10

01 xcxy T10

>> c=[0; 1]; >> S1=(c'*(B*R1-A)^-1*B)^-1 S1 = 1.8384e-006

Step Response

Time (sec)

Am

plit

ude

0 0.5 1 1.5 2 2.50

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

G1

G2



Den geschlossenen Regelkreis motreg erhält man mittels

)t()t()t(

)t()t()t(

wSDxRDCy

wSBxRBAx

mit D = 0

)t()t(

)t()t()t(

xCy

wSBxRBAx

über

>> motreg=ss(A-B*R1,B*S1,C, [0; 0]); Benennung der Eingangs-, Ausgangs- und Zustandsgrößen (siehe Kap. 0)

>> motreg.StateName={'i'; '\omega'}; >> motreg.OutputName={'i'; '\omega'}; >> motreg.InputName={'\omega_{Soll}'};

Sprungantwort des geschlossenen Regelkreises

>> step(motreg)

Anmerkung:

\omega ist die LaTeX-Formatierung für

\omega_{Soll} ist die LaTeX-Formatierung für Soll

0

1

2

3

4

5

6

7

8x 10

-4 From: Soll

To: i

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 20

0.2

0.4

0.6

0.8

1

To:

Step Response

Time (sec)

Am

plit

ude



Übertragungsmatrix und Pole des geschlossenen Regelkreises

>> Gmot=tf(motreg) Transfer function from input to output... 0.003677 #1: --------- s + 5.001 25 #2: --------------- s^2 + 10 s + 25 >> pole(Gmot(2,1)) ans = -5.0005 -5.0000 >> pole(Gmot(1,1)) ans = -5.0005

Simulinkmodell



Im Folgenden wird die Regelung beschleunigt indem ein komplex konjugiertes Polpaar (motreg2) vorgegeben bzw.

die Summe der Zeitkonstanten halbiert (motreg3) wird. Bei der Verwendung eines komplex konjugierten Poolpaars

wird ein leichtes Überschwingen der Motorkreisfrequenz in Kauf genommen, die Summe der Zeitkonstanten wird

bei 400 ms belassen. Bei der Beschleunigung der Regelung wird der Steller stärker belastet.

>> pR2 = [pR12+i*5 pR12-i*5]; % Komplex konjugiertes Poolpaar >> R2=place(A,B,pR2); >> S2=(c'*(B*R2-A)^-1*B)^-1; >> motreg2=ss(A-B*R2,B*S2,C, [0; 0]); >> motreg2.StateName={'i'; '\omega'}; motreg2.OutputName={'i'; '\omega'}; >> motreg2.InputName={'\omega_{Soll}'}; >> TSR = 400e-3/2; % Halbierung der Summe der Zeitkonstanten >> pR12=-2/TSR; >> pR3 = [pR12 pR12*1.0001]; >> R3=place(A,B,pR3); >> S3=(c'*(B*R3-A)^-1*B)^-1; >> motreg3=ss(A-B*R3,B*S3,C, [0; 0]); >> motreg3.StateName={'i'; '\omega'}; motreg3.OutputName={'i'; '\omega'}; >> motreg3.InputName={'\omega_{Soll}'}; >> R1, R2, R3 R1 = -1.9975 -0.0680 R2 = -1.9975 -0.0680 R3 = -1.9925 -0.0680 >> S1, S2, S3 S1 = 1.8384e-006 S2 = 3.6765e-006 S3 = 7.3537e-006

Für die Regelung wäre es noch interessant die Stellgröße zu kennen, daher wir diese dem System noch als dritte

Ausgangsgröße hinzugefügt. Hierfür wird folgende Gleichung benötigt.

)t()t(wS)t(u

)t()t(u)t(u

T

T

w

xr

xr



Da C und D gleichzeitig geändert werden muss

>> motreg.c=[motreg.c; -R1]; motreg.d=[motreg.d; S1]; ??? Error using ==> lti.subsasgn at 44 The values of the "c" and "d" properties must be matrices with the same number of rows.

ist dies nur über den set Befehl möglich (siehe Kap. 0).

>> set(motreg, 'c',[motreg.c; -R1], 'd',[motreg.d; S1], 'OutputName',[get(motreg,'OutputName');'u']); >> set(motreg2,'c',[motreg2.c; -R2],'d',[motreg2.d; S2] ,'OutputName',[get(motreg2,'OutputName');'u']); >> set(motreg3,'c',[motreg3.c; -R3],'d',[motreg3.d; S3] ,'OutputName',[get(motreg3,'OutputName');'u']); Ausgabe der Sprungantwort

>> step(motreg,motreg2,motreg3) >> grid on >> legend('motreg','motreg2','motreg3')

0

0.2

0.4

0.6

0.8

1x 10

-3 From: Soll

To: i

0

0.5

1

1.5

To:

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 20

0.02

0.04

0.06

0.08

0.1

To: u

Step Response

Time (sec)

Am

plitu

de

motreg

motreg2

motreg3



3.1.2.3 Reglerauslegung durch linear-quadratische (LQ) Optimierung

Die Ermittlung der Reglermatrix R erfolgt über die Minimierung von quadratischen Gütekriterien I. In MATLAB

werden die folgenden beiden Gütekriterien unterstützt.

Bei Gütekriterium 1 werden die Zustandsgrößen, bei Gütekriterium 2 werden die Ausgangssignale optimiert. Wobei

die beiden symmetrischen Bewertungsmatrizen Q (positiv semidefinite) und P (positiv definite) die Optimierung

steuern. Die Definitheit (positiv definit bzw. positiv semidefinit) stellen positive Zeitfunktionsergebnisse innerhalb

des Integrals sicher.

Teilausdruck Forderung

0)t()t(T xQx Q ist positiv semidefinit,

symmetrisch

Alle Eigenwerte größer oder gleich 0

und Q = QT

0)t()t(T uPu P ist positiv definit,

symmetrisch

Alle Eigenwerte größer 0 und P = PT

Die Matrixelemente der Matrizen Q und P müssen größer gleich null sein. Wenn die Zustandsgrößen beim

Gütekriterium 1 bzw. die Ausgangsgrößen beim Gütekriterium 2 und die Stellgrößen unabhängig voneinander

optimieren werden sollen, so dürfen nur in der Hauptdiagonalen der Matrizen Q und P Werte stehen

(Diagonalmatrix diag). Dies ist in der Regel der Fall. Beispiel für ein System dritter Ordnung mit drei Eingängen:

332211

33

22

11

q,q,qdiag

q00

0q0

00q

Q

Wobei bei Gütekriterium 1 q11 x1, q22 x2 und q33 x3 bzw. bei Gütekriterium 2 q11 y1, q22 y2 und q33 y3 zugeordnet ist.

332211

33

22

11

p,p,pdiag

p00

0p0

00p

P

Wobei p11 u1, p22 u2 und p33 u3 zugeordnet ist. Für die Bestimmung der Definitheit werden die Eigenwerte der

Matrizen benötigt. Diese erhält man aus den Nullstellen des charakteristischen Polynoms. Bestimmung der

Eigenwerte i (mit i = 1 ... n) der Matrix nn11 q,,qdiag Q .

n

1i

iinn11 qq,,qdiagdet I

iii q mit 0qiii

Für die Eigenwerte i (mit i = 1 ... p) der Diagonalmatrix P erhält man analog.

iii p mit 0piii

Gütekriterium MATLABbefehl

1

0

TT dt)t()t()t()t(I uPuxQx

lqr

2

0

TT dt)t()t()t()t(I uPuyQy

lqry



Verwendet man Diagonalmatrizen für Q und P, so erhält man für das Gütekriterium 1 (im Folgenden wird nur noch

Bezug auf Gütekriterium 1 genommen).

0

p

ki

kk

2

k

n

1i

ii

2

i dtpuqxI

Je größer ein qii gewählt wird desto größer wird sein zugehöriger Summenanteil ii

2

i qx und desto stärker wird der

quadratische Zeitflächenanteil dtxq0

2

iii

der Zustandsgröße xi bestraft. Das heißt je größer qii gewählt wird desto

schneller erfolgt die Regelung der zugehörigen Zustandsgröße bzw. desto schneller nähert sich die zugehörige

Zustandsgröße null wenn null als Sollwert vorgegeben wird. Je größer ein pii gewählt wird desto größer wird sein

zugehöriger Summenanteil ii

2

i pu und desto stärker wird der quadratische Zeitflächenanteil dtup0

2

iii

der

Stellgröße ui bestraft. Kleine pii ermöglichen also eine schnellere Regelung mit größeren Stellgrößen (die der reelle

Steller auch liefern können muss) und größere pii verursachen eine langsamere energiesparendere Regelung mit

kleineren Stellgrößen. Von Bedeutung sind aber nicht die absoluten Werte von qii und pii sondern deren Verhältnisse

untereinander z.B.

kk

ii

q

q oder

mm

ll

p

p oder

ll

ii

p

q mit i = 1...n, k = 1...n, l = 1...p, m = 1...p und i ≠ k bzw. l ≠ m

Zu Beginn kann P = I gewählt werden. Die Parameter q11, q22, ..., qnn können so gewählt werden, dass die Produkte

KKqKqKq2

nnn

2

222

2

111

im ersten Ansatz etwa gleich sind, d.h. die Konstante K ergeben. Dadurch wird erreicht, dass die Regelung der

einzelnen Zustandsgrößen gleich optimiert wird. Ki entspricht dabei der Verstärkung der Zustandsgröße xi (sofern

die Verstärkung berechenbar ist und C = I bei der Berechnung der Verstärkung ist). Wird eine Zustandsgröße xi

nicht geregelt bzw. man ist an einer Optimierung nicht interessiert, so kann qii gleich 0 gesetzt werden.

Zur Regelung wird wieder das Motormodell mot aus Kap. 3.1 verwendet.

>> R=2; L=500e-6; k=68e-3; J=10e-6; ku=5e-5; >> A=[-R/L -k/L; k/J -ku/J]; B=[1/L; 0]; C=[1 0; 0 1]; D=[0; 0]; >> mot=ss(A,B,C,D); >> Gmot=tf(mot) Transfer function from input to output... 2000 s + 10000 #1: --------------------- s^2 + 4005 s + 944800 1.36e007 #2: --------------------- s^2 + 4005 s + 944800 >> dcgain(mot) ans = 0.0106 14.3946



>> P=1; Q=diag(dcgain(mot)) Q = 0.0106 0 0 14.3946

Für die Berechnung der Reglermatrix R (hier R1) wird der Befehl lqr verwendet.

>> [R1, Sric, poleR1] = lqr(mot, Q, P); R1, poleR1 R1 = 3.4152 3.7227 poleR1 = 1.0e+003 * -5.4177 + 4.7176i -5.4177 - 4.7176i

Zusätzlich zur Reglermatrix R1 können noch die Lösung der algebraischen Riccati Gleichung Sric und die Pole des

geschlossenen Regelkreises poleR1 ermittelt werden. Berechnung des Vorfilters.

>> c=[0; 1]; S1=(c'*(B*R1-A)^-1*B)^-1; Berechnung des geschlossenen Regelkreises.

>> temp = {'i'; '\omega'}; >> motreg1=ss(A-B*R1,B*S1,C, [0; 0], 'StateName', temp, 'OutputName', temp, ... 'InputName', {'\omega_{Soll}'});

>> set(motreg1, 'c',[motreg1.c; -R1], 'd',[motreg1.d; S1], ... 'OutputName',[get(motreg1,'OutputName');'u']); >> step(motreg1)



Im Folgenden sollen die Matrizen P (im Beispiel ist P ein Skalar und wird deshalb fortan als P bezeichnet) und Q

variiert werden. Angegeben werden die Veränderungen der Matrix Q und des Skalar P bezüglich der Ausgangslage

im Modell motreg1.

In einem ersten Schritt soll die Regelung der Motorkreisfrequenz (Zustandsgröße x2) beschleunigt werden. Im

Gütekriterium muss also dafür gesorgt werden, dass dieser Zeitflächenanteil stärker bestraft wird. Aus diesem Grund

muss q22 erhöht werden. Im Modell motreg2 wird q22 verzehnfacht.

>> Q2=Q; Q2(2,2)=Q2(2,2)*10; P2=1; >> [R2, Sric, poleR2] = lqr(mot, Q2, P2); >> S2=(c'*(B*R2-A)^-1*B)^-1; >> motreg2=ss(A-B*R2,B*S2,C, [0; 0], 'StateName', temp, 'OutputName', temp, ... 'InputName', {'\omega_{Soll}'}); >> set(motreg2, 'c',[motreg2.c; -R2], 'd',[motreg2.d; S2], ... 'OutputName',[get(motreg2,'OutputName');'u']);

Eine Verlangsamung der Regelung wird durch das Erhöhen von P erreicht, da dadurch Stelleingriffe stärker bestraft

werden. Im folgenden Modell motreg3 wird P daher verzehnfacht.

>> Q3=Q; P3=10; >> [R3, Sric, poleR3] = lqr(mot, Q3, P3); >> S3=(c'*(B*R3-A)^-1*B)^-1; >> motreg3=ss(A-B*R3,B*S3,C, [0; 0], 'StateName', temp, 'OutputName', temp, ... 'InputName', {'\omega_{Soll}'}); >> set(motreg3, 'c',[motreg3.c; -R3], 'd',[motreg3.d; S3], ... 'OutputName',[get(motreg3,'OutputName');'u']);

Eine Beschleunigung der Regelung wird durch eine Verkleinerung von P erreicht (Modell motreg4, P = 1 / 10).

>> Q4=Q; P4=1/10; >> [R4, Sric, poleR4] = lqr(mot, Q4, P4); >> S4=(c'*(B*R4-A)^-1*B)^-1; >> motreg4=ss(A-B*R4,B*S4,C, [0; 0], 'StateName', temp, 'OutputName', temp, ...

-0.5

0

0.5

From: Soll

To: i

0

0.5

1

1.5

To:

0 0.2 0.4 0.6 0.8 1 1.2 1.4

x 10-3

-2

0

2

4

To: u

Step Response

Time (sec)

Am

plit

ude



'InputName', {'\omega_{Soll}'}); >> set(motreg4, 'c',[motreg4.c; -R4], 'd',[motreg4.d; S4], ... 'OutputName',[get(motreg4,'OutputName');'u']);

Aus der weiter unten abgebildeten Sprungantwort kann man entnehmen, dass diese Maßnahme zu dem nahezu

gleichen Ergebnis führt wie die Verzehnfachung von q22 beim Modell motreg2.

>> R2, R4, S2, S4 R2 = 7.2243 11.9232 R4 = 7.2295 11.9232 S2 = 11.9979 S4 = 11.9979

Eine Verzehnfachung von q11 (Zustandsgröße x1 = i) im Modell motreg5 hat, wie man der folgenden Sprungantwort

(nahezu deckungsgleich mit Modell motreg1) entnehmen kann, so gut wie keinen Einfluss. Eine Vergrößerung von

q11 bestraft den quadratischen Stromzeitflächenanteil stärker. Dies hat zur Folge, dass die Regelung langsamer wird,

da der Strom (momentbildende Größe) proportional zum Antriebsmoment ist. Dieser Effekt ist aber erst bei einer

Vergrößerung von q11 um den Faktor 1 000 der Sprungantwort entnehmbar.

>> Q5=Q; Q5(1,1)=Q5(1,1)*10; P5=1; >> [R5, Sric, poleR5] = lqr(mot, Q5, P5); >> S5=(c'*(B*R5-A)^-1*B)^-1; >> motreg5=ss(A-B*R5,B*S5,C, [0; 0], 'StateName', temp, 'OutputName', temp, ... 'InputName', {'\omega_{Soll}'}); >> set(motreg5, 'c',[motreg5.c; -R5], 'd',[motreg5.d; S5], ... 'OutputName',[get(motreg5,'OutputName');'u']); >> step(motreg1,motreg2,motreg3,motreg4,motreg5)



Anmerkung:

Für die Praxis sind die oben dargestellten Regler viel zu schnell ausgelegt.

Nächstes Ziel muss es sein das zeitliche Einschwingverhalten der Regelung zu verlangsamen.

Siehe dazu in Kap. 3.1.3 Beispiel: Regler mit Beobachter.

-0.5

0

0.5

1

From: Soll

To: i

0

0.5

1

1.5

To:

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8

x 10-3

-10

0

10

20

To: u

Step Response

Time (sec)

Am

plit

ude

motreg1

motreg2

motreg3

motreg4

motreg5



3.1.3 Luenberger Zustandsgrößenbeobachter

3.1.3.1 Zustandsraumregler mit vollständigem Luenberger Zustandsgrößenbeobachter

In vielen Anwendungsfällen sind Zustandsgrößen nicht oder nur mit erheblichem Aufwand messbar, d.h. sie stehen

für die Regelung nicht zur Verfügung. In solchen Fällen kann ein Luenberger Zustandsgrößenbeobachter eingesetzt

werden, der die Zustandsgrößen anhand der Ausgangsgröße(n) schätzt. Das Beobachtermodell besteht im

Wesentlichen aus einer Kopie des Prozessmodells mit einer gewichteten Beobachterfehleraufschaltung.

Voraussetzungen hierfür sind:

Kenntnis des Prozessmodells. Bei Abweichungen der Parameter des Beobachters von den

Parametern des Prozeßmodells konvergieren die Schätzfehler der Zustandsgrößen nicht gegen null

bzw. bei einem vereinfachten Beobachtermodell z.B. durch Ordnungsreduktion ergeben sich

Abweichungen zum realen beobachteten Prozess.

Vollständige Beobachtbarkeit des Systems (siehe Kap. 3.1.1.2). Für das Beispiel

Permanentmagnetgleichstrommotor ist dies gegeben.

Die geschätzten Größen erhalten ein zusätzliches „^“ Zeichen und die Schätzfehler werden durch ein zusätzliches

„~“ gekennzeichnet. Im Folgenden ist die Regelung eines Prozess mittels Zustandraumregler mit Luenberger

Zustandsgrößenbeobachter dargestellt.

Die Teilsysteme Beobachter und Prozess werden durch folgende Systemgleichungen beschrieben.

Prozess Beobachter

)t()t()t(

)t()t()t(

uDxCy

uBxAx

)t()t(ˆ)t(ˆ

)t(~)t()t(ˆ)t(ˆB

uDxCy

yKuBxAx

Mit den Schätzfehlern )t(ˆ)t()t(~ yyy und )t(ˆ)t()t(~

)t(ˆ)t()t(~

xxx

xxx

Das folgende Bild zeigt einen detailierteren Aufbau.

-R

+

+

S

Prozess

Vorfilter

Führungsgröße

+

-

Beobachter



Für den Beobachter gilt allgemein.

)t()t()t(ˆ)t(ˆ

)t()t(ˆ)t()t()t(ˆ)t(ˆ

)t(ˆ)t()t()t(ˆ)t(~)t()t(ˆ)t(ˆ

BBB

B

BB

yKuDKBxCKAx

uDxCyKuBxAx

yyKuBxAyKuBxAx

Für den Beobachterfehler des geschlossenen und des offenen Regelkreis gilt, da sich u(t) herauskürzt.

)t(~)t(~

)t(ˆ)t()t(~

)t()t()t()t(ˆ)t()t()t(~

B

B

BBB

xCKAx

xxCKAx

uDxCKuDKBxCKAuBxAx

B

A

+

+

C

D

+

+

-R

+

+

S

Prozess

Vorfilter

Führungsgröße

Reglermatrix

B

A

+

+

C

D

+

+

Beobachter

+

KB

+

-

Beobachtermatrix



Der Beobachterfehler der Zustandsgrößen des offenen und des geschlossenen Regelkreises besitzt eine Dynamik,

die durch die Systemmatrix CKAA BB ausgedrückt werden kann. Die Beobachtermatrix KB kann durch

die Festlegung der Eigenwerte der Systemmatrix AB (Beobachterpole) mittels Polvorgabe bestimmt werden. Zur

Berechnung der Reglermatrix R mittels Polvorgabe (Zustandsraumregelung ohne Beobachter) sieht MATLAB zwei

Befehle vor (siehe auch Kap. 3.1.2.2) place und acker. Da die Systemmatrix des geschlossenen Regelkreises

RBA (Zustandsraumregelung ohne Beobachter) eine ähnliche Struktur aufweist wie die Systemmatrix des

Beobachterfehlers CKAA BB kann die Polvorgabe beim Beobachter (Berechnung von KB) ebenfalls

mittels der Befehle place und acker erfolgen. Begründung: Da

CKAA BB T

B

TTT

B

TT

B KCACKAA ↔ RBA

und wegen

T

B

T

BB sdetsdetsdet AIAIAI

gilt für die Beobachterpole pBi mit i = 1 ... n (bei einem System n’ter Ordnung)

n

1i

i B

T

B

TT

B pssdetsdet KCAICKAI .

KB erhält man also über den Ausdruck KB = place(A ', C ', pB) '; wobei es sich bei pB um einen Vektor handelt, der

die vorzugebenden Pole enthält.

Beobachter ohne Regler

Wird der Beobachter, wie im folgenden Bild dargestellt, nur zur Schätzung der Zustandsgrößen eingesetzt, d.h. der

Beobachter ist nicht in eine Regelung eingebettet,

so gilt.

)t()t()t(ˆ)t(ˆ

)t()t()t()t(ˆ)t(ˆ

)t()t()t(ˆ)t(ˆ

BB

BBBB

BBB

xCKuBxCKAx

uDKxCKuDKBxCKAx

yKuDKBxCKAx

Die Wahl der Beobachterpole orientieren sich also an den Polen der Systemmatrix A des Prozesses. Um eine gute

Schätzung der Zustandsgrößen des Prozesses zu erhalten sollten die Realteile der Beobachterpole deutlich

„schneller“ sein als die Realteile der Systempole des Prozesses. Für gewöhnlich werden nur reelle Pole vorgegeben.

Prozess

+

-

Beobachter



Regler mit Beobachter

Für den geschlossenen Regelkreis gilt hingegen.

)t()t()t(ˆ)t(ˆ

)t()t(ˆ)t()t(ˆ)t(ˆ

)t(ˆ)t()t(

)t()t()t(ˆ)t(ˆ

BB

BB

BB

xCKwSBxRBCKAx

xCKxRwSBxCKAx

xRwSu

xCKuBxCKAx

Umformung zu einer Beobachtergleichung.

)t(~)t()t(ˆ)t(ˆ

)t()t(~)t(ˆ)t(ˆ

)t()t(ˆ)t()t(ˆ)t(ˆ

B

B

B

yKwSBxRBAx

wSBxCKxRBAx

wSBxxCKxRBAx

Vom Beobachter aus gesehen wird ein geschlossener Regelkreis wie in Kap. 3.1.2 beschrieben beobachtet als wäre

ein Beobachter parallel zum geschlossenen Regelkreis aufgeschaltet (Ersatzschaltbild). Die Systemmatrix dieses

„virtuellen“ Beobachters ist CB KRBA . Für den Prozess ergeben sich folgende Gleichungen.

)t(~)t()t()t(

)t(~)t()t(ˆ

)t()t(ˆ)t()t(

)t()t()t(

xRBwSBxRBAx

xxx

wSBxRBxAx

uBxAx

Vergleicht man diese Gleichung mit dem System eines geschlossenen Regelkreises ohne Beobachter,

)t()t()t( wSBxRBAx

so stellt man fest, dass der Beobachter erst nach dem Abklingen des Beobachterfehlers die Regelung nicht mehr

„stört“.

Die Wahl der Beobachterpole orientieren sich an den Polen des geschlossenen Regelkreises ohne Beobachter, also

an den Eigenwerten der Matrix RBA . Um eine gute Schätzung der Zustandsgrößen des geregelten Prozesses

zu erhalten sollten die Realteile der Beobachterpole deutlich „schneller“ sein als die Realteile der Pole des

geschlossenen Regelkreises. Für gewöhnlich werden nur reelle Pole vorgegeben.

Vorgehensweise:

Entwurf der Regelung ohne Beobachter wie in Kap. 3.1.2 beschrieben.

Ermittlung der Eigenwerte des geschlossenen Regelkreises ohne Beobachter aus der

dazugehörigen Systemmatrix RBA .

Polvorgabe der Systemmatrix CKAA BB auf Grundlage der Pole des geschlossenen

Regelkreises ohne Beobachter.



Beispiel: Beobachter ohne Regler

Im Folgenden soll das Beispielsystem Permanentmagnetgleichstrommotor aus Kap. 3.1. ohne Regelung

beobachtet werden.

Definition des Prozesses.

>> R=2; L=500e-6; k=68e-3; J=10e-6; ku=5e-5; >> A=[-R/L -k/L; k/J -ku/J]; B=[1/L; 0]; C=[1 0; 0 1]; D=[0; 0]; >> mot=ss(A,B,C,D);

Gemessen werden kann nur der Motorstrom i(t) = x1(t), daher muss das System wie folgt geändert werden.

>> set(mot,'c',[1 0],'d',0);

Bestimmung des schnellsten Systempols. Gesucht wird also der Pol mit dem negativsten Realteil. Auch wenn wie in

diesem Beispiel keine komplex konjugierten Pole vorliegen kann der schnellste Pol wie folgt ermittelt werden.

>> pmin = min(real(eig(mot))) % oder pmin = min(real(eig(A))) pmin = -3.7533e+003

Jetzt können die n Pole (hier n = 2) des Beobachters festgelegt werden. Die Beobachterpole sollen im Beispiel 5-mal

schneller sein als der schnellste Pol des Prozesses. Zur Verfügung stehen die beiden Befehle place (empfohlen) und

acker. Verwendet wird wie empfohlen der Befehl place. Dieser Befehl hat die Einschränkung, dass Mehrfachpole

bei der Reglerauslegung nur in der Häufigkeit von rang(B) festgelegt werden dürfen. Bezogen auf den Beobachter

muss auf rang(C T) getestet werden.

>> rank(mot.c') ans = 1

Im Beispiel dürfen also keine zwei gleichen Pole festgelegt werden. Daher wird ein Pol um den Faktor 1,0001 leicht

verändert übergeben.

>> pR = [pmin pmin*1.0001]*5; >> KB=place(mot.a',mot.c',pR)' KB =

Prozess

+

-

Beobachter



1.0e+006 * 0.0335 -2.5816

Simulinkmodell (die Anfangswerte des Beobachters weichen von 0 ab)

Prozess



Beobachter




Regler mit Beobachter

Der Beobachter aus dem vorangegangenen Beispiel soll nun um einen Regelkreis erweitert werden, der die

Motorkreisfrequenz t = x2(t) regelt.

>> R=2; L=500e-6; k=68e-3; J=10e-6; ku=5e-5; % Definition Prozess >> A=[-R/L -k/L; k/J -ku/J]; B=[1/L; 0]; C=[1 0; 0 1]; D=[0; 0]; >> mot=ss(A,B,C,D); >> P=1000; Q=diag(dcgain(mot)); % Reglerauslegung >> R1 = lqr(mot, Q, P); >> c=[0; 1]; S1=(c'*(B*R1-A)^-1*B)^-1; >> R1, S1 R1 = 0.1142 0.0691 S1 = 0.1386 >> set(mot,'c',[1 0],'d',0); % Bestimmung des >> eig(A-B*R1) % Beobachters ans = 1.0e+003 * -3.7275 -0.5058 >> pmin = min(real(eig(A-B*R1))) pmin = -3.7275e+003 >> pR = [pmin pmin*1.0001]*5; >> KB=place(mot.a',mot.c',pR)'

-R

+

+ S

Prozess

Vorfilter

Führungsgröße

+

-

Beobachter



KB = 1.0e+006 * 0.0333 -2.5462

Simulinkmodell



Simulationsergebnis



4 Anhang

4.1 Gradient, Jacobimatrix und Rechenregeln

Der Gradient ist die Ableitung einer Skalaren Funktion f(x) nach x:

)(f

)(f

x

)(f

x

)(f

)(f)(fgrad)(f

N

1

x

x

N

1

x

x

x

x

xxx

x mit

N

1

x

x

x ( : Nabla-Operator)

Die Jacobimatrix ermöglicht die Ableitung einer Vektorfunktion f(x) nach x:

N1

T

N

T

1

T

N

T

1

N

N

2

N

1

N

N

2

2

2

1

2

N

1

2

1

1

1

x

)(,,

x

)()(

)(

)(fgrad

)(fgrad

)(f

)(f

)()(

x

)(f

x

)(f

x

)(f

x

)(f

x

)(f

x

)(f

x

)(f

x

)(f

x

)(f

)()(

xfxfxJ

x

xf

x

x

x

x

x

x

xJx

xf

xxx

xxx

xxx

xJx

xf

f

f

f

mit

)(f

)(f

)(

N

1

x

x

xf

N

1

x

x

x



Rechenregeln: Vektor b (Nx1), c (1xN), Matrix A (NxN), Einheitsmatrix I, Vektorfunktion f(x) (Nx1) und g(x) (Nx1)

Häufig benötigter Ausdrücke:

T

TT

cx

xcb

x

bx

x

xb

Ax

xA

Ix

xI

x

x

xxIx

xx

22 T

T

xAAxAxAxx

xAxA

x

x

x

xAx

TT

TTT

Für: T

AA : xAx

xAx

2

T

Produktregel:

)()(

)()()()(

TTT

xfx

xgxg

x

xf

x

xgxf

)()(

2)()(

TT

xfx

xf

x

xfxf

Ableitung der obigen Rechenregeln:

Ableitung:

bx

bx

x

xb

N

1

N

N

1i

ii

1

N

1i

ii

TT

b

b

x

xb

x

xb



A

A

A

A

A

xA

xA

x

xA

xA

x

xA

N

1

TT

N

TT

1

T

N

T

1

N

1

Zeile

Zeile

Zeile

Zeile

Zeilegrad

ZeilegradZeile

Zeile

Produktregel:

N

1i

i

N

i

N

1i

i

1

i

N

1i

i

N

i

N

1i

i

1

i

N

N

1i

ii

1

N

1i

ii

T

)(fx

)(g

)(fx

)(g

)(gx

)(f

)(gx

)(f

x

)(g)(f

x

)(g)(f

)()(

xx

xx

xx

xx

xx

xx

x

xgxf

)()(

)()()()(

)(

x

)(

x

)(

)(

x

)(

x

)(

)(x

)(

)(x

)(

)(x

)(

)(x

)(

)()(

TTT

T

1

T

1

T

N

T

1

T

1

T

1

T

N

T

1T

xfx

xgxg

x

xf

x

xgxf

xf

xg

xg

xg

xf

xf

xfxg

xfxg

xgxf

xgxf

x

xgxf



4.2 Methoden

4.2.1 Nullstellensuche mittels Newton-Verfahren

Bei einer Nullstellensuche ist das folgende Problem ( ) zu lösen. Häufig findet man hierfür das Newton-

Verfahren. Hierfür wird ( ) durch eine Taylorreihe mit Abbruch nach dem linearen Glied approximiert.

( ) ( ) ( )

|

( )

Im Anschluss wir das Problem mit dieser Näherung erneut formuliert

( ) ( ) ( )

|

( ) ( ) ( )

( )

( ) ( )

( )

Danach wird der Punkt um den die Reihe entwickelt worden ist durch den alten Iterationsschritt xn-1 und die x

Variable durch den nächsten Iterationsschritt xn ersetzt:

Eingesetzt erhält man

( ) ( )

( )

Nach Umformung erhält man das Newton-Verfahren

( )

( )

( )

( )

Für das mehrdimensionale (N dimensional) Problem ( ) [

( ) ( )

( )

]

erhält man folgende Näherung nach Taylor (Abbruch nach dem linearen Glied) unter Verwendung der Jacobimatrix

(siehe Kap. 4.1) an der Stelle

( ) ( )

[ [ ( )

]

[ ( )

]

[ ( )

]

[ ( )

]

]

⏟ ( )

( ) ( ) ( ) ( )



mit ( ) ( ) [ ( )

]

( ) i = 1 … N

( ) ( ) ( ) ( ) ( ) ( ) [ ( )] ( )

[ ( )] ( )

mit

erhält man die Iterationsformel zu

[ ( )] ( )



4.2.2 Minimieren von Gütekriterien, Minimumsuche

Bei vielen Problemstellungen (adaptive Filter generell, Optimierung, Approximation) besteht die Notwendigkeit

eine skalare Güte I (Maß der Abweichung) zu minimieren bzw. allgemein ein Minimum zu suchen. Die Güte ist eine

Funktion von Parametern a1, a2, … , aM, die zu einem Parametervektor a zusammengefasst werden können:

I = f(a)

Die vorgestellten Gradientenverfahren finden nur das Minimum in der Nähe des Startwertes, bei mehreren Minima

wird daher nicht unbedingt das absolute Minimum (globales Minimum) gefunden.

Bei der Festlegung der Gütefunktion ist daher darauf zu achten, dass die Gütefunktion nur ein Minimum aufweist.

Soll das globale Minimum gefunden werden, so empfiehlt es sich ein Verfahren wie z.B. genetische Algorithmen

einzusetzen.

4.2.2.1 Methode des steilsten Abstiegs (steepest descent, gradient descent)

Das Minimum der der Güte I erhält man nach der Methode des steilsten Abstiegs durch folgende Iterationsformel

(siehe bezüglich Gradient

Kap. 4.1):

|

mit dem zeitveränderlichen Stepsizeparameter µn. Oft findet man auch bei quadratischen Gütekriterien:

|

Es existieren viele weitere Ansätze basierend auf der Methode des steilsten Abstiegs, die z.B.

die Stabilität

die Konvergenzgeschwindigkeit

verbessern sollen. In den meisten Fällen wird der Stepsizeparameter als konstant zu µ angenommen:

|

Für den skalaren Fall, bei dem die Güte nur von einem Parameter a abhängt erhält man folgende Iterationsformel:

|

Der Parameter a wird also entgegengesetzt dem Gradienten korrigiert.

: I(a) steigt für größer werdende Werte für a, das Minimum (sofern vorhanden)

liegt bei kleineren Werten für a, a muss also kleiner werden. Dies ist gewährleistet, da

.

: I(a) fällt für größer werdende Werte für a, das Minimum (sofern vorhanden)

liegt bei größeren Werten für a, a muss also größer werden. Dies ist gewährleistet, da

.



: Der momentane Wert für a repräsentiert

o ein Minimum: die Suche muss abgebrochen werden. Dies ist nur theoretisch erreichbar.

o ein Maximum: ein Minimum kann nicht gefunden werden. Dies ist möglich, wenn der Startwert

für a auf dieses Maximum initialisiert worden ist.

Je näher an am wahren Wert für a liegt, desto mehr verringert sich die Annäherungsgeschwindigkeit an den wahren

Wert für a, da der Gradient

in der Nähe des Minimums abnimmt.

In den meisten Fällen handelt es sich bei der Iterationsformel um ein nichtlineares zeitdiskretes

Zustandsraumsystem. Die Stabilität der Iteration kann daher nur über ein nichtlineares Stabilitätskriterium überprüft

werden. Der Schrittweitenparameter µn beeinflusst die Stabilität der Iterationsformel:

Wird µ = konstant zu klein festgelegt, so dauert die Iteration sehr lange.

Wird µ = konstant zu groß angenommen, so ergibt sich entweder ein unbedämpftes oszillierendes

Einschwingen um den wahren Wert oder eine instabile Iteration oder bei mehreren Minima wird eventuell

ein dazwischen liegendes Maximum übersprungen und ein falsches Minimum wird gefunden. Letzteres

kann auch geschehen, wenn a0 zu groß gewählt wird.

Bisher wurde für jeden zu schätzenden Parameter die gleiche Schrittweite verwendet. Ein bestimmtes µ kann für

einen Parameter eine langsame Konvergenz bedeuten für einen anderen Parameter zu einer instabilen Schätzung

führen. Kompromisse sind nicht in allen Fällen möglich. Daher kann für die Schätzung des Parameters ai ein eigenes

µi mit i = 1 … M zugeordnet werden. Hierfür wird der skalare Parameter µ durch die M x M Diagonalmatrix µ

ersetzt:

|

bzw.

|

mit ( )

[ ]

Die Methode des steilsten Abstiegs lässt sich auch als zeitkontinuierliches Zustandsraumsystem ausdrücken:

( )

( ) ∫

bzw.

( )

( ) ∫



-1.5 -1 -0.5 0 0.5 1 1.50.75

0.8

0.85

0.9

0.95

1

1.05

1.1

1.15

x

y

4.2.2.1.1 Beispiel: Minimumsuche Polynom (eindimensional)

Gegeben sei folgendes Polynom.

( ) 1

1

1

Gesucht werden die Minima, hierfür wird die erste Ableitung benötigt

( 1) 1

Extrema voraussichtlich bei x = -1, 0, 1

Ob ein Minima oder Maxima vorliegt erhält man über die zweite Ableitung

1

1

√

|

|

|

1

Es ergeben sich also Minima / Tiefpunkte für 1

Zur Minimasuche mittels der Methode des steilsten Abstiegs wird I = y(x) gesetzt und x wird als Parameter

interpretiert. Es ergibt sich aus:

|

die Iterationsformel:

( )

|

(

1)

Abgebrochen wird die Iteration, wenn der Betrag der Differenz | | eine Schwelle unterschreitet.



Datei stdesc_pol.m % Funktion deren Minimum zu finden ist

x = -1.5:0.01:1.5;

y = 1/4*x.^4 - 1/2*x.^2 + 1;

mu = 0.1; % Schrittweitenparameter µ

x0 = 1.5; % Startwert der Iteration

xn = x0; % Ersten Iterationswert auf Startwert initialisieren

d = inf; % Initialisiere Startwert Betrag der Differenz

close all;% Schliesse alle figures

% Iteration

while d > 1e-5 % Iteriere solange bis der Betrag der Differenz <= 1e-5

% Plotten der Funktion und des momentanen Iterationsschritts

plot(x,y,xn,1/4*xn^4 - 1/2*xn^2 + 1,'ro'); grid on;

pause(0.5);

% Iteration

dI_dx = xn*(xn^2-1); % Berechne Gradient dI/dx

xn1 = xn - mu*dI_dx; % Berechne nächsten Iterationsschritt

d = abs(xn1 - xn); % Berechne Betrag der Differenz

xn = xn1; % Alter Iterationsschritt = aktueller Iterationsschritt

end

xn

4.2.2.1.2 Beispiel: Minimumsuche Polynom (zweidimensional)

Gesucht wir das Minima der folgenden zweidimensionalen Funktion mit [ ] :

( ) ( 1) ( )

( ) ( )

Das Minimum liegt bei [1 ]

( )

|

[ ( )

( )

]

[ ( 1)

( )]

( [1 ]) bzw. (1 ) [

1 ]

Abgebrochen wird die Iteration, wenn der Betrag der Differenz | | eine Schwelle unterschreitet.

-10-5

05

10

-10

0

100

50

100

150

200

250

300

x1

x2

f(x

1,x

2)



Datei stdesc_pol2.m % Funktion deren Minimum zu finden ist

[X,Y] = meshgrid(-10:10,-10:10);

Z=(X-1).^2+(Y-2).^2;

mesh(X,Y,Z);

zlabel('f(x_1,x_2)'); ylabel('x_2'); xlabel('x_1');

mu = 0.1; % Schrittweitenparameter µ

x0 = [2; 1]; % Startwert der Iteration

xn = x0; % Ersten Iterationswert auf Startwert initialisieren

d = inf; % Initialisiere Startwert der Differenz

% Iteration

while d > 1e-5 % Iteriere solange bis die Differenz <= 1e-5

% Iteration

xn1 = xn - 2*mu*(xn-[1; 2]); % Berechne nächsten Iterationsschritt

d = sqrt((xn1 - xn)'*(xn1 - xn)); % Berechne Betrag der Differenz

xn = xn1 % Alter Iterationsschritt

% =

% aktueller Iterationsschritt

end



4.2.2.1.3 Änderung der Abtastzeit

Ausgehend von der zeitkontinuierlich Form der Methode des steilsten Abstiegs,

( )

die näherungsweise mittels vorwärts Euler mit der Abtastzeit Ta diskretisiert werden kann, erhält man aus:

( )

durch Einsetzen von

( )

( )

näherungsweise:

|

⏟

|

Das heißt, dass bei einer Änderung der Abtastzeit auch der Schrittweitenparameter angepasst werden muß, um

dieselbe Schätzdynamik zu erhalten.

|

mit:

Näherungsweise kann hierfür folgende Formel verwendet werden:

Einführung in MATLAB und Simulink - Hochschule Heilbronn · PDF fileEinführung in...

Documents

Transcript of Einführung in MATLAB und Simulink - Hochschule Heilbronn · PDF fileEinführung in...