Folien Control

MATLAB Control System Toolbox
MATLAB
Control System Toolbox
Vorlesung Matlab/Simulink
Dipl.-Ing. U. Wohlfarth 1
Umfang
• Beschreibung linearer, zeitinvarianter Systeme (LTI):
– zeitkontinuierlich und zeitdiskret

– Single–Input/Single–Output (SISO) und
Multiple–Input/Multiple–Output (MIMO)
• Umwandeln und Bearbeiten der Systeme
• Analysieren der Systemeigenschaften
• Entwurf und Optimierung von Reglern
Beschreibung von LTI-Systemen
Beschreibung
linearer, zeitinvarianter
Systeme (LTI-Systeme)
Lineare, zeitinvarianter Systeme (LTI–Modelle)
Parametrische Beschreibung
• Übertragungsfunktion/Transfer Function (TF)
• Nullstellen–Polstellen–Darstellung/Zero–Pole–Gain (ZPK)
• Zustandsdarstellung/State–Space (SS)
Nichtparametrische Beschreibung
• Frequenzgang–Daten–Modelle/Frequency Response Data (FRD)
Übertragungsfunktion/Transfer Function (TF)
• Übertragungsverhalten im Laplace–Bereich
• Rationale Funktion in s:
num(s) am sm + am−1 sm−1 + . . . + a1 s + a0

h(s) = =
den(s) bn sn + bn−1 sn−1 + . . . + b1 s + b0
Zählerpolynom num und Nennerpolynom den
Zählerordnung m und Nennerordnung n
TF–SISO–Übertragungsfunktion erstellen
1. Befehl tf(num, den): num und den als Vektoren

mit Koeffizienten von s in absteigender Reihenfolge.
>> h = tf([2 -3],[1 1])
2. Rationale Funktion in s
a) Definieren von s als TF–System

>> s = tf(’s’)
b) Übertragungsfunktion als rationale Funktion in s

>> h = (s+2) / (s^2 + 5*s + 4)
TF–MIMO–Übertragungsfunktion
• zweidimensionale N y×N u–Matrix H von SISO–TF:

 num num12 
  11
h11 h12  den11 den12 
   
H =   =  
 
h21 h22  num21 num22 
den21 den22
• Matrixelement hij : Übertragungsfunktion vom

Eingang j zum Ausgang i
• N y Zeilen =
c Ausgänge, N u Spalten =
c Eingänge
TF–MIMO–Übertragungsfunktion erstellen
1. Definieren der einzelnen SISO–TF:
a) Befehl tf(num, den) / rationale Funktion in s

b) Matrix H definieren
2. Befehl tf(NUM,DEN): Cell Array NUM für Zähler-

polynome und DEN für Nennerpolynome (N y×N u)
   
num11 num12 den11 den12
   
NUM =   DEN =  
num21 num22 den21 den22
Null-/Polstellen–Darstellung/Zero–Pole–Gain (ZPK)
• Übertragungsverhalten im Laplace–Bereich
• Rationale Funktion in s mit Nullstellen und Polstellen:
(s − z1) · . . . · (s − zm−1) · (s − zm)

h (s) = k ·
(s − p1) · . . . · (s − pn−1) · (s − pn)
k Verstärkungsfaktor (reell)
z1 , . . . , z m Zähler–Nullstellen (reell/konj. komplex)
p1 , . . . , p m Nenner–Nullstellen (reell/konj. komplex)
ZPK–SISO–Übertragungsfunktion erstellen
1. Befehl zpk (z,p,k): Nullstellenvektor z , Polstel-

lenvektor p und Verstärkungsfaktor k .
>> h = zpk([-6 1 1],[-5 1],3)
2. Rationale Funktion in s
a) Definieren von s als ZPK–System

>> s = zpk(’s’)
b) Übertragungsfunktion als rationale Funktion in s

>> h = 2 * 1 / ((s-1)*(s+2))
ZPK–MIMO–Übertragungsfunktion
• zweidimensionale N y×N u–Matrix H von SISO–ZPK:

 z11 z12 
  k · k12 ·
h11 h12  11 p11 p12 
 
   
H =   = 



h21 h22  z21 z22 
k21 · k22 ·
p21 p22
• Matrixelement hij : Übertragungsfunktion vom

Eingang j zum Ausgang i
• N y Zeilen =
c Ausgänge, N u Spalten =
c Eingänge
ZPK–MIMO–Übertragungsfunktion erstellen
1. Definieren der einzelnen SISO–ZPK:
a) Befehl zpk(z,p,k) / rationale Funktion in s

b) Matrix H definieren
2. Befehl zpk (Z,P,K): Cell Array Z für Nullstellen-

polynome und P für Polstellenpolynome (N y × N u),
N y×N u–Matrix K der Verstärkungsfaktoren
     
z11 z12 p11 p12 k11 k12
Z =   P =   K =  
z21 z22 p21 p22 k21 k22
Zustandsdarstellung/State–Space (SS)
DGL 1. Ordnung für jedes Speicherelement (Integrator)
⇒ n DGLs 1. Ordnung statt eine DGL n–ter Ordnung
Zustands–DGL: x: Zustandsvektor (N x×1)

u: Eingangsvektor (N u×1)
ẋ = A x + B u y: Ausgangsvektor (N y×1)
A: Zustandsmatrix (N x×N x)
Ausgangsgleichung: B: Eingangsmatrix (N x×N u)
C: Ausgangsmatrix (N y×N x)
y = Cx + Du D: Durchschaltmatrix (N y×N u)
SS–Modell erstellen
• Befehl ss(A,B,C,D):
   
" # " # 0 1 0 0
1 2 1 1    
A= B= C = 1 2 

 D = 0 0 


3 4 0 1
3 1 0 0
>> ss([1 2 ; 3 4],[1 1 ; 0 1],[0 1 ; 1 2 ; 3 1],0)
• Durchschaltanteil oft 0: D = 0
• SISO–Systeme: u→u y→y B→b C → cT
Frequenzgang–Daten–Modelle (FRD)
• Frequenz–Daten aus Messung oder Simulation
• Sinus–Anregung: y(t) = | G(ω) | · sin (ωt + ϕ(ω))
⇒ y(t) phasenverschoben und amplitudenmoduliert
• Frequenzgangfunktion: F (jω) = | F (jω) | · e j ϕ(ω)
r
Betrag: | F (jω) | = Re{F (jω)}2 + Im{F (jω)}2
Im{F (jω)}
Phase : ϕ(ω) = arctan
Re{F (jω)}
Frequenzgang–Daten–Modelle erstellen
• Befehl frd(ant, f req, eh):
ant Vektor mit den komplexen Frequenzantworten

f req Vektor mit gespeicherten Frequenzen
eh Einheit der Frequenz (’rad/s’ oder ’Hz’)
• Beispiel: >> freq = [0.01 0.1 1 10 100 1000 10000] ;

>> ant = (1-j*freq) ./(1+freq.^2)
>> sysfrd = frd(ant,freq,’Units’,’rad/s’)
• MIMO–System: ant ist Tensor (N y×N u×Nf )
Zeitdiskrete Modelle
• Zusätzlicher Parameter: Abtastzeit Ts
tf(num,den,Ts) zpk(z,p,k,Ts)
ss(a,b,c,d,Ts) frd(ant,freq,Ts)
• Abtastzeit unspezifiziert: Ts = -1
• DSP–Format: h = filt ([1 -0.5],[1 1 -2],0.01)
• Zustandsdarstellung: x(k + 1) = A x(k) + B u(k)
y(k) = C x(k) + D u(k)

Zeitverzögerungen
Zeitkontinuierlich:
• Zwischen Ein- und Ausgängen (TF, ZPK, FRD):

set(sys,’IODelay’,Td)
• Am Ein- oder Ausgang (SS):

set(sys,’InputDelay’,Tde)
set(sys,’OutputDelay’,Tda)
Zeitdiskret:
• Pade-Approximation: pade(sys,n)
Umwandeln und Bearbeiten von LTI–Modellen
Umwandeln und Bearbeiten
von LTI–Modellen
LTI–Objekte
• LTI–Modelle gespeichert als Cell Arrays mit vordefi-

nierten Modell–Eigenschaften und ihren Werten
• Allgemeine Modell–Eigenschaften:
Ts, InputDelay, OutputDelay, ioDelayMatrix, InputName,
OutputName, InputGroup, OutputGroup, Notes, Userdata
• Modellspezifische Modell–Eigenschaften:
TF: num, den, Variable (s, p; z, q, z^-1)
ZPK: z, p, k, Variable (s, p; z, q, z^-1)
SS: a, b, c, d, StateName
FRD: Frequency, ResponseData, Units
Modell–Eigenschaften setzen, ändern und abrufen
• Setzen und Ändern von Modell–Eigenschaften:

– direkt: sys = tf(. . .,’EigN ame’,EigW ert)
– Befehl set: set(sys,’EigN ame’,EigW ert,. . .)
– “.“–Befehl: sys.EigN ame = EigW ert
• Abrufen von Modell–Eigenschaften:

– Befehl get: get(sys,’EigN ame’)
– “.“–Befehl: sys.EigN ame
• Schnellabfrage: tfdata, zpkdata, ssdata, frddata
Rangfolge und Vererbung von Modell–Eigenschaften
• Vorrangliste: FRD > SS > ZPK > TF
• Umwandeln: – vorher: sys = systf + tf(sysss)
– nachher: sys = tf(systf + sysss)
• Vererbung von Modell–Eigenschaften
– Diskret: alle Abtastzeiten gleich bzw. unspezifiziert
– Variable Variable: ¦ kont.: p > s
¦ diskret: z^-1 > q > z

Umwandlung von Modell–Typen
• Explizite Umwandlung: Übergabe des Systems an

Befehle tf(sys), ss(sys), zpk(sys) oder frd(sys,freq)
• Umwandlung mit MATLAB–Befehlen:
zp2tf(z,p,k) tf2zp(num,den) tf2ss(num,den)
ss2tf(A,B,C,D,iu) ss2zp(A,B,C,D,i) zp2ss(z,p,k)
• Automatische Umwandlung: Operationen wandeln

Modelle automatisch in benötigten Modelltyp um
Arithmetische Operatoren
• Addition und Subtraktion: Parallelschaltung
y = G1 · u + G 2 · u ⇔ sys = sys1 + sys2
• Multiplikation: Reihenschaltung
y = G1 · v = G1 · (G2 · u) ⇔ sys = sys1 * sys2
• Matrix-Inversion: u = G−1y ⇔ sys = inv(sys)
• links- und rechtsseitige Matrix–Division:
G1−1G2 ⇔ sys1 \ sys2 G1G2−1 ⇔ sys1 / sys2
Extrahieren und Ändern von LTI–Modellen
• Ansprechen der Ein- und Ausgänge mit sys(i,j)
• Teilsystem: – extrahieren: subsys = systf(1,2)
– ändern: systf(2,1) = subsys
• Ein-/Ausgänge:
– löschen: systf(:,1) = []
– hinzufügen: systf = [systf,sys] (Typ nach Rang)
systf(:,2) = sys (Typ systf)

Verknüpfen von LTI–Modellen
• Horizontal: sys = [ sys1 , sys2 ]
• Vertikal: sys = [ sys1 ; sys2 ]
• Diagonal: sys = append(sys1,sys2)
• Parallel und seriell:
sys = parallel(sys1,sys2,in1,in2,out1,out2)
sys = series(sys1,sys2,outputs1,inputs2)
• Rückkopplung: sys = feedback(sys1,sys2)
Zeitkontinuierliche und zeitdiskrete Systeme
• Kontinuierlich → diskret: sysd = c2d(sysc,Ts)
Diskret → kontinuierlich: sysc = d2c(sysd,methode)
• Diskretisierung: – Halteglied 0. Ordnung: zoh

