Universidade Federal do ABC

Centro de Engenharia, Modelagem e Ciências Sociais Aplicadas

ESTB029-17 - Análise e Controle de Sistemas Mecânicos
1º quadrimestre de 2022

LABORATÓRIO 04
CONTROLADOR PD, PI E PID

1. Objetivo
Este laboratório tem por objetivo utilizar o Matlab para projetar controladores PI, PD e PID.

2. Introdução

2.1. Melhorando o erro em regime permanente com o controlador PI

Dado um sistema do tipo 0, sabemos que, para uma entrada degrau, vamos obter um erro de estado
estacionário constante. Uma possível maneira de se melhorar o erro de estado estacionário é alterando
o tipo do sistema, de modo que o erro de estado estacionário para uma entrada degrau seja nulo. Isso pode
ser feito incluindo um polo na origem do sistema, através de um controlador integrador, com função de
transferência K/s. O problema de utilizar controladores nesse formato é que alteramos a posição dos polos e
zeros do sistema, e assim alteramos a resposta transitória do sistema, fazendo com que uma resposta
transitória antes possível deixe de fazer parte do Lugar das Raízes do sistema, como pode ser visto na Figura
1.

Figura 1 - Polo em A está no lugar das raízes sem o controlador integrador e não está no lugar das raízes
com o controlador integrador.

Uma maneira de resolver isso é incluir um zero, próximo ao polo da origem, como mostra a Figura 2.

Figura 2 - Polo em A está aproximadamente no mesmo lugar das raízes com a inclusão do polo e do
zero.

Quando o zero está bem próximo da origem, θzc ≈ θpc, e o comportamento do sistema é pouco alterado. Esse
controlador é chamado de controlador PI, ou controlador proporcional e integral, uma vez que a inclusão do
zero equivale a somar um controlador proporcional com outro integral, como mostra a equação 1.

𝐾(𝑠 + 𝑎) 𝐾⁄ (1)
𝑎
=𝐾+
𝑠 𝑠

A comparação entre as saídas apenas com o ganho simples e com o controlador PI pode ser vista na Figura 3.
Figura 3 - Comparação das saídas de um sistema com controladores de ganho simples (original) e PI.

2.2. Melhorando a resposta transitória com o controlador PD

Podemos também projetar um controle que melhore a ultrapassagem percentual e o tempo de acomodação.
Para isso devemos alterar a forma do lugar das raízes. Uma das maneiras possíveis é incluir um zero no
sistema, através da inclusão de um derivador no sistema de controle. Esse controlador é chamado de
controlador proporcional derivativo (PD). Sua função de transferência pode ser vista na equação 2, e o
diagrama de blocos de um sistema com controlador PD é mostrado na Figura 4.

𝐺𝑐 (𝑠) = 𝐾(𝑠 + 𝑧𝑐 ) = 𝐾𝑠 + 𝐾𝑧𝑐 = 𝐾2 𝑠 + 𝐾1 (2)

Figura 4 - Comparação das saídas de um sistema com controladores de ganho simples (original) e PI.

2.3. Melhorando o erro em regime permanente e a resposta transitória com o controlador PID
Combinando os controladores PD e PI é possível obter uma melhora tanto no erro de estado estacionário
quanto na resposta transitória de forma independente. Um controlador desse tipo é chamado de controlador
PID. Sua função de transferência pode ser vista na equação 3, e o diagrama de blocos de um sistema com
controlador PD é mostrado na Figura 5.
 2 𝐾1 𝐾 (3)
𝐾2 𝐾1 𝑠 + 𝐾2 + 𝐾3 𝑠 2 𝐾3 (𝑠 + ⁄𝐾 𝑠 + 2⁄𝐾 )
3 3
𝐺𝑐 (𝑠) = 𝐾1 + + 𝐾3 𝑠 = =
𝑠 𝑠 𝑠

Figura 5 - Comparação das saídas de um sistema com controladores de ganho simples (original) e PI.

O projeto do controlador segue as seguintes etapas:

1. calcular o desempenho do sistema com ganho simples para determinar a melhoria necessária
2. projetar o PD para atender à resposta transitória
3. simular o sistema, verificar se os requisitos foram atendidos e reprojetar se necessário
4. projetar o controlador PI para produzir o e(∞) desejado
5. determinar os ganhos K1, K2 e K3
6. simular o sistema, verificar se os requisitos foram atendidos e reprojetar se necessário

