Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea.

Este exercício mostra as respostas para um controle de trajetória com 03 tipos de técnicas de controle e
diferentes quantidades de variáveis de entrada, sendo controle clássico com entrada Ɵ*, controle com
vetor completo de entradas referenciais completo W* ; Ɵ* ; ∫ Ɵ* , e vetor de entradas completo mais
comando direto. As análises comparações entre os sistemas de controle são descritas no final do trabalho.
O sistema é de primeira ordem, cujos parâmetros são: J = 0,015 kgm2; b = 0,01 Nms/rad. Considere ainda
a trajetória: θ*(t) = 8π cos(πt) rad e a característica de carga: TL(t) = 10.sign (ω) Nm.
EXERCÍCIO 1
1-A) Na figura 01 é visto o diagrama de blocos para o controle clássico em cascata, não foi incluída a
entrada referência de velocidade devido a que o problema não descreve se esta entrada é necessária, e o
controle clássico com entrada somente com referência de Ɵ* é um bom exemplo para mostrar a diferença
da sua resposta em relação ás plantas com vetor de entrada completo.

Fig. 01
1-B) Os ganhos d Kpw Kpo Kiw do controlador e a função de transferência do acionamento Teta/ teta*
obtida são: Kpw = 7 Kpo = 31 Kiw = 1930

G(S)=

Os polos e os zeros são: Zeros = -275.7143

Polos = -634,45 ; -296,11 + 482,58i ; -296;11 - 482;58i ; -030,81
Na figura 02 é mostrado o mapa de polos e zeros.

1-C) Já, na figura 03 é mostrada a curva do módulo da resposta em frequência da rigidez dinâmica com J
no seu valor nominal, sendo exibido na cor verde ao lado direito e que esta junto (unido) á linha em
vermelho no lado esquerdo da curva.

Fig. 02 Fig. 03
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 2

1-D) o módulo da resposta em frequência da função FRF| Ɵ / Ɵ *| é mostrado na figura 04. Observar que
a curva em que J esta em seu valor nominal é a curva em verde.

Fig. 04

1-E) Na figura 05 é visto a resposta no tempo Ɵ(t) foi calculada pela soma das contribuições do sinal de
referência Ɵ*(t) na entrada e seu valor somado com a contribuição de TL(t) para a saída, representando
assim a resposta total como Ɵ(t) = Ɵ(t)/Ɵ*(t)+ Ɵ(t)/TL(t). Ainda na figura 05 é visto a velocidade obtida
W(t). E na figura 06 é mostrado o erro de rastreamento da trajetória.

Fig. 05 Fig. 06

1-F) O torque fornecido pelo acionamento foi calculado pela expressão Tac= TL+ bW+ JdW/dt, e é
apresentado na figura 07. Na mesma figura 07 são mostradas a velocidade de saída da planta, e a potência
fornecida pelo sistema de acionamento.
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 3

Fig. 07

1-G) Na figura 03 que já foi mostrada nas páginas anteriores são mostrados FRF |TL/Ɵ| para os casos em
que o parâmetro J da planta é estimado com variação de 20% para mais e para menos.
Já na figura 04 são mostrados FRF |Ɵ /Ɵ| para os casos em que J varia também +20% e -20%.

------------------------------------------------------------------------------------------------------------------------------
EXERCÍCIO 2
2-A)

Gc

2-B)

Ba= 3.5268
Ka= 96.6694
Kia= 303.5797

zeros= -3.1404
polos= -956.2896 ; -270.1310 ;
-27.2732 ; -3.6099

G(S)=
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 4

2-C)

2-D)
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 5

2-E)

2-F)

2-G) Veja estas as curvas FRF |TL / Ɵ| e FRF | Ɵ / Ɵ*| com J variando em +20% e em -20%, nas
figuras já mostradas anteriormente para as questões 2-C) e 2-D) , pois todas curvas estão embutidas nos
referidos gráficos.
------------------------------------------------------------------------------------------------------------------------------
EXERCÍCIO 3
3-A)

Gc
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 6

3-B)

Ba = 7.7769
Ka = 216.5851
Kia = 680.1444

Zeros = -3.1403
polos = -2079,1
-278,3
-27,4
-3,6

G(S)=

3-C)
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 7

3-D)

3-E)

3-F)
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 8

3-G) Veja estas as curvas FRF |TL / Ɵ| e FRF | Ɵ / Ɵ*| com J variando em +20% e em -20%, nas
figuras já mostradas anteriormente para as questões 3-C) e 3-D) , pois todas curvas estão embutidas nos
referidos gráficos.
------------------------------------------------------------------------------------------------------------------------------
EXERCÍCIO 4
O controle de posição é capaz de trabalhar com trajetórias realizáveis, e deve ter uma resposta sem
oscilação. No controle clássico há acoplamento entre as malhas interna e externa, e para não haver
oscilação deverá haver frequências de corte bem diferentes entre as malhas. Foram modelados a fonte de
conjugado com frequência de corte de 200 Hz, malha de velocidade em 50 Hz, malha de posição em 5
Hz, malha integral de posição, quando usada, em 0,5 Hz. O controle clássico tem o problema na
inadequação da referência de velocidade e acoplamento natural entre as malhas de velocidade e posição,
devido ao cascateamento, neste sistema houve polos imaginários e que estes polos imaginários
provocaram uma pequena oscilação, mas que com o ajuste dos ganhos com um possível aumento pode ser
suficiente para eliminar as oscilações passando os polos a ficarem reais. Os módulos dos ganhos para os
três controladores foram parecidos, mas o controle clássico apresentou variação bem superior aos outros
sistemas de controle quando houve erros na estimação de J, por isso se pode dizer que o controle clássico
tem robustez menor que os outros. O controlador com vetor completo e comando direto foi aquele que
melhor apresentou robustez quando J é mau estimado. O torque gerado pelo sistema de acionamento é
maior na situação do uso do controlador clássico, desta forma o atuador receberá sinais de maior
intensidade e haverá menor estabilidade.

Para o controle clássico a robustez é bem mais baixa nas frequências mais baixas, que nos sistema de
controle mais completos com integral de posição.

O controle de movimento com vetor completo ([ω*(t) θ*(t) ∫θ*(t) dt ]) tem a vantagem de conseguir
eliminar o erro em regime permanente através da ação integral. Caso usássemos o desacoplamento da
perturbação seria melhorada a rigidez dinâmica.
O desacoplamento dos estados entra em ação quando as constantes de tempo elétrica e a dinâmica estão
próximas, isto é, velocidades próximas. Com as malhas em paralelo quando usamos o vetor de entrada
completo, se tem a vantagem que os ganhos podem ser ajustados independentemente, em comparação
com o controle clássico.

O desacoplamento dos estados ocorre pois tanto nos sistemas de controle com vetor completo, quando no
controlador com vetor completo e comando direto, devido a que foram escolhidas faixas de passagem
bem distintas entre cada malha de controle. No sistema com comando direto, há o benefício em que o
sistema de controle trabalha principalmente com os fluxos de comando da perturbação e por isso a rigidez
dinâmica foi muito melhorada.

O erro de rastreamento da trajetória é bem maior no caso do uso do controle clássico, que nos demais
casos. E entre o uso ou não do comando direto para os controladores com vetor completo de entrada, o
comando direto faz que o rastreamento seja um pouco melhor.

Referências.
Notas de aula da disciplina acionamentos elétricos –UFMG.
Notas de aula da disciplina Controle de sistema Lineares –UFMG.
Livro: Sistema de Controle Modernos, Dorf.
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 9

Codigo MATLAB do controle de controle de movimento (posição) clássico em cascata.

'EXERCICIO 3, SISTEMA DE CONTROLE INCLUINDO COMANDO DIRETO'
% Observações
% obs 1 parcela Teta(t) / W*(t) da linha 183
%OBS 2: planta completa (G_planta_completa_MF) função G(S)= Teta(S)/ Teta*(S), onde
a entrada é teta* e a saída é teta na linha 68,
%sendo oque a integral de teta é via Kia/S: %G_planta_completa_MF= feedback(
(Kia*integral+ Ka)*(G_velocidade_MF)*(integral), 1, -1) % -------------->>>>>
% obs 3: codigo que insere o comando direto no calculo da função de transferencia
teta/ teta* na linha 52 sendo: G_ComandoD_Conversor_Mecanica=
feedback(G_Conversor*G_Mecanica, (J_ComandoD/integral+ B_ComandoD), -1); %
Controlador * mecanica e realimentação no comando direto
%OBS 4: para obtenção de FT_Rigidez_dinamica= 1/ G_TL_TetaComIntegralTeta, fiz
calculos teta/TL começando com a simplificação de blocos na parte do comando direto

clear all
close all
clc

