Einführung in MATLAB und Simulink - Hochschule Heilbronn · PDF fileEinführung in...
Transcript of 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
MSc. Dipl.-Ing. (FH) U. Ingelfinger
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
MSc. Dipl.-Ing. (FH) U. Ingelfinger
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
MSc. Dipl.-Ing. (FH) U. Ingelfinger
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 2
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 3
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 4
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 5
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 6
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 7
>> 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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 8
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 9
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 10
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.
-
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 11
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 12
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 13
>> 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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 14
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 15
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 16
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 17
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 18
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 19
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 20
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 21
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 22
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 23
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 24
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 25
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 26
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 27
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 28
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 29
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 30
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 31
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 32
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 33
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 >>
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 34
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 35
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.
Befehlsbeschreibung Befehl(e)
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 36
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 37
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 38
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 39
1.9.2.3 Anpassung, Beschriftung des Koordinatensystems
Befehlsübersicht
Befehlsbeschreibung Befehl(e)
Ü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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 40
1.10 Eval
Die Funktion eval führt den übergebenen String als Befehl aus.
Beispiel:
string = input('Dateiname','s') eval (['load ',Dateiname,'.asc'])
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 41
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 42
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 43
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 44
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 45
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 46
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 47
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
+
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 48
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 49
Ü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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 50
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 51
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)
C Ausgangsmatrix (q, n)
D Durchgangsmatrix (q, 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
+
+
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 52
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 53
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 54
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 55
1.12.3.2 tf-Modell spezifische Eigenschaften
Die folgenden Eigenschaften (bis auf die Member Variable, ioDelay) sind rein tf-Modell spezifisch.
Membername Datentyp Aufgabe
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.
Membername Datentyp Aufgabe
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').
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 56
1.12.3.4 ss-Modell spezifische Eigenschaften
Die folgenden Eigenschaften sind rein ss-Modell spezifisch.
Membername Datentyp Aufgabe
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').
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 57
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’)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 58
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).
'tustin' Bilineare Transformation (Tustin).
'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).
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 59
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).
'tustin' Bilineare Transformation (Tustin).
'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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 60
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 61
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 62
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 63
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 64
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 65
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 66
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 67
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:
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 68
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).
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 69
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 70
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 71
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 72
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 73
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).
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 74
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 75
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 76
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 77
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“:
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 78
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 …”.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 79
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 80
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 81
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 82
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 83
Ü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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 84
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 𝒙𝟎
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 85
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
𝑠 𝒉(𝒙 𝒖 𝑡) 𝒚
��
𝒙𝟎
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 86
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 87
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 88
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)
+ +
+ +
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 89
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 90
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 91
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 92
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 93
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 94
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 95
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 96
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 97
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 98
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 99
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 100
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(
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 101
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 102
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 103
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
0cosmkcosmsinmxcxdxmm bb
2
baaaba
eingesetzt.
Einsetzen von
cosxksin
g a in
0cosmkcosmsinmxcxdxmm bb
2
baaaba
ergibt
2
b
a
b
aa2
a
sinm
m
m
xcxdcosgsin
x
Einsetzen von
cos
ksingxa
in
0cosmkcosmsinmxcxdxmm bb
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 104
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 105
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 106
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 107
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 108
Subsystem Pendel II
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 109
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 110
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:
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 111
Implementierung in Simulink (Subsystem Pendel II b)
Öffnen des Subsystems Pendel II b durch doppelclick oder Selektion im Modelbrowser
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 112
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:
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 113
Implementierung in Simulink (Subsystem Pendel II c)
Subsystems Pendel II c
Quelltext Matlab Function
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 114
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
+ +
+
+ +
+
+ +
+
+ +
+
+
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 115
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 116
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.
Simulationsergebnisse
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'. ......
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 117
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
𝑤𝑘 𝑤 𝑘 𝑢 𝑘 𝑢𝑘
𝑦𝑘 𝑦 𝑘
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 118
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 119
Die zweite Alternative ist im Simulink-Modell modelle\discrete\pi_diskret.slx implementiert.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 120
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)
C Ausgangsmatrix (q, n)
D Durchgangsmatrix (q, 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
+
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 121
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 122
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 123
Simulinkmodell Variante I
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 124
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 125
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 126
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 127
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 128
Ü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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 129
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 130
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 131
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 132
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 133
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 134
Ü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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 135
Simulationsergebnisse
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 136
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 137
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 138
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 139
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 140
>> 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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 141
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 142
'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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 143
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 144
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 145
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 146
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 147
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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 148
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 149
1.0e+006 * 0.0335 -2.5816
Simulinkmodell (die Anfangswerte des Beobachters weichen von 0 ab)
Prozess
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 150
Beobachter
Simulationsergebnisse
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 151
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 152
KB = 1.0e+006 * 0.0333 -2.5462
Simulinkmodell
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 153
Simulationsergebnis
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 154
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 155
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 156
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 157
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
( ) ( )
[ [ ( )
]
[ ( )
]
[ ( )
]
[ ( )
]
]
⏟ ( )
( ) ( ) ( ) ( )
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 158
mit ( ) ( ) [ ( )
]
( ) i = 1 … N
( ) ( ) ( ) ( ) ( ) ( ) [ ( )] ( )
[ ( )] ( )
mit
erhält man die Iterationsformel zu
[ ( )] ( )
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 159
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
.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 160
: 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.
( )
( ) ∫
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 161
-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.
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 162
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)
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 163
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
Einführung in MATLAB und Simulink
MSc. Dipl.-Ing. (FH) Uwe Ingelfinger 12.06.14 164
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: