IMPLEMENTACION DE CONTROLES DIFUSOS

CAMILO ANDRES ANGEL HERNANDEZ

ANGEL ISSAC LOBO
CONTROL III

INTRODUCCION
En este artculo se explicara el
procedimiento para realizar un
controlador difuso e implementarlo en
un en la tarjeta de STM32F para ver sus
resultados, nos apoyaremos con varias
herramienta de programacin como son
Matlab, dev c++ cube mx, entre otros, la
idea principal de este ejercicio es
entender la lgica difusa y aplicarla en
un sistema para obtener resultados, se
implementar para un sistema de
pndulo y se realizara las pruebas a FIGURA 1 COMFIGURACION DE VARIABLES DE
travs de los diferentes programas ENTRADA Y SALIDA

antes mencionados, cabe anotar que el Para implementar el codo se

principal objetivo de este artculo es
aplicar el programa en sistema de la
vida real ya que las propiedades de esta
tarjeta hacen que se pueda realizar esta
prctica con un precisin y detalle
excepcional..
MARCO TERICO
programaran dos variables de entrada
las cuales son la velocidad (vel) y la
posicin (pos) y una sola salida en esta
caso ser la fuerza o tencin que se le
aplica al sistema. Para la velocidad se
implementaran los conjuntos difusos de
la siguiente forma

Para la implementacin del pndulo se

realizar la primera programacin en
Matlab con ayuda del tool fuzzy en el
cual se implementaran con tres conjunto
difusos y se realizarn las
correspondientes pruebas.
Entonces empezamos a configurar los
conjuntos difusos para da una de las
entradas y para la salida lo cuales estn
definidos de la siguiente manera;

FIGURA 2 CONJUNTOS DIFUSOS DE VELOCIDAD

en la grafica podemos observar que el

conjunto est definido en el rango de -
30 hasta 30 la cual est definida en
grados, se usaron dos figuras tipo
trapecio y na tipo triangular en donde la
velocidad negativa (VN) esta definida:
FIGURA 3 POSICION DEL CONJUNTO DIFUSO
VELOCIDAD NEGATIVA VN
Y de esta forma se configuran los dems
conjuntos.
FIGURA 4 CONJUNTOS DIFUSOS DE POSICION
Para la posicin se usara la escala
entre -30 y 30 la cual est definida en
centmetros para el clculo.
FIGURA 5 CONJUNTOS DIFUSOS DE TENCION
Con respecto a la salida en el sistema
se aplicar un voltaje el cual est en el
rango de -24 hasta 24 voltios, esta
salida depender de las reglas
programadas en el controlador y de las
variables de entrada.
Despus de tener los diferentes
conjuntos difusos procederemos a
programar las reglas las cuales se
aplicaran dependiendo de las diferentes
situaciones en las que se encuentren las
entradas del sistema cuyas reglas son:
PN PZ PP
VN TN TN TZ
VZ TN TZ TP
VP TZ TP TP
1. If (VEL is PZ) and (POS is
PZ) then (TEN is TZ) (1)
2. If (VEL is PN) and (POS is
PP) then (TEN is TZ) (1)
3. If (VEL is PP) and (POS is
PN) then (TEN is TZ) (1)
4. If (VEL is PP) and (POS is
PZ) then (TEN is TP) (1)
5. If (VEL is PP) and (POS is
PP) then (TEN is TP) (1)
6. If (VEL is PZ) and (POS is
PP) then (TEN is TP) (1)
7. If (VEL is PZ) and (POS is
PN) then (TEN is TN) (1)
8. If (VEL is PN) and (POS is
PZ) then (TEN is TN) (1)
9. If (VEL is PN) and (POS is
PN) then (TEN is TN) (1)
Entonces el sistema estara dado con
las implicaciones de esta forma:
Ahora procederemos a pasar el cdigo
a lenguaje de programacin de C ya
que es necesario para programarlo en else
workbench PZ= (Pos-PZa)/ (PZb-PZa);
end
Para entender como fusiona el cdigo end
en C primero se programar en Matlab de
la siguiente manera if (Pos>=PPb)
PP=1;
Primero se definen las variables tanto de else
posicin como de velocidad y tencin if (Pos<=PPa)
PP=0;
%posicin P Claves else
PNa=-5; PP= (Pos-PPa)/ (PPb-PPa)
PNb=0; end
PZa=-5;
PZb=0; end
PZc=5;
PPa=0; % Velocidad
PPb=5; if (Vel<=VNa)
VN=1;
%Velocidad P Claves else
VNa=-10; if (Vel>=VNb)
VNb=0; VN=0;
VZa=-10; else
VZb=0; VN= (VNb-Vel)/ (VNb-VNa);
VZc=10; end
VPa=0; end
VPb=10;

%Salida P Claves if (Vel<=VZa || Vel>=VZc)

TNa=-8; VZ=0;
TNb=0; else
TZa=-8; if (Vel>=VZb)
TZb=0; VZ= (VZc-Vel)/ (VZc-VZb);
TZc=8; else
TPa=0; VZ= (Vel-VZa)/ (VZb-VZa);
TPb=8; end
end
En seguida se realiza la comparacin de
cada una de las variables de entrada del if (Vel>=VPb)
sistema por separado. VP=1;
else
%Posicin if (Vel<=VPa)
VP=0;
If (Pos<=PNa) else
PN=1; VP= (Vel-VPa)/ (VPb-VPa);
else end
if (Pos>=PNb) end
PN=0;
else Luego se procede a realizar la inferencia
PN= (PNb-Pos)/(PNb-PNa); que en programa fuzzy realizaba la
end misma funcin que las reglas que se
end
programaron en el mismo para esta
parte del programa se realiza un vector
if (Pos<=PZa || Pos>=PZc)
en donde se ira almacenando toda la
PZ=0; informacin donde se evala la salida
else
if (VZ>PZ)
if (Pos>=PZb)
Arg(1)=PZ;
PZ= (PZc-Pos)/ (PZc-PZb);
else empieza a implementar los recorrido de
Arg (1)=VZ; los vectores antes creados:
end
for i=2:3
if (VN>PP) if (Arg(1)<Arg(i))
Arg (2)=PP; Arg(1)=Arg(i);
else end
Arg (2)=VN; end
end % salidas a TP
for i=5:6
if (VP>PN) if (Arg(4)<Arg(i))
Arg (3)=PN; Arg(4)=Arg(i);
else end
Arg (3)=VP; end
end % salidas a TN
for i=8:9
if (Arg(7)<Arg(i))
if (VP>PZ)
Arg(7)=Arg(i);
Arg (4)=PZ;
end
else
end
Arg (4)=VP;
end
Despus procedemos a programar la
if (VP>PP)
Arg (5)=PP; defusificacion y la implicacin y
else procedemos a imprimir la sala del
Arg (5)=VP; sistema:
end
sum=0;
sump=0;
if (VZ>PP)
Arg (6)=PP;
else for x=-21:42/100:21
Arg (6)=VZ;
end
if (x<=TNa)
if (VZ>PN) TN=1;
Arg (7)=PN; else
else if (x>=TNb)
Arg (7)=VZ; TN=0;
end else
TN= (TNb-x)/(TNb-
if (VN>PZ) TNa);
Arg (8)=PZ; end
else end
Arg (8)=VN;
end if (TN>Arg(7)) %
Implicaci?n y Agregaci?n
if (VN>PN) temp(1)=Arg(7);
Arg (9)=PN; else
else temp(1)=TN;
Arg (9)=VN; end
end

if (x<=TZa || x>=TZc)
Despus de la inferencia se procede a TZ=0;
programar as sentencias la agregacin else
que una parte importante del programa if (x>=TZb)
TZ=(TZc-x)/(TZc-TZb);
ya que es donde se empieza a definir la else
salida con la ayuda de los conjuntos TZ=(x-TZa)/(TZb-TZa);
difusos, en esta parte del programa se end
 end

if (TZ>Arg(1)) %
Implicaci?n y Agregaci?n
temp(2)=Arg(1);
else
temp(2)=TZ;
end

if (x>=TPb)
TP=1; Al ingresa los dos vemos como salida
else cambia en este caso la velocidad se
if (x<=TPa)
program a -12 radianes/seg y la
TP=0;
else posicin en -12 grados y la respuesta en
TP= (x-TPa)/(TPb- la salida es de -12.5 voltios,
TPa); procederemos a ejecutar el programa en
end la venta de comandos de Matlab para
end
verificar los resultados
if (TP>Arg(4)) %
Implicaci?n y Agregaci?n
temp(3)=Arg(4);
else
temp(3)=TP;
end

for i=2:3
if(temp(1)<temp(i))
temp(1)=temp(i);
end
end

sump=sump+temp(1)*x;
sum=sum+temp(1);

end

Sal=sump/sum

Como se puede observar los resultados

Antes de pasar el cdigo C realizaremos
unas pruebas para verificar que el
cdigo funcione y en la salida
obtengamos los mismos datos,
entonces para el ejercicio de prueba se
programara ambos con los mismos
datos de entrada:
son muy similares, y ya realizado esta
prueba procedemos a realizar la
programacin en c que sigue la misma
lgica y orden que la programacin en
Matlab en el que cdigo para este ser:
#include "stdio.h"
#include "conio.h"
//POCISION
#define PNa -5.0
#define PNb 0.0
#define PZa -5.0 */
#define PZb 0.0 if (Pos<=PNa){
#define PZc 5.0 PN=1;
#define PPa 5.0 }else{
#define PPb 0.0 if (Pos>=PNb){
PN=0;
//VELOCIDAD }else{
#define VNa -10.0 PN= (PNb-Pos)/(PNb-PNa);
#define VNb 0.0 }}
#define VZa -10.0 if (Pos<=PZa || Pos>=PZc){
#define VZb 0.0 PZ=0;
#define VZc 10.0 }else{
#define VPa 10.0 if (Pos>=PZb){
#define VPb 0.0 PZ=(PZc-Pos)/(PZc-PZb);
}else{
//TENSION PZ=(Pos-PZa)/(PZb-PZa);
#define TNa -8.0 }}
#define TNb 0.0 if (Pos>=PPb){
#define TZa -8.0 PP=1;
#define TZb 0.0 }else{
#define TZc 8.0 if (Pos<=PPa){
#define TPa 8.0 PP=0;
#define TPb 0.0 }else{
float PP= (Pos-PPa)/(PPb-PPa);
VN,VP,VZ,TN,TP,TZ,PN,PP,PZ,Pos,Ve
}}
l,Sal,sum,sump;
/*
float Arg[9],temp[9];
velocidad
int i,x;
*/
int main(){
if (Vel<=VNa){
Pos=-22.0;
VN=1;
Vel=22.0;
}else{
/*
posicion
 9. si VN PN ----> TN
if (Vel>=VNb){ */
VN=0; if (VZ>PZ){
}else{ Arg[1]=PZ;
VN= (VNb-Vel)/(VNb-VNa); }else{
}} Arg[1]=VZ;
if (Vel<=VZa || Vel>=VZc){ }
VZ=0; if (VN>PP){
}else{ Arg[2]=PP;
if (Vel>=VZb){ }else{
VZ=(VZc-Vel)/(VZc-VZb); Arg[2]=VN;
}else{ }
VZ=(Vel-VZa)/(VZb-VZa); if (VP>PN){
}} Arg[3]=PN;
if (Vel>=VPb){ }else{
VP=1; Arg[3]=VP;
}else{ }
if (Vel<=VPa){ if (VP>PZ){
VP=0; Arg[4]=PZ;
}else{ }else{
VP= (Vel-VPa)/(VPb-VPa); Arg[4]=VP;
}} }
/*
inferencia if (VP>PP){
1. si VZ PZ ----> TZ Arg[5]=PP;
2. si VN PP ----> TZ }else{
3. si VP PN ----> TZ Arg[5]=VP;
4. si VP PZ ----> TP }
5. si VP PP ----> TP
6. si VZ PP ----> TP if (VZ>PP){
7. si VZ PN ----> TN Arg[6]=PP;
8. si VN PZ ----> TN }else{
 Arg[6]=VZ; if (Arg[7]<Arg[i]){
} Arg[7]=Arg[i];
if (VZ>PN){ }}
Arg[7]=PN; /*Implicaci?n, Defuzzificaci?n,
Agregaci?n*/
}else{
for (x=-21;x<=21;x++){
Arg[7]=VZ;
if (x<=TNa){
}
TN=1;
if (VN>PZ){
}else{
Arg[8]=PZ;
if (x>=TNb){
}else{
TN=0;
Arg[8]=VN;
}else{
}
TN= (TNb-x)/(TNb-TNa);
if (VN>PN){
}
Arg[9]=PN;
if (TN>Arg[7]){ //% Implicaci?n y
}else{
Agregaci?n
Arg[9]=VN;
temp[1]=Arg[7];
}
}else{
/*
temp[1]=TN;
Adelanto de Parte de la agregaci?n
}
*/
if (x<=TZa || x>=TZc){
//salidas a TZ
TZ=0;
for (i=2;i<=3;i++){
}else{
if (Arg[1]<Arg[i]){
if (x>=TZb){
Arg[1]=Arg[i];
TZ=(TZc-x)/(TZc-TZb);
}}
}else{
// salidas a TP
TZ=(x-TZa)/(TZb-TZa);
for (i=5;i<=6;i++){
}}
if (Arg[4]<Arg[i]){
if (TZ>Arg[1]){ // % Implicaci?n y
Arg[4]=Arg[i]; Agregaci?n

} } temp[2]=Arg[1];

// salidas a TN }else{

for (i=8;i<=9;i++){ temp[2]=TZ;

}
if (x>=TPb){
TP=1;
}else{
if (x){
TP=0;
}else{ CONCLUISIONES

TP= (x-TPa)/(TPb-TPa); La implementacin de estos programas

en una aplicacin real necesita un
}} dispositivo que pueda realizar el clculo
if (TP>Arg[4]){ //% Implicaci?n y de la rusificacin de los sistemas.
Agregaci?n Estos sistemas se pueden implementar
temp[3]=Arg[4]; con facilidad con un margen de error
muy bajo.
}else{
Los controladores difusos pueden
temp[3]=TP; ayudar a tomar decisiones en los
diferentes sistemas que se programa y
}
que estos puede ayudar a solucionar
for (i=2;i<=3;i++){ varios problemas cotidianos

if(temp[1]<temp[i]){
temp[1]=temp[i];
}}
sump=sump+temp[1]*x;
sum=sum+temp[1];
}
printf("%f",Sal);
}
De igual forma procedemos a verificar
que el programa arroje los mismos datos
que los programas anteriores

Como se puede observar la salida en el

programa c es igual a programacin
tanto del fuzzy como del cdigo en
Matlab, ahora procedemos a programar
la tarjeta STM32F.