matlab control system toolbox - eal.ei.tum.de · matlabcontrolsystemtoolbox...

MATLAB Control System Toolbox

MATLAB

Control System Toolbox

Lehrstuhl fur Elektrische Antriebssysteme und Leistungseelektronik

Simulation mit Matlab/Simulink 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

• Ubertragungsfunktion/Transfer Function (TF)

• Nullstellen–Polstellen–Darstellung/Zero–Pole–Gain (ZPK)

• Zustandsdarstellung/State–Space (SS)

Nichtparametrische Beschreibung

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




Ubertragungsfunktion/Transfer Function (TF)

• Ubertragungsverhalten im Laplace–Bereich

• Rationale Funktion in s:

h(s) =num(s)

den(s)=

am sm + am−1 sm−1 + . . . + a1 s + a0

bn sn + bn−1 sn−1 + . . . + b1 s + b0

Zahlerpolynom num und Nennerpolynom den

Zahlerordnung m und Nennerordnung n




TF–SISO–Ubertragungsfunktion 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) Ubertragungsfunktion als rationale Funktion in s

>> h = (s+2) / (s^2 + 5*s + 4)




TF–MIMO–Ubertragungsfunktion

• zweidimensionale Ny×Nu–Matrix H von SISO–TF:

H =

h11 h12

h21 h22

=

num11

den11

num12

den12

num21

den21

num22

den22

• Matrixelement hij: Ubertragungsfunktion vom

Eingang j zum Ausgang i

• Ny Zeilen = Ausgange, Nu Spalten = Eingange




TF–MIMO–Ubertragungsfunktion 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 fur Zahler-

polynome und DEN fur Nennerpolynome (Ny×Nu)

NUM =

num11 num12

num21 num22

DEN =

den11 den12

den21 den22




Null-/Polstellen–Darstellung/Zero–Pole–Gain (ZPK)

• Ubertragungsverhalten im Laplace–Bereich

• Rationale Funktion in s mit Nullstellen und Polstellen:

h (s) = k ·(s− z1) · . . . · (s− zm−1) · (s− zm)

(s− p1) · . . . · (s− pn−1) · (s− pn)

k Verstarkungsfaktor (reell)

z1, . . . , zm Zahler–Nullstellen (reell/konj. komplex)

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




ZPK–SISO–Ubertragungsfunktion erstellen

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

lenvektor p und Verstarkungsfaktor 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) Ubertragungsfunktion als rationale Funktion in s

>> h = 2 * 1 / ((s-1)*(s+2))




ZPK–MIMO–Ubertragungsfunktion

• zweidimensionale Ny×Nu–Matrix H von SISO–ZPK:

H =

h11 h12

h21 h22

=

k11 ·z11

p11k12 ·

z12

p12

k21 ·z21

p21k22 ·

z22

p22

• Matrixelement hij: Ubertragungsfunktion vom

Eingang j zum Ausgang i

• Ny Zeilen = Ausgange, Nu Spalten = Eingange




ZPK–MIMO–Ubertragungsfunktion 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 fur Nullstellen-

polynome und P fur Polstellenpolynome (Ny×Nu),

Ny×Nu–Matrix K der Verstarkungsfaktoren

Z =

z11 z12

z21 z22

P =

p11 p12

p21 p22

K =

k11 k12

k21 k22




Zustandsdarstellung/State–Space (SS)

DGL 1. Ordnung fur jedes Speicherelement (Integrator)

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

Zustands–DGL:

x = A x + B u

Ausgangsgleichung:

y = C x + D u

x: Zustandsvektor (Nx×1)

u: Eingangsvektor (Nu×1)

y: Ausgangsvektor (Ny×1)

A: Zustandsmatrix (Nx×Nx)

B: Eingangsmatrix (Nx×Nu)

C: Ausgangsmatrix (Ny×Nx)

D: Durchschaltmatrix (Ny×Nu)




SS–Modell erstellen

• Befehl ss(A,B,C,D):

A =

[1 2

3 4

]B =

[1 1

0 1

]C =

0 1

1 2

3 1

D =

0 0

0 0

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 ϕ(ω)

Betrag: |F (jω) | =

√Re{F (jω)}2+ Im{F (jω)}2

Phase : ϕ(ω) = arctanIm{F (jω)}

Re{F (jω)}Lehrstuhl fur Elektrische Antriebssysteme und Leistungseelektronik



Frequenzgang–Daten–Modelle erstellen

• Befehl frd(ant, freq, eh):

ant Vektor mit den komplexen Frequenzantworten

freq 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 (Ny×Nu×Nf)




Zeitdiskrete Modelle

• Zusatzlicher Parameter: Abtastzeit Ts

tf(num,den,Ts)

ss(a,b,c,d,Ts)

zpk(z,p,k,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) = Ax(k) + Bu(k)

y(k) = Cx(k) + Du(k)




Zeitverzogerungen

Zeitkontinuierlich:

• Zwischen Ein- und Ausgangen (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, andern und abrufen

• Setzen und Andern von Modell–Eigenschaften:

– direkt: sys = tf(. . .,’EigName’,EigWert)

– Befehl set: set(sys,’EigName’,EigWert,. . .)

– “.“–Befehl: sys.EigName = EigWert

• Abrufen von Modell–Eigenschaften:

– Befehl get: get(sys,’EigName’)

– “.“–Befehl: sys.EigName

• 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: Ubergabe 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 benotigten Modelltyp um




Arithmetische Operatoren

• Addition und Subtraktion: Parallelschaltung

y = G1 · u+G2 · 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 Andern von LTI–Modellen

• Ansprechen der Ein- und Ausgange mit sys(i,j)

• Teilsystem: – extrahieren: subsys = systf(1,2)

– andern: systf(2,1) = subsys

• Ein-/Ausgange:

– loschen: systf(:,1) = []

– hinzufugen: systf = [systf,sys] (Typ nach Rang)

systf(:,2) = sys (Typ systf)




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

• Ruckkopplung: 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 verzogerter Systeme

• Geanderte Abtastzeit: sys = d2d(sys,Ts)




Analyse der Systemeigenschaften

Analyse der

Systemeigenschaften




Ubersicht

• Allgemeine Eigenschaften

• Modell–Dynamik

• Systemantwort im Zeitbereich

• Systemantwort im Frequenzbereich

• Ordnungsreduktion

• Zustandsbeschreibungen




Allgemeine Eigenschaften

• Uberprufung und Abfrage von durch MATLAB

bestimmte Systemeigenschaften

• Nutzlich fur die Programmierung komplexer Skripts

und Funktionen:

– Auswerteroutinen

– Komplexe Plots erstellen

• Systemeigenschaften oder Boolsche Werte (ja/nein)

als Ruckgabewerte




Modelltyp, Zeitdaten, Struktur, Große

• Modelltyp: – ausgeben: class(sys)

– prufen: isa(sys,’classname’)

• Zeitdaten: – zeitkontinuierlich: isct(sys)

– zeitdiskret: isdt(sys)

– Verzogerungen: hasdelay(sys)

• Struktur: – Ein- & Ausgange: isempty(sys)

– Ordnung: isproper(sys)

– SISO–Modell: issiso(sys)

• Große: size(sys)




Modell–Dynamik

• Stationare (Gleich–)Verstarkung: dcgain(sys)

– Frequenz ist s = 0 bzw. z = 1

– Reine Integratoren: Verstarkung ∞

• Naturliche Frequenzen und Dampfungen: damp(sys)

– Pole: pi = α± j β

– Frequenzen: ωn =√α2+ β2

– Dampfungen: D = −α

√α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 Dampfung und naturlicher Frequenz:

– kontinuierlich: sgrid

– zeitdiskret: zgrid




Normen und Kovarianz

• Normen eines LTI–Modells:

– zur Stabilitatsanalyse

– H2–Norm: norm(sys,2)

– H∞–Norm: norm(sys,inf [,tol])

[ninf,fpeak] = norm(sys,inf)

• Kovarianz (weißes Rauschen): [P,Q] = covar(sys,W)

– P ist Autokorrelationsfunktion Φyy der Ausgange

– Q ist Autokorrelationsfunktion Φxx der Zustande




Systemantwort im Zeitbereich

• Systemantwort kontinuierlich/diskret:

y(t) = CeAtx0 +t∫

τ=0

(CeA(t−τ)B+D

)u(τ) dτ

y[k] = CAkx0 +k−1∑

i=0

(CAk−i−1B+D

)u[i]

• Befehlsaufruf: [y,t,x] = befehl(sys,par)

• Zeitvektor: t = 0:dt:Tf

• Ausgang y: – SIMO: length(t)×Ny

– MIMO: length(t)×Ny ×Nu




Freie Bewegung, Impuls- und Sprungantwort

• Freie Bewegung: [y,t,x] = initial(sys,x0,[,t])

– Eingange 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 wahlt automatisch passende Abtastzeit dt

• Testsignal: [u,t] = gensig(typ,tau[,Tf,Ts])

– typ : ’sin’ Sinus

’pulse’ Pulse

’square’ Rechteck

– tau : Periodendauer

– Tf : Gesamtdauer

– Ts : Abtastzeit




Systemantwort im Frequenzbereich

Frequenzgang: Komplexe Antwort auf sinusformige An-

regung im eingeschwungenen Zustand

Voraussetzung: System asymptotisch stabil, d.h. Real-

teile aller Eigenwerte kleiner null

Frequenzgang–UF: F (jω) = |F (jω) | · e j ϕ(ω)

Betrag: |F (jω) | =

√Re{F (jω)}2+ Im{F (jω)}2

Phase : ϕ(ω) = arctanIm{F (jω)}

Re{F (jω)}




Frequenzantwort und Bode–Diagramm

• Frequenzantwort berechnen:

– Einzelne Frequenz f : frsp = 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,Pm,Wcg,Wcp] = margin(sys)