2.4. Regra de sintonia de Ziegler-Nichols

Considere o sistema de controle mostrado na Figura 6 no qual um controlador PID é utilizado para controlar
o sistema. Vamos aplicar a regra de sintonia de Ziegler-Nichols na determinação dos parâmetros do
controlador. O controlador PID tem a seguinte função de transferência.

1 (4)
𝐺𝑐 (𝑠) = 𝐾𝑝 (1 + + 𝑇𝑑 𝑠)
𝑇𝑖 𝑠
 Figura 6 – Sistema com controle PID.

Como a planta tem um integrador, utilizamos o segundo método das regras de sintonia de Ziegler-Nichols.
Fazendo Ti = ∞ e Td = 0, obtemos a função de transferência de malha fechada como segue:

𝐶(𝑠) 𝐾𝑝 (5)
=
𝑅(𝑠) 𝑠(𝑠 + 1)(𝑠 + 5) + 𝐾𝑝

O valor de Kp que torna o sistema marginalmente estável, de modo que ocorram oscilações sustentadas, pode
ser obtido pelo uso do critério de estabilidade de Routh. Uma vez que a equação característica do sistema em
malha fechada é:

𝑠 3 + 6𝑠 2 + 5𝑠 + 𝐾𝑝 = 0 (6)

A tabela de Routh fica:

s3 1 5
s2 6 Kp
s1 30 − 𝐾𝑝
6
s0 Kp

Examinando os coeficientes da primeira coluna da tabela de Routh, determinamos que oscilações sustentadas
existirão de Kp = 30. Portanto, o valor crítico KCU = 30 e a equação característica resulta em:

𝑠 3 + 6𝑠 2 + 5𝑠 + 30 = 0 (7)

Para encontrar a frequência de oscilação sustentada, substituímos s = jω na equação característica, como

segue:

(𝑗𝜔)3 + 6(𝑗𝜔)2 + 5(𝑗𝜔) + 30 = 0 (8)

Ou
6(5 − 𝜔2 ) + 𝑗𝜔(5 − 𝜔2 ) = 0 (9)

Portanto, a frequência da oscilação sustentada será 𝜔2 = 5 → 𝜔 = √5. Logo, o período de oscilação

sustentada é:

2𝜋 (10)
𝑃𝑐𝑢 = = 2,8099
𝜔

De acordo com a Tabela 1, determinamos os ganhos do controlador PID:

𝐾𝑝 = 0,6𝐾𝑐𝑢 = 18 (11)
𝑇𝑖 = 0,5𝑃𝑐𝑢 = 1,405 (12)
𝑇𝑑 = 0,125𝑃𝑐𝑢 = 0,35124 (13)

Tabela 1 – Regra de sintonia de Ziegler-Nichols baseada no ganho e período críticos.

A função de transferência do controlador PID é, portanto,

1 1 6,3223(𝑠 + 1,4235)2 (14)

𝐺𝑐 (𝑠) = 𝐾𝑝 (1 + + 𝑇𝑑 𝑠) = 18 (1 + + 0,35124𝑠) =
𝑇𝑖 𝑠 1,405𝑠 𝑠

O controlador PID tem um polo na origem e um zero duplo em s = -1,4235. Um diagrama de blocos do
sistema de controle com o controlador PID é mostrado na Figura 7.
 Figura 7 – Diagrama de blocos do sistema com o controlador PID.

A resposta desse sistema ao degrau unitário é mostrada na Figura 8. O sobressinal máximo na resposta ao
degrau unitário é de aproximadamente 62%. Ele pode ser reduzido fazendo-se uma sintonia fina dos
parâmetros do controlador.

Figura 8 – Curva de resposta ao degrau unitário de um sistema com controlador PID projetado com o uso
da regra de sintonia de Ziegler-Nichols.

2.5. Especificações de sistemas de ordem superior a 2

Admitindo um sistema de 3ª ordem com dois polos complexos e outro no eixo real, sua resposta ao degrau
unitário é dada por:

1 𝑏𝑐 (15)
𝐶(𝑠) = 𝑅(𝑠)𝐺(𝑠) = 2
𝑠 (𝑠 + 𝑎𝑠 + 𝑏)(𝑠 + 𝑐)

Expandindo em frações parciais, temos:

 1 𝐴𝑠 + 𝐵 𝐶 (16)
𝐶(𝑠) = + 2 +
𝑠 𝑠 + 𝑎𝑠 + 𝑏 𝑠 + 𝑐

Onde:

𝑐𝑎 − 𝑐 2 (17)
𝐴=
𝑐 2 + 𝑏 − 𝑐𝑎
𝑐𝑎2 − 𝑐 2 𝑎 − 𝑏𝑐 (18)
𝐵=
𝑐 2 + 𝑏 − 𝑐𝑎
−𝑏 (19)
𝐶= 2
𝑐 + 𝑏 − 𝑐𝑎

Podemos perceber que, quanto maior o valor de c, menos o terceiro polo influencia na resposta do sistema.
Quando c → ∞, temos que A = -1, B = -a e C = 0, e a saída se aproxima a:

1 𝑠+𝑎 (20)
𝐶(𝑠) = − 2
𝑠 𝑠 + 𝑎𝑠 + 𝑏

𝑏
Essa saída é exatamente a resposta ao degrau de um sistema de 2ª ordem padrão [𝐺(𝑠) = 𝑠2 +𝑎𝑠+𝑏].

3. Atividade para a aula

Dado o sistema da Figura 9 operando com uma ultrapassagem de 20%, o programa apresentado abaixo
projeta um controlador PID de modo que o tempo de pico diminua em um terço e o erro de estado
estacionário seja nulo.

Figura 9 – Sistema com ganho simples.

clear all;
close all;
more off;
clc;
s = tf('s');
G = (s+8)/((s+3)*(s+6)*(s+10))
H = 1;
UP = 20;

disp(['Qual valor de zeta corresponde a \%UP = ' num2str(UP) ' %?']);

zeta = findZeta(UP)

disp(['Qual o valor do ganho K que fornece a \%UP = ' num2str(UP) ' %?']);
[K,sigma_d,omega_d] = findK(G*H,zeta)

disp('Controlador PI');
Gc_pi = (s+0.5)/s;
[K_pi,sigma_d_pi,omega_d_pi] = findK(Gc_pi*G*H,zeta)

disp('Controlador PD reduzindo Tp em 1/3');

omega_d_pd = omega_d/(2/3)
sigma_d_pd = omega_d_pd/tan(acos(zeta))
[polos , zeros] = pzmap(G*H);
angulo_pd_rad = pi-findAngle(polos,zeros,-sigma_d_pd+i*omega_d_pd)
angulo_pd = (angulo_pd_rad-2*pi)*180/pi
zc = (omega_d_pd/tan(angulo_pd_rad)) + sigma_d
Gc_pd = (s+zc);
[K_pd,sigma_d_pd,omega_d_pd] = findK(Gc_pd*G*H,zeta)

disp('Controlador PID');
[K_pid,sigma_d_pid,omega_d_pid] = findK(Gc_pi*Gc_pd*G*H,zeta)

Gc_pid = K_pid*Gc_pi*Gc_pd;
coeficientes = cell2mat(Gc_pid.num);
K_3 = coeficientes(1)
K_2 = coeficientes(3)
K_1 = coeficientes(2)

disp('Simulacao entrada degrau');

Npontos=10000;
tempos = linspace(0,7,Npontos);
u_degrau = ones(1,Npontos);
F = feedback(K*G,1);
[Y,T,X] = lsim(F,u_degrau,tempos);

F_pi = feedback(K_pi*Gc_pi*G,1);
[Y_pi,T,X] = lsim(F_pi,u_degrau,tempos);

F_pd = feedback(K_pd*Gc_pd*G,1);
[Y_pd,T,X] = lsim(F_pd,u_degrau,tempos);

F_pid = feedback(K_pid*Gc_pi*Gc_pd*G,1);
[Y_pid,T,X] = lsim(F_pid,u_degrau,tempos);

figure(1);
plot(tempos,Y,'b');
hold on;
plot(tempos,Y_pi,'r');
plot(tempos,Y_pd,'k');
plot(tempos,Y_pid,'m');
grid on;
legend('Ganho simples','PI','PD','PID');

% function [K,sigma_d,omega_d] = findK(G,zeta)

% Encontra o valor de K que faz o lugar das raizes
% cruzar a reta correspondente de determinado zeta.
function [K,sigma_d,omega_d] = findK(GH,zeta)

passo = 0.02;

[polos , zeros] = pzmap(GH);

num_GH = cell2mat(GH.num);
for n = 1:length(num_GH)
if(num_GH(n) ~= 0)
Ganho1 = num_GH(n);
break;
end
end
den_GH = cell2mat(GH.den);
for n = 1:length(den_GH)
 if(den_GH(n) ~= 0)
Ganho2 = den_GH(n);
break;
end
end
Ganho = Ganho1/Ganho2;

cosseno = zeta;
seno = sqrt(1-zeta^2);

modulo = 0.5;
ponto = (-cosseno+seno*i)*modulo;
angulo = findAngle(polos,zeros,ponto);
delta_modulo = 1;
contador = 0;
erro_angulo = mod(pi-angulo+pi,2*pi)-pi;
while(abs(erro_angulo)>1e-4)
contador = contador + 1;
modulo = modulo + delta_modulo;
ponto = (-cosseno+seno*i)*modulo;
angulo_novo = findAngle(polos,zeros,ponto);
delta_angulo = angulo_novo-angulo;
erro_angulo = mod(pi-angulo_novo+pi,2*pi)-pi;
if delta_angulo==0
delta_angulo=1e-6;
end
delta_modulo = passo*delta_modulo*erro_angulo/delta_angulo;
angulo = angulo_novo;

%disp([contador angulo modulo]);

if(contador>10000)
break;
end
end

sigma_d = modulo*cosseno;
omega_d = modulo*seno;
 M = 1;
for p = 1:length(polos)
M=M/abs(-sigma_d+i*omega_d-polos(p));
end
for p = 1:length(zeros)
M=M*abs(-sigma_d+i*omega_d-zeros(p));
end

K = 1/(M*Ganho);
if(contador>1000)
disp('ERRO: findK: nao encontrou K');
end

end

% Funcao [zeta] = findZeta(UP)

% Encontra o valor de zeta que corresponde a uma
% dada ultrapassagem percentual
function [zeta] = findZeta(UP)
zeta = sqrt(1/((pi*pi/((log(UP/100.0))^2)) + 1));
end

function angulo = findAngle(polos,zeros,ponto)

angulo=0;
for p = 1:length(polos)
angulo=angulo-angle(ponto-polos(p));
end
for p = 1:length(zeros)
angulo=angulo+angle(ponto-zeros(p));
end

end

4. Atividades para entregar

4.1. O sistema com realimentação unitária mostrado na Figura 10 opera com 10% de ultrapassagem quando
submetido a uma entrada degrau unitário.

Figura 10 – Sistema com realimentação unitária.

Sabe-se que sua função de transferência é dada por:

𝐾 (21)
𝐺(𝑠) =
(𝑠 + 1)(𝑠 + 3)(𝑠 + 5)

Pede-se:
a. Qual o tipo do sistema? Explique.
b. Qual valor de ζ corresponde à %UP de 10%?
c. Qual o valor do ganho K que fornece a %UP de 10%?
d. Qual o valor da constante de erro estático para esse valor de K? E o erro de estado estacionário?
e. Projete um controlador PI que elimine o erro de estado estacionário.
f. Projete um controlador PD que reduza o tempo de pico pela metade.
g. Projete um controlador PID que elimine o erro de estado estacionário e reduza o tempo de pico pela
metade.
h. Plote, em um mesmo gráfico, as saídas do sistema original e dos sistemas controlados.
i. Encontre os tempos de acomodação de cada um dos sistemas

4.2. Considere o sistema de controle mostrado no item 2.4. Faça uma sintonia fina dos parâmetros do
controlador PID de forma que a resposta ao degrau unitário apresente o sobressinal máximo entre 2% e 10%
e o tempo de acomodação seja menor que 3 s. Utilize uma abordagem computacional em Matlab.