92048254 Control Fuzzy PID Angulo Salazar

1

Control Fuzzy PID en una planta de luminosidad en Matlab mediante comunicación Serial

Karen Nataly Angulo Acunso José Julián Salazar Vaca


Karen N. Angulo

José J. Salazar

Estudiantes de Ingeniería Mecatrónica de la Escuela Politécnica del Ejército

1. RESUMEN

En el siguiente artículo se presenta la implementación de un control PID Fuzzy para

una planta de iluminación manejada por un PWM, determinando las reglas para su

respectivo comportamiento a través de sus variables de entrada y salida, mediante

la programación en Matlab realizando la comunicación serial con el computador.

Se detallará el procedimiento necesario para el cálculo de las variables que

intervienen en el control Fuzzy PID y la relación existente entre ellas.

Se realiza el análisis de estabilidad, se implementa el control PD en lazo cerrado y un control difuso, donde el control difuso hace la función de compensador para eliminar el error en estado estable.

2. ABSTRACT

The present paper describes implementation for lighting plant driven by PWM,

setting the rules for respective controlled behavior using the appropiate input and

output variables programming in matlab stablishing serial communication

between circuit and PC.

It will be detailed the neccesary procedure to calculate the variables which will

work in fuzzy PID control and relationship between them, stability analysis will be

done, setting a PD closed-loop control and Fuzzy control, where the fuzzy one

makes the function of compensator for deleting steady state error.

3. PALABRAS CLAVE

Fuzzy, PID, Sintonización, Error, Comunicación Serial, derivada, compensador, set

point, Kp. FPD controllers, FPD+I Controllers.

4. FILIACIÓN DEL AUTOR

Karen Nataly Angulo Acunso [email protected] +59384682247

José Julián Salazar Vaca [email protected] +59384587028

Estudiantes de Ing. Mecatrónica 9no nivel cursando la materia de Automatización

Industrial Mecatrónica.

mailto:[email protected]

mailto:[email protected]

2



5. INTRODUCCIÓN

5.1 Objetivos

Diseñar un controlador Fuzzy-PID para una planta de iluminación mediante la

programación en Matlab y la comunicación serial para adquirir los datos.

5.2 Objetivos Específicos

Analizar y establecer el sistema.

Determinar las constantes del controlador PID que estabilice la planta.

Escoger el mejor control de acuerdo a la respuesta de la planta

Realizar las reglas para el control difuso del error en el controlador PID.

5.3 Alcance de estudio

El alcance del presente proyecto es fortalecer los conceptos obtenidos de los

controladores PID y Fuzzy relacionándolos entre sí para la optimización del

controlador del sistema logrando que el lector utilice el documento para

conocer el procedimiento que debe seguir en el control de una planta de

iluminación.

Además se puede utilizar el artículo para elección del tipo de controlador de

acuerdo a la respuesta requerida por el lector mayor rapidez o mayor

estabilización y de acuerdo a esto parámetros decidir el controlador que más

se ajuste o si es necesario utilizarlos juntos.

6. GENERALIDADES

6.1 Controlador FUZZY PID

Cuando el problema de control es regular la salida del proceso en torno a un

punto de ajuste, es posible considerar el error como una entrada incluso en un

controlador difuso y la integral del error y la derivada del error puede ser usado

como entrada también.

Sin embargo en el controlador PID es difícil hablar del efecto de cada factor de

ganancia en el tiempo de subida, sobre pico, y el tiempo de establecimiento

porque los controladores fuzzy PID exigen mayores cambios además de

trabajar con su no linealidad y ganancias.

Se requiere encontrar un procedimiento de ajuste sistemático haría más simple

la instalación de controladores difusos.

Los controladores PID pueden ser sintonizados en una variedad de formas,

incluyendo la sintonización de Ziegler-Nichols puesto que dan forma al bucle,

los métodos de análisis mediante la optimización, la colocación del autotuning.

3



6.2 Control Fuzzy Proporcional y Derivativo

La acción derivativa ayuda a predecir el error y el control proporcional–

derivado utiliza la acción derivada para mejorar la estabilidad de lazo cerrado.

La estructura del controlador PID es:

Ec(1)

La señal de control es proporcional a una estimación de los segundos por

delante del error Td, donde la estimación se obtiene por la interpolación. Para

Td=0 el control es puramente proporcional, cuando Td se aumenta

gradualmente, se vuelve amortiguado. Si es demasiado grande Td el sistema se

vuelve sobreamortiguado y comenzará a oscilar de nuevo.

Fig1.Fuzzy PD controller

La entrada del controlador fuzzy proporcional derivativo (FPD) es el error y la

derivada del error. En el control fuzzy el último término es usualmente llamado

cambio del error.

Ec(2)

Esta es una aproximación discreta al cociente diferencial utilizando una

diferencia en atraso. En los controladores anteriores no se usaba el tiempo de

muestreo para determinar el cambio del error.

La salida del controlador es una función no lineal del error y del cambio del

error.

Ec(3)

Ec(4)

Ec(5)

4



Ec(6)

La aproximación corresponde a la sustitución de la superficie de fuzzy de

entrada-salida con un plano.

La aproximación es mejor si se escoge el universo de salida sea la suma de la

entrada de los universos de entrada.

El fuzzy PID puede ser aplicado cuando el control proporcional es inadecuado.

El término derivativo reduce el sobre pico, pero puede ser sensible al ruido o

bien a un cambio abrupto a la referencia causando el fenómeno llamado

derivate kick.

6.3 Control Incremental

Si hay un error en estado estacionario, es necesaria la acción integral.

La acción integral aumentará la señal de control si hay un error positivo

pequeño, no importa cuán pequeño sea el error, la acción integral siempre

volverá a cero en el estado de equilibrio. Es posible obtener un controlador

fuzzy PID utilizando el error y el cambio en el error como entradas a la base de

reglas.

La experiencia muestra, que es bien difícil de escribir las reglas para el acción

integral. No se ahondará en este concepto debido a que el presente artículo no

es usado.

Fig2. Control Fuzzy integral

6.4 Control Integral- proporcional y derivativo.

Es sencillo visualizar en un controlador Fuzzy PID con tres términos de entrada:

error, integral del error y derivada del error. Una regla basada con 3 entradas,

sin embargo se vuelve un valor grande, las reglas del error suelen ser un

problema.

Entonces es común separar la acción integral como un controlador fuzzy PD+I.

El error integral es calculado.

Ec(7)

5



Fig3. Controlador fuzzy PD+I

El controlador es así una función de 3 entradas.

Ec(8)

La aproximación lineal es:

Ec(9)

En la última línea se asume que GE no es cero:

Ec(10)

Ec(11)

Ec(12)

Este controlador provee todos los beneficios de un controlador PID, pero

también las desventajas del derívate kick e integrador winup.

Tabla1. Rápida referencia de los controladores.

7. MATERIALES Y MÉTODOS 7.1 Diseño del circuito

Para el diseño de la planta se estableció el funcionamiento de acuerdo al control que se desea realizar.

6



La variación de luminosidad requiere un PWM para la variar la frecuencia del foco, para evitar realizar un circuito de potencia se reemplazó el foco por una lámpara de leds que consume una potencia mucho menor a la de un foco. Para el control es necesario medir la cantidad de luminosidad por lo tanto se requiere un sensor, el escogido es una fotorresistencia (LDR) que varía valor de resistencia de acuerdo a la luminosidad que sensa.

7.2 Implementación del circuito Para realizar el circuito se deben establecer el acondicionamiento de las señales para el funcionamiento de los componentes. Divisor de Voltaje El sensor que se utiliza (LDR) tiene una salida de variación de resistencia, debido a que este tipo de señal un microcontrolador no leería se acondicionó a voltaje mediante un circuito divisor, el cual consta de una alimentación de voltaje de 5V, una resistencia de 10K y la salida del LDR en paralelo; de esta manera se obtiene una variación de voltaje de 0-3.5V que será la variable de entrada al controlador PWM El PWM es un variador de frecuencia, en el presente proyecto se aplica para la variación de luminosidad de la lámpara. Con la ayuda de un microcontrolador PIC16F877A se realizará la generación del PWM, generando un código de programación que realiza la conversión de voltaje a porcentaje de frecuencia de salida. Dentro del pic también se realiza la programación de la comunicación y la librería para el control de LCD para visualizar los datos. A continuación se muestra el programa del PIC

#include <serial232_pic.h>

#include <flex_lcd.c>

float pv=0, send=0;

int16 pwm=0;

int16 pid=0;

char pidc=0;

#int_RDA

void RDA_isr(void)

{

pidc=getch();

if (pidc=='0')

7



{pid=0;}

else

{pid=pidc;}

}

void main()

{ setup_adc_ports(AN0_AN1_VSS_VREF);

setup_adc(ADC_CLOCK_DIV_8);

setup_psp(PSP_DISABLED);

setup_spi(SPI_SS_DISABLED);

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);

setup_timer_1(T1_DISABLED);

setup_timer_2(T2_DIV_BY_16,249,1);

setup_ccp1(CCP_PWM);

setup_ccp2(CCP_OFF);

set_pwm1_duty(0);

set_pwm2_duty(0);

setup_comparator(NC_NC_NC_NC);

enable_interrupts(INT_RDA);

enable_interrupts(GLOBAL);

lcd_init();

while(true)

{

set_adc_channel(0);

delay_us(10);

int1 done = adc_done();

8



while(!done) {

done = adc_done();

}

pv=read_adc();

send=pv*5/1023;

pwm=pid*4;//envio de duty cycle por porcentaje

set_pwm1_duty(pwm);

delay_ms(20);

lcd_gotoxy(1,1);

printf(lcd_putc,"SP %lu PWM %lu",pid,pwm);

printf(lcd_putc," ");

lcd_gotoxy(1,2);

printf (lcd_putc,"PV= %2.2f V",send);

printf ("%.2fF",send);

delay_us(10);

}

} Acondicionamiento a la salida del PWM Debido a que la salida PWM del PIC maneja corrientes bajas, se requiere aumentar la corriente para el funcionamiento de la lámpara de leds por tal motivo se requirió un transistor 2N3904 para limitar la corriente de la lámpara y controlar la variación de frecuencia. Comunicación Serial Para la comunicación serial se utiliza un Max232 que realiza la conversión de TTL a serial y conector DB9 en el que se realizará la conexión de los pines con el transmisor y receptor serial del PIC y el computador.

9



Fig4.Circuito implementado

7.3 Diseño del Controlador PID - Determinación de la función de transferencia y constantes de PID

Antes de realizar la programación del controlador en Labview se debe encontrar las constantes Kc, Ti y Td. Para determinar estas constantes se requiere la función de transferencia de la planta, para lo cual se realizan mediciones de entrada y salida. Mediante una función de Matlab (Ident) se ingresan los datos tomados y se determina la función de transferencia.

Fig5. Función Ident para determinar la función de transferencia

10



Con la ayuda de esta función se obtienen las constantes para la función de transferencia.

Fig6. Función de transferencia obtenida

Una vez determinada la función de transferencia se escoge el método para el diseño del controlador: el método escogido es Ziegler Nichols mediante una programación en matlab se encuentran las constantes.

11



Obteniendo las constantes, en la gráfica podemos notar que el overshoot obtenido es de 44.4% :

Fig7.Gráfica de controlador PID

A continuación mostraremos la gráfica del controlador luego de la sintonización realizada para

el artículo Control Fuzzy y PID en una planta de luminosidad en Labview de los mismos

autores. El objetivo del presente estudio es alcanzar esta sintonización mediante un control

Fuzzy PD o Fuzzy PD+I.

12



Fig8. Gráfica de estabilización del controlador

7.4 Cálculos Se realizaron cálculos para dos controladores Fuzzy PD y Fuzzy PD+I de acuerdo a lo establecido anteriormente en el punto 6.4.

Estos valores fueron obtenidos por la sintonización en matlab por el método de

Ziegler-Nichols.

[ ]

[ ]

Debido a que las variaciones del error en nuestro sistema son mayores que 1 en

algunos casos se decidió usar un rango de -50 a 50 de esa manera GE tendría

una ganancia unitaria.

13



Ec(13)

Ec(14)

Ec(15)

Con los valores obtenidos se procede a realizar la programación para los diferentes tipos de controladores Fuzzy PID.

7.5 Reglas para la fuzzificación del error

CE/E NB NS ZE PS PB

NB PB PB PS PS ZE

NS PB PS PS ZE NS

ZE PS PS ZE NS NS

PS PS ZE NS NS NB

PB ZE NS NS NB NB

Tabla2. Reglas para la fuzzificación

CE : Cambio en el error E: Error PB: Positive Big PS: Positive Small ZE: Zero NS: Negative Small NB: Negative Big Los rangos para las variables se detallaran a continuación en la explicación de la fuzzificación.

7.6 Programación en Matlab

o Controlador Fuzzy PD con derivada en el error con filtro.

Es el controlador fuzzy utilizado por defecto en el cual se usa la derivada del error. Con un filtro que asienta la señal cuando se empieza a disparar. %ESCUELA POLITECNICA DEL EJERCITO %AUTOMATIZACION MECATRONICA %ANGULO KAREN %SALAZAR JOSE JULIAN %----------------------------------------------------- %CONTROL FUZZY PD DE ILUMINACION %Uso de derivada del error y filtro

14



%----------------------------------------------------- warning off clc clear all fismat=readfis('FPD'); l=0; pidc = 0; sp=input('Ingrese % luminocidad: '); sp2=sp/2; kp=7.5; %0.018; kd=0.65595; %0.0000045; ki=0.017798; %0.0000006722; GE=1; GCE=3.0354; GIE=0.08236; GU=0.2161; error1=0; error2=0; % Deri=0; Io=0; sent=0; lastsent=0; i=0; clear tgrafy clear tgrafx clear show % Configuraion recepcion---------------------------- s=serial('COM7'); set(s,'BaudRate',19200,'DataBits',8,'Parity','none','StopBits',1,'FlowControl','none','timeout',5,'terminator',70,'inputbuffersize',1024,'requesttosend','off'); num=30; tabla=zeros(num,3); while (1) pidc = sp2; i=i+1; sent=0; fopen(s) dato=fscanf(s); pause(0.05) fclose(s) dato=strrep(dato,'F',''); daton=str2double(dato); sent=5.0982*(daton^3)-3.3542*(daton^2)+17.09*daton-0.1518;

15



%Perturbacion-------------------------------------------- if (sent >= 60) && (sent<=120) sp2=15; elseif (sent >= 121) && (sent <= 250) sp2=6; elseif (sent>=251) sp2=1; else sp2=sp/2; end; %Filtro---------------------------------------------------- if (sp2 >= sent+20)||(sp2 <= sent-20) sent=sp2; end; %----------------------------------------------------------- %--------------PID------------------ error1=sp2-sent; %dinput=sent-lastsent; %Prop=(kp*error1); %Inte=(Io*ki*error1); %Io=Inte; Deri=(kd*(error1-error2)/3); %Deri=-1*(kd*(dinput)/3); %pid=(Prop+Inte+Deri); Deriv=Deri*GCE; lastsent=sent; error2=error1; u=evalfis([error1 Deriv], fismat); out=u*GU; %----Generacion de señal FPD----------------------------- pidc=convergent(sp2*(1+out)); if (pidc >= 49) pidc = sp2; elseif (pidc <= 0) pidc = sp2; end; clc sp sent2=sent*2; disp(' # % Luz Error') tabla(i,1)=i; tabla(i,2)=sent2; tabla(i,3)=error2; disp(tabla) %----------- grafica------------------------------ tgrafy(1,i)=sp;

16



tgrafy(2,i)=tabla(i,2); tgrafx(i)=i; %t=whos('envio'); % Configuraion envio 1----------------------------- set(s,'outputBufferSize',512); %t.bytes fopen(s) fprintf(s,'%s',pidc) pause(0.05) fclose(s) l=l+1; if l==10 cc=input('¿Continuar?: 1/0 --> '); if (cc == 1) sp=0; sp=input('Ingrese % luminocidad: '); sp2=sp/2; % sent=0; % lastsent=0; pidc=sp2; l=0; error1=sp2-sent; error2=0; % Deri=0; elseif (cc == 0) break; end; end; plot(tgrafx,tgrafy) title('Respuesta del Sistema') xlabel('Iteracion') ylabel('Respuesta') AXIS([0 i 0 100]) end

o Controlador Fuzzy PD con derivada de salida con filtro.

Se analizó también un controlador Fuzzy PD con derivada a la salida para analizar posibles problemas relacionados con el derívate kick. De igual manera se usó un filtro para evitar que el valor de la salida se dispare.

warning off clc clear all fismat=readfis('FPD'); l=0; pidc = 0; sp=input('Ingrese % luminocidad: ');

17



sp2=sp/2; kp=7.5; %0.018; kd=0.65595; %0.0000045; ki=0.017798; %0.0000006722; GE=1; GCE=3.0354; GIE=0.08236; GU=0.2161; error1=0; error2=0; % Deri=0; Io=0; sent=0; lastsent=0; i=0; clear tgrafy clear tgrafx clear show % Configuraion recepcion---------------------------- s=serial('COM7'); set(s,'BaudRate',19200,'DataBits',8,'Parity','none','StopBits',1,'FlowControl','none','timeout',5,'terminator',70,'inputbuffersize',1024,'requesttosend','off'); num=30; tabla=zeros(num,3); while (1) pidc = sp2; i=i+1; sent=0; fopen(s) dato=fscanf(s); pause(0.05) fclose(s) dato=strrep(dato,'F',''); daton=str2double(dato); sent=5.0982*(daton^3)-3.3542*(daton^2)+17.09*daton-0.1518; %Perturbacion-------------------------------------------- if (sent >= 60) && (sent<=120) sp2=15; elseif (sent >= 121) && (sent <= 250) sp2=6; elseif (sent>=251) sp2=1; else sp2=sp/2; end; %Filtro---------------------------------------------------- if (sp2 >= sent+20)||(sp2 <= sent-20) sent=sp2;

18



end; %----------------------------------------------------------- %--------------PID------------------ error1=sp2-sent; dinput=sent-lastsent; %Prop=(kp*error1); %Inte=(Io*ki*error1); %Io=Inte; %Deri=(kd*(error1-error2)/3); Deri=-1*(kd*(dinput)/3); %pid=(Prop+Inte+Deri); Deriv=Deri*GCE; lastsent=sent; error2=error1; u=evalfis([error1 Deriv], fismat); out=u*GU; %----Generacion de señal PID con perturbacion---- pidc=convergent(sp2*(1+out)); if (pidc >= 49) pidc = sp2; elseif (pidc <= 0) pidc = sp2; % else pidc=convergent(sp2*(1+out)); end; clc sp sent2=sent*2; disp(' # % Luz Error') tabla(i,1)=i; tabla(i,2)=sent2; tabla(i,3)=error2; disp(tabla) %----------- grafica------------------------------ tgrafy(1,i)=sp; tgrafy(2,i)=tabla(i,2); tgrafx(i)=i; %t=whos('envio'); % Configuraion envio 1----------------------------- set(s,'outputBufferSize',512); %t.bytes fopen(s) fprintf(s,'%s',pidc) pause(0.05) fclose(s) l=l+1; if l==10

19



cc=input('¿Continuar?: 1/0 --> '); if (cc == 1) sp=0; sp=input('Ingrese % luminocidad: '); sp2=sp/2; % sent=0; % lastsent=0; pidc=sp2; l=0; error1=sp2-sent; error2=0; % Deri=0; elseif (cc == 0) break; end; end; plot(tgrafx,tgrafy) title('Respuesta del Sistema') xlabel('Iteracion') ylabel('Respuesta') AXIS([0 i 0 100]) End

o Control fuzzy PD+I

Se trabaja solo con el error y la sumatoria de la acción integral. La acción integral se multiplica con el GIE encontrado en la Ec 15, este valor es sumado con el fuzzy y a esto se multiplica por la ganancia Gu.

A continuación se presenta la programación en el matlab:

warning off clc clear all fismat=readfis('FPD'); l=0; pidc = 0; sp=input('Ingrese % luminocidad: '); sp2=sp/2; kp=7.5; %0.018; kd=0.65595; %0.0000045; ki=0.017798; %0.0000006722; GE=1; GCE=3.0354; GIE=0.08236; GU=0.2161; error1=0; error2=0; % Deri=0; Io=0; sent=0;

20



lastsent=0; i=0; clear tgrafy clear tgrafx clear show % Configuraion recepcion---------------------------- s=serial('COM7'); set(s,'BaudRate',19200,'DataBits',8,'Parity','none','StopBits',1,'FlowControl','none','timeout',5,'terminator',70,'inputbuffersize',1024,'requesttosend','off'); num=30; tabla=zeros(num,3); while (1) pidc = sp2; i=i+1; sent=0; fopen(s) dato=fscanf(s); pause(0.05) fclose(s) dato=strrep(dato,'F',''); daton=str2double(dato); sent=5.0982*(daton^3)-3.3542*(daton^2)+17.09*daton-0.1518; %Perturbacion-------------------------------------------- if (sent >= 60) && (sent<=120) sp2=15; elseif (sent >= 121) && (sent <= 250) sp2=6; elseif (sent>=251) sp2=1; else sp2=sp/2; end; %Filtro---------------------------------------------------- if (sp2 >= sent+20)||(sp2 <= sent-20) sent=sp2; end; %----------------------------------------------------------- %--------------PID------------------ error1=sp2-sent; %dinput=sent-lastsent; %Prop=(kp*error1); Inte=(Io*ki*error1); Io=Inte; Deri=(kd*(error1-error2)/3); %Deri=-1*(kd*(dinput)/3);

21



%pid=(Prop+Inte+Deri); Deriv=Deri*GCE; lastsent=sent; error2=error1; Integr=Inte*GIE; u=evalfis([error1 Deriv], fismat); out=(u+Integr)*GU; %----Generacion de señal FPD----------------------------- pidc=convergent(sp2*(1+out)); if (pidc >= 49) pidc = sp2; elseif (pidc <= 0) pidc = sp2; end; clc sp sent2=sent*2; disp(' # % Luz Error') tabla(i,1)=i; tabla(i,2)=sent2; tabla(i,3)=error2; disp(tabla) %----------- grafica------------------------------ tgrafy(1,i)=sp; tgrafy(2,i)=tabla(i,2); tgrafx(i)=i; %t=whos('envio'); % Configuraion envio 1----------------------------- set(s,'outputBufferSize',512); %t.bytes fopen(s) fprintf(s,'%s',pidc) pause(0.05) fclose(s) l=l+1; if l==10 cc=input('¿Continuar?: 1/0 --> '); if (cc == 1) sp=0; sp=input('Ingrese % luminocidad: '); sp2=sp/2; % sent=0; % lastsent=0; pidc=sp2; l=0; error1=sp2-sent; error2=0; Io=0; % Deri=0;

22



elseif (cc == 0) break; end; end; plot(tgrafx,tgrafy) title('Respuesta del Sistema') xlabel('Iteracion') ylabel('Respuesta') AXIS([0 i 0 100]) end

7.7 Reglas y rangos de fuzzyficación del error

o Rangos del error El rango intermedio es más pequeño para que se pueda obtener una mejor respuesta para un error de 0.

Fig9. Fuzzificación de la variable de error

23



o Rangos del cambio de error

Fig10. Fuzzificación de la variable cambio de error

o Rangos de variable de salida El rango de valor de cero es más pequeño para que se pueda obtener una mejor respuesta.

Fig11. Rangos de Salida

24



De igual manera para el labview se realizó la fuzzificación con las mismas reglas y rangos con la ayuda de una herramienta de este programa que permite crear el archivo fuzzy .fs.

Fig12. Superficie obtenida de la fuzzificación

7.8 Controladores en Labview

Como trabajo adicional se realizaron los controladores FPD con la derivada del error y el FPD+I para comparar la respuesta respecto a la programación en matlab, debido a que la toma de datos es mejor y más rápida. FPD Las líneas de programación en el matlab se convierten en método gráfico para realizar las operaciones aritméticas y la respectiva conexión con las DAQ para adquirir y generar los datos.

25



Fig13. Programación en Labview FPD

FPD+I

Esta vez se le agrega a la programación la constante integral con sus respectivas operaciones para el control.

26



Fig14. Programación en Labview FPD+I

8. RESULTADOS

Se implementó la planta con los circuitos antes mencionados y se realizó la conexión serial para intercambiar los datos entre el programa en el computador (Matlab) y el microcontrolador encargado de manejar la luminosidad de la lámpara. 8.1 Control FPD con derivada en el error

o A continuación se presenta la gráfica de la respuesta de la planta con

el controlador FDP con la derivada del error sin filtro.

27



Fig.15 Respuesta al controlador FPD con derivada del error sin filtro

o Ahora se puede comparar la respuesta del mismo controlador con filtro. Se puede observar que el filtro es otra manera que ayuda a eliminar el derivate kick.

Fig16. Respuesta de controlador FPD con derivada del error con filtro

Se puede notar la diferencia en la respuesta del controlador el filtro ingresado evita la formación de picos y sobresaltos en la salida.

28



o Se muestra el resultado de las iteraciones para un control FPD con derivada en el error y con filtro observando la variación del error y porcentaje de luminosidad a la salida del microcontrolador.

Tabla3. Presentación de las iteraciones realizadas en el matlab

29



Fig17. Control FPD derivada del error y filtro

8.2 Control FPD con derivada a la salida

Otro método con el que realizaron pruebas para observar la respuesta del controlador fue con derivada de la salida, el cual es otra manera de eliminar el derívate kick que se produce sin necesidad de un filtro.

Fig18. Respuesta del controlador FPD con derivada a la salida

30



8.3 Control FPD+I Se muestra la gráfica para un controlador FPD+I, como se mencionó anteriormente este tipo de controlador tienes las mismas ventajas que un PID sin embargo en este se produce el fenómeno de derívate kick y winup los cuales deben ser eliminados mediantes filtros y establecimiento de límites.

Fig19. Respuesta del control FPD+I

8.4 Control en Labview

Se realizó el controlador en labview como un adicional para la verificación de la respuesta. Las respuestas en el Labview sirvieron como guía para observar la diferencia de operación del controlador de acuerdo al software de programación además de realizarse el control en tiempo real dentro de un entorno gráfico. Se observa que el tiempo de estabilización del sistema está bordeando los valores de 3 a 4s.

31



Fig20. Control FPD en labview

32



Fig21. Control FPD+I en labview

9. CONCLUSIONES Y RECOMENDACIONES

- El uso de un controlador FPD+I ofrece todas las ventajas de los controladores anteriormente citados sin embargo, la aplicación del criterio para usar cada una de las configuraciones depende el sistema a ser aplicado.

- Tal como se mostró en la figura 7, la respuesta real del sistema ofrece tiempos de estabilización demasiado altos, además de un overshoot considerable, en el estudio anteriormente realizado "Control PID de la luminosidad de una lámpara de LEDs referenciado a una LDR", sirviéndose de las constantes obtenidas, se produjo un refinamiento de las mismas para adecuar la planta de modo más efectivo, figura 8; ahora con la implementación del controlador fuzzy pd o fuzzy pd+il la refinación de las variables se da de forma automática y el sistema se estabiliza de acuerdo al set point requerido, sin embargo no llega a los tiempos usados con el refinamiento manual.

- El uso de controladores fuzzy no lineales ayudaría a q el sistema no produzca un comportamiento similar a un crisp pid controller, ya que las respuestas se acomodarían mejor al sistema, sin embargo, la respuesta obtenida fue sumamente satisfactoria para esta aplicación, que en este caso utilizó un fuzzificación lineal.

- Es necesario una sintonización previa de las constantes PID antes de la implementación de un controlador de la magnitud de un Fuzzy PD+I, ya que éste es el punto de partida para encontrar las ganancias responsables del controlador [GE, GCE, GIE, GU].

- Es importante conocer posibles rangos de acción del error en el sistema, debido que con esto se pueden setear rangos de acción para las entradas del error y del cambio del error [derivada del error], así como el valor de GE que es asumido dependiendo de los valores anteriores.

10. REFERENCIAS

Tuning of Fuzzy PID Controllers. Jantzen Jan, Technical University of Denmark: Dept of automation. Jantzen Jan. Dessing of fuzzy Controllers, Technical University of Denmark: Dept of automation.

https://docs.google.com/document/edit?id=1Xcu0nYEUPb03MXdxvmewMzF4xxOzPgEfw-gNZkkyrbc&hl=en&pli=1 http://www.dia.uned.es/~fmorilla/MaterialDidactico/El%20controlador%20PID.pdf

https://docs.google.com/document/edit?id=1Xcu0nYEUPb03MXdxvmewMzF4xxOzPgEfw-gNZkkyrbc&hl=en&pli=1

https://docs.google.com/document/edit?id=1Xcu0nYEUPb03MXdxvmewMzF4xxOzPgEfw-gNZkkyrbc&hl=en&pli=1

http://www.dia.uned.es/~fmorilla/MaterialDidactico/El%20controlador%20PID.pdf

33



Documents

92048254 Control Fuzzy PID Angulo Salazar