LABORATORIO DI ANALISI DEI SISTEMI 1 L`ANALISI DEI SISTEMI

Transcript

L’ANALISI DEI SISTEMI
CON MATLAB E SIMULINK
DISPENSE DEL CORSO
LABORATORIO DI
ANALISI DEI SISTEMI 1
Davide Giglio
Telefono: 010 353 2748
E-mail: [email protected]
CORSO DI LAUREA IN INGEGNERIA INFORMATICA
UNIVERSITÀ DEGLI STUDI DI GENOVA – FACOLTÀ DI INGEGNERIA
Indice
★ Matlab
★
★
★
★
★
★
Il Control System Toolbox
Rappresentazione dei sistemi LTI in Matlab
Caratteristiche dei sistemi LTI
Interconnessione di sistemi
Sistemi MIMO (multi-input-multi-output)
LTI Viewer e Risposte nel tempo
★ Simulink
★ Il Control System Toolbox
LABORATORIO DI ANALISI DEI SISTEMI 1
2
Introduzione
I problemi di Analisi dei Sistemi posso essere risolti
in maniera agevole utilizzando Matlab e Simulink
Matlab fornisce funzioni di base per il trattamento delle matrici,
ed è quindi possibile analizzare alcune proprietà strutturali
quali, ad esempio, la controllabilità e l’osservabilità
di un sistema LTI.
Simulink invece consente di simulare il comportamento
nel tempo di un sistema ed è quindi possibile analizzare alcune
proprietà dinamiche quali, ad esempio, il comportamento a
regime di un sistema LTI al variare del segnale di ingresso.
Inoltre, il Control System Toolbox fornisce specifici comandi
e funzioni per la rappresentazione e l’analisi di sistemi lineari
tempo-invarianti a tempo continuo (e non solo...)
3
1
Introduction
Control System Toolbox
What Is the Control System Toolbox?
MATLAB® has a rich collection of functions immediately useful to the control
engineer or system theorist. Complex arithmetic, eigenvalues, root-finding,
matrix inversion, and FFTs are just a few examples of MATLAB’s important
numerical tools. More generally, MATLAB’s linear algebra, matrix
computation, and numerical analysis capabilities provide a reliable foundation
for control system engineering as well as many other disciplines.
The Control System Toolbox builds on the foundations of MATLAB to provide
functions designed for control engineering. The Control System Toolbox is a
collection of algorithms, written mostly as M-files, that implements common
control system design, analysis, and modeling techniques. Convenient
graphical user interfaces (GUI’s) simplify typical control engineering tasks.
Control systems can be modeled as transfer functions, in zero-pole-gain, or
state-space form, allowing you to use both classical and modern control
techniques. You can manipulate both continuous-time and discrete-time
systems. Conversions between various model representations are provided.
Time responses, frequency responses, and root loci can be computed and
graphed. Other functions allow pole placement, optimal control, and
estimation. Finally, the Control System Toolbox is open and extensible. You
can create custom M-files to suit your particular application.
4
Rappresentazione dei Sistemi LTI
E’ possibile definire un sistema LTI attraverso:
★ la rappresentazione tramite equazioni di stato
!
ẋ(t) = A x(t) + B u(t)
y(t) = C x(t) + D u(t)
★ la rappresentazione tramite funzione di trasferimento
T (s) =
N (s)
D(s)
=
bm sm + bm−1 sm−1 + . . . + b1 s + b0
sn + an−1 sn−1 + . . . + a1 s + a0
★ la rappresentazione tramite zeri, poli e guadagno
T (s) =
k · (s − z1 ) · . . . · (s − zm )
(s − p1 ) · . . . · (s − pn )
In Matlab è possibile utilizzare tutte tre le rappresentazioni
5
Rappresentazione tramite equazioni di stato

%
&
%
&
0
1
1

 ẋ =
x+
u
−6 −5
−4

'
(

y= 1 0 x
A = [0 1; -6 -5]
>>
A =
B = [1; -4]
1
-5
1
-2
C = [1 0]
C =
1
>>
a =
x1
x2
x1
0
-6
x2
1
-5
B =
0
-6
>>
>>
sys_se = ss(A,B,C,D)
>>
0
D = [0]
D =
Una volta definite le matrici
che caratterizzano il sistema
si utilizza la funzione
ss (state-space)
0
b =
x1
x2
c =
y1
d =
y1
u1
1
-4
x1
1
x2
0
u1
0
Continuous-time model.
6
Rappresentazione tramite funzione di trasferimento
T (s) =
s+1
s2 + 5s + 6
Due modi equivalenti:
Definizione diretta della
funzione di trasferimento
nella variabile complessa s
>>
s = tf('s')
Transfer function:
s
>>
Utilizzo della funzione tf
con coefficienti i vettori
che rappresentano il
numeratore e il denominatore
Specifica, in maniera esplicita,
che “s” è la variabile della
sys_tf = (s+1)/(s^2+5*s+6)
Transfer function:
s + 1
------------s^2 + 5 s + 6
>>
sys_tf = tf([1 1],[1 5 6])
Transfer function:
s + 1
------------s^2 + 5 s + 6
7
Rappresentazione tramite zeri, poli e guadagno
T (s) =
s+1
s2
+ 5s + 6
=
★ zeri: -1
★ poli: -2 e -3
★ guadagno: +1
1 · (s + 1)
(s + 2)(s + 3)
>> zeri = -1
>> poli = [-2 -3]
>> guad = 1
zeri =
poli =
guad =
-1
-2
-3
Utilizzo della funzione zpk
con coefficienti i vettori contenenti
gli zeri, i poli e i guadagni
1
>> sys_zpk = zpk(zeri,poli,guad)
Zero/pole/gain:
(s+1)
----------(s+2) (s+3)
8
Le funzioni ss, tf e zpk possono essere utilizzate
per passare velocemente da una rappresentazione all’altra
Applico la funzione tf
al sistema descritto attraverso
equazioni di stato
>> sys_se
a =
x1
x2
x1
0
6
x1
x2
u1
1
-4
b =
c =
y1
x1
1
x2
1
-5
>> sys_new_tf = tf(sys_se)
Transfer function:
s + 1
------------s^2 + 5 s - 6
Applico la funzione zpk
equazioni di stato
x2
0
>> sys_new_zpk = zpk(sys_se)
d =
y1
u1
0
Zero/pole/gain:
(s+1)
----------(s-1) (s+6)
9
>>
Applico la funzione ss
sys_tf
Transfer function:
s + 1
------------s^2 + 5 s + 6
>> sys_new_se = ss(sys_tf)
a =
x1
x2
b =
x1
x2
Applico la funzione zpk
>> sys_new_zpk = zpk(sys_tf)
Zero/pole/gain:
(s+1)
----------(s+3) (s+2)
x1
-5
4
u1
1
0
c =
x1
1
y1
d =
y1
x2
-1.5
0
x2
0.25
u1
0
10
>>
sys_zpk
Applico la funzione ss
zeri, poli e guadagno
>> sys_new_se = ss(sys_zpk)
a =
x1
x2
Zero/pole/gain:
(s+1)
----------(s+2) (s+3)
b =
x1
x2
Applico la funzione tf
zeri, poli e guadagno
c =
y1
x1
-2
0
x2
1
-3
u1
0
1
x1
-1
x2
1
>> sys_new_tf = tf(sys_zpk)
Transfer function:
s + 1
------------s^2 + 5 s + 6
d =
y1
u1
0
11
E’ possibile aggiungere un ritardo al sistema
(generico, in ingresso o in uscita)
★ Ritardo generico indipendente per ciascuna
coppia (variabile di ingresso / variabile di uscita)
Tyj ,ui (s) = e
−τi,j s
·
N (s)
D(s)
★ Rappresentazione tramite equazioni di stato con
ingressi ritardati e/o uscite ritardate
!
ẋ(t) = A x(t) + B u(t − τ )
y(t) = C x(t − θ) + D u(t − (θ + τ ))
12
>> sys_se = ss(A,B,C,D,'inputdelay',0.1)
a =
x1
x2
x1
0
6
x2
1
-5
>> sys_tf = tf(N,D,'inputdelay',0.1)
Transfer function:
b =
x1
x2
s + 1
exp(-0.1*s) * ------------s^2 + 5 s + 6
u1
1
-4
>> sys_zpk = zpk(zeri,poli,guad,'inputdelay',0.1)
c =
y1
d =
y1
x1
1
x2
0
Zero/pole/gain:
(s+1)
exp(-0.1*s) * ----------(s+2) (s+3)
u1
0
Input delays (listed by channel): 0.1
13
La struttura del sistema viene memorizzata
in una struttura dati denominata “LTI object”
E’ possibile accedere alle informazioni di tale struttura dati
utilizzando il comando get
>> get(sys_se)
a:
b:
c:
d:
e:
StateName:
Ts:
ioDelay:
InputDelay:
OutputDelay:
InputName:
OutputName:
InputGroup:
OutputGroup:
Notes:
UserData:
[2x2 double]
[2x1 double]
[1 0]
0
[]
{2x1 cell}
0
0
0.1
0
{''}
{''}
{0x2 cell}
{0x2 cell}
{}
[]
Si può accedere
ai singoli elementi della
struttura dati “LTI object”
attraverso il carattere “.”
>> sys_se.a
ans =
0
6
1
-5
14
>>
>>
>>
>>
sys_se.statename = ['Var_1'; 'Var_2'];
sys_se.inputname = 'input';
sys_se.outputname = 'output';
sys_se
a =
Var_1
Var_2
Var_1
0
6
Var_2
1
-5
E’ possibile effettuare delle
assegnazioni direttamente sulla
struttura dati “LTI object”
>> get(sys_se)
b =
Var_1
Var_2
c =
output
d =
output
input
1
-4
Var_1
1
Var_2
0
input
0
Input delays (listed by channel): 0.1
a:
b:
c:
d:
e:
StateName:
Ts:
ioDelay:
InputDelay:
OutputDelay:
InputName:
OutputName:
InputGroup:
OutputGroup:
Notes:
UserData:
[2x2 double]
[2x1 double]
[1 0]
0
[]
{2x1 cell}
0
0
0.1
0
{'input'}
{'output'}
{0x2 cell}
{0x2 cell}
{}
[]
15
Ogni rappresentazione fornisce il proprio insieme di dati
>> get(sys_tf)
num:
den:
Variable:
Ts:
ioDelay:
InputDelay:
OutputDelay:
InputName:
OutputName:
InputGroup:
OutputGroup:
Notes:
UserData:
{[0 1 1]}
{[1 5 6]}
's'
0
0
0
0
{''}
{''}
{0x2 cell}
{0x2 cell}
{}
[]
>> get(sys_zpk)
z:
p:
k:
Variable:
Ts:
ioDelay:
InputDelay:
OutputDelay:
InputName:
OutputName:
InputGroup:
OutputGroup:
Notes:
UserData:
{-1}
{1x1 cell}
1
's'
0
0
0
0
{''}
{''}
{0x2 cell}
{0x2 cell}
{}
[]
>> sys_zpk.p{1,1}
ans =
-2
-3
16
LTI
OBJECT
17
Le informazioni che caratterizzano un sistema
★ matrici A, B, C e D per la rappresentazione SS
★ numeratore e denominatore per la rappresentazione TF
★ zeri, poli e guadagno per la reppresentazione ZPK
possono essere acquisite con i comandi
ssdata, tfdata e zpkdata
>> [num,den] = tfdata(sys)
>> [z,p,k] = zpkdata(sys)
num =
z =
[1x3 double]
>> num{1,1}
[-1]
ans =
den =
[1x3 double]
0
1.0000
1.0000
[2x1 double]
>> den{1,1}
ans =
1.0000
>> p{1,1}
p =
-2.0000
-3.0000
k =
5.0000
6.0000
ans =
1.0000
18
Caratteristiche dei Sistemi LTI
Il Control System Toolbox fornisce alcune funzioni di base
per l’analisi delle principali caratteristiche di un sistema LTI
class
Specifica la tipologia di un sistema (“ss”, “tf” o “zpf”)
size
Numero di input e di output nel sistema
ndims
Dimensione del sistema (numero di stati)
isct
Vale 1 se il sistema è continuo
isdt
Vale 1 se il sistema è discreto
issiso
Vale 1 se il sistema è single-input-single-output
hasdelay
Vale 1 se il sistema presenta ritardi
pole
Poli del sistema
zero
Zeri del sistema
dcgain
Guadagno del sistema
19
Caratteristiche dei Sistemi LTI
>> size(sys)
State-space model with 1 output, 1 input, and 2 states.
>> class(sys)
>> ndims(sys)
>> issiso(sys)
ans =
ans =
ans =
ss
2
1
>> isct(sys)
>> isdt(sys)
>> hasdelay(sys)
ans =
ans =
ans =
1
>> pole(sys)
ans =
-2.0000
-3.0000
0
0
>> zero(sys)
>> dcgain(sys)
ans =
ans =
-1
0.1667
20
Interconnessione di Sistemi
Matlab gestisce in maniera molto efficiente i
sistemi interconnessi
permettendo la determinazione immediata delle rappresentazioni
(tramite equazioni di stato, funzioni di trasferimento o
zeri / poli /guadagno) del sistema complessivo
Le operazioni che possono essere effettuate sono:
★
★
★
★
★
★
Somma e sottrazione (sistemi in parallelo)
Prodotto (sistemi in serie)
Retroazione
Concatenazione orizzontale
Concatenazione verticale
“Append”
21
Regole di Precedenza
Le operazioni appena descritte operano su più sistemi
che possono avere rappresentazioni differenti
(LTI object di tipo differente)
Non è quindi ovvio il tipo di LTI object del sistema risultante.
Le tre rappresentazioni (SS, TF e ZPK) hanno la seguente gerarchia:
SS > ZPK > TF
Il sistema risultante è quindi:
★ SS se almeno un operando è SS
★ ZPK se non vi sono operandi SS e almeno uno è ZPK
★ TF se tutti gli operandi sono TF
22
s
SOMMA E SOTTRAZIONE
(sistemi in parallelo)
represents the parallel interconnection shown below.
sys1
y1
+
u
+
sys2
y
y2
sys
Nel caso di rappresentazione tramite
equazioni di stato il sistema risultante
è caratterizzato dalle seguenti matrici
!
"
!
"
A1 0
B1
A=
B=
0 A2
B2
C=
!
C1
aresys
two state-space
If sys1 and sys2>>
= sys1 + models
sys2 with data A 1, B 1, C 1, D 1 and
A 2, B 2, C 2, D 2 , the state-space data associated with sys1 + sys2 is
C2
"
D = D 1 + D2
>> sys = parallel(sys1,sys2)
A1 0
B1
,
,
D1 + D2
C1 C2 ,
0 A2
B2
T (s)
= T1 (s) + T2 (s)
funzione
di trasferimento
il sistema
risultante
and
Scalar addition
is also supported
and behaves
as follows:
if sys1 is MIMO
seguente
funzione
sys2 is SISO, sys1 è+ caratterizzato
sys2 produces a dalla
system
with the same
dimensions as
sys1 whose ijth entry is sys1(i,j) + sys2.
Similarly, the subtraction
of two LTI models
LABORATORIO
DI ANALISI
DEI SISTEMI 1
23
>>
>>
>>
>>
A
B
C
D
=
=
=
=
[0 1; -6 -5];
[1; -4];
[1 0];
0;
Sistema 1
>> sys1 = ss(A,B,C,D)
a =
x1
x2
x1
0
-6
x1
x2
u1
1
-4
b =
c =
y1
x1
1
y1
u1
0
d =
x2
1
-5
Sistema 2
>> N = 1;
>> D = [1 4 3];
x2
0
>> sys2 = tf(N,D)
Transfer function:
1
------------s^2 + 4 s + 3
24
>> sys = sys1 + sys2
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
x1
0
-6
0
0
x2
1
-5
0
0
x3
0
0
-4
2
x4
0
0
-1.5
0
>> tf(sys)
Transfer function:
s^3 + 6 s^2 + 12 s + 9
-------------------------------s^4 + 9 s^3 + 29 s^2 + 39 s + 18
u1
1
-4
0.5
0
>> zpk(sys)
c =
y1
x1
1
y1
u1
0
d =
x2
0
x3
0
x4
1
Zero/pole/gain:
(s+3) (s^2 + 3s + 3)
-------------------(s+2) (s+3)^2 (s+1)
25
Multiplication
PRODOTTO
(sistemi in serie)
Multiplication of two LTI models connects them in series. Specifically,
sys = sys1 * sys2
returns an LTI model sys for the series interconnection shown below.
v
u
>> sys = sys1 * sys2
sys2
sys1
y
>> sys = series(sys2,sys1)
Notice the reverse orders of sys1 and sys2 in the multiplication and block
diagram. This is consistent with the way transfer matrices are combined in a
! H 1 and H 2 , then
"
series connection: if sys1 and sys2 have transfer matrices
A=
A1
0
B1 C2
A2
y =caso
H 1 v di
= H
) u
Nel
rappresentazione
1 ( H 2 u ) = ( H 1 ! H 2tramite
For state-space models sys1 and sys2 with data A 1, B 1, C 1, D 1 and
!
"
seguenti
Aè2,caratterizzato
B 2, C 2, D 2 , the dalle
sys1*sys2
is
state-space
data matrici
associated with
C = C1 D1 C2
A1 B1 C2
,
B1 D2
,
C1 D1 C2 ,
B=
!
B 1 D2
B2
"
D = D 1 D2
D1 D2
B 2 di rappresentazione tramite
Nel caso
T (s) = T1 (s) · T2 (s)
funzione di trasferimento il sistema risultante
Finally, if sys1 is MIMO and sys2 is SISO, then sys1*sys2 or sys2*sys1 is
è caratterizzato dalla seguente funzione
0
A2
interpreted as an entry-by-entry scalar multiplication and produces a system
with the same dimensions as sys1, whose ijth entry is sys1(i,j)*sys2.
LABORATORIO
DI ANALISI
SISTEMI 1
Inversion and
RelatedDEI
Operations
26
>> sys = sys1 * sys2
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
x1
0
-6
0
0
x2
1
-5
0
0
x3
0
0
-4
2
u1
0
0
0.5
0
x4
1
-4
-1.5
0
>> tf(sys)
Transfer function:
s + 1
-------------------------------s^4 + 9 s^3 + 29 s^2 + 39 s + 18
>> zpk(sys)
c =
y1
x1
1
y1
u1
0
d =
x2
0
x3
0
x4
0
Zero/pole/gain:
(s+1)
------------------(s+2) (s+3)^2 (s+1)
27
• parallel connects two LTI models in parallel.
• lft performs the Redheffer star product on two LTI models.
• connect works with append to apply an arbitrary interconnection scheme to
a set of LTI models.
RETROAZIONE
For example, if sys1 has m inputs and p outputs, while sys2 has p inputs and
m outputs, then the negative feedback configuration of these two LTI models
+
u
–
sys1
y
(si è posto, per semplicità, D1 = D2 = 0)
sys2
A=
>> sys = feedback(sys1,sys2)
C=
è caratterizzato dalla seguente funzione
!
!
A1
−B1 C2
B2 C1
A2
!
"
B1
B=
0
C1
T (s) =
0
"
"
D=0
T1 (s)
1 + T1 (s)T2 (s)
28
>> sys = feedback(sys1,sys2)
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
x1
0
-6
0.5
0
x2
1
-5
0
0
x3
0
0
-4
2
u1
1
-4
0
0
x4
-1
4
-1.5
0
>> tf(sys)
Transfer function:
s^3 + 5 s^2 + 7 s + 3
-------------------------------s^4 + 9 s^3 + 29 s^2 + 40 s + 19
>> zpk(sys)
c =
y1
x1
1
y1
u1
0
d =
x2
0
x3
0
x4
0
Zero/pole/gain:
(s+3) (s+1)^2
------------------------------------(s+1) (s+3.755) (s^2 + 4.245s + 5.06)
29
sys = append(sys1,sys2)% block diagonal appending
In I/O terms, horizontal and vertical concatenation have the following
block-diagram interpretations (with H 1 and H 2 denoting the transfer
matrices of sys1 and sys2).
CONCATENAZIONE ORIZZONTALE
La concatenazione orizzontale
H1
mantiene
separatiy1i due ingressi
H1
u1
+
+
u2
H2
>> sys = [sys1 u,1 sys2]
y = H1 , H2
u2
Horizontal Concatenation
y
u
equazioniHdi2 stato il sistema
risultante
y2
!
"
A1 0
A= y
HA
10
12
=
u
C=
y2
!
C1
H2
C2
"
B=
D=
Vertical Concatenation
!
!
You can use concatenation as an easy way to create MIMO transfer functions
!
or zero-pole-gain models. For example,
H = [ tf(1,[1 0]) 1 ; 0 tf([1 –1],[1 1]) ]
è caratterizzato
dalle due funzioni di trasferimento
specifies
LABORATORIO1DI ANALISI DEI SISTEMI 1
T (s) =
B1
0
D1
H1 (s)
0
B2
D2
"
"
H2 (s)
"
30
>> sys = [sys1 , sys2]
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
c =
y1
d =
y1
x1
0
-6
0
0
u1
1
-4
0
0
x1
1
u1
0
x2
1
-5
0
0
x3
0
0
-4
2
Transfer function from input 1 to output:
s + 1
------------s^2 + 5 s + 6
Transfer function from input 2 to output:
1
------------s^2 + 4 s + 3
u2
0
0
0.5
0
x2
0
x4
0
0
-1.5
0
>> tf(sys)
>> zpk(sys)
x3
0
x4
1
u2
0
Zero/pole/gain from input 1 to output:
(s+1)
----------(s+2) (s+3)
Zero/pole/gain from input 2 to output:
1
----------(s+3) (s+1)
31
2)% block diagonal appending
d vertical concatenation have the following
ns (with H 1 and H 2 denoting the transfer
CONCATENAZIONE VERTICALE
H1
+
+
y
y1
u
H2
y2
>> sys = y [sys1
H 1; sys2]
1
=
u
y2
H2
ation
La concatenazione verticale
mantiene separati le due uscite
!
"
!
"
A1 0
B1
A=
B=
0 A2
B2
C=
Vertical Concatenation
as an easy way to create MIMO transfer functions
Nel caso di rappresentazione
or example,
; 0
!
C1
0
tramite
tf([1 –1],[1 1]) ]
è caratterizzato dalle due funzioni di trasferimento
0
C2
"
T (s) =
D=
!
!
H1 (s)
H2 (s)
D1
D2
"
"
32
>> sys = [sys1 ; sys2]
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
x1
0
-6
0
0
x2
1
-5
0
0
x3
0
0
-4
2
x4
0
0
-1.5
0
>> tf(sys)
Transfer function from input to output...
s + 1
#1: ------------s^2 + 5 s + 6
#2:
u1
1
-4
0.5
0
1
------------s^2 + 4 s + 3
>> zpk(sys)
c =
y1
y2
d =
y1
y2
x1
1
0
x2
0
0
x3
0
0
x4
0
1
u1
0
0
Zero/pole/gain from input to output...
(s+1)
#1: ----------(s+2) (s+3)
#2:
1
----------(s+3) (s+1)
33
odels
“APPEND”
to specify the block-decoupled LTI model interconnection.
u1
u2
sys1
sys2
y1
La funzione “append” crea
un sistema i cui due sottosistemi
sys1 0
sono completamente
disaccoppiati
y2
0
sys2
Appended Models
Transfer Function
!
"
!
"
A1 0
B1 0
>> sys
append(sys1,sys2)
for=more
information on this function. A =
See append
B=
0 A2
0 B2
!
"
Feedback and Other Interconnection Functions
C1 0
D=
The following LTI model interconnection functionsC
are=useful for specifying
0 C2
closed- and open-loop model configurations:
!
D1
0
• feedback puts two LTI models with compatible dimensions in a feedback
!
configuration. Nel caso di rappresentazione tramite
H1 (s)
T (s) =
di trasferimento
il sistema risultante
connects two
LTI models in series.
• series funzione
0
è caratterizzato
dalle
funzioni
di trasferimento
• parallel
connects two
LTIdue
models
in parallel.
0
D2
"
0
H2 (s)
"
• lft performs the Redheffer star product on two LTI models.
• connect works with append to apply an arbitrary interconnection scheme to
34
>> sys = append(sys1,sys2)
>> tf(sys)
a =
Transfer function from input 1 to output...
s + 1
#1: ------------s^2 + 5 s + 6
x1
0
-6
0
0
x1
x2
x3
x4
b =
x1
x2
x3
x4
c =
y1
y2
d =
y1
y2
u1
1
-4
0
0
x1
1
0
u1
0
0
x2
1
-5
0
0
x3
0
0
-4
2
#2:
0
Transfer function from input 2 to output...
#1: 0
u2
0
0
0.5
0
x2
0
0
x4
0
0
-1.5
0
#2:
x3
0
0
1
------------s^2 + 4 s + 3
x4
0
1
u2
0
0
>> zpk(sys)
Zero/pole/gain from input 1 to output...
(s+1)
#1: ----------(s+2) (s+3)
#2:
0
Zero/pole/gain from input 2 to output...
#1: 0
#2:
1
----------(s+3) (s+1)
35
Sistemi MIMO
Si consideri il seguente sistema LTI
u2 (t)
u1 (t)
+
-
TA (s)
+
TB (s)
+
y1 (t)
y2 (t)
TC (s)
y3 (t)
Il sistema ha 2 ingressi e 3 uscite
36
Sistemi MIMO
u2 (t)
+
u1 (t)
-
TA (s)
+
TB (s)
+
TA (s) =
y1 (t)
y2 (t)
TC (s)
TC (s) =
1
s
TB (s) =
s+1
(s + 2)(s + 3)
=
1
s+1
s+1
s2 + 5s + 6
y3 (t)
!
ẋA (t) = uA (t)
yA (t) = xA (t)
uA (t) = u1 (t) − yC (t)
!
ẋB (t) = −xB (t) + uB (t)
yB (t) = xB (t)
uC (t) = yB (t)

 ẋC1 (t) = xC2 (t)
ẋC2 (t) = −6xC1 (t) − 5xC2 (t) + uC (t)

yC (t) = xC1 (t) + xC2 (t)
uB (t) = u2 (t) + yA (t)
y1 (t) = yB (t)
y2 (t) = u2 (t) + yA (t)
y3 (t) = yC (t)
37
Sistemi MIMO
ẋA (t) = −xC1 (t) − xC2 (t) + u1 (t)
y1 (t) = xB (t)
ẋB (t) = xA (t) − xB (t) + u2 (t)
y2 (t) = xA (t) + u2 (t)
ẋC1 (t) = xC2 (t)
y3 (t) = xC1 (t) + xC2 (t)
ẋC2 (t) = xB (t) − 6xC1 (t) − 5xC2 (t)


0




 1



ẋ(t)
=


 0



0





0




y(t) =  1



0


0 −1 −1

−1
0
0 
 x(t) + 

0
0
1 
1 −6 −5
1
0
0
0
0
1


1
0
0
0


0
1 
 u(t)
0 
0
0
0 0
0  x(t) +  0 1  u(t)
1
0 0
38
Sistemi MIMO
>> MIMOsys = ss(A,B,C,D)
>> A = [ 0 0 -1 -1; ...
-1 -1 0 0; ...
0 0 0 1; ...
0 1 -6 -5 ]
>> C = [ 0 1 0 0; ...
1 0 0 0; ...
0 0 1 1 ]
A =
C =
0
-1
0
0
0
-1
0
1
-1
0
0
-6
0
1
0
-1
0
1
-5
1
0
0
0
0
1
0
0
1
a =
x1
x2
x3
x4
b =
x1
x2
x3
x4
>> B = [ 1 0; 0 1; 0 0 ; 0 0 ]
x1
0
-1
0
0
x2
0
-1
0
1
u1
1
0
0
0
u2
0
1
0
0
x1
0
1
0
x2
1
0
0
u1
0
0
0
u2
0
1
0
x3
-1
0
0
-6
x4
-1
0
1
-5
x3
0
0
1
x4
0
0
1
B =
1
0
0
0
c =
0
1
0
0
y1
y2
y3
>> D = [ 0 0; 0 1; 0 0 ]
D =
0
0
0
0
1
0
d =
y1
y2
y3
39
Sistemi MIMO
a =
x1
x2
x3
x4
>> get(MIMOsys)
a:
b:
c:
d:
e:
StateName:
Ts:
ioDelay:
InputDelay:
OutputDelay:
InputName:
OutputName:
InputGroup:
OutputGroup:
Notes:
UserData:
[4x4
[4x2
[3x4
[3x2
[]
{4x1
0
[3x2
[2x1
[3x1
{2x1
{3x1
{0x2
{0x2
{}
[]
double]
double]
double]
double]
cell}
double]
double]
double]
cell}
cell}
cell}
cell}
b =
x1
x2
x3
x4
>> issiso(MIMOsys)
ans =
x1
0
-1
0
0
x2
0
-1
0
1
x3
-1
0
0
-6
ingresso
1
0
0
0
x4
-1
0
1
-5
disturbo
0
1
0
0
0
c =
uscita
usc_dist
usc_inf
d =
>> size(MIMOsys)
uscita
usc_dist
usc_inf
State-space model with 3 outputs, 2 inputs, and 4 states.
x1
0
1
0
x2
1
0
0
x3
0
0
1
ingresso
0
0
0
x4
0
0
1
disturbo
0
1
0
>> MIMOsys.InputName = {'ingresso' 'disturbo'};
>> MIMOsys.OutputName = {'uscita' 'usc_dist' 'usc_inf'};
40
Sistemi MIMO
>> tf(MIMOsys)
Transfer function from input "ingresso" to output...
uscita:
-s^2 - 5 s - 6
-----------------------------s^4 + 6 s^3 + 11 s^2 + 5 s - 1
usc_dist:
usc_inf:
s^3 + 6 s^2 + 11 s + 6
-----------------------------s^4 + 6 s^3 + 11 s^2 + 5 s - 1
-s - 1
-----------------------------s^4 + 6 s^3 + 11 s^2 + 5 s - 1
>> zpk(MIMOsys)
Zero/pole/gain from input "ingresso" to output...
uscita:
- (s+3) (s+2)
--------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
usc_dist:
(s+1) (s+2) (s+3)
--------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
- (s+1)
Transfer function from input "disturbo" to output...
usc_inf: --------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
s^3 + 5 s^2 + 6 s + 4.469e-016
uscita: -----------------------------Zero/pole/gain from input "disturbo" to output...
s^4 + 6 s^3 + 11 s^2 + 5 s - 1
usc_dist:
usc_inf:
s^4 + 6 s^3 + 11 s^2 + 4 s - 2
-----------------------------s^4 + 6 s^3 + 11 s^2 + 5 s - 1
s^2 + s - 8.674e-018
-----------------------------s^4 + 6 s^3 + 11 s^2 + 5 s - 1
uscita:
s (s+3) (s+2)
--------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
usc_dist:
usc_inf:
(s-0.2695) (s+1) (s^2 + 5.27s + 7.42)
--------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
s (s+1)
--------------------------------------(s-0.1479) (s+1) (s^2 + 5.148s + 6.761)
41
Array di Sistemi LTI
u(t)
2s + 1
+
-
(s − 1)(s + 2)
y(t)
k
2s + 1
2s + 1
s2 + s − 2
Tcompl (s) =
= 2
k(2s + 1)
s + (2k + 1)s + (k − 2)
1+ 2
s +s−2
E’ possibile analizzare il sistema al variare di k
42
In Matlab esiste il concetto di “Array di Sistemi LTI”
Sistema sulla
catena diretta
>> num1 = [2 1];
>> den1 = [1 1 -2];
>> sys1 = tf(num1,den1)
Transfer function:
2 s + 1
----------s^2 + s - 2
Successivamente
si definisce, per ogni
elemento del vettore
definito in precedenza,
il sistema
k
Bisogna definire
innanzitutto il vettore
di elementi per cui
studiare il comportamento del sistema
>> k = [-2 -1 0 1 2];
>> sys2_1 = tf(k(1),1)
Transfer function:
-2
>> sys2_2 = tf(k(2),1)
Transfer function:
-1
>> sys2_3 = tf(k(3),1)
Transfer function:
0
>> sys2_4 = tf(k(4),1)
Transfer function:
1
>> sys2_5 = tf(k(5),1)
Transfer function:
2
43
Si crea infine l’array >> ARRAYsys(:,:,1) = feedback(sys1,sys2_1);
>> ARRAYsys(:,:,2) = feedback(sys1,sys2_2);
di sistemi retroazionati >> ARRAYsys(:,:,3) = feedback(sys1,sys2_3);
>> ARRAYsys(:,:,4) = feedback(sys1,sys2_4);
>> ARRAYsys(:,:,5) = feedback(sys1,sys2_5)
Model ARRAYsys(:,:,1,1)
=======================
Transfer function:
2 s + 1
------------s^2 - 3 s - 4
=======================
Transfer function:
2 s + 1
----------s^2 - s - 3
=======================
Transfer function:
2 s + 1
----------s^2 + s - 2
=======================
ELEMENTI
DELL’ARRAY
Transfer function:
2 s + 1
------------s^2 + 3 s - 1
=======================
Transfer function:
2 s + 1
--------s^2 + 5 s
5x1 array of continuous-time transfer functions.
5x1 array of continuous-time transfer functions.
44
>> ss(ARRAYsys)
Model ans(:,:,1,1)
==================
a =
x1
x2
b =
x1
x2
x1
3
2
x1
x2
b =
u1
2
0
x1
x2
x1
1
y1
y1
a =
x2
2
0
c =
d =
Model ans(:,:,2,1)
==================
u1
0
x2
0.25
c =
y1
d =
y1
x1
1
2
x2
1.5
0
u1
0
a =
x1
x2
b =
u1
2
0
x1
1
Model ans(:,:,3,1)
==================
x1
x2
x2
0.25
c =
y1
d =
y1
x1
-1
2
a =
x2
1
0
x1
x2
b =
u1
2
0
x1
1
Model ans(:,:,4,1)
==================
x1
x2
x2
0.25
u1
0
c =
y1
d =
y1
x1
-3
1
x2
1
0
a =
x1
x2
b =
u1
2
0
x1
1
Model ans(:,:,5,1)
==================
x1
x2
x2
0.5
u1
0
c =
y1
d =
y1
x1
-5
0.5
x2
0
0
u1
2
0
x1
1
x2
1
u1
0
5x1 array of continuous-time state-space models.
45
Una volta definito l’array è semplice visualizzare l’andamento nel tempo
del segnale di uscita per tutti gli elementi del parametro
>> step(ARRAYsys)
>> impulse(ARRAYsys)
Step Response
5
4.5
4.5
4
4
3.5
3.5
3
3
Amplitude
Amplitude
Impulse Response
5
2.5
2.5
2
2
1.5
1.5
1
1
0.5
0.5
0
0
1
2
3
4
5
6
0
0
Time (sec)
1
2
3
4
5
6
Time (sec)
46
LTI Viewer
LTI Viewer è uno specifico analizzatore / visualizzatore
di sistemi lineari tempo invarianti a tempo continuo o discreto
>> sys = ss(A,B,C,D)
Si consideri il seguente
sistema LTI
>>
>>
>>
>>
A
B
C
D
=
=
=
=
[0 1; -6 -5];
[1; -4];
[1 0];
0;
a =
x1
x2
b =
x1
x2
c =
y1
d =
y1
x1
0
-6
x2
1
-5
u1
1
-4
x1
1
x2
0
u1
0
>> tf(sys)
Transfer function:
s + 1
------------s^2 + 5 s + 6
>> zpk(sys)
Zero/pole/gain:
(s+1)
----------(s+2) (s+3)
47
LTI Viewer
>> LTIview(sys)
48
LTI Viewer
LTI Viewer consente la visualizzazione di
specifici grafici per l’analisi dei sistemi LTI.
In particolare:
★ risposta al gradino (step)
★ risposta all’impulso (impulse)
49
LTI Viewer
Altri grafici sono:
★ diagrammi di bode (bode)
★ mappa dei poli e degli zeri (pole/zero)
50
LTI Viewer
L’ambiente “Proprietà” consente di specificare
la modalità di visualizzazione della curva
51
LTI Viewer
Ogni tipologia di grafico consente la
visualizzazione di una serie di informazioni
che caratterizzano il segnale presente
nel viewer.
per quanto riguarda le risposte al gradino
e all’impulso si hanno le seguenti
informazioni:
★ Peak Response
Valore massimo raggiunto dal segnale
★ Settling Time
Tempo per arrivare a regime
★ Rise Time
Tempo per passare dal 10% al 90% del valore del segnale
★ Steady State
Valore raggiunto a regime dal segnale
52
LTI Viewer
53
I valori che caratterizzano
il settling time e il rise time
possono essere modificati
nell’ambiente “Proprietà”
L’ambiente “Plot Configuration”
consente di modificare il layout del
LTI Viewer specificando quanti e
quali grafici visualizzare
54
LTI Viewer
55
LTI Viewer
LTI Viewer consente di analizzare / visualizzare
più segnali contemporaneamente
Si consideri
(oltre al precedente)
il seguente
sistema LTI
>> sys2 = tf(1, [1 3])
Transfer function:
1
----s + 3
>> LTIview
56
LTI Viewer
57
LTI Viewer
Ogni singolo grafico può
essere abilitato / disabilitato
Le proprietà vengono
specificate per ogni
singolo grafico
58
LTI Viewer
Anche i sistemi MIMO possono essere
analizzati / visualizzati con LTI Viewer
>> LTIview(MIMOsys)
59
Risposte nel Tempo
Il Control System Toolbox di Matlab contiene specifiche funzioni
per la visualizzazione di risposte nel tempo di sistemi LTI
★ Step
Risposta al gradino
★ Impulse
Risposta all’impulso
★ Initial
Risposta Libera
!
"
1
−1
y(t) = L
T (s) ·
s
!
"
y(t) = L−1 T (s)
!
"
y(t) = L−1 C (sI − A)−1 x(0− )
La risposta libera può essere ottenuta solo
per sistemi rappresentati tramite
equazioni di stato
60
Risposte nel Tempo
Si consideri il
sistema LTI
>> s = tf('s')
Transfer function:
s
>> sys = (s+4)/((s+2)*((s+1)^2+9))
Transfer function:
s + 4
----------------------s^3 + 4 s^2 + 14 s + 20
>> step(sys)
>> impulse(sys)
61
Risposte nel Tempo
condizioni
iniziali
>> sys_se = ss(sys)
a =
x1
-4
8
0
x1
x2
x3
b =
x1
x2
x3
x1
0
y1
y1
x0 =
-2
1
-4
x3
-0.625
0
0
>> initial(sys_se,x0)
u1
0.5
0
0
c =
d =
x2
-1.75
0
4
>> x0 = [-2; 1; -4]
x2
0.25
x3
0.25
u1
0
62
Risposte nel Tempo
Su questi grafici è possibile visualizzare i valori
peak response, settling time, rise time e steady state
visti in precedenza
63
Risposte nel Tempo
In generale, su questa
tipologia di grafici, è
possibile mettere uno
o più “marker” che
indicano, oltre al nome
del sistema, il tempo
(in secondi) e il valore
del segnale (ampiezza)
Questi marker vengono utili
per misurare determinati
punti particolari del segnale
o nel confronto di più segnali
64
Simulink - Control System Toolbox
Il Control System Toolbox di Simulink
contiene tre blocchi
★ Input Point
Specifica, in uno schema
Simulink da analizzare, il
punto da considerare come
ingresso del sistema
★ LTI System
Sistema LTI in una delle
rappresentazioni viste in
precedenza
★ Output Point
Specifica, in uno schema
Simulink da analizzare, il
punto da considerare come
uscita del sistema
65
(in cui sono indicati gli ingressi e le uscite)
Step
1
1
s
s+1
Integrator
Transfer Fcn
y2 (t)
u1 (t)
Band-Limited
White Noise
Scope
y1 (t)
u2 (t)
(s+1)
(s+2)(s+3)
y3 (t)
Zero-Pole
E’ possibile analizzare / visualizzare il comportamento del
sistema tra un certo ingresso e una certa uscita inserendo nel
sistema i blocchi “Input Point” e “Output Point”
66
Step
Input Point
1
1
s
s+1
Integrator
Transfer Fcn
Output Point
Scope
Band-Limited
White Noise
(s+1)
(s+2)(s+3)
Zero-Pole
Selezionando “Linear Analysis” dal menù “Tools”
si apre automaticamente un LTI Viewer che analizza / visualizza
il comportamento del sistema tra i punti di ingresso e uscita indicati
67
Importante:
se il sistema, tra i punti di
ingresso e uscita indicati,
è non-lineare, deve essere
linearizzato con il comando “Get Linearized Model”
Nota: si possono mettere più punti di ingresso e di uscita
(in questo caso verrà analizzato / visualizzato un sistema MIMO)
68
Un altro esempio di punti di ingresso e di uscita
Step
1
1
s
s+1
Integrator
Transfer Fcn
Scope
Input Point
Band-Limited
White Noise
(s+1)
Output Point
(s+2)(s+3)
Zero-Pole
69
Si osservi la differenza tra
sistema senza disturbo e
sistema con disturbo in ingresso
Step
1
1
s
s+1
Integrator
Transfer Fcn
Scope
(s+1)
(s+2)(s+3)
Zero-Pole
Step
1
1
s
s+1
Integrator
Transfer Fcn
Scope
Band-Limited
White Noise
(s+1)
(s+2)(s+3)
Zero-Pole
70
Esempio
di
Sistema
Fisico
SISO Example: the DC Motor
A simple model of a DC motor driving an inertial load shows the angular rate
of the load, ! ( t ) , as the output and applied voltage, v a pp ( t ) , as the input. The
ultimate goal of this example is to control the angular rate by varying the
applied voltage. This picture
shows Elettrico
a simple model of the DC motor.
Motore
i(t)
R
+
L
vapp(t)
+
vemf(t)
-
I
Load
L
Inertial
DC Motor
-
Kf!(")
Viscous
friction
Load J
"(t)
Torque
!(t)
Angular rate
Figure 2-1: A Simple Model of a DC Motor Driving an Inertial Load
In this model, the dynamics of the motor itself are idealized; for instance, the
magnetic field is assumed to be constant. The resistance of the circuit is
71
Esempio di Sistema Fisico
Il motore elettrico rappresentato in figura può essere
rappresentato come un sistema dinamico LTI.
★ l’ingresso del sistema è costituito dalla tensione applicata
ai morsetti esterni
u(t) −→ Vapp (t)
★ lo stato del sistema è costituito dalla corrente nel circuito
elettrico e dalla velocità angolare della massa inerziale
!
"
i(t)
x(t) −→
ω(t)
★ l’uscita del sistema è costituito dalla velocità angolare della
massa inerziale
y(t) −→ ω(t)
72
Le equazioni di stato possono essere ottenute:
★ dalla legge di Newton (bilanciamento dei momenti angolari)
per quanto riguarda la velocità angolare della massa inerziale
J·
dω(t)
dt
=
!
i
τi (t) = τ (t) − Kf · ω(t)
MOMENTO ANGOLARE
FORZA DI ATTRITO
τ (t) = Km · i(t)
ω (t) =
!
Km
J
i(t) −
Kf
J
ω(t)
73
Le equazioni di stato possono essere ottenute:
★ dalla legge di Kirchoff alle maglie (bilanciamento delle tensioni)
per quanto riguarda la corrente nel circuito elettrico
Vapp (t) = R · i(t) + L ·
di(t)
dt
FORZA ELETTROMOTRICE
TENSIONE IN INGRESSO
i (t) = −
!
+ Vemf (t)
Vemf (t) = Kb · ω(t)
R
L
i(t) −
Kb
L
ω(t) +
1
L
Vapp (t)
74
Le equazioni di stato del motore elettrico sono quindi


R
K
b

%
&

−
−

!


i
(t)

L
L



=


!

ω
(t)
Km
Kf


−
J
J




%
&



.
i(t)



 y(t) = 0 1 ·
ω(t)


·

%
i(t)
ω(t)
&

1

 L 
+
 · Vapp (t)
0
75
Si considerino
i seguenti dati:
>>
>>
>>
>>
>>
>>
R=2
L = 0.5
R = 2.0;
L = 0.5;
Km = 0.015;
Kb = 0.015;
Kf = 0.2;
J = 0.02;
Km = 0.015
Kb = 0.015
Kf = 0.2
>>
>>
>>
>>
A
B
C
D
=
=
=
=
[
[
[
[
-R/L -Kb/L; Km/J -Kf/J ];
1/L; 0 ];
0 1 ];
0 ];
J = 0.02
76
>> sys_motore = ss(A,B,C,D)
a =
x1
x2
b =
x1
x2
c =
y1
d =
y1
x1
-4
0.75
x2
-0.03
-10
>> sys_motore_tf = tf(sys_motore)
Transfer function:
1.5
-----------------s^2 + 14 s + 40.02
u1
2
0
x1
0
x2
1
u1
0
>> sys_motore_zpk = zpk(sys_motore)
Zero/pole/gain:
1.5
------------------(s+4.004) (s+9.996)
77

LABORATORIO DI ANALISI DEI SISTEMI 1 L`ANALISI DEI SISTEMI

Transcript

Documenti analoghi

Scarica catalogo SYS@CE

sys@ce e` solo system retail!

Il nuovo registratore di cassa su tablet android

Manuale sintetico per l`uso del Control System Toolbox di Matlab

SYS@CE

Guida al Control Toolbox

SYS@101 - AMF System

Lucidi aggiuntivi su MATLAB - LaDiSpe

PRISMA Template