Control 3 – Semestre B-2022

Yuarth Hernández C.I. 25.822.068

Profesor: Jormany Quintero

Tarea 11: Diseño e implementación de Controladores en Digital

Para el siguiente sistema en continuo

Diseñe un controlador PID en discreto usando la técnica de asignación de polos.

El controlador debe cumplir con las siguientes especificaciones: Anule el error en estado
estacionario, Sobredisparo menor del 10%, Tiempo de asentamiento menor a un tercio del
Ts en lazo abierto.

Ante una entrada escalón unitario simule la salida y(k), el error e(k) y la señal de control
u(k) del sistema controlado. Establezca análisis de los resultados para e(k) y para u(k).

Parte 1: Control PID por asignación de polos

Lo primero que se debe tomar en cuenta a la hora del diseño de un controlado PID con
asignación de polos es definir las especiaciones de diseño, para ello primero analizaremos
la información de nuestro sistema en lazo abierto.

En nuestro caso nuestra planta es de tercer orden, se debe saber que la técnica de
asignación de polos en discreta no funciona para sistemas de tercer orden o mayor, por lo
tanto eliminaremos el polo menos dominante del sistema, para llevarle a segundo orden y
que conserve su dinámica original.

Usando MATLAB escribimos la función de transferencia y con el comando pole()

determinamos los polos y elegimos el menos dominante:

>> sys3

sys3 =

s+1
------------------------
s^3 + 13 s^2 + 42 s + 10
Continuous-time transfer function.

>> pole(sys3)

ans =

-7.7417
-5.0000
-0.2583

El polo menos dominante es -7.7417, se elimina y se construye el nuevo sistema con los
dos polos restantes:

Discretizamos la planta con el comando c2d, y usando el método ‘Impulse’, utilizando un

período de muestreo definido por:

0.015 tslz < To < 0.15 tslz

Donde tslz es el tiempo de asentamiento en lazo cerrado de la planta, calculándolo en
Matlab se obtiene tslz = 8.925
Así
0,05(tslz) < To < 0.15(tslz)
0,05(8.925) < To < 0.15(8.925)
0.4463 < To < 1.3388

To = 0.8
Reescribimos el sistema con potencias negativas:

Gp(z) es la planta en discreto, ahora debemos hallar el controlador PID Gc(z) para realizar
el control.

El primer paso es hallar nuestro sistema deseado, para a partir de allí diseñar el
controlador.
Teniendo en cuenta que se necesita que el sistema controlado cumpla con:

 Sobrepico < 10%

 Tiempo de asentamiento < Tiempo de asentamiento menor a un tercio del Ts en

lazo abierto.
 Eliminar el error en estado estacionario

Calculamos las especificaciones del sistema en lazo abierto con el comando stepinfo():
RiseTime: 8
SettlingTime: 15.2000
SettlingMin: 1.2972
 SettlingMax: 1.3514
Overshoot: 0
Undershoot: 0
Peak: 1.3514
PeakTime: 63.2000

El Ts en lazo abierto es 15.2 segundos, por lo que para el diseño del PID se requeire un Ts
<5.066 segundos.
Procedemos a diseñar el sistema deseado, teniendo en cuenta la forma del sistema de
segundo orden:

Realizamos los cálculos en Matlab:

Definiendo el sobredisparo Mp = 0.03 y el tiempo de asentamiento ts = 1, hallamos los
coecifientes del sistema deseado:

fa=sqrt(((log(Mp/100))^2)/(pi^2+((log(Mp/100))^2)))
Wn=3/(fa*ts)

num=[Wn^2];
den=[1 2*fa*Wn Wn^2];
tau=1/(abs(max(roots(den))));

sys=tf(num,den)
sysd=c2d(sys,0.8,'impulse');%sistema deseado discreto
Gs = tf([0 0.495],[1 -0.52 0.09],0.8,'variable','z^-1')

Obteniendo:

Donde Gs es el Sistema deseado discretizado.

