Wuolah Free Trabajo CPC

Trabajo-cpc.
pdf
jandrocc
Control Por Computador
3º Grado en Ingeniería Electrónica, Robótica y Mecatrónica
Escuela de Ingenierías Industriales

Universidad de Málaga
Reservados todos los derechos.

No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.

Universidad de Málaga

Escuela de Ingenierías Industriales
Control por computador

TRABAJO GRUPAL CPC CURSO 2020/2021

a64b0469ff35958ef4ab887a898bd50bdfbbe91a-3744698
Trabajo general grupal de control por computador 2020/2021
ÍNDICE

Ejercicio 1 2
Ejercicio 2 2
Ejercicio 3 3
Ejercicio 4 4
Ejercicio 5 6
Ejercicio 6 12
Ejercicio 7 14
Ejercicio 8 16

Ejercicio 9 17
Ejercicio 10 21

Ejercicio 11 24
Ejercicio 12 26
Ejercicio 13 27
Ejercicio 14 34

Ejercicio 15 36
Ejercicio 16 41
Ejercicio 17 46
Compra Coins y descarga sin publicidad.

Los parámetros generados por el compañero con mayor edad son los siguientes:
[Ki Kb Jeq beq Ra La Kr Kw n]= [0.0488 0.0387 0.0059 0.0288 0.2875 0.0049 3.8197
1.0000 0.1000]
La función de transferencia del sistema de posición Gpos es la siguiente:
0.0488*n 0.00488
Gpos = s*((0.0049*s+0.2875)*(0.0059*s+0.0288)+0.0488*0.0387) = 2.891*e−05 * s3 + 0.001837*s2 + 0.01017* s
El sistema en bucle abierto viene dado por:
sistbucle abierto = Gpos * H (s)
Para calcular la ecuación diferencial hemos igualado nuestro sistema de bucle abierto a la
salida partido la entrada y hemos hecho la transformada inversa de Laplace para así
obtener la ecuación diferencial, con condiciones iniciales nulas.
Y (s) 0.00488 *3.8197

Gpos * H (s) = U (s)
= 2.891*e−05 * s3 + 0.001837*s2 + 0.01017* s
Y (s) * [2.891 * e−05 * s3 + 0.001837 * s2 + 0.01017 * s] = U (s) * 0.00488 * 3.8197
Aplicamos transformada inversa de Laplace y suponemos condiciones iniciales nulas.
2.891*e^-05* y‘’’(t)+ 0.001837* y‘’(t) + 0.01017*y‘(t) = 0.00488*3.8197*u(t)

Para obtener la función de transferencia en discreto se debe usar el comando “c2d” con un
tiempo de muestreo T y usar el método “zoh” ya que se trata de discretizar una planta .
Hemos discretizado cada función por separado, tanto la planta como el sensor.
Los comandos usados en Matlab han sido los siguientes:
-Gposz=c2d(Gpos,T,'zoh')
-Gbaz=Gposz*Hz=Gposz*3.8197
Nuestra función de transferencia en bucle abierto discretizada sería:
0.006875 z 2 + 0.01447 z + 0.001464

Gbaz = z 3 − 1.793 z 2 + 0.8345 z − 0.04171
Para la ecuación en diferencias habría que repetir el mismo proceso que en el apartado 2.

Y (z)
Gbaz = U (z)
Despejando, multiplicando el denominador de Gbaz por Y(z) y el numerador por U(z) y por
último aplicando la transformada inversa de Z se obtiene lo siguiente.
Y (z) * (z 3 − 1.793 * z 2 + 0.8345 * z − 0.04171) = U (z) * (0.006875 * z 2 + 0.8345 * z − 0.04171)
A continuación aplicamos la transformada inversa de Z y nos daría lo siguiente:
y[k+3]-1.793*y[k+2]+0.8345*y[k+1]-0.04171*y[k ]= 0.006875*u[k+2] + 0.01447*u[k+1] + 0.001464*u[k]

La función de transferencia del sistema de velocidad sería la siguiente:
0.00488
Gvel = 2.891*e−05 * s2 + 0.001837*s + 0.01017
Ahora despejamos nuestro coeficiente que está acompañando a s^2 y obtenemos lo

siguiente:
168.8
Gvel = s2 + 63.54*s +351.8
Para la descripción de espacio de estado en sistema continuo utilizamos los siguientes

comandos en Matlab:
-G_vel_matriz=ss(G_vel)
-G_vel_matriz = “No es canónica”
A=
x1 x2
x1 -63.55 -21.98
x2 16 0
B=
u1
x1 4
x2 0
C=
x1 x2
y1 0 2.637
D=
u1
y1 0
Para tiempo discreto sería con T=0.05 y hold0, se muestran los comandos usados en
Matlab:
-G_vel_matriz_z=c2d(G_vel_matriz,T,'zoh')
-G_vel_matriz_z =
G=
x1 x2
x1 -0.02451 -0.2912

x2 0.2119 0.8173
H=
u1
x1 0.05298
x2 0.03323
C=
x1 x2
y1 0 2.637
D=
u1
y1 0

