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

[email protected]

Flores Bustinza, Edwing Irwing

[email protected]

Torres Chavez, Jonathan Emmanuel

[email protected]

mailto:[email protected]




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:


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.

√

√


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:


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


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



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:



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



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.



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



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



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



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



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:



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:



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:



%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)')


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')


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)')


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')


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



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



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



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



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



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



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.



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



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



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



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:



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



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



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.



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



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



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)])



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;


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).



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



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)


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)


comp_5 = min(w2_1,w2_2); % MIN (E=Z, CE=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)


comp_8 = min(w3_1,w2_2); % MIN (E=P, CE=Z)


comp_9 = min(w3_1,w3_2); % MIN (E=P, CE=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;


respuesta=0;


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



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



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”



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”



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.



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).



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



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



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



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



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



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





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.



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).



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.

Documents

Diseño de un Controlador PID Difuso para una planta de Segundo Orden Sub-amortiguada usando LABVIEW