Ahora procedemos a hallar el polinomio característico Pc(z), tomando en cuenta el
algoritmo para control pid por asignación de polos:

Donde,

Procedemos a calcular Pc(z) en MAPLE:

>

>

>

>
>

>
>

>

>
Donde se obtiene

1+0.8𝑞0 −1.83 − 0.55𝑞0 + 0.8𝑞1 0.845 − 0.55𝑞0 + 0.8𝑞2

𝑃𝑐(𝑧) = −0.015−0.55𝑞2 + −0.015−0.55𝑞2
𝑧 −1 + −0.015−0.55𝑞2
𝑧 −2 + 𝑧 −3

Ahora hallamos el polinomio deseado característico, ya teniendo el sistema deseado Gs,

tomamos el polinomio característico y le añadimos un polo, para poder realizar la
igualación Pc(z) = Pd(z), esto es:
>
>

>

𝑃𝑑(𝑧) = 151.88 + 105.023 𝑧 −1 − 11.9371 𝑧 −2 + 𝑧 −3

Ahora se procede a hace Pc(z) = Pd(z) para hallar los coeficientes q0,q1 y q2:

>
>

>

>
>

Se toma el valor absoluto de los coeficientes q0, q1 y q2 y se diseña el controlador PID en

MATLAB

Procedemos a realizar el control en lazo cerrado.

a) Simulación de la salida y(k) ante una entrada escalón:

Usando MATLAB:
Gc = tf([1.196370858 1.502077978 0.02778631894],[1 -
1],0.8,'variable','z^-1'); %Controlador pid
aa=Gc*Gp;

Gcon=feedback(aa,1)
stepinfo(Gcon)

figure(1)
subplot(3,1,1)
step(Gcon)
title('Sistema controlado con PID - Señal y(k)')
grid on
La señal y(k) es la salida del sistema, o el sistema controlado con el controlador PID, con
el comando stepinfo() verificamos si el sistema cumple con lo requerido:
>> stepinfo(Gcon)

ans =

RiseTime: 0
SettlingTime: 4.8000
SettlingMin: 1.0000
SettlingMax: 1.0883
Overshoot: 8.8258
Undershoot: 0
Peak: 1.0883
PeakTime: 0.8000
El sistema controlado presenta un Ts de 4.8 segundos el cual es menor al tercio de Ts en
lazo abierto (5.066 segundos), con un sobredisparo 8.83 % < 10 % tambien cumple esa
especificación, en la gráfica se observa como el sistema llega al valor de referencia
definido como 1 (escalón unitario), por lo que se elimina el error de estado estacionario.

A continuación se observa la comparación del sistema controlado con el sistema en lazo

abierto:

b) Simulación del error e(k) ante una entrada escalón:

Usando MATLAB:

num2=[1];
den2=[1];
ref=tf(num2,den2);

e=ref-Gcon;
subplot(3,1,2)
step(e)
grid on
title('Señal de error e(k)- Control PID')

Se obtiene:

c) Simulación de u(k) ante una entrada escalón:

subplot(3,1,3)

U=feedback(Gc,Gp)
u=e*U
step(u)
grid on
title('Señal de Control - Señal u(k)')
Se obtiene:

El controlador PID logra que el sistema alcance las especificaciones definidas, el sistema
controlado es mucho más rápido logrando llegar al estado estacionario en 4.8 segundos,
cuando en lazo abierto tardaba más de 15 segundos.
La señal de error e(k) en nuestro sistema de control PID es la señal actuante que llega al
controlador PID para luego ejercer la señal de control sobre la planta, como se sabe el
error dinámico es la diferencia entre el valor de referencia (escalón unitario r(k)) menos la
salida (sistema controlado y(k))
Luego de que la señal de error e(k) llega a nuestro controlador PID, se genera la señal
u(k), que es la salida del PID, es la señal de control que llega a la planta.
Parte 2: Control con PID con retardo
En este caso al añadir retardo al controlador también añadimos un grado de libertad más,
por lo que para este control utilizaremos la planta original de tercer orden.

