UNIVERSIDADE FEDERAL DO ABC

FERNANDO HENRIQUE GOMES ZUCATELLI

Controle Robusto Multivari

avel:
Projeto Final

SANTO ANDRE
09 DE STEMBRO DE 2014

Introducao
Por notacao usamos:
GL =

C (sI A)1 L

como a matriz que deve se aproximar da malha objetivo GKF .

A malha aberta GN K(s) e tal que GN = C (sI A)1 B e K(s) = G (sI A +
B G + H C)1 H.
CT
Sendo H =
, com calculado como solucao da seguinte equacao algebrica de

Riccati com o parametro escolhido especificamente para o projeto:

A + AT + L LT

1
CT C = 0

BT K
, com K calculado como solucao da seguinte equacao algebrica de Riccati

com o parametro escolhido especificamente para o projeto:

EG=

1
K A AT K C T C + K B B T K = 0

2 Graficos

Figura 1: Barreiras de desempenho e de estabailidade

Figura 2: Passando pelas entre as Barreiras

c para mesmo grafico da Figura 2

Figura 3: Utilizando a funcao sigma do Matlab

Figura 4: Malha Aberta GN K(s)

Figura 5: Malha Fechada CN

Figura 6: Resposta ao degrau em ambas as entradas do sistema

3 Programa
3.1 Calculo das Barreiras
%% Projeto Controle Robusto Multivariavel - C
alculo das Barreiras
%{
Autor: Fernando Henrique Gomes Zucatelli
%}
%% limpeza
format long
clc
clear all
close all
%===
%% Defini
cao das matrizes do modelo do helicoptero

[A, B, C, D] = matrizes_ABCD_originais; % Projeto

lA = length(A);
%===
%% Frequencias de fronteira
w_0 = 0.5; %Freq. m
axima da barrira desempenho
w_n = 10; %Freq. m
nima da barrira estabilidade
w_final = 500; %Freq. m=m
axima da barrira estabilidade
w = 0.1:0.1:w_final;
lw = length(w);
E = zeros(1,lA);
EM = zeros(1,lw);
a33 = linspace(-0.2,-0.16,20);
alpha_d = 0.05;
p = 1/alpha_d;
% N~
ao h
a varia
ca
~o de par^
ametros em B
B1 = B;
%% Looping para maior erro multiplicativo
for k = 1:lw
for n = 1:length(a33)
% Matriz A com varia
cao
% -0.2 <= a33 <= -0.16
A1=[-0.005131
0
0
-0.07366
0
0
0
0
0
0
0

de parametro do projeto
0
0
a33(n)
0

0;...
0
0;...
0
0;...
-0.462 0.9895;...
-0.9895 -0.462];

% Matriz de fun
coes de transferencia da planta com varia
cao de parametros
% G1=C*inv(1i*w(k)*eye(lA)-A1)*B1;
G1=C/(1i*w(k)*eye(lA)-A1)*B1;
% Matriz de fun
coes de transferencia dos atuadores

AT=(400/ ((1i*w(k))^2 + 20*1i*w(k) + 400)

)* eye(2); % Projeto

% Matriz de fun
coes de transferencia da planta real
GR=G1*AT;
% Matriz de fun
coes de transferencia da planta nominal
% GN=C*inv(1i*w(k)*eye(lA)-A)*B;
GN=C/(1i*w(k)*eye(lA)-A)*B;
% Matriz de fun
coes de transferencia do erro multiplicativo
% ERR=(GR-GN)*inv(GN);
ERR=(GR-GN)/(GN);
% Calculo dos valores singulares da matriz de erro multiplicativo
ERR1=svd(ERR);
% Calculo do valor singular maximo da matriz de erro multiplicativo
E(n)=max(ERR1);
end
% Calculo do valor singular maximo para uma dada frequencia
EI = max(E);
EM(k) = max(EI);
end
%% Looping para inverso do erro multiplicativo
EM1 = zeros(1,lw);
for k=1:lw
EM1(k) = 1/EM(k);

% Determina
cao da barreira de robustez da estabilidade

end

%% Looping para barreira de robustez do desempenho k<1000

e evitar looping infini
% Dessa forma ela
e devidamente c
alculada at
e a posi
c~
ao de w de valor w_0
k = 1;
ww = w(k);
while ww <= w_0 && k < 1000

DES(k) = p/(1 - EM(k));

k = k+1;
ww = w(k);
end

% Determina
cao da barreira de robustez do desempenho

%% Looping de organiza
cao dos graficos das barreiras especificadas
BARR = zeros(1,lw);
for k=1:lw
if w(k) <= w_0;
BARR(k)=20*log10(DES(k));
elseif w(k) < w_n;
BARR(k)=NaN;
else
BARR(k)=20*log10(EM1(k));
end
end
%% Figura com as barreiras
figure
semilogx(w ,BARR,r), xlabel(\omega), ylabel(dB)
grid on
%% Salvando vetores para serem usados depois
% Descomentar somente quando for salvar.
%%{
save w w
save BARR BARR
%}

3.2 Matrizes ABCD

function [Ap, Bp, Cp, Dp] = matrizes_ABCD_originais
Ap=[-0.005131
0
0
-0.07366
0
0

0
0
-0.1829

0
0
0

0;...
0;...
0;...

0
0

0
0

0
0

-0.462 0.9895;...
-0.9895 -0.462];

Bp=[-0.629 +0.624;...
+0.055
-0.172;...
+0.03
-0.108;...
-0.186
-0.139;...
-1.23
-0.056];
Cp=[-0.7223 -0.517 0.3386 -0.1633 0.1121;...
-0.8913 +0.4728 0.9876 +0.8425 0.2186];
Dp = 0;
end

3.3 Programa Principal

%% Projeto_Robusto_Barreira_calculada_02
%% Hist
orico e Vers~
oes
%{
Autor: Fernando Henrique Gomes Zucatelli
Vers~
ao 02
Valores de mu e rho ajustados.
Barreiras corrigidas
Alterando padr~
ao da escrita de figure()
Programa vers
atil, com uso de load w BARR
e puxando as matrizes de arquivo externo.
Vers~
ao 01
Copiando programa e definindo fun
c~
oes base
%}
%% Limpeza
format long
close all

clear all
clc
%% Carregar w, BARR salvos do arquivo "Robusto_barreiras.m"
%%{
load w
load BARR
%}
%% Carregar Emaxs, Emins, salvos deste arquivo para evitar calcular o tempo todo
% Carregando todas as vari
aveis para os gr
aficos de uma vez s
o
%%{
load Projeto_Robusto_Barreira_calculada_variaveis
%}
lw = length(w);
%% Refazendo gr
afico de barrreira calculado em "Robusto_Barreiras.m"
figure(1)
leg = Barreiras;
semilogx(w,BARR,r);
legend(leg, Location, Best)
xlabel(\omega), ylabel(dB);
title(Barreiras);
grid on, hold on
saveas(gcf,Fig_1_Barreiras.jpg)
%% Matrizes
% Defini
cao das matrizes do modelo do helicoptero
[Ap,
[lAp
[lBp
[lCp
[lDp
% Gp
%===

Bp, Cp, Dp] = matrizes_ABCD_originais;

cAp] = size(Ap);
cBp] = size(Bp);
cCp] = size(Cp);
cDp] = size(Dp);
= Cp * inv (sI - Ap)*Bp;

%% Vetor de entrada de controle u

% u = [u1 ; u2];

10

% [lu cu] = size(u);

lu = 2; cu = 1;
%% Matrizes estendidas
%====
A = [zeros(lu, cBp)
zeros(lu, cAp);...
Bp
Ap];
B = [eye(lu);...
zeros(lAp,lu)];
C = [zeros(lu)

Cp];

D = Dp;
[lA cA]
[lB cB]
[lC cC]
[lD cD]
%====

=
=
=
=

size(A);
size(B);
size(C);
size(D);

%% Escolha de mu e L
%% C
alculo de L de acordo com a vers~
ao estendida
% L_L = -inv(Cp*inv(Ap)*Bp);
L_L = -inv(Cp/(Ap)*Bp);
L_H = -inv(Ap)*Bp*L_L;
L = [L_L;
L_H];
[lL cL] = size(L);
%% Escolha de mu
%
%
%
%

Registrando todos os mu tentados em ordem cronol

ogica
mu = 1;
mu = 10^(-2); % cruza desempenho
mu = 10^(-3); % cruza estabilidade

11

% mu
% mu
% mu
mu =
% mu
% mu

= 0.5*10^(-2); %cruza estabilidade, quase ok

= 0.6*10^(-2); %ok
= 0.65*10^(-2); %ok
0.7*10^(-2); %ok
= 0.8*10^(-2); %ok, mas muito em cima
= 0.9*10^(-2); %cruza desempenho, quase ok

s = 1i*w; %s = j * omega % usando "1i" assim o Matlab faz mais r

apido
%% c
alculo de G_mu_L
% C
alculo de G_mu_L , Emax , Emin.
% C
alculo comentado para rodar apenas gr
aficos.
%{
% mu tal que G_mu_L satisfa
ca as barreiras
% G_mu_L = C*inv(s * eye(lA) - A)*L/sqrt(mu)
% Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
% G_mu_L e
uma matriz quadrada (linhas de C) x (colunas de L)
% Cada camada de G_mu_L e
a matriz para uma frequencia w
G_mu_L = zeros(lC,cL,lw);
Emax
= zeros(1,lw);
Emin
= zeros(1,lw);
% looping para preencher as posi
co
~es de G_mu_L e gerar o gr
afico
for k=1:lw
G_mu_L(:,:,k) = (C/(s(k) * eye(lA) - A) * L)/sqrt(mu);
% copiado e adaptado de "Robusto_1.m"
%===
ERR1
= svd(G_mu_L(:,:,k)); % Calculo dos valores singulares da matriz
Emax(k) = max(ERR1);

% Calculo do valor singular maximo da matriz

Emin(k) = min(ERR1);
%===
end
%}

% Calculo do valor singular minimo da matriz

12

% Criada todas as G_mu_L, gr

afico do valor singular
figure(2)
semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax),g,w,20*log10(Emin),b)
legend(strvcat(leg, E_{max},E_{min}), Location, Best);
xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares G_{\mu}_L Sistema com \mu = , num2str(mu) ];
title(titulo);
saveas(gcf,Fig_2_G_mu_L.jpg)
hold off
%% C
alculo de Sigma
% C
alculo de Sigma s
o continua se G_mu_L satisfizer as condi
c~
oes das barreiras
% help are
%{
X = ARE(A,
exists) to
A*X + X*A

% compara
c~
ao e explica
c~
ao no coment
ario
B, C) returns the stablizing solution (if it
the continuous-time Riccati equation:
- X*B*X + C = 0

nosso problema:
A * Sigma + Sigma * A - (Sigma * C * C * Sigma)/mu + L * L

nosso
A
Sigma
C * C/mu
L * L

==
==
==
==
==

are
A
X
B
C

Portanto
Sigma = are(A, C * C/mu, L * L);
%}
Sigma = are(A, (C * C)/mu, L * L);
%% C
alculo de H

= 0

13

H = Sigma * C / mu;
[lH cH] = size(H);
%% C
alculo de Malha Objetivo G_KF
% C
alculo de G_KF , Emax_G_KF , Emin_G_KF.
% C
alculo comentado para rodar apenas gr
aficos.
%{
% mu tal que G_KF satisfa
ca as barreiras
% G_KF = C*inv(s * eye(lA) - A)*H
% Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
% G_KF
e uma matriz quadrada (linhas de C) x (colunas de H)
% Cada camada de G_mu_L e
a matriz para uma frequencia w
G_KF
= zeros(lC,cH,lw);
Emax_G_KF
= zeros(1,lw);
Emin_G_KF
= zeros(1,lw);
% looping para preencher as posi
co
~es de G_KF e gerar o gr
afico
for k=1:lw
G_KF(:,:,k) = (C/(s(k) * eye(lA) - A)) * H;
%===
ERR1

= svd(G_KF(:,:,k));

% Calculo dos valores singulares da matriz

Emax_G_KF(k) = max(ERR1);

% Calculo do valor singular maximo da matriz

Emin_G_KF(k) = min(ERR1);
%===
end
%}

% Calculo do valor singular minimo da matriz

% Criada todas as G_KF, gr

afico do valor singular
figure(3)
semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax_G_KF),g,w,20*log10(Emin_G_KF),b)
legend(strvcat(leg, E_{max},E_{min}), Location, Best);

14

xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares Malha Objetivo G_{KF} Sistema com \mu = , num2str(m
title(titulo);
saveas(gcf,Fig_3_G_KF.jpg)
%% Compara
ca
~o de solu
ca
~o de programa
c~
ao sigma
%%{
sys_G_KF = ss(A,H,C,D);
sigma(sys_G_KF,w,k)
grid on,
hold off
%}
saveas(gcf,Fig_3_G_KF.jpg)
%% C
alculo de K
% Registrando todos os rho tentados em ordem cronol
ogica
% 0 < rho << 1 % cheap control
% rho = 10^(-2); % Ruim cruza Desempenho
% rho = 10^(-3); % Ruim cruza Desempenho
% rho = 10^(-4); % Ruim cruza Desempenho
% rho = 10^(-8); %Melhrou cruza a ponta do Desempenho, ainda n~
ao a Estabilidade
% rho = 10^(-9);
rho = 10^(-10); % ok
% rho = 10^(-11); % ok
% help are
%{
X = ARE(A,
exists) to
A*X + X*A

% compara
c~
ao e explica
c~
ao no coment
ario
B, C) returns the stablizing solution (if it
the continuous-time Riccati equation:
- X*B*X + C = 0

nosso problema:
-K * A - A * K - C * C + (K * B * B * K)/rho = 0
+A * K + K * A - (K * B * B * K)/rho + C * C = 0

nosso
A
K

==
==
==

are
A
X

15

B * B/rho
C * C

==
==

B
C

Portanto
K = are(A, B * B/rho, C * C);
%}
K = are(A, B * B/rho, C * C);
%% C
alculo de G (Zustandsr
uckf
uhrungskovektor: u = -G*x_hut)
G = B * K /rho;
[lG cG] = size(G);
%% Compensador K_s
% K_s = G * inv(s*eye(lA) - A + B*G + H*C ) * H;
% C
alculo de K_s , Emax_K_s , Emin_K_s.
% C
alculo comentado quando se quer apenas rodar os gr
aficos.
%{
% Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
% K_s = G/(s * eye(lA) - A + B*G + H*C ) * H;
% Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
% K_s
e uma matriz quadrada (linhas de G) x (colunas de H)
% Cada camada de K_s e
a matriz para uma frequencia w
K_s
Emax_K_s
Emin_K_s

= zeros(lG,cH,lw);
= zeros(1,lw);
= zeros(1,lw);

% looping para preencher as posi

co
~es de G_mu_L e gerar o gr
afico
for k=1:lw
K_s(:,:,k) = G/(s(k)*eye(lA) - A + B*G + H*C ) * H;
%===
ERR1

= svd(K_s(:,:,k));

% Calculo dos valores singulares da matriz

16

Emax_K_s(k) = max(ERR1);

% Calculo do valor singular maximo da matriz

Emin_K_s(k) = min(ERR1);
%===
end
%}

% Calculo do valor singular minimo da matriz

% Criada todas as K_s, gr

afico do valor singular
figure(4)
% semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax_K_s),k,w,20*log10(Emin_K_s),m)
legend(E_{max}(K_s),E_{min}(K_s), Location, Best);
xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares Compensador K_s Sistema com \mu = , num2str(mu), ,
title(titulo);
saveas(gcf,Fig_4_K_s.jpg)
hold off
%% C
alculo de G_N com os integrador em G_a
% C
alculo de G_N , G_N_K_s , C_N
% C
alculo comentado quando se quer apenas rodar os gr
aficos.
%{
% Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
% G_a
= eye(lu)/s;
% G_p
= Cp * inv (s*I - Ap)*Bp;
% G_N
= G_p * G_a;
% G_N_K_s
= G_N * K_s;
% C_N
= inv(I + G_N_K_s)*G_N_K_s
%
%
%
%
%

Nesta express~
ao s
e um vetor, ent~
ao haver
a um for para cada w
G_a
e uma matriz quadrada (linhas de u)
x (colunas de u)
G_p
e uma matriz quadrada (linhas de Cp) x (colunas de Bp)
G_N
e uma matriz quadrada (linhas de G_p) x (colunas de G_a)
Cada camada de G_N e
a matriz para uma frequencia w

G_a

= zeros(lu,lu,lw);

17

G_p
= zeros(lCp,cBp,lw);
G_N
= zeros(lCp,lu,lw); %produto de G_p * G_a
G_N_K_s
= zeros(lCp,cH,lw); %produto de G_N * K_s
C_N
= zeros(lCp,cH,lw);
Emax_G_N
= zeros(1,lw);
Emin_G_N
= zeros(1,lw);
Emax_G_N_K_s = zeros(1,lw);
Emin_G_N_K_s
= zeros(1,lw);
Emax_C_N
= zeros(1,lw);
Emin_C_N
= zeros(1,lw);
% looping para preencher as posi
co
~es de G_mu_L e gerar o gr
afico
for k=1:lw
G_a(:,:,k)
= eye(lu)/s(k);
G_p(:,:,k)
= Cp / (s(k)*eye(lAp) - Ap) * Bp;
G_N(:,:,k)
= G_p(:,:,k) * G_a(:,:,k);
G_N_K_s(:,:,k) = G_N(:,:,k) * K_s(:,:,k);
%
C_N(:,:,k)
= inv( eye(lCp) + G_N_K_s(:,:,k)) * G_N_K_s(:,:,k);
C_N(:,:,k)
= (eye(lCp) + G_N_K_s(:,:,k)) \ G_N_K_s(:,:,k);
%===
ERR1

= svd(G_N(:,:,k));

Emax_G_N(k) = max(ERR1);

% Calculo dos valores singulares da matriz

% Calculo do valor singular maximo da matriz

Emin_G_N(k) = min(ERR1); % Calculo do valor singular minimo da matriz

%===
%===
ERR1
= svd(G_N_K_s(:,:,k)); % Calculo dos valores singulares da matriz
Emax_G_N_K_s(k) = max(ERR1);

% Calculo do valor singular maximo da matriz

Emin_G_N_K_s(k) = min(ERR1); % Calculo do valor singular minimo da matriz

%===
%===
ERR1
= svd(C_N(:,:,k)); % Calculo dos valores singulares da matriz
Emax_C_N(k) = max(ERR1);

% Calculo do valor singular maximo da matriz

18

Emin_C_N(k) = min(ERR1);
%===
end
%}

% Calculo do valor singular minimo da matriz

% Criada todas as G_N, grafico do valor singular

figure(5)
% semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax_G_N),k,w,20*log10(Emin_G_N),y)
legend(E_{max}(G_N),E_{min}(G_N), Location, Best);
xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares Planta G_N Sistema com \mu = , num2str(mu), , \rho
title(titulo);
saveas(gcf,Fig_5_G_N.jpg)
hold off

% Compensador G_N_K_s = G_N * K_s

figure(6)
semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax_G_N_K_s),b,w,20*log10(Emin_G_N_K_s),c)
legend(strvcat(leg, E_{max}(G_N * K_s),E_{min}(G_N * K_s)), Location, Best)
xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares de Malha Aberta (G_N * K_s) Sistema com \mu = , num
title(titulo);
saveas(gcf,Fig_6_G_N_K_s.jpg)

% Malha Fechada C_N = inv(I + G_N_K_s)*G_N_K_s

figure(7)
semilogx(w,BARR,r);
grid on, hold on
semilogx(w,20*log10(Emax_C_N),b,w,20*log10(Emin_C_N),c)
legend(strvcat(leg, E_{max}(C_N),E_{min}(C_N)), Location, Best);
xlabel(\omega), ylabel(dB);
titulo = [ Valores Singulares de Malha Fechada C_N Sistema com \mu = , num2str(mu
title(titulo);
saveas(gcf,Fig_7_C_N.jpg)

19

%% Resposta ao Degrau em cada entrada

% Defini
ca
~o das matrizes do sistema em malha fechada
%{
[ x_dot ] = A_MF*[ x ] + B_MF * [r]
[ w_dot ]
[ w ]
[
y
[ w ]
%}

] = C_MF*[ x ] + D_MF * [r]

A_MF = [(A-B*G )
(B*G);...
zeros(lA,cA)
(A-H*C)];
B_MF = [zeros(lA,lu);...
H];
C_MF = [C zeros(lC,cA)];
D_MF = zeros(lC);

% tempo de simula
ca
~o e fun
ca
~o de refer^
encia r
%%{
tempo = linspace(0,1,200);
r = zeros(1,length(tempo));
for i=1:length(tempo)
r(1,i)=1;
r(2,i)=0;
end
%}
% Simula
ca
~o da resposta
figure(8)
sys_MF = ss(A_MF, B_MF, C_MF ,D_MF);
lsim(sys_MF,r,tempo); grid on
xlabel(t), ylabel(Amplitude);
titulo = [ Resposta ao degrau da Malha Fechada Sistema com \mu = , num2str(mu),
title(titulo);
saveas(gcf,Fig_8_Resp_degrau.jpg)

20

%% Fim
%% Salvando todos vetores para os gr
aficos em um u
nico arquivo
%%{
save Projeto_Robusto_Barreira_calculada_variaveis ...
Emax Emin Emax_K_s Emin_K_s Emax_G_N Emin_G_N ...
Emax_G_N_K_s Emin_G_N_K_s Emax_G_KF Emin_G_KF ...
Emax_C_N Emin_C_N tempo r
%}