Diseño e Implementación de Un Regulador Autoajustable, Mediante Identificación Por Mínimos Cuadrados Recursivos y Control Por El Método de Síntesis Directa Zafiriou-Morari

{
ki=0; n=1;
Si
Aplicar entada pseudo-aleatoria
u(k)=random
No
Sistema en
reposo
No
u(k)=0
Algoritmo RLS
ki=0;
n=n+1;
Clculo el error residual a priori Normalizado

N(k)=(k)/y(k)
N(k)<Max
Si
Fin del Pre-tuning
no
Si
ki=ki+1
ki>nfi
)(
{ }
) )(
)(
)
) )
(
(
) )(
)(
)
) )
( (
))
( )
)}
)}
{ }
( )
( )
}19
(
(
(
(
(
)
)
)(
)
(
)(
)
)
21
)(
27
Cambio en la
referencia
No
Esperar al siguiente
tiempo de muestreo
Si
Is=1;
Ii=0;
Iteracin=0;
Ha sido
encontrado
Yes
s=Ractual-Ranterior
=0.5(Is+Ii)
No
Iteracin =Itermax
Hallar S(z) y T(z)
Mediante divisin
sinttica encontrar
Iteracin =Iteracin +1
Ajustar el vector de prediccin

'= + uss [1 1 1]1Nc
ci>Lmax
Si
Is=Is;
Ii= ;
No
ci<Lmin
No
Is=;
Ii=Ii;
Si
}}
{
{
setup(block);
'Tunable'
block.NumDialogPrms = 13;
block.DialogPrmsTunable=
{'Tunable','Tunable','Tunable','Tunable','Tunable','Tunable','Tunable','Tunable','Tuna
ble','Tunable','Tunable','Tunable','Tunable'};
block.NumDialogPrms(1)
block.NumInputPorts = 3;
block.NumOutputPorts = 2;
block.NumInputPorts(1)
block.NumOutputPorts(1)
block.NumOutputPorts(2)
block.SampleTimes = [block.DialogPrm(1).Data 0];
block.SetPreCompInpPortInfoToDynamic;
block.SetPreCompOutPortInfoToDynamic;
block.InputPort(1).Complexity
block.InputPort(1).DataTypeId
block.InputPort(1).SamplingMode
block.InputPort(1).Dimensions
=
=
=
=
block.OutputPort(1).Complexity
block.OutputPort(1).DataTypeId
block.OutputPort(1).SamplingMode
block.OutputPort(1).Dimensions
CheckPrms.
'Real';
0;
'Sample';
1;
=
=
=
=
'Real';
0;
'Sample';
1;
block.RegBlockMethod('CheckParameters',
block.RegBlockMethod('ProcessParameters',
block.RegBlockMethod('PostPropagationSetup',
block.RegBlockMethod('Start',
block.RegBlockMethod('Outputs',
@CheckPrms);
@ProcessPrms);
@DoPostPropSetup);
@Start);
@Outputs);
block.SetAccelRunOnTLC(true);
T = block.DialogPrm(1).Data;
if T <= 0
error('--EL TIEMPO DE MUESTREO DEBE SER UN NUMERO POSITIVO DISTINTO DE CERO--');
end
block.NumDworks = 8+2*block.DialogPrm(2).Data
block.Dwork(1).Name
block.Dwork(1).Dimensions
block.Dwork(1).DatatypeID
block.Dwork(1).Complexity
block.Dwork(1).UsedAsDiscState
block.AutoRegRuntimePrms;
=
=
=
=
=
'U'; %%historia pasada de u(k)

block.DialogPrm(2).Data;
0;
'Real';
true;
block.Dwork(1)
block.Dwork(2)
block.Dwork(3)
block.Dwork(4)
block.Dwork(5)
block.Dwork(6)
block.Dwork(7)
block.Dwork(8)
block.Dwork(9,10,...,2 +8)
AutoUpdateRuntimePrms
block.AutoUpdateRuntimePrms;
block.Dwork(1).Data = zeros(1, block.DialogPrm(2).Data)';
%-------------------------------------------------------------------------%CONTROLADOR DE SINTESIS DIRECTA ZAFRIOU & MORARI

%-------------------------------------------------------------------------A=[1 theta(1:n)'];
B=[theta(n+1:2*n)'];
raices_A=roots(A);
raices_B=roots(B);
B_positivo=[];
B_negativo=[];
for i=1:length(raices_B);
if real(raices_B(i))>=0
B_positivo=[B_positivo raices_B(i)];
else
B_negativo=[B_negativo raices_B(i)];
end
end
B_positivo_estable=[];
B_positivo_inestable=[];
if length(B_positivo)>0
for i=1:length(B_positivo);
if abs(B_positivo(i))<0.9999
B_positivo_estable=[B_positivo_estable B_positivo(i)];
else
if abs(B_positivo(i))>1.00001
B_positivo_inestable=[B_positivo_inestable 1/(B_positivo(i))];
else
B_negativo=[B_negativo B_positivo(i)];
end
end
end
else
end
planta=tf([theta(n+1:2*n)'],[1 theta(1:n)'],1);
[Z,GAIN]=zero(planta);
ganancia_num=1;
for i=1:length(B_positivo_inestable);
ganancia_num=ganancia_num*(1-((B_positivo_inestable(i))));
end
ganancia_den=1;
for i=1:length(B_positivo_inestable);
ganancia_den=ganancia_den*(1-1/(B_positivo_inestable(i)));
end
for i=1:length(B_negativo);
ganancia_den=ganancia_den*(1-B_negativo(i));
end
GANANCIA=ganancia_num/(ganancia_den*GAIN);
Q=zpk(raices_A,[zeros(1,length(B_negativo)+1) B_positivo_estable B_positivo_inestable],
GANANCIA,1);
%-------------------------------------------------------------------------%AJUSTE FILTRO ANTISATURACION

%-------------------------------------------------------------------------OFFSET_IDENT=block.DialogPrm(3).Data;
AMP_IDENT=block.DialogPrm(4).Data;
Ls=block.DialogPrm(5).Data;
Li=block.DialogPrm(6).Data;
Nc=block.DialogPrm(7).Data;
if R_actual==R_anterior
alf=block.Dwork(8).Data(2);
else
Q=tf(Q);
alf=0;
U_estableciemiento=-1*Ucontrol(1);
Amp_step=R_actual-R_anterior;
RF=tf([Amp_step*(1-alf) 0 0],[1 -(1+alf) alf],1);
U=minreal(Q*RF);
[Num_U,gan_U]=zero(U);
Num_U=gan_U*poly(Num_U);
Den_U=pole(U);
Den_U=poly(Den_U);
B=[Num_U zeros(1,Nc-length(Num_U))];
A=[Den_U zeros(1,Nc-length(Den_U))];
rho=zeros(1,Nc);
for i=1:Nc
cosiente=B(1)/A(1);
rho(i)=cosiente;
D=A*cosiente;
for j=1:Nc
B(j)=B(j)-D(j);
end
B=[B(2:Nc) 0];
end
rho=rho-U_estableciemiento*ones(1,Nc);
nivel_energia=0;
for i=1:Nc
if rho(i)<=Ls && rho(i)>=Li
else
nivel_energia=1+nivel_energia;
break
end
end
if nivel_energia==1
sup=1;
inf=0;
alf=0.5;
for h=1:8
RF=tf([Amp_step*(1-alf) 0 0],[1 -(1+alf) alf],1);
U=minreal(Q*RF);
[Num_U,gan_U]=zero(U);
Num_U=gan_U*poly(Num_U);
Den_U=pole(U);
Den_U=poly(Den_U);
B=[Num_U zeros(1,Nc-length(Num_U))];
A=[Den_U zeros(1,Nc-length(Den_U))];
rho=zeros(1,Nc);
for i=1:Nc
cosiente=B(1)/A(1);
rho(i)=cosiente;
D=A*cosiente;
for j=1:Nc
B(j)=B(j)-D(j);
end
B=[B(2:Nc) 0];
end
rho=rho-U_estableciemiento*ones(1,Nc);
nivel_energia=0;
for i=1:Nc
if rho(i)<=Ls && rho(i)>=Li
else
nivel_energia=1+nivel_energia;
break
end
end
if nivel_energia==1
inf=alf;
else
sup=alf;
end
alf=(sup+inf)/2;
end
end
end
block.DialogPrm(13).Data
alf
alf_robusto
%-------------------------------------------------------------------------%INCLUSIN DEL PARMETRO DE ROBUSTEZ

%-------------------------------------------------------------------------alf_robusto=block.DialogPrm(13).Data;
if alf_robusto>alf
alf=alf_robusto;
else
end
block.Dwork(8).Data(2)=alf;
%-------------------------------------------------------------------------%TRASNFORMACION DEL CONTROLADOR EQUIVALENTE EN LAZO ABIERTO A LAZO CERRADO

%-------------------------------------------------------------------------F=tf([(1-alf) 0],[1 -alf],1);
minreal(planta);
GP=minreal(planta*Q);
Control=minreal((Q*F)/(1-(GP*F)));
Control=tf(Control);
Control=minreal(Control);
block.Dwork(7).Data(4)
block.Dwork(7).Data(10)
%-------------------------------------------------------------------------%OBTENCION DE LA SALIDA DEL CONTROL u(k)

%-------------------------------------------------------------------------[ceros_control,gain_control]=zero(Control);
polos_control=pole(Control);
numcontrol=gain_control*poly(ceros_control);
dencontrol=poly(polos_control);
salida_control=0;
for m=1:length(numcontrol);
salida_control=real((numcontrol(m)*Econtrol(m))+salida_control);
end
for m=2:length(dencontrol);
salida_control=(dencontrol(m)*Ucontrol(m-1)*(-1))+salida_control;
end
salida_control=real(salida_control/dencontrol(1));
if block.Dwork(7).Data(4)==1
if salida_control>Ls
block.OutputPort(1).Data=Ls;
else
if salida_control<Li
block.OutputPort(1).Data=Li;
else
block.OutputPort(1).Data = salida_control;
end
end
else
block.OutputPort(1).Data =0;
no_exitacion=block.Dwork(7).Data(7:9)';
no_exitacion=[block.InputPort(1).Data no_exitacion(1:2)];
prom_no_exitacion1=(abs(no_exitacion(1))-abs(no_exitacion(2)));
prom_no_exitacion=abs(prom_no_exitacion1)+abs(prom_no_exitacion2)+abs(prom_no_exitacion3);
if prom_no_exitacion<0.001
block.Dwork(7).Data(7:10)=[1 1 1 1];
Econtrol=zeros(1,n+1);
else
block.Dwork(7).Data(7:10)=[no_exitacion 0];
end
end
else
Lsident=block.DialogPrm(11).Data;
Liident=block.DialogPrm(12).Data;
y=block.InputPort(1).Data;
if y<Liident
block.OutputPort(1).Data=AMP_IDENT*2*(0.5)+OFFSET_IDENT;
else
if y>Lsident
block.OutputPort(1).Data=AMP_IDENT*2*(-0.5)+OFFSET_IDENT;
else
block.OutputPort(1).Data=AMP_IDENT*2*(randint(1,1)-0.5)+OFFSET_IDENT;
end
end
end
block.Dwork(9,10,...,2 +8)
%-------------------------------------------------------------------------%IDENTIFICACION MEDIANTE MINIMOS CUADRADOS RECURSIVOS (RLS)

%-------------------------------------------------------------------------P=[];
for i=1:2*block.DialogPrm(2).Data;
P=[P; block.Dwork(8+i).Data'];
end
P=P(1:2*n,1:2*n);
psi=block.Dwork(5).Data(1:2*n);
theta=block.Dwork(6).Data(1:2*n);
% Paso 1: obtener y(k) , u(k)
u=block.OutputPort(1).Data;
y=block.InputPort(1).Data;
% Paso 2: calcular el error e%
e=y-psi'*theta;
error=abs(e/y);
% Paso 3: calcular la matriz de ganacia L%
c=block.Dwork(3).Data;
L=(P*psi)*(inv(psi'*P*psi+c));
% Paso 4: recalcular theta%
theta=theta+e*L;
block.OutputPort(2).Data(1:2*n) =theta';
comp_c=0;
% Paso 5:Actualizar factor de olvido
for i=1:length(psi')
comp_c=psi(i)'+comp_c;
end
for i=1:length(L')
comp_c=L(i)'+comp_c;
end
if comp_c==0
c=0.9;
else
c=1-(1-psi'*L)*(error*2000);
end
cmin=block.DialogPrm(8).Data;
cmax=block.DialogPrm(9).Data;
if c<=cmin
c=cmin;
else
if c>=cmax
c=cmax;
end
end
block.Dwork(3).Data=c;
% Paso 6: Actualizar la matriz de covarianzas P%
P=(1/c)*((eye(2*n)-L*psi')*P);
% Paso 7: Actualizar psi%
for m=1:2*n-1;
h=2*n-m;
psi(h+1)=psi(h);
end
psi(1)=-y;
psi(n+1)=u;
block.Dwork(5).Data(1:2*n)=psi;
block.Dwork(6).Data(1:2*n)=theta;
for i=1:2*n;
block.Dwork(8+i).Data(1:2*n)=P(i,1:2*n);
end
%-------------------------------------------------------------------------%PRE-TUNING (VALIDACION DEL MODELO MEDIANTE EL ERROR A PRIORI NORMALIZADO)

%-------------------------------------------------------------------------error_ident_max=block.DialogPrm(10).Data/100;
block.Dwork(7).Data(4) =1;
else
error_ident=block.Dwork(7).Data(1:3)';
error_ident=[error error_ident(1:2)];
prom_error_ident=(abs(error_ident(1))+abs(error_ident(2))+abs(error_ident(3)));
block.Dwork(7).Data(1:3)=error_ident;
termino_pre_tuning=block.Dwork(7).Data(4);
if termino_pre_tuning==1
block.Dwork(4).Data= block.Dwork(4).Data;
else
if abs(prom_error_ident)<error_ident_max
else
if block.Dwork(7).Data(5)<=50*n
block.Dwork(7).Data(5) =1+block.Dwork(7).Data(5);
block.Dwork(4).Data= block.Dwork(4).Data;
else
block.Dwork(7).Data(5)=0;
block.Dwork(4).Data= block.Dwork(4).Data+1;
block.Dwork(7).Data(6)=0;
end
end
end
else
alpha=1000000;
block.Dwork(1).Data
block.Dwork(2).Data
block.Dwork(3).Data
block.Dwork(5).Data
=
=
=
=
zeros(1, block.DialogPrm(2).Data)';
zeros(1, block.DialogPrm(2).Data)';
0.97;
zeros(2*block.DialogPrm(2).Data,1);
block.Dwork(6).Data = ones(2*block.DialogPrm(2).Data,1);
block.Dwork(7).Data(1:5) = zeros(5,1);
for i=1:2*block.DialogPrm(2).Data;
block.Dwork(8+i).Data = zeros(1,2*block.DialogPrm(2).Data);
block.Dwork(8+i).Data(i)=alpha;
end
block.OutputPort(1).Data = 0;
no_exitacion=block.Dwork(7).Data(7:9)';
no_exitacion=[block.InputPort(1).Data no_exitacion(1:2)];
prom_no_exitacion1=((no_exitacion(2))-(no_exitacion(1)))/block.DialogPrm(1).Data;
prom_no_exitacion2=((no_exitacion(3))-(no_exitacion(2)))/block.DialogPrm(1).Data;
prom_no_exitacion3=((no_exitacion(3))-(no_exitacion(1)))/(2*block.DialogPrm(1).Data);
prom_no_exitacion=abs(prom_no_exitacion1)+abs(prom_no_exitacion2)+abs(prom_no_exitacion3);
if prom_no_exitacion<0.001
block.Dwork(7).Data(6:9)=[1 1 1 1];
else
block.Dwork(7).Data(6:9)=[0 no_exitacion];
end
end
end
Elapsed time is 0.060174 seconds.
PWM del Motor
Motor DC
Sensor
TAD
TAD
0 a 5 V dc
Input
Acondicionamiento
de la seal
10 a -10 V dc
PWM
Comparador
generador PWM
Oscilador Miller - Schmitt
Etapa de potencia
Acondicionamiento
de la Seal
Sensor optoelectrnico
Conversor de
Frecuencia a Voltaje,
LM2907
Error in ==> STR at 4

setup(block);

Diseño e Implementación de Un Regulador Autoajustable, Mediante Identificación Por Mínimos Cuadrados Recursivos y Control Por El Método de Síntesis Directa Zafiriou-Morari

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Diseño e Implementación de Un Regulador Autoajustable, Mediante Identificación Por Mínimos Cuadrados Recursivos y Control Por El Método de Síntesis Directa Zafiriou-Morari

Hochgeladen von

Copyright:

Verfügbare Formate

{

Clculo el error residual a priori Normalizado

Hallar S(z) y T(z)

Ajustar el vector de prediccin

block.SampleTimes = [block.DialogPrm(1).Data 0];

'U'; %%historia pasada de u(k)

block.Dwork(1).Data = zeros(1, block.DialogPrm(2).Data)';

%-------------------------------------------------------------------------%CONTROLADOR DE SINTESIS DIRECTA ZAFRIOU & MORARI

%-------------------------------------------------------------------------%AJUSTE FILTRO ANTISATURACION

%-------------------------------------------------------------------------%INCLUSIN DEL PARMETRO DE ROBUSTEZ

%-------------------------------------------------------------------------%TRASNFORMACION DEL CONTROLADOR EQUIVALENTE EN LAZO ABIERTO A LAZO CERRADO

%-------------------------------------------------------------------------%OBTENCION DE LA SALIDA DEL CONTROL u(k)

%-------------------------------------------------------------------------%IDENTIFICACION MEDIANTE MINIMOS CUADRADOS RECURSIVOS (RLS)

% Paso 1: obtener y(k) , u(k)

%-------------------------------------------------------------------------%PRE-TUNING (VALIDACION DEL MODELO MEDIANTE EL ERROR A PRIORI NORMALIZADO)

Elapsed time is 0.060174 seconds.

PWM del Motor

Error in ==> STR at 4

Das könnte Ihnen auch gefallen