>> sys3

sys3 =

s+1
------------------------
s^3 + 13 s^2 + 42 s + 10

Discretizando en MATLAB la planta:

num3=[1 1];
den3=[1 13 42 10];

sys3=tf(num3,den3);
sysd3=c2d(sys3,0.8,'impulse'); %planta en discreto
 1∗10−15 ∗𝑧 −3
Por comodidad modificaremos la planta multiplicándole:
1∗10−15 ∗𝑧 −3

Esto para representar el sistema con potencias negativas, y lograr en Pc(z) = Pd(z) un
sistema de ecuaciones con # incógnitas = # ecuaciones. La constante 1 ∗ 10−15 que se
añade es para hacer los términos independientes tanto del numerador como del
denominador valores muy cercanos a cero.
La función de transferencia de la planta nos queda:

Como se puede observar los términos de z-3 tanto del numerador son valores muy
cercanos a cero, por lo que no los consideraremos parte del sistema y se maneja el
sistema en segundo orden para poder resolver el sistema de ecuaciones previo.

La planta nos quedaría:

La cual sigue manteniendo el mismo comportamiento que la planta original y la planta

modificada en la parte 1, esto se puede comprar obteniendo la información del sistema:

Gp2 =

1.757e-17 z^-1 - 3.506e-18 z^-2

---------------------------------------
 1e-15 - 8.336e-16 z^-1 + 1.659e-17 z^-2

Sample time: 0.8 seconds

Discrete-time transfer function.

>> step(Gp2)
>> stepinfo(Gp2)

ans =

RiseTime: 8
SettlingTime: 15.2000
SettlingMin: 0.0694
SettlingMax: 0.0769
Overshoot: 0
Undershoot: 0
Peak: 0.0769
PeakTime: 63.2000

Al igual que la planta modificada de la parte 1, el sistema en lazo abierto sigue sin
sobredisparo y con el tiempo de asentamiento en 15.20 segundos.
El controlador PID con retraso tiene la siguiente configuración:

Ahora se procede a hallar Pc(z) = A.P + B.Q y el sistema deseado Pd(z) partiendo de las
especificaciones ya definidas.
Como el sistema es de cuarto orden, se añaden dos polos no dominantes:

>
>

>
>

>

>

>

>

>
Así:

𝑃𝑐(𝑧)
1 ∗ 10−15
=
1.659 ∗ 10−17 𝛾 − 3.5060 ∗ 10−18 𝑞2
−1.8336 ∗ 10−15 − 1 ∗ 10−15 𝛾 + 1.7570 ∗ 10−17 𝑞𝑜 −1
+( )𝑧
1.659 ∗ 10−17 𝛾 − 3.5060 ∗ 10−18 𝑞2
8.5019 ∗ 10−16 + 1.8336 ∗ 10−15 𝛾 − 3.5060 ∗ 10−18 𝑞𝑜 + 1.7570 ∗ 10−17 𝑞1 −2
+( )𝑧
1.6590 ∗ 10−17 𝛾 − 3.5060 ∗ 10−18 𝑞2
1.6590 ∗ 10−17 − 8.5019 ∗ 10−16 𝛾 − 3.5060 ∗ 10−18 𝑞1 + 1.7570 ∗ 10−17 𝑞2 −3
+( ) 𝑧 + 𝑧 −4
1.6590 ∗ 10−17 𝛾 − 3.5060 ∗ 10−18 𝑞2

>

>

Finalmente,
𝑃𝑑(𝑧) = 330.09 − 431.93𝑧 −1 + 167.21𝑧 −2 − 16.45𝑧 −3 + 𝑧 −4
Ahora se iguala Pc(z) = Pd(z), se resuelve el sistema de ecuaciones para hallar q0, q1, q2
yγ:

>
>

>

>

>

Al resolver el sistema de ecuaciones se obtiene:

q0 = 38.365
q1 = -27.4533
q2 = -0.1589
γ = 0.1490

Construyendo el controlador PID con retardo en MATLAB:

