1

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 2023

LABORATÓRIO 01
SIMULAÇÃO DE SISTEMAS LINEARES, ESTABILIDADE E ERROS EM REGIME PERMANENTE

1. Objetivo
Esta aula prática tem por objetivo:
a. apresentar algumas das ferramentas básicas de simulação de modelos matemáticos do Matlab. Desta
forma será possível encontrar a resposta de um sistema de equações diferenciais ordinárias lineares (com
coeficientes que não variam no tempo), de acordo com as condições iniciais fornecidas.
b. apresentar comandos do Matlab que são úteis na manipulação de funções de transferência, de modo a
simplificar diagramas de blocos. Mostram-se formas de fazer a soma (addpoly) e a multiplicação (conv) de
polinômios, bem como fazer o Matlab tratar funções de transferência como um “objeto” (tf). Desta forma será
possível utilizar comandos que associam esses objetos em série (series), paralelo (parallel) e em feedback
unitário (feedback). Por fim será analisado como se altera e visualiza a posição dos zeros e dos polos de uma
função de transferência quando se modifica alguns dos seus coeficientes.
c. utilizar o Matlab para determinar o erro de estado estacionário de sistemas com retroação unitária e não-
unitária.

2. Introdução
Simular sistemas dinâmicos (sejam eles mecânicos, elétricos, fisiológicos, etc.) significa desenvolver um
modelo matemático representativo deste sistema na forma de uma EDO e encontrar uma solução desta equação
para uma condição inicial particular. Desta forma, é possível observar o comportamento deste sistema frente
a alterações nos parâmetros deste modelo, bem como a diferentes condições iniciais. Fazer esta simulação
computacionalmente significa poder estudar a resposta desse sistema frente a diferentes condições sem precisar
fazer testes experimentais, que em geral são caros e demorados.

2.1. Principais comandos do Matlab para simulação de sistemas

Comando linspace
Em alguns casos é interessante impor o vetor de tempos utilizado na simulação. O comando vetor_tempos =
linspace(ti,tf,N); ajuda nesses casos, criando um vetor entre ti e tf com N elementos linearmente espaçados.

Comando ss
 2

O comando sistema = ss(A,B,C,D); cria um modelo no espaço de estados a partir das matrizes A, B, C e D.
Esse modelo pode ser utilizado para simulação do sistema, ou para se encontrar a função de transferência, por
exemplo.

Comando tf
Utilizado para calcular a função de transferência, pode ser usado tendo como entrada o modelo no espaço de
estados (funcao = tf(sistema);), ou os coeficientes do numerador e do denominador da função de transferência
na forma de vetores (funcao = tf(num,den);).

Comando lsim
Simula a resposta de um sistema linear invariante no tempo dada uma entrada arbitrária ([Y,T,X] =
lsim(sistema,U,vetor_tempos);). Caso não sejam passados argumentos de saída
(lsim(sistema,U,vetor_tempos);), os gráficos das saídas são mostrados na tela.

Comando step
Simula a resposta de um sistema linear invariante no tempo dada uma entrada tipo degrau unitário ([Y,T,X] =
step(sistema,vetor_tempos);). Caso não sejam passados argumentos de saída (step(sistema,vetor_tempos);), os
gráficos das saídas são mostrados na tela.

Comando impulse
Simula a resposta de um sistema linear invariante no tempo dada uma entrada tipo impulso
([Y,T,X] = impulse(sistema,vetor_tempos);). Caso não sejam passados argumentos de saída
(impulse(sistema,vetor_tempos);), os gráficos das saídas são mostrados na tela.

Comando residue
O comando [r,p,k] = residue(num,den); fornece a expansão em frações parciais da função de transferência
cujos coeficientes do numerador e do denominador são dados por num e den. A saída é da forma:

𝑛𝑢𝑚(𝑠) 𝑟1 𝑟2 𝑟3
𝐺 (𝑠 ) = = + + + ⋯+ 𝑘
𝑑𝑒𝑛(𝑠) 𝑠 − 𝑝1 𝑠 − 𝑝2 𝑠 − 𝑝3

Muitas vezes ao simplificar uma função de transferência necessitamos fazer operações de soma e multiplicação
com os polinômios do numerador e denominador das funções de transferência que aparecem no diagrama de
blocos. Sabemos que o Matlab representa polinômios por um vetor de coeficientes. Por exemplo, para
representar os polinômios 𝑝1 (𝑠) = 𝑠 + 2 e 𝑝2 (𝑠) = 𝑠 2 + 2𝑠 − 4 e atribui-los às variáveis num e den, usa-se o
seguinte comando:

den = [1 2 -4];
 3

num = [1 2];

Caso você queira somar o polinômio p1(s) com o polinômio p2(s), não é possível fazer a simples soma das
variáveis num e den:

p = num + den
??? Error using ==> plus
Matrix dimensions must agree.

Isto acontece porque o Matlab está tentando somar dois vetores de dimensões diferentes. Para sanar este
problema crie uma função chamada addpoly tal como abaixo, não esquecendo de gravá-la com o nome
addpoly.m:
function p = addpoly(p1,p2)
% This function adds two vectors that are understood as a vector
% of polynomials coefficients.
% Example:
% p1(x) = x^2 + 3*x + 1; p2(x) = 2*x - 4; p(x) = p1(x) + p2(x) = x^2 + 5x - 3
% p1 = [1 3 1]; p2 = [2 -4]; p = addpoly(p1,p2)
% p = 1 5 -3
p = [ zeros(1, size(p1,2)-size(p2,2) ) p2] + [zeros(1, size(p2,2)-size(p1,2)) p1];

Note que a função addpoly não é uma função nativa do Matlab. É uma função definida pelo usuário e se baseia
em um princípio muito simples. Para que a adição de vetores funcione tal como uma adição de polinômios, é
necessário que os dois vetores tenham o mesmo tamanho. Portanto, o que a função faz é apenas completar com
zeros à esquerda aquele polinômio que tem o tamanho menor.
Já a operação de multiplicação de polinômios não encontra equivalente com a multiplicação de vetores. No
entanto, existe outra operação entre vetores que se comporta tal como uma multiplicação de polinômios do
ponto de vista de seus coeficientes. É a operação de Convolução Discreta, cujo comando no Matlab se chama
conv.

Comando zpk: o comando G = zpk(Gzeros,Gpolos,K); fornece a função de transferência a partir dos polos,
zeros e ganho.

Comando zp2tf: o comando [numG, denG] = zp2tf(Gzeros,Gpolos,K); fornece o numerador e denominador

da função de transferência a partir dos polos, zeros e ganho.

Comando tf2zp: o comando [Gzeros,Gpolos] = tf2zp(numG, denG); fornece os polos e zeros a partir do
numerador e denominador da função de transferência.
 4

2.2. Tratando funções de transferência como objetos

Comandos tf, series e parallel

Uma forma alternativa de fazer operações com funções de transferência é usando a função tf. Esta função,
pertencente ao toolbox de controle, cria um “objeto” interno que representa uma função de transferência, a
partir dos vetores de coeficientes do numerador e denominador. Veja neste exemplo como criar a função de
transferência G(s) e K(s) definidas nas Equações 1 e 2, respectivamente.

2 (1)
𝐺 (𝑠 ) =
𝑠−3

1 (2)
𝐾 (𝑠 ) =
𝑠

>> G = tf([ 2],[1 -3])

Transfer function:
2
_________
s-3

>> K = tf(1,[1 0])

Transfer function:
1
__
s

Definindo a função de transferência desta forma, a soma e a multiplicação de funções de transferência podem
ser feitas através dos operadores usuais * e +. No entanto, lembre-se que associar duas funções de transferência
em série equivale a multiplicar as funções de transferência e que a associação em paralelo, equivale a somá-
las. Desta forma, os comandos series e parallel também podem ser usados. Veja no exemplo a seguir.

>> K*G >> series(K,G)

Transfer function: Transfer function:
2 2
______________ ______________
s^2 - 3 s s^2 - 3 s
 5

>> K+G >> parallel(K,G)

Transfer function: Transfer function:
3s–3 3s–3
______________ ______________
s^2 - 3 s s^2 - 3 s

Comando feedback
Também é possível encontrar a função de transferência quando existe um laço de realimentação tal como
mostrado na Figura 1.

Figura 1 – Função de transferência equivalente de um sistema com realimentação negativa.

2.3. Visualização de polos e zeros da função de transferência

Saber a posição dos polos e zeros no plano Real x Imaginário de uma função de transferência é uma tarefa
importante na análise de sistemas de controle. É possível visualizar os polos/zeros de duas maneiras. A
primeira é usando os comandos pole e zero. Eles retornam um vetor contendo os polos e zeros da função de
transferência, que por sua vez podem ser plotados normalmente.

Polos = pole(sistema)
Zeros = zero(sistema)
figure, plot(real(Polos),imag(Polos),'x',real(Zeros),imag(Zeros),'o','MarkerSize',12)
legend('Polos','Zeros','location','NorthWest')
xlabel('Real')
ylabel('Imaginario')
grid