– Halteglied 1. Ordnung: foh
– Tustin–Approximation: tustin
• Diskretisierung verzögerter Systeme
• Geänderte Abtastzeit: sys = d2d(sys,Ts)
Analyse der Systemeigenschaften
Analyse der
Systemeigenschaften
Übersicht
• Allgemeine Eigenschaften
• Modell–Dynamik
• Systemantwort im Zeitbereich
• Systemantwort im Frequenzbereich
• Ordnungsreduktion
• Zustandsbeschreibungen
Allgemeine Eigenschaften
• Überprüfung und Abfrage von durch MATLAB

bestimmte Systemeigenschaften
• Nützlich für die Programmierung komplexer Skripts

und Funktionen:
– Auswerteroutinen
– Komplexe Plots erstellen
• Systemeigenschaften oder Boolsche Werte (ja/nein)

als Rückgabewerte
Modelltyp, Zeitdaten, Struktur, Größe
• Modelltyp: – ausgeben: class(sys)

– prüfen: isa(sys,’classname’)
• Zeitdaten: – zeitkontinuierlich: isct(sys)

– zeitdiskret: isdt(sys)
– Verzögerungen: hasdelay(sys)
• Struktur: – Ein- & Ausgänge: isempty(sys)

– Ordnung: isproper(sys)
– SISO–Modell: issiso(sys)
• Größe: size(sys)
Modell–Dynamik
• Stationäre (Gleich–)Verstärkung: dcgain(sys)
– Frequenz ist s = 0 bzw. z = 1
– Reine Integratoren: Verstärkung ∞
• Natürliche Frequenzen und Dämpfungen: damp(sys)
– Pole: pi = α ± j β
q
– Frequenzen: ωn = α2 + β 2
α
– Dämpfungen: D = − q
α2 + β 2
Nullstellen und Pole eines LTI–Modells
• Nullstellen: zero(sys)
• Polstellen: – Eigenwerte der Matrix A: pole(sys)

– Wurzeln des Polynoms c: roots(c)
• Sortieren: – zeitkontinuierlich: [s,ndx] = esort(p)

– zeitdiskret: [s,ndx] = dsort(p)
• Null–Polstellen–Verteilung: [p,z] = pzmap(sys)
Linien gleicher Dämpfung und natürlicher Frequenz:

– kontinuierlich: sgrid
– zeitdiskret: zgrid
Systemantwort im Zeitbereich
• Systemantwort kontinuierlich/diskret:
Zt µ ¶
y(t) = CeAtx0 + CeA(t−τ )B + D u(τ ) dτ
τ =0
X µ
k−1 ¶
y[k] = CAk x0 + CAk−i−1B + D u[i]
i=0
• Befehlsaufruf: [y,t,x] = bef ehl(sys,par)
• Zeitvektor: t = 0:dt:Tf
• Ausgang y: – SIMO: length(t) × N y

– MIMO: length(t) × N y × N u
Freie Bewegung, Impuls- und Sprungantwort
• Freie Bewegung: [y,t,x] = initial(sys,x0,[,t])

– Eingänge zu Null gesetzt
– Anfangswerte des Zustandsvektors x0
• Impulsantwort: [y,t,x] = impulse(sys[,t])

– zeitkontinuierlich: Dirac–Impuls δ(t)
– zeitdiskret: Einheitsimpuls δ[k]
• Sprungantwort: [y,t,x] = step(sys[,t])

– zeitkontinuierlich: Einheitssprung σ(t)
– zeitdiskret: Folge von δ[k]
Systemantwort auf Testsignal
• Systemantwort: [y,t,x] = lsim(sys,u,t,[,x0])
– beliebiger Eingangssignalvektor u
– lsim wählt automatisch passende Abtastzeit dt
• Testsignal: [u,t] = gensig(typ,tau[,Tf ,T s])
– typ : ’sin’ Sinus – tau : Periodendauer

’pulse’ Pulse – Tf : Gesamtdauer
’square’ Rechteck – Ts : Abtastzeit
Systemantwort im Frequenzbereich
Frequenzgang: Komplexe Antwort auf sinusförmige An-

regung im eingeschwungenen Zustand
Voraussetzung: System asymptotisch stabil, d.h. Real-
teile aller Eigenwerte kleiner null
Frequenzgang–ÜF: F (jω) = | F (jω) | · e j ϕ(ω)

r
Betrag: | F (jω) | = Re{F (jω)}2 + Im{F (jω)}2
Im{F (jω)}
Phase : ϕ(ω) = arctan
Re{F (jω)}
Frequenzantwort und Bode–Diagramm
• Frequenzantwort berechnen:
– Einzelne Frequenz f : f rsp = evalfr(sys,f )
– Frequenzvektor w: H = freqresp(sys,w)
• Bode–Diagramm: [mag,phase,w] = bode(sys)
– Frequenzvektor ω (w) als logarithmische x-Achse
– Amplitudengang |F (jω)| (mag) doppeltlogarithmisch
– Phasengang ϕ(ω) (phase) halblogarithmisch
Amplituden- und Phasenrand
• Befehl [Gm,P m,Wcg,Wcp] = margin(sys)
Amplitudenrand Gm, Phasen–Durchtrittsfrequenz Wcg

Phasenrand P m, Amplituden–Durchtrittsfrequenz Wcp
Stabilität für: ω A < ωϕ FR > 1 ϕR > 0
• Struktur stabil = allmargin(sys)
Amplitudenrand: GainMargin und GMFrequency

Phasenrand: PhaseMargin und PMFrequency
Totzeitrand: DelayMargin und DMFrequency
Stabilität: Stable, 1 bei Stabilität, 0 sonst.
Plot des Bode–Diagramms
Bode Diagram
Gm = 6.0218 dB (at 1.7322 rad/sec), Pm = 27.142 deg (at 1.2328 rad/sec)
20
Magnitude (dB)
−20
−40
−60
0
Phase (deg)
−90
−180
−270
−1 0 1
10 10 10
Frequency (rad/sec)
Nyquist–Diagramm
• Nyquist–Diagramm: [re,im,w] = nyquist(sys)

Real- und Imaginärteil der Übertragungsfunktion des
offenen Regelkreises von ω = 0 bis ∞ (Ortskurve):
Z0(jω) −jωTt
−F0(jω) = ·e ; n0 > m0 , Tt ≥ 0
N0(jω)
ω=+∞
• Stabilität: ∆ φsoll = nr · π + na · π2
ω=+0
nr , na: Anzahl in- bzw. grenzstabiler Pole
• Kritischer Punkt: −1 + j 0
Plot des Nyquist–Diagramms
Nyquist Diagram
2
Imaginary Axis
−1
−2
−3
−2 −1 0 1 2 3 4
Real Axis
LTI–View
GUI für LTI–Systeme
Import und Export von

Systemen
Start mit: >> ltiview
Beobachtbarkeit
• Beobachtbarkeitsmatrix: obsv(A,C)
· ¸T
– Ob = CT AT CT (AT )2CT . . . (AT )n−1CT
– Rang(Ob) =
c Anzahl der beobachtbaren Zustände
• Beobachtbarkeitsform: obsvf(A,B,C,[tol])
– Transformation: A = TATT , B = TB , C = CTT

– Transformiertes System:
   
· ¸
 Ano A12   Bno 
A =   B =   C = 0 Co
0 Ao Bo
Steuerbarkeit
• Steuerbarkeitsmatrix: ctrb(A,B)
· ¸
– Co = B AB A2 B . . . An−1B
– Rang(Co) =
c Anzahl der steuerbaren Zustände
• Steuerbarkeitsform: ctrbf(A,B,C,[tol])
– Transformation: A = TATT , B = TB , C = CTT

– Transformiertes System:
   
· ¸
 Anc 0   0 
A =   B =   C = Cnc Cc
A21 Ac Bc
Entwurf und Optimierung von Reglern
Entwurf und Optimierung

von Reglern
Übersicht
• Wurzelortskurvenverfahren
• Interaktiver Reglerentwurf mit dem SISO Design Tool
• Polplazierung in Verbindung mit

Zustandsrückführung und Zustandsbeobachtung
• Linear–quadratisch optimale Regelung
• Kalman–Filter als Zustandsbeobachter

für verrauschte Signale
Reglerentwurf mit Wurzelortskurvenverfahren
• Wurzelortskurve: Verhalten der Pole des geschlosse-

nen Regelkreises in Abhängigkeit des Rückführverstär-
kungsfaktors k in der komplexen Null–Polstellen–Ebene
• Übertragungsfunktion offener Regelkreis

nR nS nM
− G0 = k · G R · GS · GM = k·
dR dS dM
• Pole von G0 = Wurzeln des Nennerpolynoms von G
d0 + k · n 0 = d R dS dM + k · n R nS nM = 0
Befehle zum Wurzelortskurvenverfahren
• Wurzelortskurve:
u y
rlocus(sys[,k]) - i
6
-
GR -
GS t -
−
[r,k] = rlocus(sys)
k ¾
GM ¾
r = rlocus(sys,k)
• Verstärkungsfaktoren interaktiv auslesen:
[k,r] = rlocfind(sys)
[k,r] = rlocfind(sys,p)
SISO Design Tool
SISO Design Tool
Reglerentwurf mit:
• Bode-Diagramm
• WOK–Verfahren
Start mit:
sisotool (sys)
Zustandsregelung
Vollständige Zustandsrückführung mit Rückführmatrix K

-
D
Strecke: w- hu s - ẋ Z
xs y
- h - - ? -
- h
6
B 6
C
ẋ = Ax + Bu −
¾
A s
y = Cx + Du K ¾
Regelgesetz (w = o): u = −Kx
Geschlossener Regelkreis: ẋ = (A − B K) · x
Zustandsbeobachtung - Luenberger–Beobachter
Rückführung des Ausgangsfehlers über L

-
D
Beobachter: u ẋ Z
xs y
s - - h - - ? -
- h
B 6
C
x̂˙ = A x̂ + B u + L e
¾
A
ŷ = C x̂ + D u ¾
e ?
L h
6
−
Z
s - - ?
x̂˙
h -
x̂s -
ŷ
- h -
Ausgangsfehler: B 6
C 6
e = y − ŷ = C (x − x̂) A
-
D
Polplazierung
• Polplazierung: Rückführmatrix K so berechnen, daß

Pole des geschlossenen Regelkreis den Polen eines vor-
gegebenen Wunschpolynoms entsprechen.
• Zustandsregler–Rückführvektor k/Rückführmatrix K
k = acker(A,b,p)
K = place(A,B,p)
[K,prec,message] = place(A,B,p)
• Zustandsbeobachter–Rückführmatrix L
L = acker(A’,c’,p) .’
L = place(A’,C’,p) .’
Zustandsregler und Zustandsbeobachter erstellen
• Zustandsbeobachter erstellen
est = estim(sys,L)
est = estim(sys,L,sensors,known)
• Zustandsregler mit Zustandsbeobachter erstellen

rsys = reg(sys,K,L)
rsys = reg(sys,K,L,sensors,known,controls)
-
ud (known)- est x̂ - u-
−K t
y (sensors) - (L)
Linear–quadratisch optimale Regelung
• Minimierung eines quadratischen Gütekriteriums:

(Q gewichtet Zustände, R gewichtet Eingänge)
Z∞ µ ¶
J (x, u) = xT Q x + uT R u + 2 xT N u dt
t=0
• Algebraische Matrix–Riccati–Gleichung lösen
0 = AT S + S A − ( S B + N ) R−1 ( BT S + NT ) + Q
• Rückführmatrix: K = R−1 ( BT S + NT )
LQ–optimierte Regler–Rückführmatrix K
• LQ–optimierte Regler–Rückführmatrix K
[K,S,e] = lqr(A,B,Q,R[,N ])
[K,S,e] = dlqr(A,B,Q,R[,N ])
[Kd,S,e] = lqrd(A,B,Q,R[,N ],T s)
[K,S,e] = lqry(sys,Q,R[,N ])
• Befehl lqrd: Abtastzeit T s
• Befehl lqry:
Z∞ µ ¶
J (y, u) = yT Q y + uT R u + 2 yT N u dt
t=0
Probleme der numerischen Darstellung
Probleme der
numerischen Darstellung
Numerische Mathematik
• Algorithmen zur näherungsweisen Lösung mathemati-

scher Probleme, z.B. aus Mathematik, Naturwissen-
schaft, Technik, ...
• Bewertung der Lösungsverfahren nach verschiedenen

Kriterien, z.B.
– Rechenaufwand und -geschwindigkeit

– Speicherplatzbedarf
– Fehleranalyse
Fehlerbegriffe in der numerischen Mathmatik
• Fehlerklassen:
1. Datenfehler/Eingangsfehler → Konditionierung
2. Verfahrensfehler → unvollständige Modellierung
3. Rundungsfehler → numerische Instabilität
• Absoluter Fehler εk und relativer Fehler δk :
xk − x̃k
εk = xk − x̃k δk =
xk
Exakte Werte xk und Näherungswerte x̃k mit 1 ≤ k ≤ n

Kondition eines Problems — Natürliche Instabilität
• Auswirkung von Datenfehlern auf Ergebnisse:

Änderungen
Kondition
Eingangsdaten → Ergebnisse
gut geringe → geringe
schlecht geringe → große
• Konditionszahlen: – Matrix–Inversion: cond(A[,p])

condest(A)
– Eigenwerte: condeig(A)
• Faustregeln:
– Verlorene Dezimalstellen log10(cond (A))
– schlecht konditioniert cond(A) >> 1/sqrt(eps)
Numerische Instabilität
• Auswirkungen des Lösungsalgorithmus auf Ergebnis

• Stellen für Gleitkomma–Zahlen begrenzt
→ Rundung der Ergebnisse
,→ Auslöschung von Stellen bei Berechnung
,→ Fehlerfortpflanzung
• Multiplikation und Division: gutartig
• Addition und Subtraktion:
gutartig, bei gleichem/entgegengesetztem Vorzeichen
bößartig, bei entgegengesetztem/gleichem Vorzeichen
und ungefähr gleich großen Zahlenwerten
Bewertung der LTI–Modelle
• Zustandsdarstellung (SS)
– Grundsätzlich am Besten geeignet!
– Algorithmen oft für SS–LTI–Modelle implementiert
• Übertragungsfunktion (TF)
– Nur für Systeme niedriger Ordnung (< 10)
– Oft schlecht konditioniert
• Nullstellen–Polstellen–Darstellung (ZPK)
– Meist besser als TF–LTI–Modell
– Probleme: mehrfache Polstellen/Polstellen bei Null
Empfehlung zur Programmierung
• Modelle möglichst als SS–LTI–Modell beschreiben.
Hierbei möglichst eine normierte bzw. austarierte Be-

schreibung bei verwenden.
• Konvertierungen zwischen Modelltypen vermeiden.
• Ergebnisse auf ihre Verläßlichkeit und Realitätsnähe

überprüfen.
Wichtigste Ingenieuraufgabe!

Folien Control

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Folien Control

Hochgeladen von

Copyright:

Verfügbare Formate

MATLAB Control System Toolbox

Control System Toolbox

• Beschreibung linearer, zeitinvarianter Systeme (LTI):

– zeitkontinuierlich und zeitdiskret

• Umwandeln und Bearbeiten der Systeme

• Analysieren der Systemeigenschaften

• Entwurf und Optimierung von Reglern

• Übertragungsfunktion/Transfer Function (TF)

• Frequenzgang–Daten–Modelle/Frequency Response Data (FRD)

num(s) am sm + am−1 sm−1 + . . . + a1 s + a0

Zählerpolynom num und Nennerpolynom den

Zählerordnung m und Nennerordnung n

1. Befehl tf(num, den): num und den als Vektoren

>> h = tf([2 -3],[1 1])

a) Definieren von s als TF–System

b) Übertragungsfunktion als rationale Funktion in s

• zweidimensionale N y×N u–Matrix H von SISO–TF:

• Matrixelement hij : Übertragungsfunktion vom

1. Definieren der einzelnen SISO–TF:

a) Befehl tf(num, den) / rationale Funktion in s

2. Befehl tf(NUM,DEN): Cell Array NUM für Zähler-

• Rationale Funktion in s mit Nullstellen und Polstellen:

(s − z1) · . . . · (s − zm−1) · (s − zm)

z1 , . . . , z m Zähler–Nullstellen (reell/konj. komplex)

p1 , . . . , p m Nenner–Nullstellen (reell/konj. komplex)

1. Befehl zpk (z,p,k): Nullstellenvektor z , Polstel-

>> h = zpk([-6 1 1],[-5 1],3)

a) Definieren von s als ZPK–System

b) Übertragungsfunktion als rationale Funktion in s

• zweidimensionale N y×N u–Matrix H von SISO–ZPK:

• Matrixelement hij : Übertragungsfunktion vom

1. Definieren der einzelnen SISO–ZPK:

a) Befehl zpk(z,p,k) / rationale Funktion in s

2. Befehl zpk (Z,P,K): Cell Array Z für Nullstellen-

DGL 1. Ordnung für jedes Speicherelement (Integrator)

⇒ n DGLs 1. Ordnung statt eine DGL n–ter Ordnung

Zustands–DGL: x: Zustandsvektor (N x×1)

>> ss([1 2 ; 3 4],[1 1 ; 0 1],[0 1 ; 1 2 ; 3 1],0)

• SISO–Systeme: u→u y→y B→b C → cT

• Frequenz–Daten aus Messung oder Simulation

• Sinus–Anregung: y(t) = | G(ω) | · sin (ωt + ϕ(ω))

⇒ y(t) phasenverschoben und amplitudenmoduliert

• Frequenzgangfunktion: F (jω) = | F (jω) | · e j ϕ(ω)

• Befehl frd(ant, f req, eh):

ant Vektor mit den komplexen Frequenzantworten

• Beispiel: >> freq = [0.01 0.1 1 10 100 1000 10000] ;

• MIMO–System: ant ist Tensor (N y×N u×Nf )

• Zusätzlicher Parameter: Abtastzeit Ts

• DSP–Format: h = filt ([1 -0.5],[1 1 -2],0.01)

• Zustandsdarstellung: x(k + 1) = A x(k) + B u(k)

y(k) = C x(k) + D u(k)

• Zwischen Ein- und Ausgängen (TF, ZPK, FRD):

• Am Ein- oder Ausgang (SS):

Umwandeln und Bearbeiten

• LTI–Modelle gespeichert als Cell Arrays mit vordefi-

• Setzen und Ändern von Modell–Eigenschaften:

• Abrufen von Modell–Eigenschaften:

• Schnellabfrage: tfdata, zpkdata, ssdata, frddata

• Vorrangliste: FRD > SS > ZPK > TF

• Umwandeln: – vorher: sys = systf + tf(sysss)

– nachher: sys = tf(systf + sysss)

• Vererbung von Modell–Eigenschaften

– Diskret: alle Abtastzeiten gleich bzw. unspezifiziert

– Variable Variable: ¦ kont.: p > s