J= 0.015
B= 0.01
J_ComandoD= 0.90*J % ---> valor QUE EU ESTOU TESTANDO PARA J
ESTIMADO do comando direto, exercicio 3
B_ComandoD= 0.90*B % ---> valor QUE EU ESTOU TESTANDO PARA B
ESTIMADO do comando direto, exercicio 3
J_nominal= J
Jmenor= J_nominal*0.8 % ---> valor de J variando PARA MENOR na
função de transferencia, questoes letra G dos exercicios
Jmaior= J_nominal*1.2 % ---> valor de J variando PARA MAIOR na
função de transferencia, questoes letra G dos exercicios

tempo_de_simulacao= 6; % ---> tempo que eu estou escolhendo paea

a simulação
tempo= linspace(0, tempo_de_simulacao, 5000);
Angulo_Teta= 8*pi*(0- cos(pi*tempo));

frequencia_corte_conversor= 200*2*pi % ---> frequencia de corte sistema elétrico

(faixa de passagem do conversor) que eu estou escolhendo
frequencia_W= -50*2*pi % ---> frequencia de corte sistema elétrico
(malha de velocidade) que eu estou escolhendo
frequencia_Teta= -5*2*pi % ---> frequencia de corte sistema elétrico
(malha de posição) que eu estou escolhendo
frequencia_Integral_Teta= -0.5*2*pi % ---> frequencia de corte sistema elétrico
(malha de integral de posição) que eu estou escolhendo

figure(1)
plot(tempo, Angulo_Teta)
xlabel('Tempo [ S ]','fontsize',12);
ylabel('Angulo Teta [ rad ]','fontsize',12);
title('Angulo Teta')
% axis([ 0 8*pi -inf inf ])

for n= 2 : length(tempo)
W_referencia(n)= (Angulo_Teta(n)- Angulo_Teta(n-1))/ (tempo(n)- tempo(n-1));
Torque_Carga(n)= 10*sign(W_referencia(n));
end

figure(2)
plot(tempo, Torque_Carga, '.-')
xlabel('Tempo [ S ]','fontsize',12);
ylabel('Torque [ Nm ]','fontsize',12);
title('Torque na Carga ')
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 10

figure(3)
G_Conversor= tf([1], [1/(frequencia_corte_conversor) 1])
bode(G_Conversor)
integral= tf(1, [1 0]);
title('Resposta em frequencia do conversor');

'####################################################################################
######################################################'
%Questao 2-B)"
G_Mecanica= feedback( (1/J)*integral, B, -1)
G_ComandoD_Conversor_Mecanica= feedback(G_Conversor*G_Mecanica, (J_ComandoD/integral-
B_ComandoD), -1); % Controlador * mecanica e realimentação no comando direto

G_velocidade_MA= G_ComandoD_Conversor_Mecanica;
[Ba, polos_GW]= rlocfind(G_velocidade_MA, frequencia_W) % calculo de Ba
G_velocidade_MF= feedback(G_velocidade_MA, Ba, -1) % W(S)/Ta*(S)

G_posicao_MA= G_velocidade_MF*integral; % --> OBS: esta calculando Kia pegando a

saida de integral de posição e realimentando via Kia, sendo que Kia esta recebendo a
realimentação e o sinal de entrada que é integral de teta
[Ka, polos_GTeta]= rlocfind(G_posicao_MA, frequencia_Teta) % calculo de Ka
G_posicao_MF= feedback(G_velocidade_MA, Ka, -1) % Teta(S) /
Ta*(S)

G_integral_posicao_MA= G_posicao_MF*integral;
[Kia, polos_GIntegralTeta]= rlocfind(G_integral_posicao_MA, frequencia_Integral_Teta)
% calculo de Kia
%G_integral_posicao_MF= feedback(Kia*G_integral_posicao_MA, 1, -1) %
Integral_Teta(S) / Integral_Teta*(S) obs: a entrada devera ser a integral de teta(t)
, ou seja: ( com 1/S depois do sinal de entrada, e entes de G_integral_posicao_MF)

Ba= Ba
Ka= Ka
Kia= Kia

% ------------>>>>> função G(S)= Teta(S)/ Teta*(S)

G_planta_completa_MF= feedback( (Kia*integral+ Ka)*(G_velocidade_MF)*(integral), 1, -
1) % -------------->>>>> função G(S)= Teta(S)/ Teta*(S), onde a entrada é teta* e
a saída é teta
G_Teta_TetaRef= G_planta_completa_MF;
zeros_G= zero(G_planta_completa_MF)
polos_G= pole(G_planta_completa_MF)

% Polos e zeros planta G(S)= Teta(S) / Teta*(S)'

figure(4)
pzmap(G_planta_completa_MF)
%pzmap(G_integral_posicao_MF) % obs: função da linha 56
grid()
title('Polos e zeros planta G(S)= Teta(S) / Teta*(S)');

% Root locus planta G(S)= Teta(S) / Teta*(S)figure(5)

figure(5)
rlocus(G_planta_completa_MF)
grid()
title('Lugar das raízes de | TL(S) / Teta(S) |');
% Bode Resposta em frequencia planta G(S)= Teta(S) / Teta*(S)

figure(6)
bode(G_planta_completa_MF)
title('Resposta em frequencia planta G(S)= Teta(S) / Teta*(S)');
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 11

'####################################################################################
######################################################'
%Questao 2-D)

% Modulo da Resposta em Frequencia de G(S)= | Teta(S) / Teta*(S) |

figure(7)
f= logspace(-1, 4, 1000);
H_nominal_planta= freqresp(G_planta_completa_MF, f);
H_nominal_planta= abs(H_nominal_planta);
H_nominal_planta= H_nominal_planta(1, :);
semilogx(f/(2*pi), H_nominal_planta);
xlabel('Frequencia [ Hz ]');
ylabel('Módulo do Ganho');
grid()
title('Modulo da resposta em frequencia |Teta(S) / Teta*(S)|');

% Resposta temporal |Teta(S)/Teta*(S) |, para entrada teta(t) somente

[y, t, x] = lsim(G_Teta_TetaRef, Angulo_Teta, tempo);
figure(8)
Resposta_G_Teta_TetaRef= y;
h11= plot(tempo, Resposta_G_Teta_TetaRef, 'Color','b','LineStyle','-. ', 'linewidth',
2 );
ax1= gca;
set(ax1,'XColor','k','YColor','b')
hold on;
h12= plot(tempo, Angulo_Teta,'-r');
hold off
title('| Teta(t) / Teta*(t) |');
legend([h11 h12],'Resposta Teta(t) / TL(t)', 'Ângulo de referência Teta*(t)','Best')

%####################################################################################
#######################################################
%Questão 2_C
G_TL_ComandoDireto= feedback(G_Mecanica, (J_ComandoD/integral- B_ComandoD), -1);
G_TL_W= feedback(G_TL_ComandoDireto, Ba*G_Conversor, -1); % malha de velocidade
G_TL_teta= feedback(G_TL_W*integral, Ka*G_Conversor, -1); % malha de posicao
G_TL_TetaComIntegralTeta= feedback(G_TL_teta, Kia*integral*G_Conversor, -1); % OBS
:malha de integral de posicao, obs: nao integrou teta na saída para obter
%integral de teta e sim considerou a relimentação de Kia/S que teria entrada teta e
não integral de teta.
G_Teta_TL= G_TL_TetaComIntegralTeta; % ----------->>> função Teta(S)/ TL(S)
FT_Rigidez_dinamica= 1/ G_TL_TetaComIntegralTeta
FT_Rigidez_dinamica_nominal= FT_Rigidez_dinamica;

%figure(30)
%bode(FT_Rigidez_dinamica)
% Resposta em Frequencia da rigidez dimamica G(S)= TL(S) / Teta(S) , com entrada
TL(t) somente
figure(9)
f= logspace(-3, 4, 1000);
H= freqresp(FT_Rigidez_dinamica, f);
H= abs(H);
H= H(1, :);
semilogx(f/(2*pi), H);
axis([ -inf inf -inf 0.4*10^5 ])
grid()
xlabel('Frequencia [ Hz= rad/2pi ]');
ylabel('Torque [ Nm ]');
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 12

title('Rigidez Dinâmica: | TL(S) / Teta(S) | ');

%####################################################################################
#######################################################
%####################################################################################
#######################################################
%Questão 2_E G_total= G_teta_teta + G_teta_TL + G_teta_W
% resposta temporal, parcela Teta / TL, para entrada TL(t) somente
figure(12)
[y, t, x] = lsim(G_Teta_TL, -Torque_Carga, tempo);
Resposta_G_Teta_TL= y;
h11= plot(tempo, Resposta_G_Teta_TL, 'color',' b', 'linewidth', 3 );
xlabel('Tempo [ S ]');
ylabel('Ângulo [ Graus ]');
ax1 = gca;
set(ax1,'XColor','k','YColor','b')
ax2 =
axes('Position',get(ax1,'Position'),'XAxisLocation','bottom','YAxisLocation','right',
'Color','none','XColor','k','YColor','r');
hold on;
%h13= line(tempo, Angulo_Teta,'Color','y','LineStyle','-.', 'Parent',ax2);
h12= plot(tempo, Torque_Carga,'Color','r','LineStyle','-', 'linewidth', 1.5,
'Parent',ax2);
ylabel('Torque [ Nm ]');
hold off
title('| Teta(t) / TL(t) |');
legend([h11 h12],'Resposta Teta(t) / W*(t)', 'Torque de carga Tl(t)', 'Best')

%####################################################################################
#######################################################
%calculo da saida Teta(t) / W*(t)

%calculo da saida Teta(t) / W*(t) quinto modo , FUNCIONA, %fechando malha interna
de velocidade através de Ba e com o sinal W* colocado em
%separado em série com uma cópia de Ba, depois fechando a malha externa de teta onde
tem Ka+ kia/S, e por ultimo multlicando W* x Ba x Gz = teta
%e pegando o caminho direto para W*Ba*integral para a saída
Gy1_ComandoDireto= feedback(G_Conversor*G_Mecanica, (J_ComandoD/integral-
B_ComandoD), -1); % Controlador * mecanica e realimentação no comando direto
Gy= feedback(Gy1_ComandoDireto, Ba, -1);
Gx= feedback(Gy*integral, (Ka+Kia*integral), -1 );
G_Teta_Wreferencia= Ba*Gx

figure(30); bode(G_Teta_Wreferencia);
figure(31); pzmap(G_Teta_Wreferencia);

figure(32)
[y, t, x] = lsim(G_Teta_Wreferencia, W_referencia, tempo);
Resposta_G_Teta_Wreferencia= y;
h11= plot(tempo, Resposta_G_Teta_Wreferencia,'b');
hold on
h13= plot(tempo, Angulo_Teta,':b');
xlabel('Tempo [ S ]');
ylabel('Ângulo [ Graus ]');
hold off
%axis([ -inf inf -80 80 ])
ax1 = gca;
set(ax1,'XColor','k','YColor','b')
ax2 =
axes('Position',get(ax1,'Position'),'XAxisLocation','bottom','YAxisLocation','right',
'Color','none','XColor','k','YColor','r');
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 13

%linkaxes([ax1,ax2],'xy')
hold on;
h12= line(tempo, W_referencia,'Color','r','LineStyle','-.', 'Parent',ax2);
ylabel('Velocidade Angular [ rad/s ]');
hold off
title(' Ândulo de saída em função da referencia de velocidade |Teta(t) / W*(t)|');
legend([h11 h12 h13],'Resposta Teta(t) / W*(t)', 'Velocidade de referência W*(t)', '
Ângulo de Referência Teta*(t)', 'Best')

%####################################################################################
#######################################################
% resposta total de Teta(t)= [ Teta(t)/Teta*(t) +Teta(t)/TL(t) ] , para entradas
Teta(t) + TL(t) obs:nao junte a parcela de Teta(t)/ W*(t)
Resposta_Total= Resposta_G_Teta_TetaRef+ Resposta_G_Teta_TL+
Resposta_G_Teta_Wreferencia; % resposta total de saída, com 2 tipos de sinais de
entrada

% --->> calculo da resposta no tempo de W(t) , para entradas Teta(t) + TL(t) + W*(t)
for n= 2 : length(tempo)
W_saida(n)= (Resposta_Total(n)- Resposta_Total(n-1))/ (tempo(n)- tempo(n-1)); %
resposta total é o ângulo de saída simulado por lsim
end

% resposta final e total para o ãngulo de saída

figure(13)
%axis([ -inf inf -30 30 ])
xlabel('Tempo [ S ]');
ylabel('Ângulo [ Graus ]');
ax1= gca;
hold on;
h11= plot(tempo, Resposta_Total, 'Color','b','LineStyle','-', 'linewidth', 3 );
h12= plot(tempo, Angulo_Teta,'Color','y','LineStyle',':', 'linewidth', 2);
h13= plot(tempo, Torque_Carga,'Color','b','LineStyle', ':');
set(ax1,'XColor','k','YColor','b')
hold off
xlabel('Tempo [ S ]');
ax2 =
axes('Position',get(ax1,'Position'),'XAxisLocation','bottom','YAxisLocation','right',
'Color','none','XColor','k','YColor','r');
hold on;
h14= plot(tempo, W_saida, 'Color','r','LineStyle','-', 'linewidth', 2, 'Parent',ax2);
h15= line(tempo, W_referencia,'Color','g','LineStyle',':', 'linewidth', 2,
'Parent',ax2);
hold off
axis([ -inf inf -85 85 ])
%linkaxes([ax1,ax2],'xy')
legend([h11 h12 h13 h14 h15],'Ângulo de saída: Teta(t)', 'Referencia do Angulo
Teta(t)', 'Torque de Carga TL(t)',' Velocidade de saída W(t)', 'Referencia da
Velocidade W*(t)', 'Best')

% Erro no rastreamento da trajetória Delta_Teta(t)

Delta_Teta= Resposta_Total'- Angulo_Teta;
figure(15)
xlabel('Tempo [ S ]');
ylabel('Ângulo [ Graus ]');
h11= line(tempo, Delta_Teta, 'Color','b', 'linewidth', 2);
axis([ -inf inf -0.3 0.3]);
ax1 = gca;
set(ax1,'XColor','k','YColor','b')
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 14

ax2 =
axes('Position',get(ax1,'Position'),'XAxisLocation','bottom','YAxisLocation','right',
'Color','none','XColor','k','YColor','r');
hold on
h12= line(tempo, Angulo_Teta,'Color','r','LineStyle','-.', 'Parent',ax2);
hold off
linkaxes([ax1,ax2],'x')
ylabel('Graus');
title('Erro de rastreamento da trajetória Teta(t) - Teta*(t)');
legend([h11 h12],'Erro de rastreamento da trajetória', 'Ângulo de referencia
Teta*(t)', 'Best')

%####################################################################################
#######################################################
%####################################################################################
#######################################################
%Questão 2_F

% derivada da velocidade angular W(t)

for n= 2 : length(tempo)
Derivada_W(n)= (W_saida(n)- W_saida(n-1))/ (tempo(n)- tempo(n-1));
Torque_acionamento(n)= J*Derivada_W(n)+ Torque_Carga(n)+ B*W_saida(n);
Potencia_acionamento(n)= Torque_acionamento(n)*W_saida(n);
end

% derivada de W(t) na saída

figure(16)
plot(tempo, Derivada_W, '.')
axis([ -inf inf -0.1*10^4 0.1.*10^4]);
title('Derivada de W(t) na saída');

% Torque do acionamento Tac(t)'), Velocidade W(t), Potencia p(t))

figure(17)
xlabel('Tempo [ S ]');
ylabel('Torque de acionamanto [ Nm ]');
ax1 = gca;
h11= line(tempo, Torque_acionamento, 'Color','b','LineStyle', '-', 'linewidth', 2);
hold on
h12= line(tempo, W_saida, 'Color','b','LineStyle', ':', 'linewidth', 0.5);
%h14= line(tempo, Torque_Carga, 'Color','y','LineStyle', '-', 'linewidth', 2);
hold off
set(ax1,'XColor','k','YColor','b')
axis([ -inf inf -85 85]);
ax2 =
axes('Position',get(ax1,'Position'),'XAxisLocation','bottom','YAxisLocation','right',
'Color','none','XColor','k','YColor','r');
hold on;
h13= line(tempo, Potencia_acionamento, 'Color','r','LineStyle', '-', 'linewidth', 1,
'Parent',ax2);
ylabel('Potencia [ Watts ]');
axis([ -inf inf -950 950]);
hold off
legend([h11, h12, h13],'Torque do acionamento Tac(t)', 'Velocidade mecânica W(t)',
'Potencia do acionamento p(t))', 'Best')
title('Torque Tac(t), Velocidade de saída W(t), Potencia p(t)');

%####################################################################################
#######################################################
'####################################################################################
######################################################'
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 15

% Questão 2-G
' ---> Calculos para J em 80%'
G_Mecanica_Jmenor= feedback( (1/Jmenor)*integral, B, -1);
G_ComandoD_Conversor_Mecanica= feedback(G_Conversor*G_Mecanica_Jmenor,
(J_ComandoD/integral- B_ComandoD), -1); % Controlador * mecanica e realimentação no
comando direto
G_velocidade_MA_Jmenor= G_ComandoD_Conversor_Mecanica;
G_velocidade_MF_Jmenor= feedback(G_velocidade_MA_Jmenor, Ba, -1); %
W(S)/Ta*(S)
G_planta_completa_MF_Jmenor= feedback( (Kia*integral+
Ka)*(G_velocidade_MF_Jmenor)*(integral), 1, -1) % -------------->>>>> função G(S)=
Teta(S)/ Teta*(S)
zeros_G= zero(G_planta_completa_MF_Jmenor) % Polos e zeros planta G(S)= Teta(S) /
Teta*(S)'
polos_G= pole(G_planta_completa_MF_Jmenor)

% J em 80%, mapa de polos e zeros G(S)= Teta(S) / Teta*(S)

figure(18)
pzmap(G_planta_completa_MF_Jmenor)
grid()
title('J em 80%, Polos e zeros planta G(S)= Teta(S) / Teta*(S)');

% Resposta em Frequencia de G(S)= | Teta(S) / Teta*(S) | com J em 80%

figure(19)
f= logspace(-1, 4, 1000);
H= freqresp(G_planta_completa_MF_Jmenor, f);
H= abs(H);
H= H(1, :);
semilogx(f/(2*pi), H);
xlabel('Frequencia [ Hz ]');
ylabel('Módulo do Ganho');
grid()
title('J em 80 %, Modulo da resposta em frequencia |Teta(S) / Teta*(S)|');

% --->>> Calculos da rigidez dinamica TL(S) / Teta(S) com J em 80%

G_TL_ComandoDireto= feedback(G_Mecanica_Jmenor, (J_ComandoD/integral- B_ComandoD), -
1);
G_TL_W= feedback(G_TL_ComandoDireto, Ba*G_Conversor, -1); % malha de velocidade
G_TL_teta= feedback(G_TL_W*integral, Ka*G_Conversor, -1); % malha de posicao
G_TL_TetaComIntegralTeta= feedback(G_TL_teta, Kia*integral*G_Conversor, -1); % OBS
:malha de integral de posicao, obs: nao integrou teta na saída para obter
%integral de teta e sim considerou a relimentação de Kia/S que teria entrada teta e
não integral de teta.
G_Teta_TL= G_TL_TetaComIntegralTeta; % ----------->>> função Teta(S)/ TL(S)
FT_Rigidez_dinamica_Jmenor= 1/ G_TL_TetaComIntegralTeta

% J em 80%, Rigidez Dinãmica

figure(20)
f= logspace(-3, 4, 1000);
H= freqresp(FT_Rigidez_dinamica_Jmenor, f);
H= abs(H);
H= H(1, :);
semilogx(f/(2*pi), H);
axis([ -inf inf -inf 0.4*10^5 ])
grid()
xlabel('Frequencia [ Hz= rad/2pi ]');
ylabel('Torque [ Nm ]');
title('J em 80%, Rigidez Dinãmica | TL(S) / Teta(S) |');

%####################################################################################
#######################################################
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 16

' ---> Calculos para J em 120%'

G_Mecanica_Jmaior= feedback( (1/Jmaior)*integral, B, -1);
G_ComandoD_Conversor_Mecanica= feedback(G_Conversor*G_Mecanica_Jmaior,
(J_ComandoD/integral- B_ComandoD), -1); % Controlador * mecanica e realimentação no
comando direto
G_velocidade_MA_Jmaior= G_ComandoD_Conversor_Mecanica;
G_velocidade_MF_Jmaior= feedback(G_velocidade_MA_Jmaior, Ba, -1); %
W(S)/Ta*(S)
G_planta_completa_MF_Jmaior= feedback( (Kia*integral+
Ka)*(G_velocidade_MF_Jmaior)*(integral), 1, -1) % -------------->>>>> função G(S)=
Teta(S)/ Teta*(S)
zeros_G= zero(G_planta_completa_MF_Jmaior) % Polos e zeros planta G(S)= Teta(S) /
Teta*(S)'
polos_G= pole(G_planta_completa_MF_Jmaior)

% J em 120%, mapa de polos e zeros G(S)= Teta(S) / Teta*(S)

figure(21)
pzmap(G_planta_completa_MF_Jmaior)
grid()
title('J em 120%, Polos e zeros planta G(S)= Teta(S) / Teta*(S)');

% Resposta em Frequencia de G(S)= | Teta(S) / Teta*(S) | com J em 80%

figure(22)
f= logspace(-1, 4, 1000);
H= freqresp(G_planta_completa_MF_Jmaior, f);
H= abs(H);
H= H(1, :);
semilogx(f/(2*pi), H);
xlabel('Frequencia [ Hz ]');
ylabel('Módulo do Ganho');
grid()
title('J em 120%, Modulo da resposta em frequencia |Teta(S) / Teta*(S)|');

% --->>> Calculos da rigidez dinamica TL(S) / Teta(S) com J em 120%

G_TL_ComandoDireto= feedback(G_Mecanica_Jmaior, (J_ComandoD/integral- B_ComandoD), -
1);
G_TL_W= feedback(G_TL_ComandoDireto, Ba*G_Conversor, -1); % malha de velocidade
G_TL_teta= feedback(G_TL_W*integral, Ka*G_Conversor, -1); % malha de posicao
G_TL_TetaComIntegralTeta= feedback(G_TL_teta, Kia*integral*G_Conversor, -1); % OBS
:malha de integral de posicao, obs: nao integrou teta na saída para obter
%integral de teta e sim considerou a relimentação de Kia/S que teria entrada teta e
não integral de teta.
G_Teta_TL= G_TL_TetaComIntegralTeta; % ----------->>> função Teta(S)/ TL(S)
FT_Rigidez_dinamica_Jmaior= 1/ G_TL_TetaComIntegralTeta

%J em 120%, Rigidez Dinãmica

figure(23)
f= logspace(-3, 4, 1000);
H= freqresp(FT_Rigidez_dinamica_Jmaior, f);
H= abs(H);
H= H(1, :);
semilogx(f/(2*pi), H);
axis([ -inf inf -inf 0.4*10^5 ])
grid()
xlabel('Frequencia [ Hz= rad/2pi ]');
ylabel('Torque [ Nm ]');
title('J em 120%, Rigidez Dinãmica | TL(S) / Teta(S) |');

% Root locus planta G(S)= Teta(S) / Teta*(S)figure(5)

figure(24)
rlocus(G_planta_completa_MF_Jmaior)
Controle de motores elétricos. Autor: Leonardo Barbosa Lima Gouvea. 17

grid()
title('Lugar das raízes de | TL(S) / Teta(S) | com J em 120%');

%####################################################################################
#######################################################
% graficos juntos para J em 80 e 120 %

% Resposta em Frequencia de G(S)= | Teta(S) / Teta*(S) | com J em 80% e em 120%

figure(25)
%f= logspace(0, 3, 1000);
f= logspace(-1, 4, 1000);
H= freqresp(G_planta_completa_MF_Jmenor, f);
H= abs(H);
H= H(1, :);
h11= semilogx(f/(2*pi), H, 'b');
hold on
H_nominal_planta= freqresp(G_planta_completa_MF, f);
H_nominal_planta= abs(H_nominal_planta);
H_nominal_planta= H_nominal_planta(1, :);
h12= semilogx(f/(2*pi), H_nominal_planta, 'g');
H= freqresp(G_planta_completa_MF_Jmaior, f);
H= abs(H);
H= H(1, :);
h13= semilogx(f/(2*pi), H, 'r');
hold off;
xlabel('Frequencia [ Hz ]');
ylabel('Módulo do Ganho');
grid()
title('J em 80%, 100%, 120%, modulo da resposta em fr |Teta(S)/Teta*(S)|');
legend([h11 h12 h13],'J em 80 %', 'J em 100 %', 'J em 120 %',' Best')

figure(26)
f= logspace(-3, 4, 1000);
H= freqresp(FT_Rigidez_dinamica_Jmenor, f);
H= abs(H);
H= H(1, :);
h11= semilogx(f/(2*pi), H, '-b', 'linewidth', 1);
H= freqresp(FT_Rigidez_dinamica_nominal, f);
H= abs(H);
H= H(1, :);
hold on;
h12= semilogx(f/(2*pi), H, '-g');
H= freqresp(FT_Rigidez_dinamica_Jmaior, f);
H= abs(H);
H= H(1, :);
h32= semilogx(f/(2*pi), H, '-r');
hold off
axis([ -inf inf -inf 0.4*10^5 ])
grid()
xlabel('Frequencia [ Hz= rad/2pi ]');
ylabel('Torque [ Nm ]');
title('J em 80%, 100%, 120%, Rigidez Dinâmica | TL(S) / Teta(S) |');
legend([h11 h12 h13],'J em 80 %', 'J em 100 %', 'J em 120 %',' Best')