Aplicaciones de diseño de controladores PID

digitales con datos de plantas reales

De La Cruz Karolay, Valarezo Jéssica, Ortiz Javier
Universidad de las Fuerzas Armadas - ESPE
Departamento de Eléctrica y Electrónica
Sangolquı́-Ecuador
dkde@espe.edu.ec,jlvalarezo1@espe.edu.ec, jgortiz2@espe

I. I NTRODUCCI ÓN manera que : ωn= 10 rad/s ; ζ=0.7. Utilice el periodo de

En las aplicaciones de control a nivel industrial, normal-
mente el valor deseado de la variable controlada o referencia,
permanece constante y se requiere una buena eliminación del
efecto de las perturbaciones o sea, se necesita un buen control
regulatorio. Ademas puede ser necesario cambiar el valor
deseado de la variable controlada, para lo que es necesario
un buen seguimiento a esos cambios. Debido a que estos dos
funcionamientos no pueden ser satisfechos en forma simulta-
nea con un controlador de solo un grado de libertad (1GdL), la
utilización de un controlador de dos grados de libertad (2GdL),
permite sintonizarlo considerando el desempeño del control
regulatorio y la robustez del lazo de control, y utilizar luego
el parámetro extra que caracteriza al segundo grado de libertad
para mejorar el desempeño del servo control.
El procedimiento de diseño del sistema de control,
usualmente, tiene como base el uso de modelos lineales
de orden reducido para representar al proceso controlado,
identificados estos en el punto de operación normal del
sistema de control. Debido a las no linealidades encontradas
en la mayorı́a de los procesos industriales, es necesario
considerar los cambios esperados en las caracterı́sticas del
proceso, estableciendo algún margen de estabilidad relativa.
Para la sintonizacion de un sistema de control realimentado
es necesario regular parámetros en el controlador para lograr
implementar un control robusto en el proceso, es decir
que tenga caracteristicas como estabilidad de las variables
de procesos a pesar de los cambios de carga, una rápida
respuesta ente los cambios de setpoint, oscilaciones mı́nimas
y rechazo a perturbaciones.
muestreo de la adquisición de datos.
b) Para los datos de (2) (Anexos) identifique el sistema
y diseñe un controlador PID2F por el método de la última
ganancia de Ziegler Nichols. Utilice el periodo de muestreo
de la adquisición de datos.
c) El sistema en (a) ahora va a ser controlado con un
periodo de muestreo de T=0.16 s. Re-diseñe el controlador
PID2F.
d) El sistema en (b) ahora va a ser controlado por un
periodo de muestreo de T=1 s. Re-diseñe el controlador PID2F.
e) A partir de los resultados de (b) seleccione un PLC de
cualquier marca y especifique como realizarı́a una configura-
ción hipotética de las ganancias PID.
IV. M ÉTODOS
En primer lugar se importaron los datos de (1) y se
procedió a la identificación del sistema, cargando los datos
en Matlab.
Entrada-Salida de los datos:

II. O BJETIVO
Ensayar el diseño de controladores digitales cuando el
modelo discreto de la planta se obtiene por identificación
utilizando datos reales de un proceso.

III. D ESCRIPCI ÓN DEL P ROBLEMA

a) Para los datos de (1) (Anexos) identifique el sistema
y diseñe un controlador PID2F por ubicación de polos de
 Con la función de Matlab delayest(datos) no se obtuvo,
razón por la cual se uso el comando arx(datos, [221]) con
el cual se obtuvo el modelo discreto arx para la posterior
obtención de la planta discretizada.
A continuación se particionó el conjunto de los datos de (1)
para estimación y validación , separando el conjunto de datos
en dos.
Entrada-Salida de datos para estimación:

A continuación se obtuvo la planta discretizada con el conjunto

de datos de estimación y validación, cuyo resultado fue el
mismo en los dos casos:

0,06621z + 0,04601
G=
z 2 − 1,271z + 0,3865

Dados los objetivos de performance ωn= 10 rad/s y ζ=0.7.

Se procedió a realizar el diseño del controlador PID2F por
ubicación de polos a partir del diseño del controlador de un
grado de libertad (PID1F).

Dado que la forma de la planta obtenida es:

b1z + b2
G=
z2 + a1z + a2
Entrada-Salida de datos para validación:
Y del controlador:

s02 + s1z + s2
C(z) =
z2+ (r − 1)z − r

Se obtuvo el controlador PID1F y a partir de este se obtuvo

el controlador PID2F.
Controlador de un grado de libertad:

12,93z 2 − 13,03z + 2,813

C(z) =
z 2 − 0,5342z − 0,4658

Controlador de dos grados de libertad:

Realizando una comparación de respuesta se obtuvo la 2,716z 2

siguiente gráfica, en la que se observa la similitud de las dos: C2(z) =
z 2 − 0,5342z − 0,4658
 x2=VarName1(length(VarName1)/
2:length(VarName1));
y2=VarName2(length(VarName1)/
2:length(VarName2));

datos=iddata(x2, y2, 1);

figure
idplot(datos)
m1=arx(datos,[2 2 1]); %1 orden denominador,
2 numerador, 3 (zˆ-1)
gz1=tf(m1);
[n,d]=tfdata(gz1,’v’);
b1=n(2);
b2=n(3);
a1=d(2);
a2=d(3);
T=0.08;
Fig. 1: Controladores PID1F y PID2F con datos de gzf=tf([b1 b2], [1 a1 a2],T);
estimación [n,d]=tfdata(gzf,’v’);
Wn=10;
E=0.7;

s1=-E*Wn+j*Wn*sqrt(1-Eˆ2);
%polo tiempo continuo
z1=exp(s1*T);
%polo discreto
zd=[z1 conj(z1) 0 0];
ez=poly(zd);
p1=ez(2);
%Se extrae coeficientes ec. car.
p2=ez(3);
p3=ez(4);
p4=ez(5);
P=[b1 0 0 1; b2 b1 0 a1-1; 0 b2 b1 a2-a1;
0 0 b1 -a2]; %matris de la planta
D=[p1-a1+1; p2-a2+a1; p3+a2; p4];
C=inv(P)*D;
%Calculo del PID1F o controlador S/R
Fig. 2: Controladores PID1F y PID2F con datos de cz=tf(C(1:3)’,[1 C(4)-1 -C(4)],T);
validación %Funcion de controlador feedback
figure
Con las gráficas obtenidas se puede apreciar que en cuanto step(feedback(cz*gzf,1));
al rechazo a las perturbaciones el PID1F y el PID2F tienen el %Salida controlada con e PID1F
mismo comportamiento, por el hecho de presentar el mismo %%PID2F
denominador en la función de transferencia, pero el PID de G=sum(C(1:3));
dos grados de libertad mejora el desempeño en cuanto al hold on
seguimiento a referencia comparado con el PID de un grado c2z=tf([G 0 0],[1 C(4)-1 -C(4)],T);
de libertad que presenta un overshoot. %controlador feed forward
step(c2z*feedback(gzf,cz));
Código en Matlab %Salida controlador por PID2F
hold off
%%Ubicación de polos T=0.8
%Datos estimación Para el literal b) se importaron los datos de (2) y se procedió
x1=VarName1(1:length(VarName1)/2); a la identificación del sistema, cargando los datos en Matlab.
y1=VarName2(1:length(VarName2)/2);
%Datos validación Entrada-Salida de datos:
 Realizando una comparación de respuesta se obtuvo la siguien-
Fig. 3: Datos de entrada/salida(2)
te gráfica, en la que se observa la similitud de los dos:

Con la función de Matlab delayest(datos) se obtuvo el

retardo de los datos cuyo valor fue cuatro, razón por la cual
se uso el comando procest(datos,0 P 1D0 ); con la cual se
obtuvo el modelo del proceso para la posterior obtención de
la planta discretizada.

A continuación se particionó el conjunto de los datos de

(2) para estimación y validación , separando el conjunto de
datos en dos.

Entrada-Salida de datos para estimación

A continuación se obtuvo la planta discretizada con el

conjunto de datos de estimación y validación, cuyo resultado
fue el mismo en los dos casos:

0,02579z + 0,009453
G(z) =
z 3 − 0,8302z 2
A continuación se procedió a realizar el diseño del contro-
lador por el método de la última ganancia de Ziegler Nichols.
Utilizando el periodo de muestreo de la adquisición de datos
T=0.5.
Dado que la forma del controlador es la siguiente:

s02 + s1z + s2
C(z) =
z 2 + (r − 1)z − r
Entrada-Salida de datos para validación Se procedió a hallar la ganancia crı́tica Ku y el periodo
crı́tico Tu. Ku se obtuvo por medio de la utilización del
comando margin(gz1) y el periodo critico Tu por medio de
la siguiente gráfica.
 Fig. 5: Controladores PID1F y PID2F con datos de
Seleccionando dos puntos del pico (3.99-1.6= 2.4) se obtuvo validación
el periodo critico Ku.
A continuación se obtuvo los valores de K, Ti, Td,r, s0, s1, s2
obteniendo el controlador de un grado de libertad y a partir Con las gráficas obtenidas se puede apreciar que en cuanto
de este se obtuvo el de dos grados de libertad. al rechazo a las perturbaciones el PID1F y el PID2F tienen
el mismo comportamiento, pero el PID de dos grados de
Controlador de un grado de libertad: libertad mejora el desempeño en cuanto al seguimiento a
referencia.
24,65z 2 − 30,57z + 8,651
C(z) = Código en Matlab
z 2 − 1,057z − 0,0566
%Datos completos
Controlador de dos grados de libertad: close all;
T=0.5;
datos=iddata(VarName1,
2,716z 2
C2(z) = VarName2,T);
z 2 − 0,5342z − 0,4658 figure
idplot(datos)
delayest(datos)

%Datos estimación
x1=VarName1(1:150);
y1=VarName2(1:150);
%Datos validación
x2=VarName1(151:300);
y2=VarName2(151:300);

%Estimación
datos=iddata(x1, y1,T);
figure
idplot(datos)
m1=procest(datos,’P1D’);
gz1=tf(m1);
figure
[a,b,c,d]=margin(gz1) %a y c
step(feedback(gz1*a,1),10)
gzf=c2d(gz1,T);
Fig. 4: Controladores PID1F y PID2F con datos de Ku=a;
estimación Tu=2.4;
K=0.4*Ku;
Ti=2*Tu/2;
Td=Tu/8; %En un incio era
/8 pero al variarle mejora
N=10;
r=-Td/(N*T+Td);
s0=K*(1+T/Ti-N*r);
s1=K*(r-1+T*r/Ti+2*N*r);
s2=-K*(r+N*r);
czn=tf([s0 s1 s2], [1 r-1 -r], T);
figure
step(feedback(czn*gzf,1),60)
%%PID2F
G=sum(s0+s1+s2);
hold on Entrada-Salida de datos para validación:
c2z=tf([G 0 0],[1 r-1 -r],T);
%controlador feed forward
step(c2z*feedback(gzf,czn));
%Salida controlador por PID2F
hold off

En el literal c) se realizo el mismo proceso que en el literal

a) con la diferencia de que se uso el comando downsample
para dividir las muestras dado que el periodo de muestreo en
este caso es el doble del periodo del literal a).

Entrada-Salida de los datos:

Realizando una comparación de respuesta se obtuvo la

siguiente gráfica, en la que se observa la similitud de las dos:

Con la función de Matlab delayest(datos) no se obtuvo,

razón por la cual se uso el comando arx(datos, [221]) con
el cual se obtuvo el modelo discreto arx para la posterior
obtención de la planta discretizada.
A continuación se particionó el conjunto de los datos de (1)
para estimación y validación , separando el conjunto de datos
en dos.
A continuación se obtuvo la planta discretizada con el conjunto
Entrada-Salida de datos para estimación: de datos de estimación y validación, cuyo resultado fue el
mismo en los dos casos:
 0,06741z + 0,04543
G=
z 2 − 1,267z + 0,3844

Dados los objetivos de performance ωn= 10 rad/s y ζ=0.7.

Se procedió a realizar el diseño del controlador PID2F por
ubicación de polos a partir del diseño del controlador de un
grado de libertad (PID1F).

Dado que la forma de la planta obtenida es:

b1z + b2
G=
z2 + a1z + a2

Y del controlador:
Fig. 7: Controladores PID1F y PID2F con datos de
2 validación
s0 + s1z + s2
C(z) =
z 2 + (r − 1)z − r
Con las gráficas obtenidas se puede apreciar que en cuanto
Se obtuvo el controlador PID1F y a partir de este se obtuvo al rechazo a las perturbaciones el PID1F y el PID2F tienen el
el controlador PID2F. mismo comportamiento, por el hecho de presentar el mismo
Controlador de un grado de libertad: denominador en la función de transferencia, pero el PID de
dos grados de libertad mejora el desempeño en cuanto al
seguimiento a referencia comparado con el PID de un grado
21z 2 − 17,55z + 3,31 de libertad que presenta un overshoot.
C(z) =
z 2 − 0,4195z − 0,5805
Código en Matlab
Controlador de dos grados de libertad:
x=downsample(VarName1,2); %Para T=0.16
x=downsample(VarName2,2); %Para T=0.16
6,759z 2
C2(z) =
z 2 − 0,4195z − 0,5805 %Datos estimación
x1=VarName1(1:length(x)/2);
y1=VarName2(1:length(y)/2);
%Datos validación
x2=VarName1(length(x)/2:length(x));
y2=VarName2(length(y)/2:length(y));

T=0.16;
datos=iddata(x2, y2,T);
figure
idplot(datos)
m1=arx(datos,[2 2 1]);
%1 orden denominador, 2 numerador, 3 (zˆ-1)
gz1=tf(m1);
[n,d]=tfdata(gz1,’v’);
b1=n(2);
b2=n(3);
a1=d(2);
a2=d(3);
gzf=tf([b1 b2], [1 a1 a2], T);
[n,d]=tfdata(gzf,’v’);
Fig. 6: Controladores PID1F y PID2F con datos de Wn=10;
estimación E=0.7;
 Con la función de Matlab delayest(datos) se obtuvo el
retardo de los datos cuyo valor fue cuatro, razón por la cual
s1=-E*Wn+j*Wn*sqrt(1-Eˆ2); %polo tiempo continuo
z1=exp(s1*T); %polo discreto se uso el comando procest(datos,0 P 1D0 ); con la cual se
zd=[z1 conj(z1) 0 0]; obtuvo el modelo del proceso para la posterior obtención de
ez=poly(zd); la planta discretizada.
p1=ez(2);
%Se extrae coeficientes ec. car. A continuación se particionó el conjunto de los datos de
p2=ez(3); (2) para estimación y validación , separando el conjunto de
p3=ez(4); datos en dos.
p4=ez(5);
P=[b1 0 0 1; b2 b1 0 a1-1; 0 b2 b1 a2-a1;
Entrada-Salida de datos para estimación
0 0 b1 -a2];
%matris de la planta
D=[p1-a1+1; p2-a2+a1; p3+a2; p4];
C=inv(P)*D;
%Calculo del PID1F o controlador S/R
cz=tf(C(1:3)’,[1 C(4)-1 -C(4)],T);
%Funcion de controlador feedback
figure
step(feedback(cz*gzf,1));
%Salida controlada con e PID1F
%%PID2F
G=sum(C(1:3));
hold on
c2z=tf([G 0 0],[1 C(4)-1 -C(4)],T);
%controlador feed forward
step(c2z*feedback(gzf,cz));
%Salida controlador por PID2F
hold off

Para el literal d) se realizo el mismo proceso que en

el literal b) con la diferencia de que se uso el comando Entrada-Salida de datos para validación
downsample para dividir las muestras dado que el periodo de
muestreo en este caso es el doble del periodo del literal b).

Entrada-Salida de datos:

Realizando una comparación de respuesta se obtuvo la siguien-

te gráfica, en la que se observa la similitud de los dos:

Fig. 8: Datos de entrada/salida(2)

 obteniendo el controlador de un grado de libertad y a partir
de este se obtuvo el de dos grados de libertad.
Controlador de un grado de libertad:
13,57z 2 − 15,45z + 3,898
C(z) =
z 2 − 1,045z + 0,04478
Controlador de dos grados de libertad:
2,016z 2
C2(z) =
z2 − 1,045z − 0,04478

A continuación se obtuvo la planta discretizada con el

conjunto de datos de estimación y validación, cuyo resultado
fue el mismo en los dos casos:

0,06541z + 0,005158
G(z) =
z 3 − 0,6155z 2
A continuación se procedió a realizar el diseño del contro-
lador por el método de la última ganancia de Ziegler Nichols.
Utilizando el periodo de muestreo de la adquisición de datos
T=1.
Dado que la forma del controlador es la siguiente:
Fig. 9: Controladores PID1F y PID2F con datos de
s02 + s1z + s2
C(z) = estimación
z 2 + (r − 1)z − r
Se procedió a hallar la ganancia crı́tica Ku y el periodo
crı́tico Tu. Ku se obtuvo por medio de la utilización del
comando margin(gz1) y el periodo critico Tu por medio de
la siguiente gráfica.

Fig. 10: Controladores PID1F y PID2F con datos de

validación

Con las gráficas obtenidas se puede apreciar que en cuanto

Seleccionando dos puntos del pico se obtuvo el periodo al rechazo a las perturbaciones el PID1F y el PID2F tienen
critico Ku. el mismo comportamiento, pero el PID de dos grados de
A continuación se obtuvo los valores de K, Ti, Td,r, s0, s1, s2 libertad mejora el desempeño en cuanto al seguimiento a
referencia.
%%PID1F
Código en Matlab function u=pid1f(x)
global uk1 uk2 ek2 ek1
%Datos completos T=0.08;
close all; y=x(1);
T=1; sp=x(2);
datos=iddata(VarName1, VarName2,T); t=x(3);
figure s0=12.627;
idplot(datos) s1=-12.6327;
s2=2.7644;
%REMUESTREO r=0.4736;
%x=VarName1(1:2:length(VarName1)); r1=r-1;
%Para T=0.16 r2=-r;
%y=VarName2(1:2:length(VarName2)); e=sp-y;
%Para T=0.16
x=downsample(VarName1,2); %Para T=0.16 if t==0
y=downsample(VarName2,2); %Para T=0.16 u=s0*e;
uk2=0;
%Datos estimación uk1=u;
x1=x(50:200); ek2=0;
y1=y(50:200); ek1=e;
%Datos validación end
x2=x(201:350);
y2=y(201:350); if t>0
u=-r1*uk1-r2*uk2+s0*e+s1*ek1+s2*ek2;
%Estimación ek2=ek1;
datos=iddata(x2, y2,T); ek1=e;
figure uk2=uk1;
idplot(datos) uk1=u;
m1=procest(datos,’P1D’); end
gz1=tf(m1);
figure
[a,b,c,d]=margin(gz1) %a y c PID2F:
step(feedback(gz1*a,1),10)
gzf=c2d(gz1,T);
Ku=a;
Tu=3.75; function u=pid2f(x)
global uk1 uk2 yk2 yk1
K=0.4*Ku; y=x(1);
Ti=2*Tu/2; sp=x(2);
Td=Tu/8; %En un incio era /8 pero al t=x(3);
variarle mejora s0=12.627;
N=10; s1=-12.6327;
r=-Td/(N*T+Td); s2=2.7644;
s0=K*(1+T/Ti-N*r); r=0.4736;
s1=K*(r-1+T*r/Ti+2*N*r); G=s0+s1+s2;
s2=-K*(r+N*r); r1=r-1;
czn=tf([s0 s1 s2], [1 r-1 -r], T); r2=-r;
figure
step(feedback(czn*gzf,1),60) if t==0
u=-s0*y+G*sp;
Las leyes de control obtenidas son las siguientes: uk2=0;
PID1F: uk1=u;
Para el literal a: yk2=0;
yk1=y;
end K=x(4);
Ti=x(5);
if t>0 Td=x(6);
u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
N=10;
yk2=yk1; T=0.1
yk1=y; r=-Td/(Td+N*T);
uk2=uk1; s0=K*(1+T/Ti-N*r ) ;
uk1=u; s1=K*(r*(1+T/Ti+2*N)-1);
end s2=-K*r*(1+N) ;
r1=r-1;
r2=-r;
Para el literal b: G=s0+s1+s2;
e=sp-y
if t==0
%%PID1F u=-s0*y+G*sp;
uk2=0;
%%PID1F uk1=u;
function u=pid1f_ziegger(x) yk2=0;
global uk1 uk2 ek2 ek1 yk1=y;
y=x(1); end
sp=x(2);
t=x(3); if t>0
K=x(4); u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
Ti=x(5); yk2=yk1;
Td=x(6); yk1=y;
N=10; uk2=uk1;
T=0.5 uk1=u;
r=-Td/(Td+N*T); end
s0=K*(1+T/Ti-N*r ) ;
s1=K*(r*(1+T/Ti+2*N)-1);
s2=-K*r*(1+N) ;
r1=r-1; PID2F:
r2=-r;
G=s0+s1+s2;
e=sp-y; function u=pid2f_ziegger(x)
if t==0 global uk1 uk2 yk2 yk1
u=s0*e; y=x(1);
uk2=0; sp=x(2);
uk1=u; t=x(3);
ek2=0; K=x(4);
ek1=e; Ti=x(5);
end Td=x(6);
N=10;
if t>0 T=0.5
u=-r1*uk1-r2*uk2+s0*e+s1*ek1+s2*ek2; r=-Td/(Td+N*T);
ek2=ek1; s0=K*(1+T/Ti-N*r ) ;
ek1=e; s1=K*(r*(1+T/Ti+2*N)-1);
uk2=uk1; s2=-K*r*(1+N) ;
uk1=u; r1=r-1;
end r2=-r;
%PID2F G=s0+s1+s2;
function u=pid2f_ziegger(x) e=sp-y
global uk1 uk2 yk2 yk1 if t==0
y=x(1); u=-s0*y+G*sp;
sp=x(2); uk2=0;
t=x(3); uk1=u;
 yk2=0; t=x(3);
yk1=y; s0=36.507;
end s1=-7+7.14*i;
s2=10.4881;
if t>0 r=-0.448;
u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
G=s0+s1+s2;
yk2=yk1; r1=r-1;
yk1=y; r2=-r;
uk2=uk1;
uk1=u; if t==0
end u=-s0*y+G*sp;
uk2=0;
uk1=u;
Para el literal c: yk2=0;
yk1=y;
end
%%PID1F
function u=pid1f(x) if t>0
global uk1 uk2 ek2 ek1 u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
T=0.16; yk2=yk1;
y=x(1); yk1=y;
sp=x(2); uk2=uk1;
t=x(3); uk1=u;
s0=36.507; end
s1=-+7.14*i;
s2=10.4881; Para el literal d:
r=-0.448;
r1=r-1;
r2=-r; %%PID1F
e=sp-y;
%%PID1F
if t==0 function u=pid1f_ziegger(x)
u=s0*e; global uk1 uk2 ek2 ek1
uk2=0; y=x(1);
uk1=u; sp=x(2);
ek2=0; t=x(3);
ek1=e; K=x(4);
end Ti=x(5);
Td=x(6);
if t>0 N=10;
u=-r1*uk1-r2*uk2+s0*e+s1*ek1+s2*ek2; T=0.1
ek2=ek1; r=-Td/(Td+N*T);
ek1=e; s0=K*(1+T/Ti-N*r ) ;
uk2=uk1; s1=K*(r*(1+T/Ti+2*N)-1);
uk1=u; s2=-K*r*(1+N) ;
end r1=r-1;
r2=-r;
PID2F: G=s0+s1+s2;
e=sp-y;
if t==0
u=s0*e;
function u=pid2f(x) uk2=0;
global uk1 uk2 yk2 yk1 uk1=u;
y=x(1); ek2=0;
sp=x(2); ek1=e;
end Td=x(6);
N=10;
if t>0 T=0.1
u=-r1*uk1-r2*uk2+s0*e+s1*ek1+s2*ek2; r=-Td/(Td+N*T);
ek2=ek1; s0=K*(1+T/Ti-N*r ) ;
ek1=e; s1=K*(r*(1+T/Ti+2*N)-1);
uk2=uk1; s2=-K*r*(1+N) ;
uk1=u; r1=r-1;
end r2=-r;
%PID2F G=s0+s1+s2;
function u=pid2f_ziegger(x) e=sp-y
global uk1 uk2 yk2 yk1 if t==0
y=x(1); u=-s0*y+G*sp;
sp=x(2); uk2=0;
t=x(3); uk1=u;
K=x(4); yk2=0;
Ti=x(5); yk1=y;
Td=x(6); end
N=10;
T=0.1 if t>0
r=-Td/(Td+N*T); u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
s0=K*(1+T/Ti-N*r ) ; yk2=yk1;
s1=K*(r*(1+T/Ti+2*N)-1); yk1=y;
s2=-K*r*(1+N) ; uk2=uk1;
r1=r-1; uk1=u;
r2=-r; end
G=s0+s1+s2;
e=sp-y
if t==0 V. C ONCLUSIONES
u=-s0*y+G*sp;
uk2=0; Se obtuvo la planta discretizada con el conjunto de datos
uk1=u; de estimación y validación, cuyo resultado fue el mismo.
yk2=0; Se obtuvo el controlador PID1F y a partir de este se obtuvo
yk1=y; el PID2F.
end EL PID2F mejora la respuesta al disminuir el overshoot
mejorando la región transitoria.
if t>0
u=-r1*uk1-r2*uk2-s0*y-s1*yk1-s2*yk2+G*sp;
yk2=yk1; VI. A NEXOS
yk1=y;
uk2=uk1; e) A partir de los resultados de (b) seleccione un PLC de
uk1=u; cualquier marca y especifique como realizarı́a una configura-
end ción hipotética de las ganancias PID.
De acuerdo a los datos obtenidos en el literal b)
realizaremos la configuración de un PID en el TIA PORTAL
(software de programacion del PLC S7-1200), la versión no
PID2F: importa ya que son similares desde la versión 11 a la versión
13.

function u=pid2f_ziegger(x) Abrir el software Tia Portal y configurar una CPU S7-1200,
global uk1 uk2 yk2 yk1 en éste caso seleccionar una cpu 1214C, un modulo adicional
y=x(1); de entradas y salidas análogas, y por ultimo configurar la
sp=x(2); direccion ip del plc.
t=x(3);
K=x(4); Declarar variables como ”set point”
Ti=x(5);
 Configurar el controlador con acción proporcional
solamente (las acciones integrales y derivativas deben ser
configuradas al mı́nimo), fijar la ganancia cerca o a 1.

Incrementar la ganancia del controlador hasta lograr

oscilaciones estables, cambie el valor setpoint de arriba hacia
abajo tanto como sea necesario para provocar oscilaciones.

Cuando la última ganancia sea determinada, fijar la

ganancia del controlador a la mitad de ese valor.

Realizar los mismos procedimientos para la accion integral

y derivativa.