UNIVERSIDADE FEDERAL DO CEARÁ

CENTRO DE TECNOLOGIA
DEPARTAMENTO DE TELEINFORMÁTICA
CURSO DE ENGENHARIA DA COMPUTAÇÃO

ABEL DE FIGUEIREDO - 396432

INGRID SIMÕES- 375147
LAIS GADELHA - 378606
LEVIR LEMOS - 400555

Erro de regime

Prática para a disciplina de Introdução aos Sistemas de Controle

Fortaleza
2019
 Erro de regime permanente é definido como a diferença entre a entrada e a saída de
um sistema quando a sua resposta entra em regime permanente (i.e. quando t tende para
infinito). O erro do sistema dependerá do tipo de entrada (degrau, rampa, parábola,etc.)
bem como do tipo de sistema (0, I, II).

Quando desejamos analisar a qualidade de um sistema, aplicamos certos sinais na

sua entrada e observamos o comportamento do sinal na sua saída. Os sinais de teste
comumente usados são as funções degrau, rampa, aceleração, impulso, senoidais, etc. A
determinação de qual entrada deve ser usada para analisar características do sistema
depende da forma da entrada a que o sistema será sujeito mais freqüentemente.
K(1+T 1s)(1+T 2s)...(1+T ms)
Em geral G(s)H(s) pode ser escrita como: G(s)H(s) = sn (1+T a)(1+T b)...(1+T ns)

onde K e os T’s são constantes.

O tipo de sistema de controle se refere à ordem do pólo G(s)H(s) em s=0. Logo, um

sistema é chamado do tipo 0, tipo 1, tipo 2, ..., se N = 0, N = 1, N = 2, ... ,respectivamente.

A tabela abaixo mostra como o erro de regime permanente se relaciona com o tipo
de sistema.

Usamos o Matlab para programar rotinas necessárias para obter a resposta de

sistema (tipo 0, 1 e 2) devido às entradas degrau, rampa, parábola.

Para a entrada do sistema de tipo 0 temos, G(s)H(s)=1/(s+2)*(s+3).

A figura abaixo mostra o comportamento do sistema após a inserção da entrada a

degrau unitário.
 Pode ser observado que o sistema estabiliza em aproximadamente 3s.

Para gerar esse gráfico foi usado o código abaixo:

Sistema do tipo 0
Entrada degrau unitário

s= tf('s');
GH = 1/((s+2)*(s+3));
sys_cl = feedback(GH,1);
t = 0:0.05:6;
y = step(sys_cl,t);
plot(t,y,'o:b');
grid;
xlabel('Tempo(segundos)')
ylabel('Amplitude')
title('Resposta ao degrau unitário de G(s)H(s)=1/(s+2)*(s+3)')

Para a programação foram usados comandos como step e plot, que neste caso,
foram utilizados no mesmo programa. Isto devido à utilização da configuração a
configuração do tempo t. O tempo foi configurado de modo a obter a melhor visualização da
reação do sistema à entrada, sem perder o que o sistema mostraria automaticamente. Com
o comando tempo é possível alterar a quantidade de pontos que serão exibidos por
subdivisão da grade no gráfico. Isso pode auxiliar (como nesse exemplo) a identificar o
espaçamento da trajetória do sistema graficamente.

Para a entrada do sistema de tipo 1 temos, G(s)H(s)=1/s*(s+2)*(s+3).

A figura abaixo mostra o comportamento do sistema após a inserção da entrada

rampa unitária, com u=t.

Para gerar este gráfico foi utilizado o código abaixo:

Sistema do tipo 1
Entrada rampa unitária

s= tf('s');
GH = 1/(s*(s+2)*(s+3));
sys_cl = feedback(GH,1);
t= 0:0.5:6;
u= t;
[y,t] = lsim(sys_cl,u,t);
figure(2)
plot(t,y,'b',t,u,'m')
xlabel('Tempo(segundos)')
ylabel('Amplitude')
title('Resposta a rampa unitária de G(s)H(s)=1/s*(s+2)*(s+3)')
 legend('entrada','saÌda');

Pode ser observada uma alteração na resposta do sistema com relação ao gráfico
do sistema de tipo 0.