A segunda maneira é através do comando pzmap. Dado um “objeto” função de transferência que foi criado
pelo comando tf ou manipulado pelos comandos series, parallel ou feedback, este comando já mostra o
gráfico com a posição dos polos e zeros.

pzmap(sistema)
 6

A seguir mostra-se os gráficos obtidos das duas formas: comando plot à esquerda e pzmap à direita.

2.4. Estabilidade de sistemas

Dado o sistema:

Figura 2 – Sistema a malha fechada.

A função de transferência a malha fechada é dada por:

𝐾 (3)
𝑇 (𝑠 ) =
𝑠3 + 18𝑠 2+ 77𝑠 + 𝐾

O exemplo abaixo é um exemplo de como determinar a faixa de ganhos K em um sistema que fará com que
o mesmo seja estável, instável e marginalmente estável.

clear
close all
clc;

% para evitar problemas com erros numericos, todo numero abaixo

% da tolerancia é considerado como zero
tolerancia = 1e-15;
 7

% cria um vetor de valores de K, variando entre 1 e 2000, de 1 em 1

K = 1:1:2000;

% matriz para guardar o resultado dos testes

estabilidade = ones(3,length(K))*nan;

% testa todos os valores de K

for n = 1:length(K)
dent = [1 18 77 K(n)];
polos = roots(dent);
r = real(polos);
if max(r) < -tolerancia % todos os polos no SPE
estabilidade(1,n) = 1;
elseif abs(max(r)) < tolerancia % algum polo no eixo imaginario jw
disp('Sistema marginalmente estável')
estabilidade(2,n) = 2;
disp(['Polos: ' num2str(polos')]);
disp(['K: ' num2str(K(n))]);
else % algum polo no SPD
estabilidade(3,n) = 3;
end
end

plot(K,estabilidade','x');
xlabel('Valores de K');
ylabel('Estabilidade do sistema (1: estável, 2: marginalmente estável, 3:instável)');
title('Exemplo 3');
legend('Estável','Marginalmente estável','Instável');

2.5. Erros em regime permanente

As constantes de erro estático são obtidas usando lim 𝑠 𝑛 𝐺(𝑠). Uma vez obtida as constantes de erro estático,
𝑠→0

podemos calcular os erros de estado estacionário para diferentes sinais de teste. Para calcular a constante de
erro estático, podemos usar o comando dcgain(G), que calcula G(s) em s = 0.
Considere o sistema da Figura 1.
 8

Figura 3 – Sistema de controle com realimentação unitária.

O programa abaixo pode ser usado para encontrar o valor de K de modo que o erro de estado estacionário
seja 10%.

clear
close all
clc

numGdK = [1 5]; % Define o numerador de G(s)/K.

denGdK = poly([0 -6 -7 -8]); % Define o denominador de G(s)/K.
% A partir das raízes do polinômio obtemos o polinômio

disp('Encontrando a funcao de transferencia');

disp('G(s)/K')
GdK = tf(numGdK,denGdK) % Cria G(s)/K.

disp('Encontrando a funcao de transferencia');

disp('sG(s)/K')
numsGdK = conv([1 0],numGdK); % Define o numerador de sG(s)/K por multiplicação de polinômios.

densGdK = denGdK; % Define o denominador de sG(s)/K.

sGdK_temp = tf(numsGdK,densGdK) % Cria sG(s)/K.

disp('Cancelando os termos comuns')
sGdK = minreal(sGdK_temp) % Cancela 's' em comum no numerador e no denominador de de sG(s)/K.

disp('Encontrando a constante de velocidade Kv/K');

disp('calculando sG(s)/K em s=0');
KvdK = dcgain(sGdK) % Calcula sG(s)/K em s=0

disp('Encontrando K para erro de estado estacionario = 10%');

erp = 0.1 % Define o erro em regime permanente
K = 1/(erp*KvdK) % Resolve para K.
 9

disp('???? Verifica a Estabilidade para ????');

disp(['???? K = ' num2str(K) ' ????']);
G = K*GdK
T = feedback(G,1); % Cria T(s).
polos = pole(T) % Exibe os polos em malha fechada.

% Plota a saida do sistema para diferentes entradas

Npontos = 5000;
tempos = linspace(0,10,Npontos);
u_degrau = ones(1,Npontos);
u_rampa = tempos;
u_parabola = tempos.*tempos;

y_degrau = lsim(T,u_degrau,tempos);
y_rampa = lsim(T,u_rampa,tempos);
y_parabola = lsim(T,u_parabola,tempos);

figure(1); hold on;

plot(tempos,u_degrau,'r');
plot(tempos,y_degrau,'b');
legend('Entrada','Saida'); xlabel('Tempo(s)'); ylabel('Sinal');
title('Degrau'); saveas(gcf,'lab4_ex1_degrau.png');
figure(2); hold on;
plot(tempos,u_rampa,'r');
plot(tempos,y_rampa,'b');
legend('Entrada','Saida'); xlabel('Tempo(s)'); ylabel('Sinal');
title('Rampa'); saveas(gcf,'lab4_ex1_rampa.png');
figure(3); hold on;
plot(tempos,u_parabola,'r');
plot(tempos,y_parabola,'b');
legend('Entrada','Saida'); xlabel('Tempo(s)'); ylabel('Sinal');
title('Parabola'); saveas(gcf,'lab4_ex1_parabola.png');

erro_degrau = u_degrau - y_degrau';

erro_rampa = u_rampa - y_rampa';
erro_parabola = u_parabola - y_parabola';
 10

figure(4);
subplot(3,1,1); plot(tempos,erro_degrau);
title('Erro Degrau'); xlabel('Tempo(s)'); ylabel('Erro');
subplot(3,1,2); plot(tempos,erro_rampa);
title('Erro Rampa'); xlabel('Tempo(s)'); ylabel('Erro');
subplot(3,1,3); plot(tempos,erro_parabola);
title('Erro Parabola'); xlabel('Tempo(s)'); ylabel('Erro');
saveas(gcf,'lab4_ex1_erros.png');

A. B. C.

Figura 4 - Entrada e saída do sistema para diferentes sinais de teste: (A) Função degrau. (B) Função rampa.
(C) Função parábola.

Figura 5 - Erros em função do tempo para os diferentes sinais de teste.

 11

3. Atividade para entregar

3.1. (2,5 pontos) Altere os coeficientes do sistema apresentado na equação 4 de modo que a ultrapassagem
percentual seja de aproximadamente 20%. Apresente os parâmetros a e b utilizados e a resposta ao degrau
unitário do novo sistema. Dica: Você pode alterar os valores de a e b aleatoriamente, ou calcular o valor de ζ
que leva a uma UP=20%. Resolva o exercício manualmente e computacionalmente.

𝑏
𝐺 (𝑠 ) =
𝑠2 + 𝑎𝑠 + 𝑏

3.2. (2,5 pontos) Utilizando o critério de Routh-Hurwitz, determine a faixa de valores de K que fazem o
sistema da equação 5 ser estável, instável e marginalmente estável. Considere o sistema com realimentação
unitária negativa. Para isso, você deve montar a tabela de Routh e calcular seus valores, observando como os
valores de K na tabela alteram o comportamento do sistema. Considere K > 0. Com base nas faixas
encontradas, escolha valores de K que fazem com que o sistema seja estável, instável e marginalmente estável·
Plote a saída ao degrau unitário para cada um dos casos de estabilidade desse sistema, indicando o valor de K
usado em cada um. Dica: para obter a resposta ao degrau unitário você pode utilizar os comandos step ou lsim.
Resolva o exercício manualmente e computacionalmente.

𝐾
𝐺 (𝑠 ) =
𝑠(𝑠 + 2)(𝑠 + 3)

3.3. (2,5 pontos) Considerando o exemplo da aula da motocicleta controlada por robô mostrado na aula de
Estabilidade, encontre os possíveis valores de KP e KD para que o sistema seja estável. Plote um gráfico que
relacione os valores de KP e KD com a estabilidade do sistema. Resolva o exercício computacionalmente.
Considere os seguintes valores para os parâmetros físicos: 𝜏 = 0,2, 𝛼1 = 9, 𝛼2 = 2,7, 𝛼3 = 1,35, ℎ =
1,09, 𝑣 = 2,0, 𝐿 = 1,0, 𝑐 = 1,36 [𝑆𝐼].

3.4. (2,5 pontos) Considere um sistema com realimentação unitária cuja função de transferência de malha
aberta seja:

𝐾
𝐺 (𝑠 ) =
𝑠(𝐽𝑠 + 𝐵)

Discuta os efeitos que as variações de K e de B produzem sobre o erro estacionário da resposta à entrada em
rampa unitária. Esboce curvas típicas de resposta à rampa unitária para valores pequenos, médios e elevados
de K, supondo que B seja constante.