Amplitudenrand Gm, Phasen–Durchtrittsfrequenz Wcg

Phasenrand Pm, Amplituden–Durchtrittsfrequenz Wcp

Stabilitat fur: ωA < ωϕ FR > 1 ϕR > 0

• Struktur stabil = allmargin(sys)

Amplitudenrand: GainMargin und GMFrequency

Phasenrand: PhaseMargin und PMFrequency

Totzeitrand: DelayMargin und DMFrequency

Stabilitat: Stable, 1 bei Stabilitat, 0 sonst.




Plot des Bode–Diagramms

Bode Diagram

Frequency (rad/sec)

Pha

se (

deg)

Mag

nitu

de (

dB)

−60

−40

−20

0

20Gm = 6.0218 dB (at 1.7322 rad/sec), Pm = 27.142 deg (at 1.2328 rad/sec)

10−1

100

101

−270

−180

−90

0




Nyquist–Diagramm

• Nyquist–Diagramm: [re,im,w] = nyquist(sys)

Real- und Imaginarteil der Ubertragungsfunktion des

offenen Regelkreises von ω = 0 bis ∞ (Ortskurve):

−F0(jω) =Z0(jω)

N0(jω)· e−jωTt ; n0 > m0 , Tt ≥ 0

• Stabilitat:ω=+∞

∆ω=+0

φsoll = nr · π + na ·π2

nr, na: Anzahl in- bzw. grenzstabiler Pole

• Kritischer Punkt: −1+ j 0




Plot des Nyquist–Diagramms

Nyquist Diagram

Real Axis

Imag

inar

y A

xis

−2 −1 0 1 2 3 4

−3

−2

−1

0

1

2

3




LTI–View

GUI fur LTI–Systeme

Import und Export von

Systemen

Start mit: >> ltiview




Ordnungsreduzierte Darstellung

• Automatische Ordnungsreduktion:

– Zustande eliminieren/Nullstellen und Pole kurzen:

sysr = minreal(sys,[tol])

– Zustand beeinflußt Ein-/Ausgange nicht:

msys = sminreal(sys)

• Explizite Ordnungsreduktion:

– Gleichverstarkung: rsys = modred(sys,elim,’mdc’)

– Zustande loschen: rsys = modred(sys,elim,’del’)




Kanonische Zustandsbeschreibungen

• Modalform: [csys,T] = canon(sys,’modal’)

– reelle Eigenwerte λi in der Diagonale

– komplexe Eigenwerte σ ± jω in Matrizen

[σ ω−ω σ

]

• Regelungsnormalform: canon(sys,’companion’)

– Char. Polynom: sn + c1sn−1+ . . .+ cn−1s+ cn

– Matrix: ARNF =

0 0 . . . . . . 0 −cn1 0 0 . . . 0 −cn−10 1 0 . . . ... ...... 0 . . . . . . ... ...0 . . . . . . 1 0 −c20 . . . . . . 0 1 −c1




Beobachtbarkeit

• Beobachtbarkeitsmatrix: obsv(A,C)

– Ob =[CT ATCT (AT)2CT . . . (AT)n−1CT

]T

– Rang(Ob) = Anzahl der beobachtbaren Zustande

• Beobachtbarkeitsform: obsvf(A,B,C,[tol])

– Transformation: A = TATT , B = TB , C = CTT

– Transformiertes System:

A =

Ano A12

0 Ao

B =

Bno

Bo

C =

[0 Co

]




Steuerbarkeit

• Steuerbarkeitsmatrix: ctrb(A,B)

– Co =[B AB A2B . . . An−1B

]

– Rang(Co) = Anzahl der steuerbaren Zustande

• Steuerbarkeitsform: ctrbf(A,B,C,[tol])

– Transformation: A = TATT , B = TB , C = CTT

– Transformiertes System:

A =

Anc 0

A21 Ac

B =

0

Bc

C =

[Cnc Cc

]




Entwurf und Optimierung von Reglern

Entwurf und Optimierung

von Reglern




Ubersicht

• Wurzelortskurvenverfahren

• Interaktiver Reglerentwurf mit dem SISO Design Tool

• Polplazierung in Verbindung mit

Zustandsruckfuhrung und Zustandsbeobachtung

• Linear–quadratisch optimale Regelung

• Kalman–Filter als Zustandsbeobachter

fur verrauschte Signale




Reglerentwurf mit Wurzelortskurvenverfahren

• Wurzelortskurve: Verhalten der Pole des geschlosse-

nen Regelkreises in Abhangigkeit des Ruckfuhrverstar-

kungsfaktors k in der komplexen Null–Polstellen–Ebene

• Ubertragungsfunktion offener Regelkreis

−G0 = k ·GR ·GS ·GM = k ·nR nS nM

dR dS dM

• Pole von G0 = Wurzeln des Nennerpolynoms von G

d0 + k · n0 = dR dS dM + k · nR nS nM = 0




Befehle zum Wurzelortskurvenverfahren

• Wurzelortskurve:

rlocus(sys[,k])

[r,k] = rlocus(sys)

r = rlocus(sys,k)k GM

GR GSi t- - - -

6

¾ ¾

u y

−

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

Vollstandige Zustandsruckfuhrung mit Ruckfuhrmatrix K

Strecke:

x = A x + B u

y = C x + D u

∫h h hs s

s

- -

-

- - - - -

¾

¾

6

?

6B

K

A

C

D

w u

−

x x y

Regelgesetz (w = o): u = − K x

Geschlossener Regelkreis: x = (A −B K) · x




Zustandsbeobachtung - Luenberger–Beobachter

Ruckfuhrung des Ausgangsfehlers uber L

Beobachter:

˙x=A x+B u + L e

y=C x +D u

Ausgangsfehler:

e = y − y =C (x− x)

∫h hs s-

-

- - - - -

¾

?

6B

A

C

D

u x x y

?

Le

¾ ?h

−

6

∫h hs s-

-

- - - - -66B

A

C

D

˙x x y




Polplazierung

• Polplazierung: Ruckfuhrmatrix K so berechnen, daß

Pole des geschlossenen Regelkreis den Polen eines vor-

gegebenen Wunschpolynoms entsprechen.

• Zustandsregler–Ruckfuhrvektor k/Ruckfuhrmatrix K

k = acker(A,b,p)

K = place(A,B,p)

[K,prec,message] = place(A,B,p)

• Zustandsbeobachter–Ruckfuhrmatrix 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)

y (sensors)-

-

-

est

(L)-

x−K -

ut




Linear–quadratisch optimale Regelung

• Minimierung eines quadratischen Gutekriteriums:

(Q gewichtet Zustande, R gewichtet Eingange)

J (x,u) =∞∫

t=0

(xT Qx+ uT Ru+2xT Nu

)dt

• Algebraische Matrix–Riccati–Gleichung losen

0 = AT S + SA − (SB+N ) R−1 (BT S+NT ) + Q

• Ruckfuhrmatrix: K = R−1 (BT S+NT )




LQ–optimierte Regler–Ruckfuhrmatrix K

• LQ–optimierte Regler–Ruckfuhrmatrix 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 ],Ts)

[K,S,e] = lqry(sys,Q,R[,N ])

• Befehl lqrd: Abtastzeit Ts

• Befehl lqry:

J (y,u) =∞∫

t=0

(yT Qy+ uT Ru+2yT Nu

)dt




Kalman–Filter

Strecke:

x =A x+B u +G w

yv =C x +D u+H w + v

Beobachter:

˙x =A x+B u + L e

y =C x +D u

Ausgangsfehler:

e = yv − y

∫g g gs s-

-

- - - - - -

¾

? ?

6B

A

C

D

u x x y yv

v

G H

s

¶¶¶¶¶7

¶¶¶¶¶7

6 6w

?

Le

¾ ?g

−

6

∫g gs s s-

-

- - - - -66B

A

C

D

˙x x y




Kalman–Filter erstellen

• Quadratischen Mittelwert des Fehlers x−x minimieren:

P = limt→∞

E{(x− x)(x− x)T}!= min

• Kalman–Filter erstellen:

[kest,L,P] = kalman(sys,Qn,Rn[,Nn,sensors,known])

[kest,L,P,M,Z] = kalman(sys,Qn,Rn,Nn)

[kest,L,P,M,Z] = kalmd(sys,Qn,Rn,Ts)

Qn, Rn: Kovarianzen Prozeß- und Meßrauschen

Systembeschreibung: sys.a = A sys.b = [ B G ]

sys.c = C sys.d = [ D H ]




LQ–optimierter Zustandsregler mit Kalman–Filter

LQ–optimierten Zustandsregler&Kalman–Filter erstellen:

rlqg = lqgreg(kest,K)

rlqg = lqgreg(kest,K,controls)

rlqg

-w

Strecke -y

t

?i¾

v¾

yv

¾udkest

(L)¾

x−Kt

u¾

-

u




Probleme der numerischen Darstellung

Probleme der

numerischen Darstellung




Numerische Mathematik

• Algorithmen zur naherungsweisen Losung mathemati-

scher Probleme, z.B. aus Mathematik, Naturwissen-

schaft, Technik, ...

• Bewertung der Losungsverfahren nach verschiedenen

Kriterien, z.B.

– Rechenaufwand und -geschwindigkeit

– Speicherplatzbedarf

– Fehleranalyse




Fehlerbegriffe in der numerischen Mathmatik

• Fehlerklassen:

1. Datenfehler/Eingangsfehler → Konditionierung

2. Verfahrensfehler → unvollstandige Modellierung

3. Rundungsfehler → numerische Instabilitat

• Absoluter Fehler εk und relativer Fehler δk:

εk = xk − xk δk =xk − xk

xk

Exakte Werte xk und Naherungswerte xk mit 1 ≤ k ≤ n




Kondition eines Problems — Naturliche Instabilitat

• Auswirkung von Datenfehlern auf Ergebnisse:

AnderungenKondition

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 Instabilitat

• Auswirkungen des Losungsalgorithmus auf Ergebnis

• Stellen fur Gleitkomma–Zahlen begrenzt

→ Rundung der Ergebnisse

↪→ Ausloschung von Stellen bei Berechnung

↪→ Fehlerfortpflanzung

• Multiplikation und Division: gutartig

• Addition und Subtraktion:

gutartig, bei gleichem/entgegengesetztem Vorzeichen

boßartig, bei entgegengesetztem/gleichem Vorzeichen

und ungefahr gleich großen Zahlenwerten




Bewertung der LTI–Modelle

• Zustandsdarstellung (SS)

– Grundsatzlich am Besten geeignet!

– Algorithmen oft fur SS–LTI–Modelle implementiert

• Ubertragungsfunktion (TF)

– Nur fur 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 moglichst als SS–LTI–Modell beschreiben.

Hierbei moglichst eine normierte bzw. austarierte Be-

schreibung bei verwenden.

• Konvertierungen zwischen Modelltypen vermeiden.

• Ergebnisse auf ihre Verlaßlichkeit und Realitatsnahe

uberprufen.

Wichtigste Ingenieuraufgabe!



matlab control system toolbox - eal.ei.tum.de · matlabcontrolsystemtoolbox...

Documents