Documente Academic
Documente Profesional
Documente Cultură
CAMPUS QUERTARO
Ingeniera Mecatrnica
Reporte de Practica
Controlador Difuso
3 Entradas, 2 Salidas.
Presentan:
Robles Robles Mario
Prez Hernandez Xochitl Citlali
Profesora:
Mota Valtierra Georgina
Junio de 2016
1. GENERALIDADES
La lgica difusa fue creada para emular la lgica humana y tomar decisiones acertadas
a pesar de la informacin. Debido a las limitaciones que tenemos para percibir el
mundo y comprenderlo de manera profunda, nos confrontamos con la incertidumbre,
la cual es resultado de la falta de informacin, particularmente de mediciones
imprecisas. La lgica difusa es una herramienta flexible que se basa en reglas
lingsticas dictadas por expertos. Por ejemplo, la velocidad de un automvil es una
variable que puede tomar distintos valores lingsticos, como alta, media o baja.
Estas variables lingsticas dictan la salida del sistema.
Un sistema difuso consta de un conjunto de principios matemticos basados en grados
de membresa o pertenencia, cuya funcin es modelar la informacin. Este modelado
se hace con base en reglas lingsticas que aproximan una funcin mediante la
relacin de entradas y salidas del sistema (composicin). Esta lgica presenta rangos
de membresa dentro de un intervalo entre 0 y 1, a diferencia de la lgica
convencional, en la que el rango se limita a dos valores: el cero o el uno.
Otra ventaja del sistema de control basado en lgica difusa es que no es necesario
conocer un modelo matemtico del sistema real, pues se puede ver como una caja
negra a la cual se le proporcionan entradas, y a travs del sistema esta planta generar
la salida deseada. En el control clsico si es necesario conocer la planta del sistema.
Para desarrollar un control con estas caractersticas, es necesario un experto, quien
tomar un registro de las situaciones que se le presentan, as como de la solucin que
el les da. Esta experiencia se traduce en reglas que usan variables lingsticas.
Con estas variables se forman reglas, las cuales regirn la accin de control, que ser la
salida del sistema.
El valor de membresa del producto cartesiano se calcula para cada par. Se construye
una matriz de relaciones, donde las filas corresponden al conjunto A y las columnas al
conjunto B.
Segn la definicin de producto cartesiano difuso, para cada par de A y B se debe
asignar un valor de membresa, lo cual se hace tomando el valor mas pequeo de los
valores de membresa entre A y B.
Ntese que en la matriz, conforme aumenta la velocidad, aumenta la intensidad de la
relacin, por lo tanto se infiere: es mas frecuente que ocurran accidentes de tipo
choque lateral o frontal a altas velocidades, y es menos frecuente que ocurran
volcaduras a bajas velocidades.
4. CONTROL DIFUSO
Un controlador difuso esta compuesto de cuatro partes principales: interfaz de
difusificacion, base de conocimiento, lgica de desiciones e interfaz de
desdifusificacion.
Distancia
Frontal
Distancia
Derecha
Motor Avance
Motor Giro
Cerca
Cerca
Cerca
Bajo
Medio
Cerca
Cerca
Aceptable
Bajo
Bajo
Cerca
Cerca
Lejos
Medio
Bajo
Cerca
Aceptable
Cerca
Bajo
Medio
Cerca
Aceptable
Aceptable
Medio
Medio
Cerca
Aceptable
Lejos
Alto
Bajo
Cerca
Lejos
Cerca
Medio
Medio
Cerca
Lejos
Aceptable
Alto
Medio
Cerca
Lejos
Lejos
Alto
Medio
Aceptable
Cerca
Cerca
Bajo
Alto
Aceptable
Cerca
Aceptable
Medio
Bajo
Aceptable
Cerca
Lejos
Alto
Bajo
Aceptable
Aceptable
Cerca
Medio
Medio
Aceptable
Aceptable
Aceptable
Alto
Medio
Aceptable
Aceptable
Lejos
Alto
Bajo
Aceptable
Lejos
Cerca
Alto
Medio
Aceptable
Lejos
Aceptable
Alto
Medio
Aceptable
Lejos
Lejos
Alto
Medio
Lejos
Cerca
Cerca
Alto
Alto
Lejos
Cerca
Aceptable
Alto
Alto
Lejos
Cerca
Lejos
Alto
Alto
Lejos
Aceptable
Cerca
Alto
Alto
Lejos
Aceptable
Aceptable
Alto
Alto
Lejos
Aceptable
Lejos
Alto
Alto
Lejos
Lejos
Cerca
Alto
Medio
Lejos
Lejos
Aceptable
Alto
Medio
Lejos
Lejos
Lejos
Alto
Medio
Trap3Alto(i) = 1;
end
if ( pot3(i) >= 25 && pot3(i) < 40 )
Trap3Alto(i) = ( (-25+pot3(i))/15 );
% de la ecuacion de la recta entre los puntos (50,1) (90,0)
end
if ( pot3(i) < 25 )
Trap3Alto(i) = 0;
end
end
%% Declaracion de las acciones de control para la salida 1
Trap1VoltajeBajo = zeros(1,100);
Triang1VoltajeMedio = zeros(1,100);
Trap1VoltajeAlto = zeros(1,100);
for i=1:100
% Funcion de membresia trapezoidal Voltaje Bajo
if ( voltajeSalida(i) < 1 )
Trap1VoltajeBajo(i) = 1;
end
if ( voltajeSalida(i) >= 1 && voltajeSalida(i) < 2 )
Trap1VoltajeBajo(i) = ( (5-( voltajeSalida(i) ))/4);
% de la ecuacion de la recta entre los puntos (-12,1) (0,0)
end
if ( voltajeSalida(i) >= 5 )
Trap1VoltajeBajo(i) = 0;
end
% Funcion de membresia trapezoidal Voltaje Medio
if ( voltajeSalida(i) < 1 )
Triang1VoltajeMedio(i) = 0;
end
if ( voltajeSalida(i) >= 1 && voltajeSalida(i) < 20 )
Triang1VoltajeMedio(i) = ( (-1 + voltajeSalida(i))/19 );
% de la ecuacion de la recta entre los puntos (80,0) (90,1)
end
if ( voltajeSalida(i) >= 20 && voltajeSalida(i) < 25 )
Triang1VoltajeMedio(i) = ( (25-voltajeSalida(i))/5 );
% de la ecuacion de la recta entre los puntos (90,1) (100,0)
end
if ( voltajeSalida(i) >= 25 )
Triang1VoltajeMedio(i) = 0;
end
% Funcion de membresia trapezoidal Voltaje Alto
if ( voltajeSalida(i) < 20 )
Trap1VoltajeAlto(i) = 0;
end
if ( voltajeSalida(i) >= 20 && voltajeSalida(i) < 25 )
Trap1VoltajeAlto(i) = ( (-20 + voltajeSalida(i) )/5 );
% de la ecuacion de la recta entre los puntos (12,1) (0,0)
end
if ( voltajeSalida(i) >= 25 )
Trap1VoltajeAlto(i) = 1;
end
end
%% Declaracion de las acciones de control para la salida 2
Trap2anguloPeq = zeros(1,100);
Triang2anguloMed = zeros(1,100);
Trap2anguloGran = zeros(1,100);
for i=1:100
% Funcion de membresia Angulo Pequeno
if ( anguloSalida(i) < 25 )
Trap2anguloPeq(i) = 1;
end
if ( anguloSalida(i) >= 25 && anguloSalida(i) < 50 )
Trap2anguloPeq(i) = ( (50 -( anguloSalida(i) ))/25);
% de la ecuacion de la recta entre los puntos (-12,1) (0,0)
end
if ( anguloSalida(i) >= 50 )
Trap2anguloPeq(i) = 0;
end
% Funcion de membresia Angulo Medio
if ( anguloSalida(i) < 25 )
Triang2anguloMed(i) = 0;
end
if ( anguloSalida(i) >= 25 && anguloSalida(i) < 50 )
Triang2anguloMed(i) = ( (-25 + anguloSalida(i))/25 );
% de la ecuacion de la recta entre los puntos (80,0) (90,1)
end
if ( anguloSalida(i) >= 50 && anguloSalida(i) < 75 )
Triang2anguloMed(i) = ( (75 - anguloSalida(i))/25 );
% de la ecuacion de la recta entre los puntos (90,1) (100,0)
end
if ( anguloSalida(i) >= 75 )
Triang2anguloMed(i) = 0;
end
% Funcion de membresia Angulo grande
if ( anguloSalida(i) < 50 )
Trap2anguloGran(i) = 0;
end
if ( anguloSalida(i) >= 50 && anguloSalida(i) < 75 )
Trap2anguloGran(i) = ( (-50 + anguloSalida(i) )/25 );
% de la ecuacion de la recta entre los puntos (12,1) (0,0)
end
if ( anguloSalida(i) >= 75 )
Trap2anguloGran(i) = 1;
end
end
%% Visualizacin de las funciones de membresia de la variable de entrada 1, 2 y 3
% Preparacion de grafica
f = figure('Name','VARIABLES DE ENTRADA');
subplot(3,1,1), plot (pot1,Trap1Bajo, pot1,Triang1Medio, pot1,Trap1Alto, 'LineWidth',
3)
hold on, plot(pot1_Val*ones(1,3),[0 0.5 1],'g','LineWidth',5)
set(gca, 'FontSize',12), legend('Cerca','Considerable','Lejos')
xlabel(['SENSOR IZQUIERDO. Variable 1 = ' num2str(pot1_Val) 'cm.'],'FontSize',12),
ylabel('\mu( Y1 )')
axis([0 50 0 1])
grid on
subplot(3,1,2), plot (pot2,Trap2Bajo, pot2,Triang2Medio, pot2,Trap2Alto, 'LineWidth',
3)
hold on, plot(pot2_Val*ones(1,3),[0 0.5 1],'m','LineWidth',5)
set(gca, 'FontSize',12), legend('Cerca','Considerable','Lejos')
xlabel(['SENSOR FRONTAL. Variable 2 = ' num2str(pot2_Val) 'cm.'],'FontSize',12),
ylabel('\mu( Y2 )')
axis([0 50 0 1])
grid on
subplot(3,1,3), plot (pot3,Trap3Bajo, pot3,Triang3Medio, pot3,Trap3Alto, 'LineWidth',
3)
hold on, plot(pot3_Val*ones(1,3),[0 0.5 1],'y','LineWidth',5)
set(gca, 'FontSize',12), legend('Cerca','Considerable','Lejos')
xlabel(['SENSOR DERECHO. Variable 3 = ' num2str(pot3_Val) 'cm.'],'FontSize',12),
ylabel('\mu( Y3 )')
axis([0 50 0 1])
grid on
hold on
%% INFERENCIA DIFUSA
% Calculo de valores de fusificacion de los antecedentes A (pot1) y B (pot2)
x0 = zeros(1,27);
y0 = zeros(1,27);
z0 = zeros(1,27);
min_uAuBuC = zeros(1,27);
for i=1:27
x0(i) = pot1_Val;
% Posiciones de los valores de fusificacion para antecedentes A
y0(i) = pot2_Val;
% Posiciones de los valores de fusificacion para antecedentes B
z0(i) = pot3_Val;
% Posiciones de los valores de fusificacion para antecedentes C
end
uAntecA = zeros (1,27);
uAntecB = zeros (1,27);
uAntecC = zeros (1,27);
% Fusificacion de los valores de entrada para X0 en las funciones bajo
uAntecA(1) = Trap1Bajo(x0(1));
uAntecA(2) = Trap1Bajo(x0(2));
uAntecA(3) = Trap1Bajo(x0(3));
uAntecA(4) = Trap1Bajo(x0(4));
uAntecA(5) = Trap1Bajo(x0(5));
uAntecA(6) = Trap1Bajo(x0(6));
uAntecA(7) = Trap1Bajo(x0(7));
uAntecA(8) = Trap1Bajo(x0(8));
uAntecA(9) = Trap1Bajo(x0(9));
% Fusificacion de los valores de entrada para X0 en las funciones Medio
uAntecA(10) = Triang1Medio(x0(10));
uAntecA(11) = Triang1Medio(x0(11));
uAntecA(12) = Triang1Medio(x0(12));
uAntecA(13) = Triang1Medio(x0(13));
uAntecA(14) = Triang1Medio(x0(14));
uAntecA(15) = Triang1Medio(x0(15));
uAntecA(16) = Triang1Medio(x0(16));
uAntecA(17) = Triang1Medio(x0(17));
uAntecA(18) = Triang1Medio(x0(18));
% Fusificacion de los valores de entrada para X0 en las funciones Alto
uAntecA(19) = Trap1Alto(x0(19));
uAntecA(20) = Trap1Alto(x0(20));
uAntecA(21) = Trap1Alto(x0(21));
uAntecA(22) = Trap1Alto(x0(22));
uAntecA(23) = Trap1Alto(x0(23));
uAntecA(24) = Trap1Alto(x0(24));
uAntecA(25) = Trap1Alto(x0(25));
uAntecA(26) = Trap1Alto(x0(26));
uAntecA(27) = Trap1Alto(x0(27));
% Fusificacion de los valores de entrada para Y0 en las funciones bajo
uAntecB(1) = Trap2Bajo(y0(1));
uAntecB(2) = Trap2Bajo(y0(2));
uAntecB(3) = Trap2Bajo(y0(3));
uAntecB(4) = Triang2Medio(y0(4));
uAntecB(5) = Triang2Medio(y0(5));
uAntecB(6) = Triang2Medio(y0(6));
uAntecB(7) = Trap2Alto(y0(7));
uAntecB(8) = Trap2Alto(y0(8));
uAntecB(9) = Trap2Alto(y0(9));
% Fusificacion de los valores de entrada para Y0 en las funciones Medio
uAntecB(10) = Trap2Bajo(y0(10));
uAntecB(11) = Trap2Bajo(y0(11));
uAntecB(12) = Trap2Bajo(y0(12));
uAntecB(13) = Triang2Medio(y0(13));
uAntecB(14) = Triang2Medio(y0(14));
uAntecB(15) = Triang2Medio(y0(15));
uAntecB(16) = Trap2Alto(y0(16));
uAntecB(17) = Trap2Alto(y0(17));
uAntecB(18) = Trap2Alto(y0(18));
% Fusificacion de los valores de entrada para Y0 en las funciones Alto
uAntecB(19) = Trap2Bajo(y0(19));
uAntecB(20) = Trap2Bajo(y0(20));
uAntecB(21) = Trap2Bajo(y0(21));
uAntecB(22) = Triang2Medio(y0(22));
uAntecB(23) = Triang2Medio(y0(23));
uAntecB(24) = Triang2Medio(y0(24));
uAntecB(25) = Trap2Alto(y0(25));
uAntecB(26) = Trap2Alto(y0(26));
uAntecB(27) = Trap2Alto(y0(27));
%Salida2
D1 = min(Triang2anguloMed,min_uAuBuC(1));
D2 = min(Trap2anguloPeq,min_uAuBuC(2));
D3 = min(Trap2anguloPeq,min_uAuBuC(3));
D4 = min(Triang2anguloMed,min_uAuBuC(4));
D5 = min(Triang2anguloMed,min_uAuBuC(5));
D6 = min(Trap2anguloPeq,min_uAuBuC(6));
D7 = min(Triang2anguloMed,min_uAuBuC(7));
D8 = min(Triang2anguloMed,min_uAuBuC(8));
D9 = min(Triang2anguloMed,min_uAuBuC(9));
D10 = min(Trap2anguloGran,min_uAuBuC(10));
D11 = min(Trap2anguloPeq,min_uAuBuC(11));
D12 = min(Trap2anguloPeq,min_uAuBuC(12));
D13 = min(Triang2anguloMed,min_uAuBuC(13));
D14 = min(Triang2anguloMed,min_uAuBuC(14));
D15 = min(Trap2anguloPeq,min_uAuBuC(15));
D16 = min(Triang2anguloMed,min_uAuBuC(16));
D17 = min(Triang2anguloMed,min_uAuBuC(17));
D18 = min(Triang2anguloMed,min_uAuBuC(18));
D19 = min(Trap2anguloGran,min_uAuBuC(19));
D20 = min(Trap2anguloGran,min_uAuBuC(20));
D21 = min(Trap2anguloGran,min_uAuBuC(21));
D22 = min(Trap2anguloGran,min_uAuBuC(22));
D23 = min(Trap2anguloGran,min_uAuBuC(23));
D24 = min(Trap2anguloGran,min_uAuBuC(24));
D25 = min(Triang2anguloMed,min_uAuBuC(25));
D26 = min(Triang2anguloMed,min_uAuBuC(26));
D27 = min(Triang2anguloMed,min_uAuBuC(27));
% Union de los conjuntos mediante Max (Unin anidada uno a uno)
C_inferido =
max(C1,max(C2,max(C3,max(C4,max(C5,max(C6,max(C7,max(C8,max(C9,max(C10,max(C11,max(C12,max(C13
,max(C14,max(C15,max(C16,max(C17,max(C18,max(C19,max(C20,max(C21,max(C22,max(C23,max(C24,max(C
25,max(C26,C27))))))))))))))))))))))))));
D_inferido =
max(D1,max(D2,max(D3,max(D4,max(D5,max(D6,max(D7,max(D8,max(D9,max(D10,max(D11,max(D12,max(D13
,max(D14,max(D15,max(D16,max(D17,max(D18,max(D19,max(D20,max(D21,max(D22,max(D23,max(D24,max(D
25,max(D26,D27))))))))))))))))))))))))));
%% Visualizacin de las acciones de control O salida del controlador
% Preparacion de grafica
f = figure('Name','ACCIONES DE CONTROL Y SALIDA');
% Graficacion de funciones de membresia acciones de control VARIABLE DUTY CYCLE
subplot(2,2,1), plot (voltajeSalida,Trap1VoltajeBajo, voltajeSalida,Triang1VoltajeMedio,
voltajeSalida,Trap1VoltajeAlto, 'LineWidth', 3)
set(gca, 'FontSize',12), legend('DuttyC.Bajo','DuttyC.Medio','DuttyC.Alto')
xlabel('Acciones de Control Salida 1'), ylabel('\mu( YS )')
axis([0 100 0 1])
grid on
% Graficacion de funciones de membresia acciones de control VARIABLE ANGULO DIRECTOR
subplot(2,2,3), plot (anguloSalida,Trap2anguloPeq, anguloSalida,Triang2anguloMed,
anguloSalida,Trap2anguloGran, 'LineWidth', 3)
set(gca, 'FontSize',12), legend('Angulo Peq','Angulo Medio','Angulo Grande')
xlabel('Acciones de Control Salida 2'), ylabel('\mu( YS )')
axis([0 100 0 1])
grid on
hold on
%% Defusificacin o calculo de salidas por metodo de centroide.
SumAcumSALIDA1 = 0;
productoAcumSALIDA1 = 0;
SumAcumSALIDA2 = 0;
productoAcumSALIDA2 = 0;
for i=1:100
productoSALIDA1 = (voltajeSalida(i)*C_inferido(i));
productoAcumSALIDA1 = productoAcumSALIDA1 + productoSALIDA1;
SumAcumSALIDA1 = SumAcumSALIDA1 + C_inferido(i);
vo2 = productoAcumSALIDA1/SumAcumSALIDA1;
productoSALIDA2 = (anguloSalida(i)*D_inferido(i));
productoAcumSALIDA2 = productoAcumSALIDA2 + productoSALIDA2;
SumAcumSALIDA2 = SumAcumSALIDA2 + D_inferido(i);
vo4 = productoAcumSALIDA2/SumAcumSALIDA2;
end
fprintf(' Vo: %d\n',vo2 )
fprintf(' An: %d\n',vo4 )
%% GRAFICACION VARIABLE DE SALIDA 1
% Graficacion de conjunto inferido de la union del modus ponens
subplot(2,2,2), plot(voltajeSalida,C_inferido,'b','LineWidth',5)
hold on, plot(vo2*ones(1,3),[0 0.5 1],'r','LineWidth',5)
xlabel(['Duty Cycle Salida: ' num2str(vo2) ' %'],'FontSize',12)
% Graficacion de voltaje de salida
subplot(2,2,2), plot(vo2*ones(1,3),[0 0.5 1],'r','LineWidth',5)
set(gca,'FontSize',18),legend('Duty Cycle PWM')
axis([0 100 0 1])
grid on
hold on
%% GRAFICACION VARIABLE DE SALIDA 2
% Graficacion de conjunto inferido de la union del modus ponens
subplot(2,2,4), plot(anguloSalida,D_inferido,'g','LineWidth',5)
hold on, plot(vo4*ones(1,3),[0 0.5 1],'r','LineWidth',5)
xlabel(['Angulo Salida: ' num2str(vo4) ' Grados'],'FontSize',12)
% Graficacion de voltaje de salida
subplot(2,2,4), plot(vo4*ones(1,3),[0 0.5 1],'r','LineWidth',5)
set(gca,'FontSize',18),legend('Angulo')
axis([0 100 0 1])
grid on
hold on
7. VALIDACIN
A continuacin se muestra un caso particular, para verificar que las salidas del
controlador programado en MATLAB son correctas de acuerdo al ToolBox integrado en
el laboratorio de matrices. Se verifican tanto los valores numricos para las dos
salidas, como la forma en la que se hacen los cortes en los conjuntos inferidos. En este
caso particular, los valores de las variables de entrada son 15, 48 y 2.
8. CONCLUSIONES
Mario Robles Robles
Los controladores difusos son una gran alternativa al control clsico, cuando se
requiere controlar un sistema MIMO (Mltiples entradas y salidas), y tienen la gran
ventaja de no requerir complejos sistemas de instrumentacin para obtener las
ecuaciones diferenciales de la planta, por lo cual es posible mediante opiniones de
expertos controlar sistemas no lineales y de elevado orden sin mayor complejidad que
la computacin de operaciones matriciales.
Personalmente, el desarrollar este controlador fue un reto, debido a que hubo
complicaciones en la comprensin de la teora para poder programar la primera
versin requerida (dos entradas y una salida). Posteriormente, despus de analizar a
detalle los fundamentos del proceso de inferencia Mamdani, fue cuestin de seguir el
procedimiento matemtico para poder extender el controlador a tres variables de
entrada y dos de salida, lo cual fue gratificante pues pudimos observar la concordancia
que hubo entre nuestros resultados y los arrojados por el ToolBox de lgica difusa de
Matlab, no solo numricamente, sino tambin en lo que respecta al mtodo de corte
de conjuntos inferidos.
REFERENCIAS BIBLIOGRAFICAS
1.
Ross J. Timothy. Fuzzy Logic with Engineering Applications. Ed. Wiley, 2004.
ISBN: 0-07-114711-X.
2.
3.
Jan Jantzen. Foundations of fuzzy control. John Wiley & Sons. 2007. ISBN:
978-0-470-02963-3.