a) Simulación de la salida y(k) ante una entrada escalón:

sys3=tf(num3,den3);
sysd3=c2d(sys3,0.8,'impulse'); %planta en discreto
Gp2 = tf([0 1.757000000*10^(-17) -3.506000000*10^(-
18)],[1.000000000*10^(-15) -8.336000000*10^(-16) 1.659000000*10^(-
17)],0.8,'variable','z^-1'); %planta en discreto z^-1

Gc1 = tf([38.36592454 -27.45332077 -0.1589369401],[1 -1.1490192940

0.1490192940],0.8,'variable','z^-1'); %Controlador pid retardo
bb=Gc2*Gp2;

Gcon2=feedback(bb,1);

figure(3)
subplot(3,1,1)
step(Gcon2)
grid on
title('Sistema controlado con PID con retardo - Señal y(k)')

La información del sistema controlado con el PID con retardo es:

>> stepinfo(Gcon2)

ans =
 RiseTime: 0
SettlingTime: 5.6000
SettlingMin: 1.0000
SettlingMax: 1.0685
Overshoot: 6.8526
Undershoot: 0
Peak: 1.0685
PeakTime: 1.6000
Donde se observa que el sistema con este controlador llega al estado estacionario a los
5.6 segundos, más lento que el PID sin retardo, pero mantiene el sobredisparo por debajo
del 10%, con un sobredisparo de 6.85%
 b) Simulación de la señal de error e(k) ante una entrada escalón:

num2=[1];
den2=[1];
ref=tf(num2,den2);

e2=ref-Gcon2;

subplot(3,1,2)
step(e2)
grid on
title('Señal de error e(k)- PID con retardo')

c) Simulación de la señal u(k) ante una entrada escalón:

subplot(3,1,3)
U=feedback(Gc2l,Gp2)
u=e2*U
step(u)
grid on
title('Controlador PID con retardo - Señal u(k)')

El controlador PID con retardo logra reducir el sobredisparo aunque resultó más lento que
el PID sin retardo, las señales de error y de control son acordes a la respuesta del
sistema.
Las tres señales graficadas:
Parte 3: Control con PID modificado (Realización 1)

Para la modificación del PID se eligió la primera configuración.

Para hallar To/Ti usaremos la tabla de zieger-nichols:

Donde,
Tu = Retardo
To = Período de muestreo
k = por definir

Para hallar el retardo podemos usar la salida del sistema en lazo abierto ante un escalón
y con el cursor de MATLAB marcar el valor del retardo:
Ya teniendo Tu, procedemos a hallar m=To/Ti , se calcula Sz y se cierra el lazo según el
diagrama de bloques:

k=-13;
Tu=0.8; %Retraso de la planta en discreto
To=0.8 ; % Periodo de muestreo
m = (0.6*tau*To)/k*((Tu+(To/2)))^2;

s0 = k;
s1=-k*(1-m);

Sz = tf([s0 s1],[1 -1],0.8,'variable','z^-1'); %Controlador pid

uz=Sz-Gcl; %Realimentacion del lazo de control [Q(z)/P(z)]*[S(z)/Q(Z)]

bbb=uz*Gp;

Gcon3=feedback(bbb,1);

figure(5)
subplot(3,1,1)
step(Gcon3)
grid on
title('Sistema controlado con PID modificado - Señal y(k)')
stepinfo(Gcon3);

La planta utilizada para implementar éste controlador fue la planta de la parte 1.

De igual forma tanto la planta de la parte 1 como la planta de la parte 2 tienen la misma
dinámica y comportamiento.

a) Simulación de la salida y(k) ante una entrada escalón:

A partir del código anterior obtiene la señal y(k), el sistema controlado con PID
modificado:

La información del sistema controlado es:

>> stepinfo(Gcon3)
ans =

RiseTime: 0
SettlingTime: 4.8000
SettlingMin: 0.9853
SettlingMax: 1.0000
Overshoot: 5.2712
Undershoot: 0
Peak: 1.0527
PeakTime: 0