Nos basaremos en esta tabla para calcular los errores de cada sistema.

Tiempo continuo
Primero procedemos a calcular los errores de cada función, tanto de velocidad como de posición de
manera continua.
El error en continuo viene dado por : e = lim s * R(s)/(1 + G(s) * H (s))

s→0
POSICIÓN
En nuestro caso, para la posición sería lo siguiente:
0.00488*Ka
G(s)= G_pos * Ka= (2.891e−5 s3 + 0.001837s
* 2 + 0.01017s) 1 integrador
y H(s)=3.8197
Para el error en régimen permanente ante una entrada escalón ( R(s)=1/s) nos saldría un error nulo
y esto se puede ver en la siguiente foto suponiendo un Ka =1

Como se puede ver, nuestro valor final sería 1 por lo que el error es 0, es decir, independientemente
de nuestro valor de Ka, nuestro error sería siempre 0 , pero el hecho de aumentar Ka incrementa la
sobreoscilación del sistema.
Además, también se podría haber calculado el error mirando la tabla de errores que hemos incluido
al principio del ejercicio. En nuestro caso tenemos que nuestro sistema es de tipo 1, ya que solo tiene

un integrador. Para el error ante una entrada escalón sale que es 0 con K p = ∞.
Para el error en régimen permanente ante una entrada rampa (R(s)=1/s^2) daría el siguiente error :
e = 1/(1.833 * K a) , tendríamos un error de estilo KR donde R= 1 por ser rampa unitaria y este error iría
disminuyendo conforme K va aumentando.

VELOCIDAD
En nuestro caso, para la velocidad sería lo siguiente:

G(s)= G_vel *Ka= K a (2.891e−0.5 s2 +0.00488
0.001837s + 0.01017)
ningún integrador
y H(s)=1
Para el error en régimen permanente ante una entrada escalón daría lo siguiente :
e = 1/(1 + 0.472 * K a) , es decir, que para que nuestro error sea lo más cercano a 0, habría que
aumentar significativamente el valor de Ka lo que produciría mucha sobreoscilación. Se puede
observar en la siguiente imagen :

Esto también se podría haber averiguado con la tabla de errores donde para este caso tenemos un
sistema tipo 0 , es decir, no tenemos ningún integrador, y para el error ante una entrada escalón
R
saldría esto : e = 1+Kp donde R=1 ya que tenemos escalón unitario.
1
Para el error ante una entrada rampa saldría e = 0 = ∞ , que también se podría haber resuelto
mirando la tabla de errores. Es decir, que al ser tipo 0, la entrada ante una rampa unitaria tiende a
infinito.
Se puede ver en la siguiente imagen:
Vemos como la respuesta (azul) tiende a despegarse de la rampa unitaria, y vemos que se va
alejando cada vez más.Va hacia infinito.
Tiempo discreto

El error en tiempo discreto viene dado por la siguiente fórmula :
R(z)
e = lim[(1 − z −1 ) * 1+G(z)*H(z)
z→1
POSICIÓN
Al discretizar nuestra G de posición tendríamos :
0.0018 z^2 + 0.003789 z + 0.0003832

ka* ---------------------------------------------------
z^3 - 1.793 z^2 + 0.8345 z - 0.04171
y H=3.8197

En el caso de la entrada escalón, nuestro sistema sigue siendo de tipo uno por lo que el error es
nulo.
Para el error en régimen permanente ante una entrada rampa (R(s)=1/s^2) daría el siguiente error :
e = 1/(1.833 * K a) , tendríamos un error de estilo KR donde R= 1 por ser rampa unitaria.
Por lo tanto el error dependería del controlador proporcional ka. Mientras más grande sea este
controlador, más pequeño será el error y viceversa.
La respuesta obtenida es la siguiente:

VELOCIDAD
Para la velocidad discretizaremos la función con un hold 0:
0.08766 z + 0.03177
G_vel_z*Ka= k a * z 2 − 0.7928 z + 0.04168
H=1;
Este sistema es de tipo 0 por lo que podremos utilizar la fórmula para una entrada escalón.
Considerando que el controlador proporcional sea igual a 1(ka=1) y una entrada escalón unitaria, el
resultado sería el siguiente:
10

R
Sabemos que el error es e = 1+Kp Siendo R la entrada escalón de valor unitario y Kp=K*Ka.
Por lo tanto, para minimizar el error tendríamos que subir la Ka lo máximo posible sin hacer
el sistema inestable.
Entrada rampa unitaria:

Al ser de tipo 0, el error en régimen permanente queda igual a ∞ y por lo tanto en este caso
de nada sirve un controlador proporcional para minimizar ese error.
11

Para obtener el sistema de posición en bucle cerrado discretizado,lo primero que hemos hecho ha
sido discretizar la planta y el sensor cada uno por su lado con un T=0.05.
0.00488
Gpos = 2.891*e−05 * s3 + 0.001837*s2 + 0.01017* s
Los comandos en Matlab usados son:

>>G_pos =
0.00488
----------------------------------------
2.891e-05 s^3 + 0.001837 s^2 + 0.01017 s
>> T=0.05;G_pos_z=c2d(G_pos,T,'zoh')
G_pos_z =
0.0018 z^2 + 0.003789 z + 0.0003832

------------------------------------
z^3 - 1.793 z^2 + 0.8345 z - 0.04171.
Los polos de nuestro sistema son :
>>pole(G_pos_z)
ans =
1.0000
0.7361
0.0567
Vemos que tenemos un integrador ( z=1) ,entonces nuestro sistema es de tipo 1 y por tanto error de
seguimiento nulo ante entrada escalón.
12
En la imagen se puede observar las siguientes características : tiempo de subida ( 0.789 seg) ,

tiempo de establecimiento ( 1.24 seg), tiempo de pico( 1,75) y sobreoscilación ( 0.809%).
Como nuestro sistema es de tipo 1 , el error ante una entrada escalón es 0 que es precisamente lo
que podemos observar en la imagen( nuestro valor final es 1).
Tipo 1, error=0, ganancia pequeña, no hay mucha sobreoscilación
13

la ganacia crítica es la que hace que el sistema esté a punto de ser inestable
Para Ka=1 tenemos :
Para Ka=10 tenemos :
Para la Ka crítica sería :
14

Como se puede ver, para calcular la Ka crítica nos hemos ido justamente al borde de la
circunferencia de radio 1 centrada en 0, que en discreto sería la zona de estabilidad del sistema, por
lo tanto, al situarnos los polos en bucle cerrado en ese punto, nos sale una ganancia de 13.905 .
Además, hemos incluido una respuesta a una entrada escalón para verificar que realmente estamos
al borde de la inestabilidad y efectivamente se cumple, nuestra respuesta mantiene una respuesta

oscilante..
También cabe comentar que al aumentar nuestra ganancia Ka estamos aumentando la

sobreoscilación aunque disminuimos el tiempo de subida y no varía prácticamente nada el tiempo de
establecimiento.
15

Como nuestro sistema es tipo 1, es decir, tiene un integrador, el error ante una entrada escalón
unitaria será 0.
Lo que hemos hecho ha sido desde “rltool” asignar las especificaciones que nos pide el ejercicio con
el sistema de posición discretizado, añadiendo tanto a H y F sus respectivos valores ( 3.8197).
El sistema que obtenemos con las especificaciones sería el siguiente :

Vemos en primer lugar que no todas las especificaciones temporales se pueden conseguir con un
controlador proporcional ya que todos los polos en bucle cerrado no se encuentran situados dentro
de la zona blanca, que sería donde se cumpliría con las especificaciones.
Además, podemos ver la respuesta temporal ante una entrada escalón. Como ya se comentó, el
error es 0 ( el valor final vale 1 ), la sobreoscilación se cumple ,pero el tiempo de establecimiento es
muy superior a 0.3 segundos por lo que habría que usar otro controlador.
16
Como ya hemos comprobado en el ejercicio anterior, las especificaciones temporales no se pueden
resolver con un controlador proporcional Ka, entonces tendremos que usar otro controlador ya sea
PD, PI o PID.
En primer lugar, tenemos que resolver los errores en régimen permanente y después nos centramos
en las especificaciones transitorias. Como nuestro error en régimen permanente ya se cumple, es
decir, es nulo, ya que como nuestro sistema es de tipo 1( tiene un integrador )( el error ante una
entrada escalón unitario es 0) nos centraremos en la respuesta transitoria.
Podemos descartar que el controlador PI y el PID ya que nos introduciría un integrador, es decir, más
precisión. Este tipo de controladores corrigen los errores en régimen permanente y como nuestro
sistema ya lo cumple no hace falta usarlos. Así que nos centramos en el PD.
UNA POSIBLE FORMA DE HACERLO : PRIMERO DESDE CONTINUO Y DESPUÉS A DISCRETO

Primero calculamos controlador en tiempo continuo :
Para hacer que las especificaciones se cumplan lo que hemos hecho ha sido añadir un cero lo más
cerca posible del polo dominante, que es el cual estaba dando un tiempo de establecimiento no
adecuado. En nuestro caso, hemos situado el cero justamente encima del polo dominante, y esto ha
hecho que nuestro LDR se modifique y por último hemos añadido un polo muy lejos del eje
imaginario para que sea este el dominante y así el tiempo de establecimiento se reduzca al tiempo
que deseemos, al igual que lo hizo la sobreoscilación al disminuir la ganancia proporcional.
El controlador que obtenemos en continuo y transformado a discreto posteriormente se puede ver

aquí :
17

PD =
274.22 (s+6.088)
----------------
(s+200)
>> PD_z=c2d(PD,0.05,'matched') ( Hemos usado el método ‘matched’ ya que no especifica)
“ojo porque según el método que usemos el pid se nos puede ir a la mierda al pasarse a
discreto” matched es asignación por polos z=e^(s*T)
PD_z =
31.805 (z-0.7376)
-----------------
(z-4.54e-05)
Reajustando en discreto la ganancia y poniendo las especificaciones obtenemos lo siguiente :

Se puede ver que las especificaciones se cumplen y que el controlador que finalmente hemos usado
en discreto para que se cumplan está abajo a la izquierda de la imagen.
18

2º POS. FORMA DE HACERLO: DESDE DISCRETO DIRECTAMENTE
Introducimos en rltool nuestras funciones de transferencia ya discretizadas. Los comandos usados en

Matlab han sido:
>> G_pos
G_pos =
0.00488
----------------------------------------
2.891e-05 s^3 + 0.001837 s^2 + 0.01017 s
Continuous-time transfer function.
>> G_pos_z=c2d(G_pos,T,'zoh')
G_pos_z =

0.0018 z^2 + 0.003789 z + 0.0003832
------------------------------------
z^3 - 1.793 z^2 + 0.8345 z - 0.04171
H=3.8197; F=3.8197;
Nuestro sistema solo con una ganancia proporcional nos da el siguiente LDR :
Haciendo ciertas modificaciones, viendo que necesitamos un PD como se dijo anteriormente e

introduciendo un cero y un polo nos da el siguiente sistema cumpliendo las especificaciones :
19

Hemos introducido un cero en 0.75 para llevar al lugar de las raíces hacia la izquierda y así
compensar los errores transitorios, y por último un polo rápido en 0 para que sea un controlador
implementable. Variando la ganancia obtenemos estos datos que se muestran en la imagen.
El controlador se puede ver en la parte izquierda debajo de la imagen.
20
En primer lugar, sabemos que nuestro sistema de posición es de tipo 1 y que el error ante
una entrada rampa da lugar a un valor que depende de la ganancia ( e_rampa= R / K) ,
entonces, si queremos que tener error nulo ante una entrada rampa necesitamos que
nuestro sistema sea de tipo 2 por lo que necesitamos introducir un integrador.
Lo que necesitaremos será un controlador PI o PID para obtener estos requisitos, vamos a
probar.
Sabemos que con una ganancia proporcional no se no se pueden cumplir las

especificaciones. Como se comentó, primero tenemos que atender a nuestras respuestas
de régimen estacionario y después a las del transitorio.
Probando solamente con un controlador PI se puede ver que no se cumplen las

especificaciones transitorias:
21

Entonces habrá que implementar un PID.

Aquí se puede ver que cumple con las especificaciones transitorias además de la respuesta
escalón. El controlador se encuentra en la imagen de arriba abajo a la izquierda.
Hemos ubicado los ceros de esa manera para hacer al sistema más estable y para que se
cumplan las especificaciones, para que así el LDR se dibuje de la manera que está en la
imagen. El polo lo hemos puesto en cero para que así no afecte demasiado al sistema,es un
polo rápido.
El lugar de las raíces es el siguiente:
22

La respuesta al escalón sería :

Y esta sería la respuesta a la rampa :
Como se puede ver hay error nulo, se va acercando cada vez más a la rampa unitaria.
23

Se produce en los PI y PID, el actuador se satura y el controlador de retroalimentación no
puede llevar la medición del set point por lo que existirá un error permanente el efecto.
Para el ejercicio 9) tenemos que:

donde esa ganancia en la realimentación representa el sensor con la ganancia requerida.
Las salidas serían las siguientes:
Vemos que se consigue perfectamente la respuesta obtenida en matlab.
La respuesta del controlador sería:
24
Vemos por tanto que no hace falta aplicarle antiwindup ya que no le afecta esta limitación al
controlador ( ya que no se mantiene durante el valor 15 durante un tiempo ).

Para el ejercicio 10)
El esquema sería el mismo que el anterior solo que cambiando los parámetros del PID y se obtiene lo
siguiente en la salida: ( sin windup)
Vemos que obtenemos una salida prácticamente idéntica que la que conseguimos en rltool.
La respuesta del controlador sería:
25

Vemos que tampoco le afecta.
Añadiendo un filtro anti windup de 0.4 al controlador conseguimos una respuesta tal que así :

Vemos que si vamos reduciendo el Kb se va reduciendo la sobreoscilación y obtenemos
una respuesta más “limpia”.
No hemos podido realizar este ejercicio ya que nos pedía una licencia de matlab la cual no
disponíamos de ella.
26

Vamos a aplicar primero Ziegler-Nichols en abierto para nuestro sistema de posición y vamos a ver
qué respuesta obtenemos cuando le aplicamos un step. Los comandos usados en Matlab:
G_pos
G_pos =
0.00488
----------------------------------------
2.891e-05 s^3 + 0.001837 s^2 + 0.01017 s
Continuous-time transfer function.
>> step(G_pos)

Nuestra respuesta no es estable por lo que por este método no es posible realizar el controlador.
Vamos a proceder con el método de Z-N en bucle cerrado. Para este método vamos a analizar la
respuesta de nuestro sistema en bucle cerrado con una ganancia proporcional Kc, la cual vamos ir
aumentando hasta obtener la Kc crítica del sistema, que se mostrará en una respuesta escalón ( será
completamente oscilante) y a partir de esa respuesta conseguiremos T ( el periodo de esa señal).
El metodo cerrado no se puede hacer ni a primer ni a segundo orden sin retardo
27

Esta imagen muestra la ganancia crítica de nuestro sistema de posición, que son unos 34,668 y
vemos con la respuesta es oscilante.

Para el periodo se calcula de la siguiente manera :
T=0.519-0.184=0.335 seg || Kc= 34.668
Usaremos un PID en paralelo que vendrá dado por la siguiente ecuación :
P ID = Kp + Ki/s + Kd * s
Las fórmulas para calcular cada ganancia son las siguientes:
Kp=0.75*Kc=26.0012
Ki=Kp/Ti = 124.17-----> Ti =T/1.6=0.2094
Kd= Kp*Td = 0.8710 -------> Td=T/10 = 0.0335
En matlab :
PID_pos=pid(26.0012,124.17,0.8710)
PID_pos=
1
Kp + Ki * --- + Kd * s
s
28
with Kp = 26, Ki = 124, Kd = 0.871
PID_pos=zpk(PID_pos)
PID_pos =
0.871 (s+23.89) (s+5.959)

-------------------------
s
Con nuestro controlador nos sale una respuesta en bucle cerrado en tiempo continuo tal
que así :

Se ve que no es un PID físicamente implementable ya que tenemos un cero más que polo,
es decir, no sería causal, por lo tanto tenemos que añadirle un filtro derivativo.
Vamos a implementar en rltool el sistema realimentado con nuestro controlador y nuestro

sistema G_pos, quedaría así :
29

Sabemos que para añadir el filtro derivativo:
sabiendo que τD = 1/N

donde τD , que es nuestra constante de tiempo derivativa,que atenuará el ruido a alta frecuencia.
Nosotros la colocaremos de tal forma de Tf sea 0.01, es decir, con N=100
Nos quedaría un sistema tal que así. Hemos hecho que nuestro controlador sea implementable
añadiendo un filtro derivativo. Además, podemos comprobar que nuestro LDR estaría muy cerca de
la inestabilidad.
Ahora lo pasamos a matlab para convertir el controlador en discreto.
PID_pos =
1 s
Kp + Ki * --- + Kd * --------
s Tf*s+1
with Kp = 24.8, Ki = 124, Kd = 0.623, Tf = 0.01
Aquí vemos nuestro filtro derivativo que sería Tf. Ahora pasamos el PID a discreto por el método
trapezoidal
PID_pos_z=c2d(PID_pos,0.05,'trapezoidal')
PID_pos_z =
30

Ts*(z+1) 1
Kp + Ki * -------- + Kd * -------------------
2*(z-1) Tf+Ts/2*(z+1)/(z-1)
with Kp = 24.8, Ki = 124, Kd = 0.623, Tf = 0.01, Ts = 0.05
Sample time: 0.05 seconds
Ahora lo pasamos a rltool con nuestro sistema G_pos_z:

Vemos que daría una respuesta inestable con este controlador. Esta respuesta puede ser
inestable debido al método que hemos usado ( trapezoidal) que ha introducido un polo en la
parte negativa de nuestra zona de estabilidad que puede ocasionar este suceso. Además,
otro factor importante es que nuestros ceros están alejados del integrador lo que provoca
que nuestro LDR se haya alejado mucho de la zona de estabilidad y se mueva hacia la
derecha ( estando prácticamente al borde nuestra zona de estabilidad, la circunferencia de
radio 1 centrada en 0).
31

Ahora vamos a probar con un controlador PI:
Sabemos que :
T=0.519-0.184=0.335 seg || Kc= 34.668
Kp=0.45*Kc=15.6006
Ti=T/1.2=0.2792 ----->Ki=kp/Ti=55.8761
En matlab:
pi=pid(15.6006,55.8761,0,0)
pi =

1
Kp + Ki * ---
s
with Kp = 15.6, Ki = 55.9
Continuous-time PI controller in parallel form.
>> pi=zpk(pi)
pi =
15.601 (s+3.582)
----------------
s
Implementandolo en rltool nos da lo siguiente :
Vemos que el sistema es prácticamente inestable al haber añadido otro integrador más.
32
Pasándolo a discreto daría lo siguiente:
PIz=c2d(pi,0.05,'trapezoidal')
PIz =
16.998 (z-0.8356)
-----------------
(z-1)

Vemos que daría una respuesta completamente inestable, no hay posibilidad de llegar a la
estabilidad con este controlador con este método, por los motivos que se comentaron en la parte de
arriba del ejercicio.
33

Nuestro sistema de velocidad es el siguiente:
0.0048
Gvel = −5 2
2.89*10 s + 0.001837*s +0.01017
Podemos ver que nuestro sistema es de orden 2 y no tiene ningún retardo.
Para el método de Z-N en cerrado no se puede aplicar con este sistema ya que nuestro sistema
sería de orden 2 y no tendría ningún retardo así que obviamos este método.
Vamos a comprobar si es posible hacer el método en abierto, es decir, tenemos que comprobar si la
respuesta ante un escalón de la planta sigue una consigna o si no es estable.

step(G_vel);
Vemos entonces que si sigue una consigna y que sería por tanto estable, entonces sí que se puede
aplicar el método en abierto.
Tenemos un valor final de 0.472. Tenemos que situarnos en las amplitudes correspondientes al
63,2% y al 23.8% del valor final . Esto es:
A(63,2%)=0.632*0.472=0.2983 ---->t1=0.181s
A(23.8%)=0.238*0.472=0.1123 ---->t2=0.0618s
34

Sabemos que :
3*(t1−t2)
d= 2 ; τ = t1 − d

Y usando nuestros valores obtenidos :
11
d=0.1788s ; τ= 5000 s
Para que sea válido el método tiene que cumplirse que :
d
0.15 < τ
< 0.6
Nuestro resultado daría : 81.2727 por lo que no se podría usar este método.
Tampoco se puede
35

Método de síntesis directa
Vamos a empezar con el método de síntesis directa, que se basa en la respuesta en bucle
cerrado del sistema. Este método en principio si se puede realizar porque tenemos una
respuesta en bucle abierto de nuestra planta estable, si esta hubiera sido inestable no se
podría aplicar este método.

Tenemos que :
Es decir, tenemos que sacar la función de transferencia en bucle cerrado de nuestro

sistema, donde R sería nuestro controlador y M(s) sería nuestro sistema en bucle cerrado,
que tenemos que asemejar a :
Como vemos en la imagen, para determinar M(s) necesitamos antes obtener el valor de
landa. Siendo M un sistema de primer orden con ganancia unitaria, lo más conveniente es
que landa sea lo más pequeña posible ya que eso reduciría la sobreoscilación y el tiempo
de establecimiento (Si acercas M(s) a 1, nos queda una salida igual a la entrada Y(s)=W(s)).
Sin embargo, no podemos pasarnos ya que esto haría que el sistema no fuese causal (se
anticipa a la entrada) y esto no es realista.
Nuestra planta de velocidad, despejando la constante que acompaña al coeficiente s^2

quedaría tal que así :
36
166.1
Gvel n = s2 + 63.56*s +351.9
Y consiguiendo ciertos parámetros de la función de 2º orden nos sale que :
ζ = 1.694 , es decir, mayor que 1, por lo tanto sistema sobreamortiguado. 63.56=2*w_n* ζ

351.9=W_n^(2)
G_vel_n=zpk(G_vel_n)
166.1
Gvel n =
(s + 57.44)*(s +6.127)
Nuestro controlador tendría la forma siguiente, habiendo realizado los cálculos necesarios
de la imagen donde se muestra el controlador R(s) y habiendo sustituido nuestra función en
bucle cerrado por la conveniente que nos dice el método.
(s+57.44)(s+6.127)
R= λ*166.1*s

La cual tenemos que igualar a :
Desarrollando el numerador e igualando término a término a nuestro función del controlador

conseguimos los siguiente datos :
τ 1 = 0.0174 τ 2 = 0.1636 K = 0.472
Y usando las fórmulas siguientes:
λ > 0.2 * τ
Donde τ será la mayor, por tanto τ =0.163 ; λ = 0.03272
37

Nos sale :
0.181
K p = 0.472 *λ
= 11.72 T i = 0.181 −−> K i = 64.75
T d = 0.0157 −−> K d = 0.1840
El pid será:
PID=pid(11.75,64.75,0.184)
PID =
1
Kp + Ki * --- + Kd * s
s
with Kp = 11.8, Ki = 64.8, Kd = 0.184
Continuous-time PID controller in parallel form.

>> PID=zpk(PID)
PID =
0.184 (s+57.58) (s+6.111)

-------------------------
s
La respuesta en rltool :
Vemos que nuestro controlador no es implementable porque tiene más ceros que polos y
por eso le introducimos un filtro derivativo. un polo lejos
38

Quedaría así el controlador:
Exportamos el controlador a matlab y procedemos a pasarlo a discreto:
PID =

18.4 (s+57.58) (s+6.111)
---------------------------------
s (s+100)
Name: C
Continuous-time zero/pole/gain model.
>> PID=pid(PID)
PID =
1 s
Kp + Ki * --- + Kd * --------
s Tf*s+1
with Kp = 11.1, Ki = 64.7, Kd = 0.0733, Tf = 0.01
El controlador en discretos sería :
PIDz=c2d(PID,0.05,'matched') se discretiza con matched
PIDz =
Ts 1
Kp + Ki * ------ + Kd * -----------
z-1 Tf+Ts/(z-1)
39

with Kp = 12.5, Ki = 64.8, Kd = 0.0238, Tf = 0.0503, Ts = 0.05
Sample time: 0.05 seconds “si nos preguntan decimos que puede que el
tiempo de muestreo sea demasiado grande”
Esta sería la respuesta con este controlador:

Método de Rovira
Vamos a utilizar la landa más pequeña posible para que el sistema sobre oscile lo menos
posible y tenga el menor tiempo de establecimiento posible pero sin pasarnos porque sino el
sistema sería anticipativo y eso no es realista.
Para aplicar el método de Rivera-morari necesitaríamos una planta que se asemejara a una
de primer orden con retardo y realimentación unitaria (no es nuestro caso). Por lo tanto, no
podemos realizar este método.
40
¿Es el sistema controlable? Ya sabemos que si pero puesto que estamos trabajando con
espacios de estado vamos a demostrarlo calculando el rango de la matriz de control.

(La función de ackerman que vamos a usar en matlab ya nos avisa si el sistema es
controlable pero no está de más recordar cómo se calcula)
[A,B,C,D]=ssdata(G_vel)
Nuestro sistema de velocidad en en formato espacio de estados viene dado por:
A=
x1 x2
x1 -63.54 -21.99
x2 16 0
B=
u1
x1 4
x2 0
C=
x1 x2
y1 0 2.637
D=
u1
y1 0
41

Ahora pasamos a comprobar que nuestro sistema es controlable sino no se puede aplicar el
método.
En matlab hemos usado los siguientes comandos:
Mc=ctrb(A,B) matriz de control
Mc =

4.0000 -254.1681
0 64.0000
>> rank(Mc)
ans =
Vemos entonces que si es controlable ya que el rango de la matriz de controlabilidad es el

mismo que el de la matriz A.
Ahora comprobamos si es observable. Los comandos usados en Matlab son los siguientes:
Mo=obsv(A,C) matriz observabilidad
Mo =
0 2.6375
42.1999 0
>> rank(Mo)
ans =
42

Polos de nuestro sistema:
Vemos que también es observable ya que el rango es el mismo que el de C.
Nuestras especificaciones del ejercicio son que nuestro polos en bucle cerrado tienen que
tener una frecuencia natural de 10 y que tiene que ser un sistema críticamente amortiguado
ζ =1 por lo que de aquí suponemos que :
ζ=1 y una frec natural de wn=10, así que podemos localizar un par de polos reales
dominantes en esa ubicación.
S 1,2 =− ζ * wn ± wn √ζ2 − 1 = [-10 y -10]
Nuestros polos dominantes estarán situados en esas posiciones.
Además nos exigen un error nulo ante consigna velocidad con amplitud unitaria y como
nuestro sistema es de Tipo 0 , es decir, no tiene ningún integrador, necesitamos aplicar el
control servo de Tipo 0.
Antes que nada, tenemos que comprobar que nuestra matriz P, que está formada por A , B
y -C, tiene que ser invertible para que el sistema tenga solución.
En matlab comprobamos eso con los siguientes comandos:
G_ext=[A B;-C 0]
G_ext =
43

-63.5420 -21.9863 4.0000
16.0000 0 0
0 -2.6375 0
>> rank(G_ext)
ans =
Vemos que esta matriz ( que equivale a la P) es invertible , es una matriz 3x3.

Ahora pasamos a expandir nuestras matrices Aext y Bext y Pext:
Aext=[A [0 0]';-C 0];

Bext=[B;0];
Pext=[-10 -10 -100];
donde nuestra matriz Pext está formada por los polos deseados en bucle cerrado de
nuestro sistema, dos de ellos están dados por la frecuencia natural y, además, como
queremos que tenga error nulo ante consigna velocidad de amplitud unitaria le introducimos
un integrador, para ello le metemos un polo más en bucle cerrado en el vector Pext y lo
situaremos en -100, ya que no puede ser más dominante que los otros dos.
Ahora calculamos el vector de ganancias Kext usando la fórmula de ackerman. En matlab

hemos introducido los siguientes comandos :
Kext=acker[Aext,Bext,Pext]
Kext = [ 14.1145 27.3159 -59.2418]
Ahora declaramos lo siguiente, negativizando la última constante del vector de ganancia:
Kext1=Kext(1);Kext2=Kext(2);Kext3=-Kext(3)
y también declaramos nuestros dos vectores K y Ki formados por :
K=[Kext1 Kext2];Ki=Kext3;
Y por último montamos las matrices de AAext, BBext, CCext y DDext :
44
AAext=[A-B*K B*Ki;-C 0];BBext=[0 0 1]'; CCext=[C 0];DDext=0; “nuestro sistema tiene rango
máximo 3”
Nuestro sistema en bucle cerrado sería el siguiente:
sis_bc=ss(AAext,BBext,CCext,DDext)
sis_bc =
A=
x1 x2 x3
x1 -120 -131.3 237

x2 16 0 0
x3 0 -2.637 0
B=
u1
x1 0
x2 0
x3 1
C=
x1 x2 x3
y1 0 2.637 0
D=
u1
y1 0
Y nuestra respuesta sería la siguiente :
45

Gba_vel_z =
0.08766 z + 0.03177
------------------------

z^2 - 0.7928 z + 0.04168

Discrete-time transfer function.
Siendo K e vector de ganancias en realimentación.

[G, H, C, D]=ssdata(Gba_vel_z)
G=
0.7928 -0.1667
0.2500 0
H=
0.5000
46

C=
0.1753 0.2541
D=
0
pzmap(sist_vel_z)

Gext=[G [0 0]';-C 0];
Hext=[H;0];
Para calcular los polos hacemos la conversión Z = es*T
Pext=[exp(-10*T) ,exp(-10*T),exp(-100*T)]
Pext =
0.6065 0.6065 0.0067
K_hat=acker(Gext,Hext,Pext)
K_hat =[-0.8539 2.7297 0.0780];
Kext1=Kext(1);Kext2=Kext(2);Kext3=-Kext(3)
47

K=[Kext1 Kext2];Ki=Kext3;
GGext=[G-H*K H*Ki;-C 0];

GGext =
-6.2644 -13.8247 29.6209

0.2500 0 0
-0.1753 -0.2541 0
HHext=[0 0 1]';
>> CCext=[C 0];DDext=0;

CCext =
0.1753 0.2541 0
sis_bc_z=ss(GGext,HHext,CCext,DDext,0.05)
Al hacer la conversión a digital, los polos se nos quedan fuera del círculo unidad
proporcionandonos un sistema inestable.
48

49

Wuolah Free Trabajo CPC

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Wuolah Free Trabajo CPC

Cargado por

Copyright:

Formatos disponibles

Trabajo-cpc.

Control Por Computador

3º Grado en Ingeniería Electrónica, Robótica y Mecatrónica

Escuela de Ingenierías Industriales

Reservados todos los derechos.

Reservados todos los derechos.

Reservados todos los derechos.

Compra Coins y descarga sin publicidad.

El sistema en bucle abierto viene dado por:

sistbucle abierto = Gpos * H (s)

Y (s) 0.00488 *3.8197

Y (s) * [2.891 * e−05 * s3 + 0.001837 * s2 + 0.01017 * s] = U (s) * 0.00488 * 3.8197

Aplicamos transformada inversa de Laplace y suponemos condiciones iniciales nulas.

2.891*e^-05* y‘’’(t)+ 0.001837* y‘’(t) + 0.01017*y‘(t) = 0.00488*​3.8197*​u(t)

Compra Coins y descarga sin publicidad.

Nuestra función de transferencia en bucle abierto discretizada sería:

0.006875 z 2 + 0.01447 z + 0.001464

Reservados todos los derechos.

Y (z) * (z 3 − 1.793 * z 2 + 0.8345 * z − 0.04171) = U (z) * (0.006875 * z 2 + 0.8345 * z − 0.04171)

A continuación aplicamos la transformada inversa de Z y nos daría lo siguiente:

y[k+3]-1.793*y[k+2]+0.8345*y[k+1]-0.04171*y[k ]= 0.006875*u[k+2] + 0.01447*u[k+1] + 0.001464*u[k]

Compra Coins y descarga sin publicidad.

Ahora despejamos nuestro coeficiente que está acompañando a s^2 y obtenemos lo

Para la descripción de espacio de estado en sistema continuo utilizamos los siguientes

-G_vel_matriz = ​“No es canónica”

Reservados todos los derechos.

Compra Coins y descarga sin publicidad.

Reservados todos los derechos.

El error en continuo viene dado por : e = lim s * R(s)/(1 + G(s) * H (s))

En nuestro caso, para la posición sería lo siguiente:

Compra Coins y descarga sin publicidad.

Reservados todos los derechos.

Compra Coins y descarga sin publicidad.

En nuestro caso, para la velocidad sería lo siguiente:

Reservados todos los derechos.

Se puede ver en la siguiente imagen:

Reservados todos los derechos.

0.0018 z^2 + 0.003789 z + 0.0003832

Compra Coins y descarga sin publicidad.

La respuesta obtenida es la siguiente:

Reservados todos los derechos.

Para la velocidad discretizaremos la función con un hold 0:

Compra Coins y descarga sin publicidad.

Entrada ​rampa unitaria​:

Reservados todos los derechos.

Compra Coins y descarga sin publicidad.

Los comandos en Matlab usados son:

Reservados todos los derechos.

0.0018 z^2 + 0.003789 z + 0.0003832

Los polos de nuestro sistema son :

Reservados todos los derechos.

Compra Coins y descarga sin publicidad.

Para la Ka crítica sería :

Compra Coins y descarga sin publicidad.

Reservados todos los derechos.

También cabe comentar que al aumentar nuestra ganancia Ka estamos aumentando la

Compra Coins y descarga sin publicidad.

El sistema que obtenemos con las especificaciones sería el siguiente :

Reservados todos los derechos.

Como ya hemos comprobado en el ejercicio anterior, las especificaciones temporales no se pueden

UNA POSIBLE FORMA DE HACERLO : PRIMERO DESDE CONTINUO Y DESPUÉS A DISCRETO

Reservados todos los derechos.

El controlador que obtenemos en continuo y transformado a discreto posteriormente se puede ver

2.891e^-05 y‘’’(t)+ 0.001837* y‘’(t) + 0.01017y‘(t) = 0.004883.8197*u(t)

y[k+3]-1.793y[k+2]+0.8345y[k+1]-0.04171y[k ]= 0.006875u[k+2] + 0.01447u[k+1] + 0.001464u[k]

-G_vel_matriz = “No es canónica”

Entrada rampa unitaria: