Está en la página 1de 21

TECNOLÓGICO NACIONAL DE MÉXICO

CAMPUS QUERÉTARO

Ingeniería Mecatrónica

Reporte de Practica
———————————————
Tópicos de Control Avanzado

Controlador Difuso
3 Entradas, 2 Salidas.

Presentan:
Robles Robles Mario
Pérez Hernandez Xochitl Citlali

Profesora:

Mota Valtierra Georgina

Junio de 2016
1. GENERALIDADES
La lógica difusa fue creada para emular la lógica humana y tomar decisiones acertadas
a pesar de la información. 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 información, particularmente de mediciones
imprecisas. La lógica difusa es una herramienta flexible que se basa en reglas
lingüísticas dictadas por expertos. Por ejemplo, la velocidad de un automóvil es una
variable que puede tomar distintos valores lingüísticos, como “alta”, “media” o baja.
Estas variables lingüísticas dictan la salida del sistema.

Un sistema difuso consta de un conjunto de principios matemáticos basados en grados


de membresía o pertenencia, cuya función es modelar la información. Este modelado
se hace con base en reglas lingüísticas que aproximan una función mediante la
relación de entradas y salidas del sistema (composición). Esta lógica presenta rangos
de membresía dentro de un intervalo entre 0 y 1, a diferencia de la lógica
convencional, en la que el rango se limita a dos valores: el cero o el uno.

Otra ventaja del sistema de control basado en lógica difusa es que no es necesario
conocer un modelo matemático del sistema real, pues se puede ver como una caja
negra a la cual se le proporcionan entradas, y a través del sistema esta planta generará
la salida deseada. En el control clásico si es necesario conocer la planta del sistema.

Para desarrollar un control con estas características, es necesario un experto, quien


tomará un registro de las situaciones que se le presentan, así como de la solución que
el les da. Esta experiencia se traduce en reglas que usan variables lingüísticas.

Con estas variables se forman reglas, las cuales regirán la acción de control, que será la
salida del sistema.

LA ESENCIA DEL CONTROL DIFUSO ES QUE CONVIERTE LA ESTRATEGIA DE


CONTROL LINGÜÍSTICO, LA CUAL SE BASA EN EL CONOCIMIENTO DE UN
EXPERTO, EN UNA ESTRATEGIA DE CONTROL AUTOMATICO.
2. TEORIA DE CONTROLADOR DIFUSO DE MAMDANI
Para la representación de los grados de pertenencia de cada uno de los elementos que
conforman el conjunto difuso, lo mas natural es extraer los datos de los fenómenos
que se va a representar y con ellos definir la forma de la función de membresía.

Existen funciones de membresía convencionales y no convencionales que permiten


realizar un mapeo de un universo nítido a un universo difuso (grados de membresía
entre 0 y 1). Entre las funciones de membresía convencionales se tienen las siguientes.

Función de Saturación.

Función Hombro.

Función Triangular.

Función Trapecio.

Función Sigmoidal.

2.1. PRODUCTO CARTESIANO DIFUSO


Es una operación entre conjuntos difusos para formar relaciones difusas. Sirve para
relacionar causas y efectos. Zadeh propuso que el valor de membresía del producto
cartesiano entre el conjunto A y el B sea el mínimo entre el valor de membresía de A y
el de B.

El valor de membresía 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.

Según la definición de producto cartesiano difuso, para cada par de A y B se debe


asignar un valor de membresía, lo cual se hace tomando el valor mas pequeño de los
valores de membresía entre A y B.

Nótese que en la matriz, conforme aumenta la velocidad, aumenta la intensidad de la


relación, 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.
2.2. VARIABLES LINGÜÍSTICAS.
Una variable lingüística adopta valores con palabras que permiten describir el estado
de un objeto o fenómeno; estas palabras se pueden representar mediante conjuntos
difusos. Una variable numérica toma valores numéricos, por ejemplo edad = 75,
mientras que una variable lingüística toma valores lingüísticos: edad es “viejo”.

Las variables lingüísticas están caracterizadas por:

(x, X, T(x), G, M) donde:

x: Nombre de la variable.

Ejemplo: Velocidad.

X: Universo de discurso o dominio físico en el cual la variable esta definida,

Ejemplo: [0 km/h - Vmax]

T(x): Conjuntos de valores lingüísticos o términos que acepta la variable.

Ejemplo: Bajo, Medio, Alto.

G: Regla sintáctica que genera los valores lingüísticos.

G: Regla semántica que asocia cada valor lingüístico T(x) con su significado o
con un conjunto difuso en X.

Ejemplo: Baja[0,55], Media[35,80], Alta[55,Vmax].

2.3. REGLA DIFUSA


Es un esquema de representación de conocimiento para capturar el conocimiento
impreciso e inexacto por naturaleza, utilizando variables lingüísticas para describir
condiciones elásticas. Su principal característica es su capacidad para ejecutar
inferencia (evaluación entre dos o mas propuestas) bajo una combinación parcial.

Esto es: se calcula el grado de combinación entre una entrada difusa A’ y una
condición difusa A. Las reglas difusas son el núcleo de los controladores difusos y
tienen una estructura de la forma:

Si x es A, entonces y es B.
2.4. MODUS PONENS DIFUSO
El modus ponens difuso se constituye por dos premisas, la primera que es un hecho, y
la segunda que es una regla difusa si-entonces. Donde x e y son variables lingüísticas,
A, A’ y B son términos lingüísticos representados por conjuntos difusos con funciones
de membresía. En general con estas dos premisas se puede obtener una conclusión y
es B’. El Modus ponens difuso es un procedimiento matemático que sirve para concluir
razonamientos difusos usando el procesamiento numérico de computadora.

La premisa, o el hecho esta representada por un conjunto A’, mientras que la regla
difusa esta representada por un producto cartesiano. Para obtener la conclusión se
computa el conjunto difuso B’ por medio de la composición de la relación difusa
(producto cartesiano) con el hecho A’

4. CONTROL DIFUSO
Un controlador difuso esta compuesto de cuatro partes principales: interfaz de
difusificacion, base de conocimiento, lógica de desiciones e interfaz de
desdifusificacion.
5. PROCESO DE DISEÑO DE CONTROLADOR.
La generalización del método de inferencia de Mamdani permite diseñar
controladores para sistemas MIMO, Múltiple Input - Múltiple Output.

1.- Identificar variables de entrada y salida del controlador.

En un momento dado, al controlador llegan las variables de entrada X0 y Y0 y Z0. De


acuerdo con la formulación matemática de Mamdani, se deben fusificar los valores de
X0 Y0 y Z0 en los conjuntos difusos de los antecedentes, A1, A2… B1, B2… C1, C2.

2.- Definir variables lingüísticas.

3.- Definir reglas de control.

A continuación, se considera el mínimo entre el valor de membresía de A1 y el valor


de membresía de B1, el mínimo entre el valor de membresía de A2 y el valor de
membresía de B2. Se repite el proceso para todas las reglas.

4.- Método de inferencia. (Modus Ponens Difuso).

Se cortan las funciones de los conjuntos consecuentes a la altura del valor mas
pequeño de los valores de fusificación. Pasa el valor de membresía mas pequeño de
cada regla y corta el conjunto C1 y el conjunto C2.

Una vez que se tienen los conjuntos cortados C’1 y C’2, éstos deben unirse para
calcular C’, que es la función de membresía del conjunto conclusión de todo el modus
ponens difuso con todas las reglas difusas del controlador.

5 - Defusificación.

Finalmente solo resta la defusificación del conjunto solución C’, para encontrar un
valor escalar Z0 que pueda ser inyectado por el controlador como variable de acción de
control.
5.1.VARIABLES DE ENTRADA Y SALIDA.
El sistema diseñado para esta practica considera 3 sensores ultrasónicos como
dispositivos de entrada, mismos que tienen un rango de medición de distancia de 0 a
50 cm, por lo cual se define el universo de discurso distancia entre 0 y 50 cm para las
tres variables de entrada.

Para las variables de salida, se ha establecido que se quieren controlar dos motores
mediante las 3 entradas ya especificadas, por lo tanto, para ambos motores se
establece una variable de salida asociada con un Dutty Cycle de una señal PWM,
misma que tiene un universo de discurso que va de 0 a 100, indicando un porcentaje
correspondiente a TON de la señal modulada por pulsos.

5.2. VARIABLES LINGÜÍSTICAS.


Para las variables de entrada, correspondientes a distancia, se han establecido 3
rangos que pueden tomar las variables difusas. Cerca, Considerable y lejos, con
funciones de membresía trapezoidal izquierda de 0 a 25cm para cerca, triangular de 10
a 40cm para considerable, y trapezoidal derecha de 25 a 50cm para lejos.
Configuración que se aprecia en la siguiente captura de plot del controlador en
MATLAB:
De manera similar, se definieron las funciones de membresía para las variables
lingüísticas de salida, definidas de la siguiente forma:

El primer motor tiene definidas las funciones DuttyCycle Bajo por un trapezoide de 0 a
2, DuttyCycle Medio con un triángulo de 1 a 25, y DuttyCycle Alto mediante un
trapezoide derecho de 20 a 100.

El segundo motor tiene una configuración de funciones de membresía simetricas, un


trapezoide para bajo de 0 a 50, un triángulo para medio de 25 a 75 y un trapezoide de
50 a 100.

5.3. REGLAS DE CONTROL


Las reglas de control fueron definidas de acuerdo al comportamiento deseado de
ambos motores, considerando que la salida 2 controla un motor de direccionamiento
de un triciclo, y la salida 1, controla el avance, teniendo un comportamiento de
evasión de obstáculos al combinarse con los sensores de detección de distancia, se
trata de un sistema de control sencillo basado en lógica difusa para la navegación
autónoma.
Antecedente 1 Antecedente 2 Antecedente 3 Consecuente 1 Consecuente 2
Distancia Distancia Distancia Motor Avance Motor Giro
Izquierda Frontal Derecha
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


6. CÓDIGO FUENTE DE CONTROLADOR
clc, clear all, close all,

pot1_Val = input('Variable 1 = '); % Llegada de variable 1
pot2_Val = input('Variable 2 = '); % Llegada de variable 2
pot3_Val = input('Variable 3 = ') % Llegada de variable 3

% Intervalos de discretizacion de los conjuntos difusos.
paso1 = 1; % Paso para el vector de entrada para variable 1
paso2 = 1; % Paso para el vector de entrada para la variable 2
paso3 = 1; % Paso para el vector voltaje de salida
pasoAngOut = 1;
pot1 = 1:paso1:50; % Declaracion de universo de discurso para la variable
linguistica giro (Angulo en grados) (10 bits)
pot2 = 1:paso2:50; % Declaracion de universo de discurso para la variable
linguistica giro (Angulo en grados) (10 bits)
pot3 = 1:paso2:50; % Declaracion de universo de discurso para la variable
linguistica giro (Angulo en grados) (10 bits)
voltajeSalida = 1:paso3:100; % Declaracion de universo de discurso para variable de
salida (en Volts)
anguloSalida = 1:pasoAngOut:100; % Declaracion de universo de discurso para variable de
salida (en Volts)
%% Definicion, funciones de membresia variable 1
Trap1Bajo = zeros(1,50);
Triang1Medio = zeros(1,50);
Trap1Alto = zeros(1,50);
for i=1:50
% Funcion de membresia trapezoidal Bajo
if ( pot1(i) < 10 )
Trap1Bajo(i) = 1;
end
if ( pot1(i) >= 10 && pot1(i) < 25 )
Trap1Bajo(i) = ( (25-pot1(i))/15 );
% de la ecuacion de la recta entre los puntos (67 1) (127 0)
end
if ( pot1(i) >= 25 )
Trap1Bajo(i) = 0;
end
% Funcion de membresia triangular Medio
if ( pot1(i) < 10 )
Triang1Medio(i) = 0;
end
if ( pot1(i) >= 10 && pot1(i) < 25 )
Triang1Medio(i) = ( (10-pot1(i))/-15 );
% de la ecuacion de la recta entre los puntos (67 0) (127 1)
end
if ( pot1(i) >= 25 && pot1(i) < 40 )
Triang1Medio(i) = ( (40-pot1(i))/15 );
% de la ecuacion de la recta entre los puntos (90,1) (100,0)
end
if ( pot1(i) > 40 )
Triang1Medio(i) = 0;
end
% Funcion de membresia trapezoidal Alto
if ( pot1(i) >= 40 )
Trap1Alto(i) = 1;
end
if ( pot1(i) >= 25 && pot1(i) < 40 )
Trap1Alto(i) = ( (-25+pot1(i))/15 );
% de la ecuacion de la recta entre los puntos (50,1) (90,0)
end
if ( pot1(i) < 25 )
Trap1Alto(i) = 0;
end
end
%% Definicion, funciones de membresia variable 2
Trap2Bajo = zeros(1,50);
Triang2Medio = zeros(1,50);
Trap2Alto = zeros(1,50);
for i=1:50
% Funcion de membresia trapezoidal Bajo
if ( pot2(i) < 10 )
Trap2Bajo(i) = 1;
end
if ( pot2(i) >= 10 && pot2(i) < 25 )
Trap2Bajo(i) = ( (25-pot2(i))/15 );
% de la ecuacion de la recta entre los puntos (67 1) (127 0)
end
if ( pot2(i) >= 25 )
Trap2Bajo(i) = 0;
end
% Funcion de membresia triangular Medio
if ( pot2(i) < 10 )
Triang2Medio(i) = 0;
end
if ( pot2(i) >= 10 && pot2(i) < 25 )
Triang2Medio(i) = ( (10-pot2(i))/-15 );
% de la ecuacion de la recta entre los puntos (67 0) (127 1)
end
if ( pot2(i) >= 25 && pot2(i) < 40 )
Triang2Medio(i) = ( (40-pot2(i))/15 );
% de la ecuacion de la recta entre los puntos (90,1) (100,0)
end
if ( pot2(i) > 40 )
Triang2Medio(i) = 0;
end
% Funcion de membresia trapezoidal Alto
if ( pot2(i) >= 40 )
Trap2Alto(i) = 1;
end
if ( pot2(i) >= 25 && pot2(i) < 40 )
Trap2Alto(i) = ( (-25+pot2(i))/15 );
% de la ecuacion de la recta entre los puntos (50,1) (90,0)
end
if ( pot2(i) < 25 )
Trap2Alto(i) = 0;
end
end
%% Definicion, funciones de membresia variable 3
Trap3Bajo = zeros(1,50);
Triang3Medio = zeros(1,50);
Trap3Alto = zeros(1,50);

for i=1:50
% Funcion de membresia trapezoidal Bajo
if ( pot3(i) < 10 )
Trap3Bajo(i) = 1;
end
if ( pot3(i) >= 10 && pot3(i) < 25 )
Trap3Bajo(i) = ( (25-pot3(i))/15 );
% de la ecuacion de la recta entre los puntos (67 1) (127 0)
end
if ( pot3(i) >= 25 )
Trap3Bajo(i) = 0;
end
% Funcion de membresia triangular Medio
if ( pot3(i) < 10 )
Triang3Medio(i) = 0;
end
if ( pot3(i) >= 10 && pot3(i) < 25 )
Triang3Medio(i) = ( (10-pot3(i))/-15 );
% de la ecuacion de la recta entre los puntos (67 0) (127 1)
end
if ( pot3(i) >= 25 && pot3(i) < 40 )
Triang3Medio(i) = ( (40-pot3(i))/15 );
% de la ecuacion de la recta entre los puntos (90,1) (100,0)
end
if ( pot3(i) > 40 )
Triang3Medio(i) = 0;
end
% Funcion de membresia trapezoidal Alto
if ( pot3(i) >= 40 )
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
%% Visualización 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));

% Fusificacion de los valores de entrada para Z0 en las funciones Bajo
uAntecC(1) = Trap3Bajo(z0(1));
uAntecC(2) = Triang3Medio(z0(2));
uAntecC(3) = Trap3Alto(z0(3));
uAntecC(4) = Trap3Bajo(z0(4));
uAntecC(5) = Triang3Medio(z0(5));
uAntecC(6) = Trap3Alto(z0(6));
uAntecC(7) = Trap3Bajo(z0(7));
uAntecC(8) = Triang3Medio(z0(8));
uAntecC(9) = Trap3Alto(z0(9));

% Fusificacion de los valores de entrada para Z0 en las funciones Medio
uAntecC(10) = Trap3Bajo(z0(10));
uAntecC(11) = Triang3Medio(z0(11));
uAntecC(12) = Trap3Alto(z0(12));
uAntecC(13) = Trap3Bajo(z0(13));
uAntecC(14) = Triang3Medio(z0(14));
uAntecC(15) = Trap3Alto(z0(15));
uAntecC(16) = Trap3Bajo(z0(16));
uAntecC(17) = Triang3Medio(z0(17));
uAntecC(18) = Trap3Alto(z0(18));

% Fusificacion de los valores de entrada para Z0 en las funciones Alto
uAntecC(19) = Trap3Bajo(z0(19));
uAntecC(20) = Triang3Medio(z0(20));
uAntecC(21) = Trap3Alto(z0(21));
uAntecC(22) = Trap3Bajo(z0(22));
uAntecC(23) = Triang3Medio(z0(23));
uAntecC(24) = Trap3Alto(z0(24));
uAntecC(25) = Trap3Bajo(z0(25));
uAntecC(26) = Triang3Medio(z0(26));
uAntecC(27) = Trap3Alto(z0(27));


%Valores de fusificacion (MAX o min) para cortar el conjunto consecuente
min_uAuBuC = max(uAntecA,uAntecB);
min_uAuBuC = max(min_uAuBuC,uAntecC);

% Corte de conjuntos mediante Ponens Difuso (min), a altura de valores de fusificacion
min_uAuB

%Salida1
C1 = min(Trap1VoltajeBajo,min_uAuBuC(1));
C2 = min(Trap1VoltajeBajo,min_uAuBuC(2));
C3 = min(Triang1VoltajeMedio,min_uAuBuC(3));
C4 = min(Trap1VoltajeBajo,min_uAuBuC(4));
C5 = min(Triang1VoltajeMedio,min_uAuBuC(5));
C6 = min(Trap1VoltajeAlto,min_uAuBuC(6));
C7 = min(Triang1VoltajeMedio,min_uAuBuC(7));
C8 = min(Trap1VoltajeAlto,min_uAuBuC(8));
C9 = min(Trap1VoltajeAlto,min_uAuBuC(9));

C10 = min(Trap1VoltajeBajo,min_uAuBuC(10));
C11 = min(Triang1VoltajeMedio,min_uAuBuC(11));
C12 = min(Trap1VoltajeAlto,min_uAuBuC(12));
C13 = min(Triang1VoltajeMedio,min_uAuBuC(13));
C14 = min(Trap1VoltajeAlto,min_uAuBuC(14));
C15 = min(Trap1VoltajeAlto,min_uAuBuC(15));
C16 = min(Trap1VoltajeAlto,min_uAuBuC(16));
C17 = min(Trap1VoltajeAlto,min_uAuBuC(17));
C18 = min(Trap1VoltajeAlto,min_uAuBuC(18));

C19 = min(Trap1VoltajeAlto,min_uAuBuC(19));
C20 = min(Trap1VoltajeAlto,min_uAuBuC(20));
C21 = min(Trap1VoltajeAlto,min_uAuBuC(21));
C22 = min(Trap1VoltajeAlto,min_uAuBuC(22));
C23 = min(Trap1VoltajeAlto,min_uAuBuC(23));
C24 = min(Trap1VoltajeAlto,min_uAuBuC(24));
C25 = min(Trap1VoltajeAlto,min_uAuBuC(25));
C26 = min(Trap1VoltajeAlto,min_uAuBuC(26));
C27 = min(Trap1VoltajeAlto,min_uAuBuC(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 (Unión 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))))))))))))))))))))))))));

%% Visualización 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

%% Defusificación 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. VALIDACIÓN
A continuación 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 numéricos 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.

Las salidas obtenidas para estas entradas son las siguientes:


8. CONCLUSIONES
Mario Robles Robles

Los controladores difusos son una gran alternativa al control clásico, cuando se
requiere controlar un sistema MIMO (Múltiples entradas y salidas), y tienen la gran
ventaja de no requerir complejos sistemas de instrumentación 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 computación de operaciones matriciales.

Personalmente, el desarrollar este controlador fue un reto, debido a que hubo


complicaciones en la comprensión de la teoría para poder programar la primera
versión requerida (dos entradas y una salida). Posteriormente, después de analizar a
detalle los fundamentos del proceso de inferencia Mamdani, fue cuestión de seguir el
procedimiento matemático 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 lógica difusa de
Matlab, no solo numéricamente, sino también en lo que respecta al método de corte
de conjuntos inferidos.

Xochitl Pérez Hernández

Para la creación del difuso primero empezamos a tratarlo solo como un dato, pero
descubrimos que esto no iba a funcionar al hacer todo el proceso de fusificación y
defusificación, por lo tanto, es mejor integrar los datos de entrada a vectores, ya que
en nuestro caso con las posiciones de los vectores se pudo realizar la pertenencia del
conjunto difuso, realizar las reglas difusas y el cortar los conjuntos de salida.

Incluso otro problema que se tuvo fue el tamaño de los vectores, todos los vectores
deben de ser del mismo tamaño sino se va a tener problemas. Otra cuestión que se nos
presento fue que no pudimos hacer la integración de las reglas por medio de OR, ya
que no se lograron hacer bien los cortes en el programa si utilizábamos AND.

Otro punto importante es el orden en el momento de fusificar las entradas, en nuestro


caso esto se hace 27 veces por variable y en orden de cómo se diseñó el sistema, este
mismo orden también se tiene que mantener al momento de hacer los cortes en las
salidas, sino presentara otro sistema difuso.
REFERENCIAS BIBLIOGRAFICAS

1. Ross J. Timothy. Fuzzy Logic with Engineering Applications. Ed. Wiley, 2004.
ISBN: 0-07-114711-X. 


2. Jang, J.-S.R., Sun, C.-T., Mizutani, E. Neuro-Fuzzy and Soft Computing: A


Computational Approach to Learning and 

Machine Intelligence. Prentice Hall, 1997. ISBN: 0-13-261066-3. 


3. Jan Jantzen. Foundations of fuzzy control. John Wiley & Sons. 2007. ISBN:
978-0-470-02963-3. 


También podría gustarte