Controle de um Pêndulo Invertido sobre um Carrinho utilizando

Controle Ótimo Quadrático

Alex Antonio Affonso

Este trabalho consiste na elaboração de um sistema de controle para um pêndulo

invertido sobre um carrinho, utilizando-se para tal, técnicas de controle ótimo quadrático.

Na figura 1 visualiza-se um esquemático do pêndulo invertido.

Figura 1.

Segundo [1], tem-se abaixo as equações que regem a dinâmica do pêndulo invertido.

Por fim, resumindo-se as equações do pêndulo invertido, obtém-se [1]:

 Como pode-se perceber, este sistema é um sistema não-linear. Portanto, deve-se

linearizá-lo em torno de um ponto de operação. Linearizando-o em torno de θ = 0 e

considerando-se os termos abaixo como desprezíveis, obtém um modelo linear para o

referido pêndulo invertido.

 2 , 2 ,  desprezados

( M  m)  x  m  l    u

( I  m  l 2 )  m  l  x  m  g  l  

Então, pode-se agora representar o modelo linearizado do pêndulo invertido por

variáveis de estado, conforme abaixo [1]:

Maiores detalhes sobre a modelagem e representação do pêndulo invertido podem

ser obtidos em [1] e em [2].

Para efetuar-se o controle de realimentação de estado do pêndulo utilizou-se u = -kx.

K é a matriz ganho da realimentação de estado K = [K1 K2 K3 K4].

Deve-se calcular K no MATLAB a fim de que o índice de desempenho J seja

minimizado:


J   ( x  Q  x  u  R  u )dt
0
 Segundo [1], considerar inicialmente Q e R dados conforme abaixo.

Pede-se ainda em [1] para considerar-se a resposta do sistema às seguintes

condições iniciais dadas abaixo.

Para validar o projeto deve-se simular o modelo não-linear e comparar os resultados

obtidos com os resultados obtidos da simulação do modelo linearizado.

Para a simulação do modelo não-linear com a função ODE23 do MATLAB, deve-se

representar o pêndulo em forma de variáveis de estado. Deve-se então considerar agora as

equações que regem a dinâmica do sistema não-linear apresentadas em [1]:

A partir das duas equações diferenciais acima e definindo-se o mesmo vetor de

estados acima definido, x, consegue-se com um pouco de álgebra obter a representação do

.  M  m   [ g  sen( x1 )  ( x 2 ) 2  sen( x1 )  cos( x1 )  1  l  ]  cos( x1 )  u  m  l  sen( x1 )  cos( x1 )  ( x 2 ) 2

x2 
 m  l  (cos( x1 )) 2  ( M  m)  [(sen( x1 )) 2  l  (cos( x1 )) 2 ]
 modelo não-linear do pêndulo invertido em variáveis de estados, as quais são apresentadas

abaixo.

De [1] sabe-se que:

.
x1  x 2

Programou-se o modelo não-linear no MATLAB, conforme abaixo.

.
x3  x 4
xdot=[x(2);(2.1*(9.81*(sin(x(1)))+
((x(2))^2)*(sin(x(1)))*(cos(x(1)))*1.5)-(cos(x(1)))*u-
0.05*(sin(x(1)))*(cos(x(1)))*((x(2))^2))/(-0.05*((cos(x(1)))^2)-

m  l  cos( x1 )  {
 M  m  [ g  sen( x1 )  ( x2 )2  sen( x1 )  cos( x1 )  1  l  ]  cos( x1 )  u  m  l  sen( x1 )  cos( x1 )
. u  m  l  sen( x1 )  ( x2 )2  m  l  (cos( x1 )) 2  ( M  m)  [(sen( x1 )) 2  l  (cos( x1 )) 2 ]
x4  
( M  m) ( M  m)
2.1*(((sin(x(1)))^2)-0.5*((cos(x(1)))^2)));
x(4);(((u+0.05*(sin(x(1)))*((x(2))^2))/(2.1))-
(0.05*(cos(x(1)))*((2.1*(9.81*(sin(x(1)))+
((x(2))^2)*(sin(x(1)))*(cos(x(1)))*1.5)-(cos(x(1)))*u-
0.05*(sin(x(1)))*(cos(x(1)))*((x(2))^2))/(-0.05*((cos(x(1)))^2)-
2.1*(((sin(x(1)))^2)-0.5*((cos(x(1)))^2))))/(2.1)))];

RESOLUÇÃO DO PROBLEMA VIA MATLAB

A fim de se resolver o problema escreveram-se em linguagem Matlab os seguintes

programas:

Pendulo.m

%Controle de Pêndulo Invertido sobre um Carrinho

% Controle Ótimo Quadrático

clear all
close all
clc

global K

%Matriz de estados A e matriz de controle B

A=[0 1 0 0; 20.601 0 0 0; 0 0 0 1; -0.4905 0 0 0];
B=[0; -1; 0; 0.5];

%Matrizes Q e R do índice de desempenho quadrático

Q=[100 0 0 0; 0 1 0 0; 0 0 1 0; 0 0 0 1];
R=0.01;

%K => Matriz de Ganho de Retroação

%P => Solução P da equação de Riccati
%E => Pólos de Malha Fechada (Autovalores de A-BK)
[K,P,E]=lqr(A,B,Q,R)

%Com realimentação
AA=A-B*K;

%Condições iniciais
I0=[0.1 0 0 0];

%Resposta do sistema às condições iniciais

%Modelo Linearizado realimentado

C=eye(4,4);
D=[0;0;0;0];
B=D;

[x,y,t]=initial(AA,B,C,D,I0);% resposta a condicao inicial I0

x1=x(:,1);
x2=x(:,2);
x3=x(:,3);
x4=x(:,4);

%Resposta do sistema às condições iniciais

%Modelo Não - Linear

[t1,x]=ode23('pendulofunction',t,I0); %Neste caso t1=t

x11=x(:,1);
x22=x(:,2);
x33=x(:,3);
x44=x(:,4);

%Sinal de controle do modelo linearizado

for i=1:length(t)
 u(i)=-K*[x1(i) x2(i) x3(i) x4(i)]';
end

%Sinal de controle do modelo não-linear

for i=1:length(t1)
u11(i)=-K*[x11(i) x22(i) x33(i) x44(i)]';
end

figure(1);
%x1 versus t: Teta x tempo
subplot(2,2,1);
plot(t,x1,'b',t1,x11,'r');grid
%%%plot(t,x1);grid
title('x1(Teta) versus t');
xlabel('t s');
ylabel('x1 = Teta');

%x2 versus t: Teta Ponto x tempo

subplot(2,2,2);
plot(t,x2,'b',t1,x22,'r');grid
title('x2(Teta Ponto) versus t');
xlabel('t s');
ylabel('x2 = Teta Ponto');

%x3 versus t: Deslocamento x tempo

subplot(2,2,3);
plot(t,x3,'b',t1,x33,'r');grid
%%%plot(t,x2);grid
title('x3(Deslocamento) versus t');
xlabel('t s');
ylabel('x3 = Deslocamento');

%x4 versus t: Velocidade x tempo

subplot(2,2,4);
plot(t,x4,'b',t1,x44,'r');grid
title('x4(Velocidade do Carrinho) versus t');
xlabel('t s');
ylabel('x4 = Velocidade do Carrinho');

figure(2);
%u versus t: Sinal de Controle (u)
subplot(2,1,1);
plot(t,u,'b',t1,u11,'r');grid
title('u versus t');
xlabel('t s');
ylabel('u = Sinal de Controle');
Subrotina Pendulo1.m

(Esta subrotina deve ser um arquivo .m localizada no mesmo caminho que o

programa principal: pendulo)

function [xdot] = pendulofunction(t,x)

global K

u=-K*[x(1); x(2);x(3); x(4)];

%observe que estamos calculando a solução do sistema com realimentação

u=-Kx

xdot=[x(2);(2.1*(9.81*(sin(x(1)))+
((x(2))^2)*(sin(x(1)))*(cos(x(1)))*1.5)-(cos(x(1)))*u-
0.05*(sin(x(1)))*(cos(x(1)))*((x(2))^2))/(-0.05*((cos(x(1)))^2)-
2.1*(((sin(x(1)))^2)-0.5*((cos(x(1)))^2)));
x(4);(((u+0.05*(sin(x(1)))*((x(2))^2))/(2.1))-
(0.05*(cos(x(1)))*((2.1*(9.81*(sin(x(1)))+
((x(2))^2)*(sin(x(1)))*(cos(x(1)))*1.5)-(cos(x(1)))*u-
0.05*(sin(x(1)))*(cos(x(1)))*((x(2))^2))/(-0.05*((cos(x(1)))^2)-
2.1*(((sin(x(1)))^2)-0.5*((cos(x(1)))^2))))/(2.1)))];

Primeiramente resolveu-se o problema para Q e R dados:

Obteve-se:
100 0 0 0
 0 1 0 0
Q , R  1
 0 0 1 0
 
 0 0 0 1

K=

-54.0554 -11.8079 -1.0000 -2.7965

P=

326.7189 69.2133 11.8079 30.3158

69.2133 15.2894 2.7051 6.9631
11.8079 2.7051 2.7965 3.4102
30.3158 6.9631 3.4102 8.3331
E=

-4.6944 + 0.9514i
-4.6944 - 0.9514i
-0.5104 + 0.4088i
-0.5104 - 0.4088i

Agora, pretende-se melhorar a resposta obtida anteriormente, ou seja, melhorar os

índices de desempenho do sistema em questão. Para isso escolheram-se:

100 0 0 0
 0 1 0 0
Q , R   0.01
 0 0 1 0
 
 0 0 0 1
 Aqui minimizou-se R a fim de se tentar obter uma melhor atuação no sinal de

controle. Note nos resultados abaixo que os índices de desempenho melhoraram, conforme

o esperado.

K=

-165.0902 -31.0313 -10.0000 -19.8639

P=

30.0891 4.3147 3.1031 5.3276

4.3147 1.0620 0.8364 1.5033
3.1031 0.8364 1.9864 1.4729
5.3276 1.5033 1.4729 2.6094

E=

-9.7166 + 3.4316i
-9.7166 - 3.4316i
-0.8330 + 0.4795i
-0.8330 - 0.4795i
 Agora escolheram-se:

100 0 0 0
 0 1 0 0
Q , R   0.01
 0 0 100 0
 
 0 0 0 1

Tenta-se assim minimizar X3, o que reduzirá os índices de desempenho do sistema.

Obteve-se:

K=

-289.6689 -61.9517 -100.0000 -74.7368

P=

89.7899 18.6900 61.9517 31.5867

18.6900 4.5391 14.7140 7.8392
61.9517 14.7140 74.7368 27.4279
31.5867 7.8392 27.4279 14.1836

E=

-9.7900 + 4.0657i
-9.7900 - 4.0657i
-2.5016 + 1.5721i
-2.5016 - 1.5721i
 Como pode-se observar, os índices de desempenho melhoraram e, ainda nesta

mesma “linha de raciocínio “, escolheram-se:

100 0 0 0
 0 1 0 0
Q , R   0.01
 0 0 800 0
 
 0 0 0 1
 Com estes valores obteve-se os seguintes resultados, que quando comparados com

os anteriores, se mostram melhores.

K=

-513.5160 -113.9266 -282.8427 -168.8891

P=

289.8697 64.3963 322.2330 118.5223

64.3963 14.9869 73.8872 27.6953
322.2330 73.8872 477.6905 142.1176
118.5223 27.6953 142.1176 52.0129

E=

-10.8272 + 6.9258i
-10.8272 - 6.9258i
-3.9138 + 1.2159i
-3.9138 - 1.215
 Assim demonstra-se que é possível obter-se melhores resultados por meio de

tentativas criteriosas em Q e R, até se obter uma resposta satisfatória.

Durante todos os gráficos acima pode-se perceber uma curva azul sobreposta a uma

curva vermelha:
  Curva Vermelha => Modelo Não-Linear;

 Curva Azul => Modelo Linearizado.

Assim demonstrou-se também com este trabalho que o modelo linearizado

representa fielmente o modelo não linear na região próxima ao ponto de equilíbrio, ou seja,

do ponto de linearização.

CONCLUSÃO: Estudou-se neste trabalho um sistema não-linear: sua modelagem e

representação em variáveis de estado, apresentando também a linearização do modelo em

torno de um ponto de operação. Empregaram-se técnicas de controle ótimo quadrático, a

fim de se controlar o pêndulo invertido sobre o carrinho. Demonstrou-se métodos para se

atingir melhores índices de desempenho e por fim validou-se o modelo linearizado com a

simulação em conjunto do modelo não-linear.

ANEXO: Diagrama de Blocos do Sistema Final
BIBLIOGRAFIA

[1] – OLIVEIRA, V. A.; Exercício – SEL 380 Controle Robusto – Controle Pêndulo Invertido sobre um

Carrinho;

[2] – OGATA, K.; Engenharia de Controle Moderno; PHB; 2a edição; 1993