Donde se puede observar que con el PID modificado el sistema cumple todas las
especificaciones requeridas:

Ts = 4.8 seg < 5.06 seg

Mp = 5.27% < 10 %
Sin error en estado estacionario.

A continuación se comparan éste sistema con la planta:

 b) Simulación de la señal de error y(k) ante una entrada escalón:

y3=step(Gcon3);

e3=u2-y3;

subplot(3,1,2)
plot(e3)
grid on
title('Señal de error e(k)- PID modificado')
 c) Simulación de la señal u(k) ante una entrada escalón:

subplot(3,1,3)
U=feedback(uz,Gp);
u=e3*U;
step(u)
grid on
title('Señal de control del PID modificado - Señal u(k) ')
El controlador PID modificado logra mantener el sistema controlado bajo las
especificaciones determinadas, incluso reduce un poco el sobredisparo, y mantiene el
tiempo de asentamiento en 4.8 segundos, por supuesto como todo controlador PID
elimina el error en estado estacionario, las señales e(k) y u(k) concuerdan con el sistema
controlado.
Graficando las tres señales juntas:
Parte 4: Control con compensador Model Matching

Para el diseño de controladores digitales por Model Matching se deben tener en cuenta
las siguientes reglas.
1) Todos los compensadores usados deben ser funciones de transferencias razonables.
2) El sistema resultante debe ser causal
3) El sistema resultante debe ser estable
4) No se puede diseñar un compensador en paralelo a la planta
En este caso Glc(z) es nuestro sistema deseado en lazo cerrado:

sys=tf(num,den);
sysd=c2d(sys,0.8,'impulse');%sistema deseado discreto
Gs = tf([0 0.5203],[1 -0.1439 0.00823],0.8,'variable','z^-1'); %sistema
deseado discreto z^-1
Gf=feedback(Gs,1); %sistema
deseado lazo cerrado
Glz= tf(5*[0.8 -0.55],[1 0.3963 0.00823],0.8,'variable','z^-1');%sistema
deseado lazo cerrado con numerador modificado

Además el numerador de Glz lo modificamos por objetivos de diseño para que cumpla con
la condición número 2, la condición se comprueba al observar que tanto nuestro sistema
deseado y la planta ambos tienen primer orden en el numerador y segundo orden en el
denominador.
La condición se comprueba con el comando pole():
>> pole(Glz)

ans =

-0.3743
 -0.0220

Donde los polos -0.3743 y -0.0220 se encuentran dentro del círculo unitario.

Ahora para hallar el compensador C(z) utilizaremos el algoritmo de realimentación de

salida:

Teniendo esto en cuenta procedemos a calcular C(z):

C=(1/Gp)*(Glz/(1-Glz));

mm=C*Gp;
Gcon4=feedback(mm,1);

Ya teniendo el compensador calculado procedemos a realizar las simulaciones:

a) Simulación de la salida y(k) ante una entrada escalón:

figure(1)
subplot(3,1,1)
step(1.04493*Gcon4)
grid on
title('Sistema controlado con Model Matching - Señal y(k)')

Y la señal comparada con la planta en lazo abierto:

figure(2)
step(1.04493*Gcon4)
grid on
hold on
step(Gp)
title('Comparacion: Sistema controlado vs Planta')
legend('Sistema controlado con M.M','Planta lazo abierto')
stepinfo(Gcon4)
 b) Simulación de la señal de error e(k) ante una entrada escalón:

num2=[1];
den2=[1];
ref=tf(num2,den2);

e4=ref-1.04493*Gcon4;

subplot(3,1,2)
step(e4)
grid on
title('Error con Model Matching - Señal e(k)')
stepinfo(Gcon4);
 c) Simulación de error e(k) ante una entrada escalón:

subplot(3,1,3)
U=feedback(C1,Gp);
u=e4*U;

step(u)
grid on
title('Señal de control por Model Matching - Señal u(k)')
Las tres señales comparadas: