% Script MATLAB para Projeto de Compensador por Atraso de Fase
%% 1. Definição do Processo (G(s))
% O processo é dado por G(s) = K / ((s+1)(s+2)(s+10))
% Precisamos de um valor para K. Para fins de demonstração, vamos assumir K=1
% Se o problema não especificar K, a solução de C(s) = (s+0.1)/(s+0.01) ainda é
válida
% e o efeito na redução do erro é como discutido. No entanto, para simulações
% de resposta ao degrau, um valor de K é necessário.
K = 1; % Assumindo K=1 para o processo. Altere se tiver um valor específico.
num_G = K;
den_G = conv([1 1], conv([1 2], [1 10])); % Multiplica os termos do denominador:
(s+1)(s+2)(s+10)
% [1 1] -> (s+1)
% [1 2] -> (s+2)
% [1 10] -> (s+10)
% conv([1 1], [1 2]) -> (s^2 + 3s + 2)
% conv([1 3 2], [1 10]) -> (s^3 + 13s^2 +
32s + 20)
G_s = tf(num_G, den_G);
disp('Função de Transferência do Processo G(s):');
disp(G_s);
%% 2. Análise do Erro de Estado Estacionário Original
% Para uma entrada degrau unitário, o erro de estado estacionário (ess)
% para um sistema Tipo 0 é 1/(1 + Kp).
% Kp = lim(s->0) G(s)
Kp_original = dcgain(G_s); % dcgain(sys) calcula o ganho DC (s->0)
% dcgain(G_s) é equivalente a K/(1*2*10) = K/20 no nosso caso.
% Se K=1, Kp_original = 1/20 = 0.05.
ess_original = 1 / (1 + Kp_original);
fprintf('Constante de Erro de Posição Original (Kp_original): %.4f\n',
Kp_original);
fprintf('Erro de Estado Estacionário Original (ess_original) para degrau: %.4f\n',
ess_original);
%% 3. Determinação do Novo Kp Requerido
% O problema pede para o erro de estado estacionário ser diminuído em dez vezes.
% Isso implica que o novo Kp deve ser 10 vezes maior.
Kp_novo_requerido = 10 * Kp_original;
fprintf('\nNovo Kp Requerido (Kp_novo_requerido): %.4f\n', Kp_novo_requerido);
% O erro desejado seria:
% ess_novo_desejado = ess_original / 10;
% fprintf('Erro de Estado Estacionário Desejado (ess_novo_desejado): %.4f\n',
ess_novo_desejado);
%% 4. Projeto do Compensador de Atraso de Fase C(s)
% C(s) = Kc * (s + z) / (s + p)
% O problema especifica p = -0.01.
p_compensador = -0.01; % Polo do compensador
% Para aumentar Kp em 10 vezes, a razão |z|/|p| deve ser 10.
% Ou seja, |z| = 10 * |p|.
z_compensador = -0.1; % Zero do compensador (deve ser maior em magnitude que o
polo)
% Calculamos Kc usando a condição de Kp_novo_requerido
% Kp_novo_requerido = Kc * (z/p) * Kp_original
% Kp_novo_requerido = Kc * (abs(z_compensador)/abs(p_compensador)) * Kp_original
% Kp_novo_requerido = Kc * 10 * Kp_original
% (K/2) = Kc * 10 * (K/20) --> K/2 = Kc * K/2 --> Kc = 1
Kc = 1; % Ganho do compensador
num_C = Kc * [1 -z_compensador]; % Numerador: Kc * (s - (-z)) = Kc * (s + z)
den_C = [1 -p_compensador]; % Denominador: (s - (-p)) = (s + p)
C_s = tf(num_C, den_C);
disp('Função de Transferência do Compensador C(s):');
disp(C_s);
%% 5. Análise do Sistema Compensado (Malha Aberta e Malha Fechada)
% Sistema de malha aberta compensado: Go(s) = C(s) * G(s)
Go_s = C_s * G_s;
disp('Função de Transferência de Malha Aberta Compensada Go(s) = C(s)G(s):');
disp(Go_s);
% Verificação do novo Kp do sistema compensado
Kp_compensado = dcgain(Go_s);
fprintf('\nConstante de Erro de Posição do Sistema Compensado (Kp_compensado):
%.4f\n', Kp_compensado);
% Erro de estado estacionário do sistema compensado
ess_compensado = 1 / (1 + Kp_compensado);
fprintf('Erro de Estado Estacionário do Sistema Compensado (ess_compensado) para
degrau: %.4f\n', ess_compensado);
% Verificação da redução do erro (deve ser aproximadamente 10x)
fprintf('Razão entre o erro original e o erro compensado: %.4f\n', ess_original /
ess_compensado);
% Sistema de malha fechada compensado (assumindo realimentação unitária):
% T(s) = Go(s) / (1 + Go(s))
T_s_compensated = feedback(Go_s, 1);
disp('Função de Transferência de Malha Fechada Compensada T(s):');
disp(T_s_compensated);
% Sistema de malha fechada original:
T_s_original = feedback(G_s, 1);
disp('Função de Transferência de Malha Fechada Original T(s):');
disp(T_s_original);
%% 6. Visualização dos Resultados
% a) Resposta ao Degrau (Step Response)
figure;
step(T_s_original, 'b--', T_s_compensated, 'r-');
grid on;
legend('Sistema Original', 'Sistema Compensado', 'Location', 'southeast');
title('Resposta ao Degrau: Sistema Original vs. Compensado');
ylabel('Amplitude');
xlabel('Tempo (s)');
% O erro de estado estacionário é a diferença entre o valor final e o valor de
entrada (1 para degrau unitário).
% Para o sistema Tipo 0, o valor final é Kp / (1 + Kp).
final_value_original = Kp_original / (1 + Kp_original);
final_value_compensated = Kp_compensado / (1 + Kp_compensado);
fprintf('\nValor final do degrau para o sistema original: %.4f\n',
final_value_original);
fprintf('Valor final do degrau para o sistema compensado: %.4f\n',
final_value_compensated);
fprintf('Erro de estado estacionário original (1 - final_value_original): %.4f\n',
1 - final_value_original);
fprintf('Erro de estado estacionário compensado (1 - final_value_compensated):
%.4f\n', 1 - final_value_compensated);
% b) Diagrama de Polos e Zeros (Pole-Zero Map)
figure;
pzmap(G_s);
hold on;
pzmap(C_s, 'g'); % Plota o compensador em verde
pzmap(Go_s, 'm'); % Plota a malha aberta compensada em magenta
grid on;
title('Diagrama de Polos e Zeros');
legend('Polos Original', 'Zeres Original', 'Polo Compensador', 'Zero Compensador',
'Polos Malha Aberta Compensada', 'Zeres Malha Aberta Compensada');
hold off;
% c) Diagrama de Bode (Bode Plot) - Para analisar o impacto na frequência
figure;
bode(G_s, 'b--', Go_s, 'r-');
grid on;
legend('Sistema Original (G(s))', 'Sistema Compensado (C(s)G(s))', 'Location',
'southwest');
title('Diagrama de Bode: Sistema Original vs. Compensado (Malha Aberta)');
% Observe o aumento do ganho em baixas frequências (lado esquerdo do gráfico de
magnitude)
% devido ao compensador de atraso de fase.