Diseño de un Controlador PID Difuso para una planta de Segundo Orden Sub-amortiguada usando LABVIEW
Transcript of Diseño de un Controlador PID Difuso para una planta de Segundo Orden Sub-amortiguada usando LABVIEW
Capítulo Sistemas de Control IEEE-UNAC
1
“Diseño de un Controlador PID Difuso para
una planta de Segundo Orden Sub-
amortiguada usando LABVIEW”
Cuya Solari, Omar Antonio
Flores Bustinza, Edwing Irwing
Torres Chavez, Jonathan Emmanuel
Capítulo Sistemas de Control IEEE-UNAC
2
I.- Objetivos
Realizar la simulación y tiempo real de un sistema lineal con
controlador PID difuso de nueve reglas, con Labview en código Puro.
Comparar las bondades de emplear lógica difusa a un controlador PID
Análogo con sintonía Ziegler Nichols común para sus parámetros Kp,
Kd y Ki.
II.- Modelamiento de una Planta Prototipo de Segundo Orden
2.1.- Diseño
Para este caso se utilizó una planta con TL082 en modo sub-amortiguado, y
para el diseño de los componentes a utilizar plantearemos las ecuaciones
eléctricas para llegar a la expresión Gp(s) de una planta prototipo de segundo
orden.
Fig 1.-Planta TL082 a diseñar
De la planta prototipo obtenemos las siguientes ecuaciones:
Despejando de las ecuaciones (1) y (2), e igualando obtenemos:
Capítulo Sistemas de Control IEEE-UNAC
3
Despejando de la ecuación (2) y reemplazándola en la ecuación (4):
Ahora reemplazando la ecuación (3):
Reemplazando las ecuaciones (3) y (6) en la ecuación (5) se obtiene la siguiente
ecuación diferencial de segundo orden:
Aplicando la transformada de LAPLACE y hallando la función de transferencia
obtenemos:
Sabemos que el sistema prototipo de segundo orden es:
Dándole la forma estándar de segundo orden a la ecuación (7):
(√
)
(√
)
Se puede observar las relaciones para los parámetros de la planta prototipo:
coeficiente de amortiguamiento, frecuencia natural y sobrepaso máximo, que
nos permitirá diseñar en modo sub-amortiguado.
√
√
Capítulo Sistemas de Control IEEE-UNAC
4
Se diseñará para una respuesta transitoria sub-amortiguada por lo
partiremos de un sobrepaso del 21%, de lo que se comienza calculando el
sobrepaso máximo de la expresión:
(
√ )
Despejando se obtiene:
√
(
)
Reemplazando el valor del sobrepaso máximo 21.5% obtenemos:
Reemplazando en la ecuación (9) y los valores de los componentes
obtenemos:
√
Despejando y resolviendo la ecuación cuadrática se obtiene:
Por lo tanto la nuestra planta tomamos los siguientes valores de componentes:
Capítulo Sistemas de Control IEEE-UNAC
5
2.2.- Prueba en Software
Simulando el momento transitorio de la planta en PROTEUS 7.7 obtenemos
un sobrepaso de 17%:
Fig 2.- Simulación Planta TL082 en Proteus 7.7
2.3.- Adquisición de los datos
Para adquirir los datos de nuestra planta diseñada anteriormente, elaboramos un código en Labview:
Fig 3.-Programacion Adquisición de datos
Capítulo Sistemas de Control IEEE-UNAC
6
Siguiendo las siguientes configuraciones para los DAQ Assistant:
Adquisidor de
Datos
Generador de la entrada
escalón (2V)
Pin ai0 a01
Modo de Adquisición Continuous Samples On Demand
Frecuencia 1KHz ---------------
Muestras por lectura 1000 ---------------
Modo de Referencia RSE: Referencia al GND del NIDAQ (0V).
RSE
Como se observa nuestro datos serán almacenados en dos archivos con
extensión .lvm, uno con cabecera (data_sub_cc.lvm) y otro sin cabecera
(data_sub_sc.lvm), con ayuda del toolkit Write to Measurement File. Luego al
realizar la adquisición de los datos obtuvimos los siguientes resultados para
las datas:
(a) (b)
Fig 4.- (a) Data sin cabecera. (b) Data con cabecera
2.4.- Ploteo en Matlab
Emplearemos el código siguiente para plotear nuestra data sin cabecera en
Matlab:
clear all; close all; clc load data_sub_sc.lvm data=data_sub_sc; t=data(:,1); y=data(:,2); u=data(:,4); figure(1) plot(t,y,'r',t,u,'b') title('\bf Ploteo de los datos – Planta Subamortiguada') legend('Salida','Entrada') grid
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 7
Y se obtiene el siguiente grafico:
Fig 5.- Datos adquiridos
III.- Identificación del Modelo Adquirido
Los dos archivos de datos se adquirieron con dos fines: Visualizarla e
identificarla en Matlab (herramienta ident , etc) e identificarla con Labview en
la herramienta Signal Express. Para nuestro caso hemos usado la herramienta
signal express para realizar la identificación del modelo adquirido con ayuda
del algoritmo ARMAX 2111 configurable en esta herramienta que mostraremos
a continuación:
a) Abrimos el entorno del Workbench Signal Express de Labview:
Fig 6.- Entorno de inicio del tool Signal Express de Labview
0 2 4 6 8 10 12-0.5
0
0.5
1
1.5
2
2.5 Ploteo de los datos – Planta Subamortiguada
Salida
Entrada
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 8
b) Cargamos nuestra data LVM con cabecera con Add Step y la ruta
especificada en la figura:
Fig 7.- Data LVM con cabecera y paquetes de datos según configuración
en la NIDAQ (1000 datos por segundo)
c) Seguidamente importamos los paquetes de datos de nuestro archivo de
adquisición “con cabecera” y seleccionamos los paquetes de entrada
(Voltage_1) y salida (Voltage_0) del sistema:
Fig 8.- Selección de paquetes de datos para entrada y salida
d) Ahora pasamos a identificar el modelo, para ello accedemos al System
Identification y estimación de parámetros, con la ruta especificada:
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 9
Fig 9.- Entorno para la Identificación
e) Luego configuramos el algoritmo de identificación para nuestra planta, para
ello ubicamos los paquetes de datos de entrada y salida seleccionados
anteriormente siguiendo el diagrama de bloques que presenta el entorno para
dicha acción.
A su vez configuramos el algoritmo a trabajar para una planta de segundo
orden subamortiguada, se elegirá el ARMAX 2111 porque presentó mejor
performance en la identificación, es decir se acerca más a los datos
adquiridos.
Fig 9.- Configuración ARMAX 2111
Fig 10.- Configuración ARMAX 2111
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 10
f) Luego haremos un panel con la performance: Señal de error (celeste), Datos
adquiridos (rojo) e identificación con ARMAX 2111(verde), además la ecuación
discreta de la identificación con ARMAX 2111.
Fig 11.- Resultados de la identificación
Como se observa la identificación fue rápida y sencilla con esta herramienta,
además de eficiente ya que si se observa la identificación con algoritmos de
recursión como el ARMAX trabajan con la señal de error (nos da
compatibilidad del modelo identificado con los datos adquiridos), y tiene como
objetivo principal la convergencia de este error a cero lo más rápido posible y
arrojarnos el modelo matemático que hace dicha acción.
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 11
g) Finalmente guardamos el archivo .sim con la información de la
identificación realizada en el signal express, para ello, realizamos la siguiente
acción:
Fig 12.- Configuración para guardar el archivo .sim
IV.- Obtención de la Función de Transferencia Gp(s)
Lo siguiente que hicimos fue tratar la ecuación de identificación por código
LABVIEW, y obtener la función de transferencia Gp(s), para luego pasar a
diseñar el controlador, con esta idea presentamos el código Labview para
dicha acción:
Fig 13.- Tratamiento ARMAX – Panel de Bloques
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 12
En este código le agregamos herramientas que nos pueden servir de guía para
un algún otro algoritmo de control a diseñar: Diagrama de Bode Magnitud,
Sistema notación variable Espacio – Estado, polos y ceros del sistema, así
como la matriz de controlabilidad para verificar si la planta identificada es
controlable o no. Este aporte le da un análisis más exhaustivo al sistema y
todo con el uso del archivo .sim que identificamos y guardamos en Signal
Express. Ver Figura 14.
Fig 14.- Tratamiento ARMAX – Panel Frontal
Y lo más importante que con este código se obtuvo la función de transferencia
en Laplace, importante para el diseño del controlador PID análogo a emplear
para luego migrar al PID difuso:
V.- Diseño del Controlador PID con Matlab
Para diseñar un controlador PID para una planta sub-amortiguada,
emplearemos la herramienta sisotool de Matlab, el cual según la
configuración que hagamos para la sintonización del PID, nos arrojara la
función de transferencia de éste, que luego nos servirá para identificar las
constantes Kp, Ki, Kd
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 13
5.1.- Diseño en Sisotool
Para comenzar nuestro diseño PID, empezaremos ingresando la palabra
sisotool en la ventana de comando de Matlab, nos aparecerá nuestro entorno
con un diagrama de bloques. Ver figura 15:
Fig 15.- Entorno Sisotool de Matlab
El diagrama de bloques que nos presenta sisotool constituye el de un sistema
de control en lazo cerrado donde el bloque amarillo “G” es la notación de
nuestra planta obtenida anteriormente, el bloque rojo “C” que viene a ser la
función de transferencia de nuestro controlador a diseñar, además de la
realimentación “H” que para nuestro caso será unitaria. Este diagrama de
bloques es configurable accediendo a la opción Control Architecture, pero
como es exactamente el sistema de control que deseamos implementar no
cambiaremos dicho diagrama. Ahora importaremos la F.T de la planta,
siguiendo la siguiente secuencia:
Fig 16.- Importando la F.T del Workspace al sisotool
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 14
5.2.- Sintonización PID
El controlador proporcional–integral-derivativo o PID, es un dispositivo de
control genérico (limitado según la planta a controlar) para procesos con
tiempo de establecimiento no muy pequeño, donde el diseñador sólo tiene que
dar valores adecuados, según lo requiera la situación, a los parámetros de
sintonía que contiene.
La herramienta sisotool nos permite interactuar con una gama de
sintonizaciones para nuestro PID, por practicidad y con fines de probar
nuestro algoritmo fuzzy más adelante realizamos dos sintonizaciones que se
configuran siguiendo la secuencia de la figura 17: PID por Ziegler – Nichols y
PID con respuesta temporal robusta (Optimizado), una vez terminada la
configuración de la sintonización se le da click en “Update Compensator”:
Fig 17.- Configuración para PID Tuning Zieger Nichols y Robusto
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 15
El tipo de algoritmo PID en que se basa nuestro trabajo es el tipo paralelo que
tiene la estructura de la figura 18, donde la actuación del controlador se
puede separar en forma de tres sumandos diferentes. Cada uno de ellos
contempla la acción proporcional, derivativa e integral:
Fig 18.- PID forma paralela
La ley de control usada para este tipo de controlador seria:
(
∫
)
Donde las constantes dela acción proporcional, integral y derivativa:
Kp: Hace que la respuesta de la planta sea más rápida sin introducir retrasos
o adelantos en la salida del sistema.
Ki: Produce la reducción del error en el estado estacionario insertando una
acción de seguimiento para el control.
Kd: Produce una acción de frenado en la respuesta del sistema y evita las
fuertes oscilaciones, tiene una acción de anticipación para el control.
Además la función de transferencia del controlador PID tiene la siguiente
estructura:
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 16
Por lo tanto, se observa que los valores de las constantes Kp, Ki y Kd elegirán
la posición de los ceros y el valor de la ganancia para el control del sistema.
Regresando a los resultados del diseño en sisotool, se tienen las ecuaciones
arrojadas para las dos sintonizaciones en cuestión en el panel de PID TUNING:
(
)
(
)
Finalmente configuramos los gráficos de simulación en lazo cerrado para el
control PID diseñado en sisotool:
Fig 19.- Configurando gráficas de resultados
Luego de configurar le damos mostrar ploteos de diseño y análisis en cada
ventana, para obtener dos gráficos: el primero nos indicara el diagrama de
bode del sistema en lazo abierto y cerrado, lo cual nos permitirá contrastar en
el dominio de la frecuencia como se da la modificación de los ceros de la
planta por la acción del controlador diseñado, el segundo grafico muestra una
comparación de las respuestas del sistema en lazo abierto y cerrado ante un
escalón unitario. Se presentan dos graficas debido a las dos sintonizaciones
que se realizaron, verificándose las bondades de la respuesta del diseño PID
robusto:
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 17
Fig 20.- Resultados Finales del diseño de controlador PID Robusto
Luego corroboraremos los resultados por código matlab usando las funciones
de transferencia arrojadas en el sisotool para las dos sintonizaciones, a su vez
le insertaremos un tren de pulsos al sistema para ver cómo responde en lazo
cerrado. Finalmente se extraerán los coeficientes Kp, Ki, Kd de cada
sintonizacion. Para todo ello usaremos el siguiente código:
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 18
%Planta en lazo abierto identificada
clear all; close all; clc
n=[0.0771137 154.535];
d=[1 12.0318 154.287];
Gp=tf(n,d)
%Gpla=zpk(Gp);
t=0:0.001:2;
u1=2*ones(size(t));
u2=2*[ones(1,1000) zeros(1,1001)];
yla=lsim(Gp,u1,t);
figure (1)
plot(t,yla,'r',t,u1,'b','Linewidth',
2)
title('\bf Planta Subamortiguada
Lazo Abierto')
xlabel('tiempo(seg)')
ylabel('Amplitud')
grid
% PID en sisotool "RESULTADOS"
%PID ROBUSTO
nc1=[0.0669 2.058 15.83];
Gc=tf(nc1,[0 1 0])
Glc1=feedback((Gp*Gc),1)
ylc1=lsim(Glc1,u2,t);
ylc=lsim(Glc1,u1,t);
Kp=nc1(2)
Ki=nc1(3)
Kd=nc1(1)
figure(2)
subplot(221)
plot(t,yla,'r','Linewidth',2),hold
plot(t,ylc,'m',t,u1,'b','Linewidth',
2)
title('\bf PID (Optimizado)')
xlabel('tiempo(seg)')
ylabel('Amplitud')
legend ('Gla','Glc','u')
grid
subplot(222)
plot(t,ylc1,'m',t,u2,'b','Linewidth'
,2),hold
title('\bf PID (Optimizado)')
legend ('Glc','u')
xlabel('tiempo(seg)')
ylabel('Amplitud')
grid
%PID ZIEGLER NICHOLS COMUN
nc2=[0.0632 4.4384 30.4];
Gc2=tf(nc2,[0 1 0])
Glc2=feedback((Gp*Gc2),1)
ylc2=lsim(Glc2,u2,t);
ylc=lsim(Glc2,u1,t);
Kpzn=nc2(2)
Kizn=nc2(3)
Kdzn=nc2(1)
subplot(223)
plot(t,yla,'r','Linewidth',2),hold
plot(t,ylc,'g',t,u1,'b','Linewidth',
2)
title('\bf PID (Zieger - Nichols)')
xlabel('tiempo(seg)')
ylabel('Amplitud')
legend ('Gla','Glc','u')
grid
subplot(224)
plot(t,ylc2,'g',t,u2,'b','Linewidth'
,2)
title('\bf PID (Zieger - Nichols)')
legend ('Glc','u')
xlabel('tiempo(seg)')
ylabel('Amplitud')
grid
Fig 20.- Resultados para dos tipos de entradas.
0 0.5 1 1.5 20
1
2
3 PID (Optimizado)
tiempo(seg)
Am
plit
ud
Gla
Glc
u
0 0.5 1 1.5 2-1
0
1
2
3 PID (Optimizado)
tiempo(seg)
Am
plit
ud
Glc
u
0 0.5 1 1.5 20
1
2
3 PID (Zieger - Nichols)
tiempo(seg)
Am
plit
ud
Gla
Glc
u
0 0.5 1 1.5 2-1
0
1
2
3 PID (Zieger - Nichols)
tiempo(seg)
Am
plit
ud
Glc
u
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 20
0.5
1
1.5
2
2.5 Planta Subamortiguada Lazo Abierto
tiempo(seg)
Am
plitu
d
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 19
De este código se obtienen las constantes Kp, Ki y Kd:
Para el PID Robusto:
Kp = 2.058
Kd = 0.0669
Ki = 15.83
Para el PID Z-N:
Kp (Z-N) = 4.4384
Kd (Z-N) = 0.0632
Ki (Z-N) = 30.4
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 20
VI.- Diseño de un controlador DPID (Parte 1)
6.1.- Control Difuso Proporcional
La entrada a un controlador difuso proporcional (PD) es el error (e), y la salida
es la señal (U).
Fig 21.- Controlador difuso proporcional (DP)
Este es el controlador más simple. Si comparamos con el controlador proporcional crisp, vemos que el control difuso proporcional tiene dos ganancias GE y GU. La ganancia sirve principalmente para sintonizar la repsuesta, hay dos ganancias que también pueden usarse para escalar la señal de entrada hacia el universo de entrada explotándolo mejor. La salida
del controlador o señal de control Un es una función no lineal de en, entonces:
La función es el mapeo de entrada-salida del controlador difuso. Usando
la aproximación lineal , tenemos:
Podemos decir que el producto de los factores de ganancias es equivalente a la ganancia proporcional, es decir, . La exactitud de la aproximación
depende principalmente de las funciones de pertenencia y las reglas. Para una mejor aproximación, es mejor escoger el mismo universo en ambos lado de la entrada y salida. Por ejemplo, asumimos que los universos de entrada son ambos [-100,100].
6.2.- Control Difuso Proporcional-Derivativo
La acción derivativa ayuda a predecir el error y el controlador proporcional-derivativo usa la acción derivativa para mejor la estabilidad en lazo cerrado. La estructura básica de un controlador PD es:
(
)
La señal de control es proporcional a una estimación del error en segundos,
dónde la estimación se obtiene por la extrapolación lineal. Para el control es completamente proporcional, y cuando se aumenta gradualmente, se tienen oscilaciones amortiguadas.
f e GU GE U u E
Base de Reglas
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 21
Si se pone demasiado el sistema se vuelve subamortiguado y empezará a oscilar de nuevo. La entrada al controlador DPD es el error y la derivada del error.
Fig 22.- Controlador difuso PD (DPD)
En el controlador difuso el último término se llama normalmente el cambio en el error y es dado por:
Esta es una aproximación discreta y usa una ecuación de diferencias recursiva (barckward). La salida del controlador es una función no lineal del error( ) y cambio del error .
De nuevo la función es el mapeo de la entrada-salida del controlador difuso, sólo en este tiempo es una superficie. Usando la aproximación lineal
, entonces:
(
)
Por la comparación, las ganancias están relacionadas de la siguiente manera:
6.3.- Control Difuso Proporcional, Integral Y Derivativo
La acción integral ayuda a que el error en estado estacionario se mantenga al valor cero, junto con el controlador proporcional-derivativo la performance del
controlador incrementa. La estructura básica de un controlador PID es:
(
∑
)
El índice n está referido al instante de tiempo. Para sintonizar debemos activar y ajustar los parámetros , y .
f GU
GE e U u
E
Base de Reglas
GCE CE ce
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 22
El controlador difuso PID presenta tres términos de entrada: error, error integral y error derivativo. Una base de la reglas con tres entradas llega a ser bastante grande y la acción íntegra resulta una molestia. Por consiguiente es común separar la acción integral en el controlador difuso PD+I (DPD+I):
Fig 23.- Controlador difuso PD+I (DPD+I)
El error integral se computa como: ∑ . El controlador es una función de las tres entradas:
[ ]
La aproximación lineal es:
(
)
Comparando esta última ecuación con la ecuación de la estructura básica (ley de control PID), las ganancias son relacionadas de la siguiente forma:
Este controlador proporciona todos los beneficios del control PID, pero también las desventajas con respecto al windup del integrador.
f GU
GE e U u
E
Base de Reglas
GCE CE ce
GIE ie IE
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 23
6.4.- Algoritmo DPID en Labview
a.- Declaración de Reglas y funciones de pertenencia de 4 y 9 reglas en
Labview
Para declarar las funciones de pertenencia, las entradas crisps y las reglas del
algoritmo difuso a emplear, usamos el Fuzzy System Designer:
Fig 24.- Uso del Fuzzy System Designer
En el entorno del Fuzzy Controller se configurarán las entradas crisps E y CE
que corresponden a las acciones Proporcional y Derivativa del Algoritmo DPID
mencionado anteriormente, también los universo de discurso, funciones de
pertenencia tipo Triangular por ser un proceso Lineal el que se va a controlar,
a su vez se declararán las reglas a trabajar para las inferencias y la
defuzzificación por centroide y la salida U se configurará funciones singletons
en N, Z y P.
Fig 25.- Configuración para el algoritmo Fuzzy
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 24
b.- Simulación y control tiempo real
Ya con el algoritmo Fuzzy cargado en el Fuzzy Controller en el panel de
bloques de Labview, pasamos a mostrar el algoritmo DPID programado:
Fig 26.- Diagrama de Bloques DPID
Fig 27.- Panel Frontal
En este código se ha incluido las ecuaciones para las ganancias GIE, GCE y
GE del DPID, a partir de las constantes Kp, Kd y Ki de la sintonía del PID
análogo común, esto me va permitir insertar las constantes que comúnmente
diseñamos y así probar la performance del algoritmo PID Difuso respecto al
control PID Análogo.
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 25
Además se incluye el Fuzzy Controller, en el cual se cargar los archivos
4rules.fs y 9rules.fs con el algoritmo difuso y la tabla de nueve y cuatro
reglas respectivamente. A su vez, la estructura case para elección entre la
simulación (Toolkit H(s)) y el tiempo real (Configuración DAQ Assistant para
TR).
Finalmente se ha incluido un parámetro de escalamiento “ ” multiplicando a
la acción derivativa y proporcional, y su reciproco multiplicando a la señal de
control resultante del controlador DPID antes de ingresar a la planta. Este
parámetro es experimental y de alguna u otra forma participa regulando la
acción PD que ingresa al algoritmo Fuzzy, por lo tanto su valor afinara a la
señal de control para realizar un mejor resultado en el control.
Para nuestro caso se tendrá en cuenta que:
GE = 1 (Valor fijo)
= 8.163 (PID Robusto)
= 9.5 (PID Z-N)
Los demás parámetros serán calculados de forma automática.
Resultados para 4 reglas
Para algoritmo Fuzzy PID con 4 reglas en tiempo real se obtuvo:
Fig 28.- Prueba tiempo real para 4 reglas
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 26
Luego verificamos el comportamiento al cambiar de caso a “Simulación”.
Fig 29.-Selección de caso “Simulación”
Resultados para 9 reglas
Para algoritmo Fuzzy PID con 9 reglas en tiempo real se obtuvo:
Fig 30.-Prueba Tiempo Real con Algoritmo de 9 reglas
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 27
Fig 31.- Cambio a simulación
VII.- Diseño de un controlador DPID (Parte 2)
Para esta segunda parte se codificara el algoritmo DPID en código puro,
empleando la aproximación trapezoidal para la acción integral, partiendo del
algoritmo mencionado en el item 6.3 y su ecuación 6.3 para la ley de control,
con la diferencia que en este algoritmo no habrá escalamiento ni parámetro
de la prueba anterior: GIE, GCE y
GE. Además el proceso de Fuzzificación y defuzzificación se hará en código
puro en un SubVi que interactuara con nuestra planta prototipo en tiempo
real.
Fig 32.- Diagrama de Bloques DPID Código Puro
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 28
7.1.- Discretización de la Planta
Como el algoritmo a realizar es enteramente discreto, entonces para realizar
las pruebas respectivas tendremos que discretizar nuestra planta, para ello se
ha creado dos códigos para dicho fin.
En el primero se ha trabajado con los coeficientes de las F.T hallada de la
notación función de transferencia, luego este modelo pasa por un toolkit de
conversión de continuo a discreto con un periodo de muestreo de (T = 0.001
seg), dando como resultado una función de transferencia discreta, la cual será
insertada a un toolkit H(z) para ser estimulada con un escalón u(t) que pasara
por mantenedor de orden cero (ZOH), obteniendo como resultado la respuesta
de nuestra planta discretizada en lazo abierto, además de ello se superpondrá
con la respuesta en continuo con ayuda del mismo estimulo u(t) pero
insertado a un toolkit H(s) con la F.T cargada. Obsérvese que las respuestas
coinciden con lo que se ha discretizado exitosamente el modelo (Ver figura 32).
Fig 33.- Diagrama de bloques Respuesta planta discreta vs Continua
En el segundo programa se ha calculado la “ecuación de diferencias” de
nuestra planta teniendo en cuenta que su estructura F.T es de la forma:
Tomando la anti-transformada “s”, se tiene la ecuación diferencial del modelo:
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 29
Con esta ecuación pasamos al espacio k con las siguientes notaciones para la
primera y segunda derivada:
,
Luego, reemplazando los términos y despejando, se tiene la ecuación de
diferencias de nuestra planta en función a los coeficientes de la F.T y el
periodo de muestreo:
(
) (
) (
) (
)
La ecuación de diferencias anterior se ha codificado en Labview usando los
registros de desplazamiento para declarar los , , y , además se
ha codificado la condición inicial “0” para los registros , , y , así
al inicio no se cargarán con valores inesperados y erróneos que afecten a los
datos verdaderos que debe arrojar el programa.
Fig 34.- Diagrama de bloques ecuación de diferencias de la Planta
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 30
El programa nos muestra los resultados de las dos formas de representar
nuestra planta discretizada:
Fig 35.- Simulación de respuesta de la planta discreta ante un escalón
unitario
7.2.- Acción Proporcional – Derivativa
Siguiendo el algoritmo DPID explicado en ítems anteriores se construyó un
SubVi llamado “FUZZY PD”, el cual recibe 4 entradas (Error, T, GCE y GE), y 5
salidas (E, CE, Grafico de U, Salida Defuzzy y Salida Final). Para fines
didácticos para monitoreo en las pruebas de Tiempo Real.
Fig 38.- Algoritmo de para el DPD discreto en Labview
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 31
7.3.- Acción Integrativa
El SubVi construído para la acción integral contiene un algoritmo interesante,
y es el de aproximación trapezoidal, uno de los más eficientes en cuanto a
diseño de PID Discreto, ya que se basa en la sumatoria de áreas de trapecios
formados por el errores mostrados en dos posiciones consecutivas de
muestreo (n y n-1), cuya base es el periodo de muestreo. Este valor
multiplicado con el 1/Ti que se calcula con la división de GIE y GE,
constituyen la acción integral, que se codifica como registro de desplazamiento
ya que necesita sumar su valor actual con el valor anterior.
Fig 37.- Algoritmo de aproximación Trapezoidal para la acción integral
7.4.- Diseño de un SubVI para Fuzzyficación y Defuzzyficación con 9
reglas en código Puro con Matlab y Labview
1.- Fuzzy System Designer de 4 y 9 reglas en código puro en matlab
Para la implementación en la plataforma Labview de un sistema fuzzyficador y
defuzzificador en código puro de 9 reglas, primero realizamos simulaciones en
el software Matlab que servirán de base para la posterior programación en
Labview.
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 32
La primera de las programaciones en Matlab muestran un programa para
poder elegir entre un sistema fuzzy de 4 reglas y 9 reglas y observar la
respuesta defuzzificada del sistema.
a) La parte inicial del código presenta las 2 entradas del sistema, cada una de
las cuales posee 3 MF (Member Shift Factor) que tienen formas triangulares
con parámetros distintos, pero con el mismo universo de discurso.
clear all ; close all ; clc
% --------------------------------------------------
% ENTRADA 1
% --------------------------------------------------
puntos_n = 201;
x1=linspace(-100,100, puntos_n); % Universo de discurso IN 1
param_in_1 = [ -100.00 -100.00 0.00
-100.00 0.00 100.00
0.00 100.00 100.00 ];
mf_in_1=zeros(3,puntos_n);
mf_in_1(1,:)=trian_mf(x1,param_in_1(1,:)); % E = N
mf_in_1(2,:)=trian_mf(x1,param_in_1(2,:)); % E = Z
mf_in_1(3,:)=trian_mf(x1,param_in_1(3,:)); % E = P
% --------------------------------------------------
% ENTRADA 2
% --------------------------------------------------
x2=linspace(-100,100, puntos_n); % Universo de discurso IN 2
param_in_2 = [ -100.00 -100.00 0.00
-100.00 0.00 100.00
0.00 100.00 100.00 ];
mf_in_2=zeros(3,puntos_n);
mf_in_2(1,:)=trian_mf(x2,param_in_2(1,:)); % CE = N
mf_in_2(2,:)=trian_mf(x2,param_in_2(2,:)); % CE = Z
mf_in_2(3,:)=trian_mf(x2,param_in_2(3,:)); % CE = P
b) Para continuar se presenta la salida del fuzzyficador que también posee 3
Member Shift Factor pero con salidas de modo Singleton que toman
únicamente 3 posibles valores: -200, 0, 200.
% --------------------------------------------------
% SALIDA
% --------------------------------------------------
y=linspace(-200,200, puntos_n); % Universo de discurso OUT
param_out = [ -300.00 -200.00 -199.00
-1.00 0.00 1.00
199.00 200.00 300.00 ];
mf_out=zeros(3,puntos_n);
mf_out(1,:)=trian_mf(y,param_out(1,:)); % U = N
mf_out(2,:)=trian_mf(y,param_out(2,:)); % U = Z
mf_out(3,:)=trian_mf(y,param_out(3,:)); % U = P
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 33
c) Ploteamos las entradas y salida del sistema, las cuales serán analizadas por
el algoritmo Mandani descrito más adelante en código puro.
% --------------------------------------------------
% PLOTEOS DE ENTRADA Y SALIDA
% --------------------------------------------------
figure(1)
subplot(3,1,1)
plot(x1,mf_in_1(1,:),'r','LineWidth',2),hold
plot(x1,mf_in_1(2,:),'g','LineWidth',2)
plot(x1,mf_in_1(3,:),'b','LineWidth',2)
grid
legend('N','Z','P')
title('Error')
axis([-100 100 0 1])
subplot(3,1,2)
plot(x2,mf_in_2(1,:),'r','LineWidth',2),hold
plot(x2,mf_in_2(2,:),'g','LineWidth',2)
plot(x2,mf_in_2(3,:),'b','LineWidth',2)
grid
legend('N','Z','P')
title('Derivada del Error')
axis([-100 100 0 1])
subplot(3,1,3)
plot(y,mf_out(1,:),'r','LineWidth',2),hold
plot(y,mf_out(2,:),'g','LineWidth',2)
plot(y,mf_out(3,:),'b','LineWidth',2)
grid
legend('N','Z','P')
title('Salida')
axis([-200 200 0 1])
Fig 38.- Entradas y Salida del sistema fuzzyficador
-100 -80 -60 -40 -20 0 20 40 60 80 1000
0.5
1Error
N
Z
P
-100 -80 -60 -40 -20 0 20 40 60 80 1000
0.5
1Derivada del Error
N
Z
P
-200 -150 -100 -50 0 50 100 150 2000
0.5
1Salida
N
Z
P
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 34
Para iniciar el algoritmo debemos tener en claro las reglas que serán colocadas
en nuestra base de reglas y que serán aplicadas en el controlador para obtener
la señal de control en la salida, las reglas son las siguientes:
Para 4 reglas: para este caso debemos aclarar que sólo se tendrán en cuenta
las entradas N y P del Error y de la Derivada del Error.
IF „E‟ IS „N‟ AND „CE‟ IS „N‟ THEN „U‟ IS „N‟
IF „E‟ IS „N‟ AND „CE‟ IS „P‟ THEN „U‟ IS „Z‟
IF „E‟ IS „P‟ AND „CE‟ IS „N‟ THEN „U‟ IS „Z‟
IF „E‟ IS „P‟ AND „CE‟ IS „P‟ THEN „U‟ IS „P‟
Para 9 reglas: para este caso si empleamos los 3 MF‟s citados en las entradas
(N, Z, P) para obtener la señal de control de salida.
IF „E‟ IS „N‟ AND „CE‟ IS „N‟ THEN „U‟ IS „N‟
IF „E‟ IS „N‟ AND „CE‟ IS „Z‟ THEN „U‟ IS „N‟
IF „E‟ IS „N‟ AND „CE‟ IS „P‟ THEN „U‟ IS „Z‟
IF „E‟ IS „Z‟ AND „CE‟ IS „N‟ THEN „U‟ IS „N‟
IF „E‟ IS „Z‟ AND „CE‟ IS „Z‟ THEN „U‟ IS „Z‟
IF „E‟ IS „Z‟ AND „CE‟ IS „P‟ THEN „U‟ IS „P‟
F „E‟ IS „P‟ AND „CE‟ IS „N‟ THEN „U‟ IS „Z‟
IF „E‟ IS „P‟ AND „CE‟ IS „Z‟ THEN „U‟ IS „P‟
IF „E‟ IS „P‟ AND „CE‟ IS „P‟ THEN „U‟ IS „P‟
a) Una vez conocidas las reglas a aplicar en cada caso, podemos estructurar el
programa de manera que ingresemos 2 entradas (x1 y x2) de valores
cualesquiera y sean procesadas en la base de 4 o 9 reglas (dependiendo del
gusto y/o necesidad del usuario), para que finalmente sean ploteada la señal
de control defuzzyficada así como la salida final que debe ser -200, 0 ó +200.
i=input('Ingresa el valor de la entrada 1 : ');
disp(['x1 = ',num2str(i)])
j=input('Ingresa el valor de la entrada 2 : ');
disp(['x2 = ',num2str(j)])
disp(' ')
var=input('Elegir la cantidad de reglas a considerar (4 Reglas), (9 Reglas) :
');
disp(' ')
disp(['Numero de reglas = ',num2str(var)])
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 35
b) De ser elegida la opción de 4 reglas se procederá con implementar el
algoritmo basado en su base de reglas, comparando los grados de pertenencia
de ambas entradas (x1 y x2) y tomar el valor mínimo, para luego comparar
(mínimo) este valor con la salida respectiva dependiendo de cada regla, y
finalmente de las 4 reglas obtener la salida máxima (superposición de gráficas)
y a este arreglo aplicarle la función de defuzzyficación y obtener un valor que
luego será clasificado entre -200, 0, +200.
if var == 4
disp(' ')
disp('HAS ELEGIDO LA FUZZYFICACION POR 4 REGLAS')
disp(' ')
mf_calificada = zeros(4,puntos_n);
w1_1 = trian_mf(i, param_in_1(1,:)); % E = N
w2_1 = trian_mf(i, param_in_1(3,:)); % E = P
w1_2 = trian_mf(j, param_in_2(1,:)); % CE = N
w2_2 = trian_mf(j, param_in_2(3,:)); % CE = P
comp_1 = min(w1_1,w1_2); % MIN (E=N, CE=N)
mf_calificada(1,:)=min(comp_1,mf_out(1,:)); % MIN (ANTERIOR, U=N)
comp_2 = min(w1_1,w2_2); % MIN (E=N, CE=P)
mf_calificada(2,:)=min(comp_2,mf_out(2,:)); % MIN (ANTERIOR, U=Z)
comp_3 = min(w2_1,w1_2); % MIN (E=P, CE=N)
mf_calificada(3,:)=min(comp_3,mf_out(2,:)); % MIN (ANTERIOR, U=Z)
comp_4 = min(w2_1,w2_2); % MIN (E=P, CE=P)
mf_calificada(4,:)=min(comp_4,mf_out(3,:)); % MIN (ANTERIOR, U=P)
conjunto_out_mf = max (mf_calificada); % Superposición de gráficas
salida=defuzzy(y,conjunto_out_mf,1); % Defuzzificación por C.M.
disp('Valor de salida defuzzy por 4 reglas:')
disp(salida)
if salida>=-200 && salida<-100 % Limitador en salida
respuesta=-200;
elseif salida>=-100 && salida<0
respuesta=0;
elseif salida>=0 && salida<100
respuesta=0;
elseif salida>=100 && salida<200
respuesta=200;
else respuesta=200;
end
disp('Valor de salida final por 4 reglas:')
disp(respuesta)
c) Una vez realizado este proceso resta obtener los resultados y mostrarlos en
un “plot”. Supongamos que ingresamos las entradas de E = -89 y CE = 69
(estos valores están siendo tomados al azar con el fin simplemente de mostrar
algún resultado indiferente).
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 36
figure(2)
subplot(2,1,1)
plot([salida salida],[0 1],'r','LineWidth',5),hold
plot(y,conjunto_out_mf,'k','LineWidth',3)
title('\fontsize{10} \color{blue} SALIDA DEFUZZY 4 REGLAS')
grid
axis([-200 200 0 1])
subplot(2,1,2)
plot(y,conjunto_out_mf,'r','LineWidth',2),hold
plot([respuesta respuesta],[0 1],'b','LineWidth',5)
title(['\fontsize{10} \color{blue} SALIDA FINAL 4 REGLAS'])
grid
axis([-200 200 0 1])
Ingresa el valor de la entrada 1 : -89
x1 = -89
Ingresa el valor de la entrada 2 : 69
x2 = 69
Elegir la cantidad de reglas a considerar (4 Reglas), (9 Reglas) : 4
Numero de reglas = 4
HAS ELEGIDO LA FUZZYFICACION POR 4 REGLAS
Valor de salida defuzzy por 4 reglas:
0
Valor de salida final por 4 reglas:
0
Fig 39.- Salida del fuzzyficador y defuzzificador de 4 Reglas
-200 -150 -100 -50 0 50 100 150 2000
0.5
1 SALIDA DEFUZZY 4 REGLAS
-200 -150 -100 -50 0 50 100 150 2000
0.5
1 SALIDA FINAL 4 REGLAS
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 37
De ser elegida la opción de 9 reglas se procederá también con implementar el
algoritmo basado en su base de reglas siguiendo el mismo criterio que la
opción anterior en la toma de valores mínimos, máximos, defuzzificación y
limitador.
elseif var==9
disp(' ')
disp('HAS ELEGIDO LA FUZZYFICACION POR 9 REGLAS')
disp(' ')
mf_calificada = zeros(9,puntos_n);
w1_1 = trian_mf(i, param_in_1(1,:)); % E = N
w2_1 = trian_mf(i, param_in_1(2,:)); % E = Z
w3_1 = trian_mf(i, param_in_1(3,:)); % E = P
w1_2 = trian_mf(j, param_in_2(1,:)); % CE = N
w2_2 = trian_mf(j, param_in_2(2,:)); % CE = Z
w3_2 = trian_mf(j, param_in_2(3,:)); % CE = P
comp_1 = min(w1_1,w1_2); % MIN (E=N, CE=N)
mf_calificada(1,:)=min(comp_1,mf_out(1,:)); % MIN (ANTERIOR, U = N)
comp_2 = min(w1_1,w2_2); % MIN (E=N, CE=Z)
mf_calificada(2,:)=min(comp_2,mf_out(1,:)); % MIN (ANTERIOR, U = N)
comp_3 = min(w1_1,w3_2); % MIN (E=N, CE=P)
mf_calificada(3,:)=min(comp_3,mf_out(2,:)); % MIN (ANTERIOR, U = Z)
comp_4 = min(w2_1,w1_2); % MIN (E=Z, CE=N)
mf_calificada(4,:)=min(comp_4,mf_out(1,:)); % MIN (ANTERIOR, U = N)
comp_5 = min(w2_1,w2_2); % MIN (E=Z, CE=Z)
mf_calificada(5,:)=min(comp_5,mf_out(2,:)); % MIN (ANTERIOR, U = Z)
comp_6 = min(w2_1,w3_2); % MIN (E=Z, CE=P)
mf_calificada(6,:)=min(comp_6,mf_out(3,:)); % MIN (ANTERIOR, U = P)
comp_7 = min(w3_1,w1_2); % MIN (E=P, CE=N)
mf_calificada(7,:)=min(comp_7,mf_out(2,:)); % MIN (ANTERIOR, U = Z)
comp_8 = min(w3_1,w2_2); % MIN (E=P, CE=Z)
mf_calificada(8,:)=min(comp_8,mf_out(3,:)); % MIN (ANTERIOR, U = P)
comp_9 = min(w3_1,w3_2); % MIN (E=P, CE=P)
mf_calificada(9,:)=min(comp_9,mf_out(3,:)); % MIN (ANTERIOR, U = P)
conjunto_out_mf = max (mf_calificada); % Superposición de gráficas
salida=defuzzy(y,conjunto_out_mf,1); % Defuzzificación por C.M.
disp('Valor de salida defuzzy por 9 reglas:')
disp(salida)
if salida>=-200 && salida<-100 % Limitador en salida
respuesta=-200;
elseif salida>=-100 && salida<0
respuesta=0;
elseif salida>=0 && salida<100
respuesta=0;
elseif salida>=100 && salida<200
respuesta=200;
else respuesta=200;
end
disp('Valor de salida final por 9 reglas:')
disp(respuesta)
Ingresa el valor de la entrada 1 : -89
x1 = -89
Ingresa el valor de la entrada 2 : 69
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 38
x2 = 69
Elegir la cantidad de reglas a considerar (4 Reglas), (9 Reglas) : 9
Numero de reglas = 9
HAS ELEGIDO LA FUZZYFICACION POR 9 REGLAS
Valor de salida defuzzy por 9 reglas:
-36.0360
Valor de salida final por 9 reglas:
0
figure(2)
subplot(2,1,1)
plot([salida salida],[0 1],'r','LineWidth',5),hold
plot(y,conjunto_out_mf,'k','LineWidth',3)
title('\fontsize{10} \color{blue} SALIDA DEFUZZY 9 REGLAS')
grid
axis([-200 200 0 1])
subplot(2,1,2)
plot(y,conjunto_out_mf,'r','LineWidth',2),hold
plot([respuesta respuesta],[0 1],'b','LineWidth',8)
title(['\fontsize{10} \color{blue} SALIDA FINAL 9 REGLAS'])
grid
axis([-200 200 0 1])
Fig 40.- Salida del fuzzyficador y defuzzificador de 9 Reglas
Finalmente si alguna de las opciones es elegida erróneamente el programa
emitirá un mensaje de error.
else
disp(' ')
disp('¡¡¡ NUMERO DE REGLAS INCORRECTO !!!')
disp(' ')
end
-200 -150 -100 -50 0 50 100 150 2000
0.5
1 SALIDA DEFUZZY 9 REGLAS
-200 -150 -100 -50 0 50 100 150 2000
0.5
1 SALIDA FINAL 9 REGLAS
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 39
2.- Fuzzy System Designer de 9 reglas en código puro en Labview
Una vez realizados todas estas experiencias en Matlab empezamos a implementar el código en Labview de 9 reglas, para lo cual realizamos los siguientes pasos: Paso 1.- Obtención de un MF trapezoidal TRAPEZE: este sub-vi tendrá el objetivo de FUZZIFICAR, esto quiere decir
convertir las entradas exactas (números reales) al dominio difuso (valores
entre cero y uno). Esta función esta implementada en el programa LABVIEW
tal y como sigue:
Aviso.- este es un indicador que nos informa si los valores ingresados son
ascendentes (a<b<c<d). Esto quiere decir que si a, b, c y d son ingresados
ascendentemente el aviso mostrara “parámetro legal” en caso contrario
mostrara “parámetro ilegal”.
Fig 41.- Diagrama de bloques del “aviso”
Parámetros de entrada.- los parámetros de entrada está formado por un
array unidimensional de cuatro elementos. Estos elementos son los límites
del trapecio que se forma al ingresarle una trama de datos (array).
Fig 42.- Diagrama de bloques del ingreso de “parámetros”
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 40
Entrada.- es el elemento o conjunto de elementos (array) que se quiere
FUZZIFICAR.
Fuzzificación.- es el resultado de la FUZZIFICACION (convertirlo al
dominio difuso, entre cero y uno).
Fig 43.- Diagrama de bloques del trapecio
La programación en conjunto es la siguiente:
Panel de control
El sub-vi “TRAPEZE” es el siguiente:
Sub-vi “TRAPEZE”
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 41
Paso 2.- Sub-Vi de Entradas de 3 MF’s
Para realizar esta etapa se tomaron en cuenta MF‟s de forma trapezoidal que fueron agrupados en un SubVI, el cual se basa en la programación del trapecio antes expuesta. Esta etapa muestra un Array de parámetros a ser ingresados en cada MF para especificar la forma exacta del trapecio, no obstante debemos indicar que convertiremos al trapecio en triángulo haciendo que 2 parámetros sean iguales, por ejemplo:
Además se especifica un aviso para saber si están siendo bien empleados los parámetros.
Debemos mencionar también que para cada MF se mostrarán las salidas respectivas y la entrada será la misma, pues debe ser evaluada en los 3 Member Shift Factor para luego pasar a la base de reglas. El SubVI resultante es de la forma:
Fig 44.- SubVI de Entradas con 3 MF’s
Paso 3.- Obtención de la Sub-vi Linspace Este sub-vi tiene el objetivo de generar una trama de datos (array) cuyas
entradas, parámetros obtenidos y salidas son:
N: es la cantidad de elementos que necesitemos generar entre los valores de “ti” y “tf”.
ti: es el valor con el que queremos que empiece nuestra trama de datos.
tf: es el valor con el que queremos que finalice nuestra trama de datos.
n: es la cantidad de espacios entre dato y dato.
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 42
h: es el paso entre dato y dato que se obtiene con las variables N, ti y tf.
tn: es el elemento n-enésimo de todo el array.
x: es el array resultante de los parámetros obtenidos.
Para crear este LINSPACE en LABVIEW seguimos las relaciones expuestas en
la figura siguiente:
Fig 45.- Diagrama de bloques del “LINSPACE”
Como podemos observar solo es necesario tener claro estas sucesiones y
plasmarlas en el diagrama de bloques de LABVIEW.
Para la creación del array “x” utilizamos el “Reshape Array”, el cual cambia la
longitud del array “x1” (array unidireccional de un elemento) a un array
unidireccional de “N” elementos. A su vez éste será el array de inicialización
del bloque de realimentación de “Replace Array Subset” (generado
automáticamente al unir la entrada y salida del mismo).
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 43
Fig 46.- Panel de control del “LINSPACE”
Paso 4.- Obtención de la función Singleton Para la realización de esta etapa se empleo el SubVI linspace para poder así
generar un universo de discurso cuyos valores de inicio, final y número de elementos pueden ser controlados. A la vez se genera un Array conformado por el valor del universo en el que se encontrará el singleton (por ejemplo: si el universo posee 1000 elementos de -200 a +200 y queremos que el singleton se ubique en la posición ocupada por +10, pues creamos un Array de la misma dimensión que el universo pero con puros valores de +10 que son ingresados por el control de nombre “Patrón”). Una vez realizado ello se comparan ambos Arrays de tal forma que en el momento en que coincidan los +10 (siguiendo el ejemplo) de ambos Arrays se genere el valor de “1” (resultado de la igualdad) y en todos los otros instantes se generen “0”s. Además debemos indicar que existe un generar de Array de puros elementos “0” para garantizar que el Array Final (Singleton) haya sido inicializado en valor por defecto. Finalmente se plotean los resultados de resultar conveniente por el usuario.
Fig 47.- SubVI de La Función Singleton
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 44
Paso 5.- Obtención de la Salida con 3 MF’s
En esta etapa los MF‟s son los Singletons antes creados y ahora agrupados de modo que constituyan la salida. Los parámetros para el Linspace de los 3 MF‟s son el mismo (pues poseen el mismo universo de discurso: X1, X2 y X3 iguales), pero los valores en los cuales se harán presentes los Singletons (Patrón Y1, Y2 y Y3) son -200, 0 y +200. Debemos indicar además que en el ploteo, el gráfico debe ser configurado en modo Barras para poder visualizar el Singleton, de lo contrario solo se verá un punto en el grado de Pertenencia 1.
Fig 48.- SubVI de la Salida con 3 MF’s
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 45
Paso 6.- Base de Reglas
En este paso programamos el algoritmo de 9 reglas de acuerdo a lo conocido y teniendo como base la programación antes realizada en Matlab. Cabe mencionar que en esta etapa estamos realizando únicamente las comparaciones por minimización.
Figura N.- Base de 9 Reglas
Fig 49.- Base de reglas en Labview
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 46
Paso 7.- Implementamos el SubVI Maximización
Este SubVI permitirá obtener la superposición de gráficas, es decir los valores máximos obtenidos luego de la aplicación de cada regla, para constituir finalmente un arreglo final que pasará a la defuzzyficación.
Fig 50.- Maximización en el Proceso de Mandani
Paso 8.- Obtención del SubVI Defuzzy Este SubVI está basado en el método del centro de masa. Se obtendrá un valor que luego será limitado en el Paso 9.
Fig 51.- Defuzzy: Centro de Masa o Centroide
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 47
Paso 9.- Función Limitador
Al estarse empleando en la salida únicamente 3 Singletons, el valor final de la salida debe ser: -200, 0 ó +200. Para ello creamos un limitador de la defuzzyficada de tal manera que el valor real de la salida y por ende de la señal de control tome esos tres valores antes definidos.
Fig 52.- Limitador para obtener Salida Final para la señal de control
Paso 10.- Ploteos Este paso no requiere de mayores explicaciones, simplemente se trata de plotear los resultados obtenidos.
Fig 53.- Programación de Ploteos
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 48
Paso 11.- Programación completa
Finalmente la programación completa del SubVI denominado FIS_9_RULER es la siguiente:
Fig 54.- Programación Final: FIS_9_RULER
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 49
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 50
3.- Simulación y Tiempo Real
Finalmente luego de haber concluido con la explicación todos los SubVi‟s
construidos para lograr el diseño final de nuestro PID Difuso de la figura 32 en
código Puro, tenemos las siguientes pestañas para la prueba en Tiempo Real:
Fig 55.- Panel Frontal del Programa
Fig 56.- Panel Frontal de resultados del SubVI FIS_9_RULES
Finalmente con los toolkits de la NIDAQ PCI 6221 configurados
adecuadamente para la prueba final, y se obtuvieron buenos resultados como
se puede constatar en la figura 57.
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 51
Fig 57.- Resultados en tiempo Real para nuestro control DPID con 9
reglas por código puro
VII.- Conclusiones
1. Acorde de la necesidad del usuario depende la recomendación de emplear 4 o 9 reglas, sin embargo debemos observar que si los MF‟s de la salida fuesen cualquier otra figura excepto singleton, los valores defuzzificados no tendrían que ser limitados y serían de un mayor rango los de 9 reglas.
2. Debemos observar que en todos los bucles “While” se ha cambiado el
símbolo del Stop, por otro cuyo símbolo es una flecha circular que
indican repetición, esto debido a que al poseer varios SubVI con bucles
del mismo tipo el programa no funciona adecuadamente pues el bucle
del SubVI más interno se ejecuta sólo y los restantes no tienen efecto;
por tal motivo se debe cambiar el símbolo del Stop por el de las flechas
continuas.
3. Implementar un algoritmo de 25 reglas podría ser tomado en cuenta en
futuras experiencias, sin embargo la planta empleada es de respuesta
rápida, por tanto un número muy alto de reglas como lo es 25, en vez
de mejorar la señal de control, la vuelve oscilatoria (inestable) por
requerir mayor tiempo de procesamiento. Precisamente alta cantidad de
reglas son empleadas para plantas que poseen respuestas lentas
(Planta de Nivel o mejor aún Planta de Temperatura).
Universidad Nacional Del Callao - Control Inteligente 2012-A
M.Sc. Ricardo Rodriguez Bustinza 52
4. Debemos recordar que las tarjetas de adquisición de datos dan valores
análogos de salida de hasta +/-10 Voltios, por tanto la señal de control
empleada para nuestra experiencia debe ser limitada para no tomar
valores elevados como los menciona el algoritmo de control
implementado de acuerdo a los universos de discurso del Fuzzy
Controler.
5. Cuando se emplea un SubVI elaborado en código puro por el
estudiante, puede ser que se necesite variar alguno de los parámetros
del PID del controlador, aunque de manera ínfima.
6. Una base de la reglas con tres entradas llega a ser bastante grande y la acción íntegra resulta una molestia. Por consiguiente es común separar la acción integral en el controlador difuso PD+I (DPD+I).
7. El empleo de la tarjeta PCI 6221 para las pruebas en tiempo real
permite al controlador entregar señal de control negativa (+/- 10V), esto es importante ya que por limitaciones de hardware a veces dejamos de entregar este voltaje que puede tener acción de control para la planta, y se pierde, trayendo como resultado un control limitado.
8. El controlador DPID nos ofrece la ventaja de mejorar la performance de control de un PID análogo con sintonía común que normalmente presenta fallas de oscilación o de sobrepaso en lazo cerrado. Como se observó en las pruebas de tiempo real, el algoritmo DPID elimina el sobrepaso casi en su totalidad y también entrega una señal de control con comportamiento más adecuado.
9. De las pruebas en tiempo real pudimos constatar la ventaja de emplear lógica difusa para el diseño de un controlador genérico como lo es el PID, que normalmente presenta fallas en procesos como los subamortiguados. La señal de control que se entrega tiene trayectoria suave y no tiene sobrepicos bruscos de tensión, lo que resultado beneficioso para la robustez del control, a diferencia de la señal de control que presenta un PID Ziegler Nichols común.