Para a entrada do sistema de tipo 2 temos, G(s)H(s)=(s+1)*(s+3)/s​2​*(s+2)*(s+3).

A figura abaixo mostra o comportamento do sistema após a inserção da entrada

parábola, com u=0.5*t.*t.

Para gerar este gráfico foi utilizado o código abaixo:

Sistema do tipo
Entrada parábola

s = tf('s');
GH = (s+1)*(s+3)/(s^2*(s+2)*(s+3));
sys_cl = feedback(GH,1);
t = 0:0.5:6;
u = 0.5*t.*t;
[y,t,x] = lsim(sys_cl,u,t);
figure(3)
plot(t,y,'b',t,u,'m')
 plot(t,y,'b',t,u,'m')
xlabel('Tempo(segundos)')
ylabel('Amplitude')
title('Resposta a parábola de G(s)H(s)=(s+1)*(s+3)/s^2*(s+2)*(s+3)')
legend('entrada','saída');

Para a questão 2 foi dado o sistema G(s)H(s)=(K*(s+3)*(s+5))/(s*(s+7)*(s+8) e

pede-se para encontrar a resposta do sistema para um entrada rampa com ganho K=1.

Abaixo é mostrado o código para a solução do problema:

Resposta do sistema a estrada rampa para um ganho k=1

s = tf('s');
K=1;
GH = (K*(s+3)*(s+5))/(s*(s+7)*(s+8));
t=0:0.1:100;
u=t;
sys_cl = feedback(GH,1);
[y,t,x]=lsim(sys_cl,u,t);
figure(1)
plot(t,y,'g',t,u,'m');
xlabel('Tempo(segundos)');
ylabel('Amplitude');
title('Erro de regime 1/Kv = 1:');
legend('saida','entrada');
erro_de_regime_1 = mean(u-y');
disp(erro_de_regime_1);

O código acima gera o seguinte gráfico:

 Também pede para encontrar o valor de K de modo que o erro de regime
permanente seja de 10% para a entrada rampa.

O cálculo para achar k (manualmente) é:

1/Kv = 0.1, portanto, Kv=10

10 = lim s->0 s(G(s)H(s))

10 = K*(s(s+3)(s+5))/(s(s+7)(s+8))

Como o limite tende a zero substituimos s por 0,logo:

10 = K*3*5/7*8

0.26K = 10

K = 37.33

O código para solucionar essa questão está abaixo:

K=37.33;
GH = (K*(s+3)*(s+5))/(s*(s+7)*(s+8));
 t=0:0.1:100;
u=t;
sys_cl = feedback(GH,1);
[y,t,x]=lsim(sys_cl,u,t);
figure(2)
plot(t,y,'g',t,u,'m');
xlabel('Tempo(segundos)');
ylabel('Amplitude');
title('Erro de regime 1/Kv = 0.1:');
legend('saida','entrada');
erro_de_regime_K10 = mean(u-y');
disp(erro_de_regime_K10);

O gráfico gera o seguinte gráfico:

Por fim, é perguntado o que devemos fazer, para a mesma entrada, para levar o erro
de regime permanente para zero.

Veja que a fórmula para achar o erro, é 1/Kv, se queremos que o erro seja
permanente para zero, sem mudar a entrada, basta que K tenda a infinito. Como 1/infinito =
0.Ou seja, devemos atribuir um grande valor a K. Para esse caso faremos K = 1 bilhão,
K=1000000000.
O código para a solucionar a questão está abaixo:

Para a mesma entrada, o que devemos fazer para levar o erro de

regime permanente para zero.

K=1000000000;
GH = (K*(s+3)*(s+5))/(s*(s+7)*(s+8));
t=0:0.1:100;
u=t;
sys_cl = feedback(GH,1);
[y,t,x]=lsim(sys_cl,u,t);
figure(3)
plot(t,y,'g',t,u,'m');
xlabel('Tempo(segundos)');
ylabel('Amplitude');
title('Erro de regime 1/Kv = 0:');
legend('saida','entrada');
erro_regime_KInfinito = mean(u-y');
disp(erro_regime_KInfinito);

O código acima nos dá o gráfico abaixo: