Universidad Autnoma de Nuevo Len

Facultad de Ingeniera Mecnica y Elctrica

Reporte #2: Sistema Lgico Difuso (Tipo I)

Profesor
Alumno
Matrcula
Materia
Fecha de entrega

:
:
:
:
:

Dr. Luis Martn Torres Trevio

Vctor de Jess Medrano Zaraza
1442635
Sistemas Inteligentes
23/10/2015

San Nicols de los Garza, Nuevo Len / 22 de octubre de 2015.

1.

Introduccin

Un sistema difuso, grosso modo, es un mapeo no lineal de un vector

de datos de entrada a una salida escalar. Este sistema es nico en su
capacidad de trabajar simultneamente con datos nmericos y valores
lingsticos [1].

Figura 1: Estructura General de un Sistema de Lgica Difusa

A continuacin, se enumera y hace una descripcin breve de los bloques
principales que forman parte de la estructura de un Sistema Difuso (ver
Figura 1):
Fusificador: Bloque en el que a cada variable de entrada se le
asigna un valor de membresa a cada uno de los conjuntos difusos que se han considerado, mediante las funciones caractersticas
asociadas a estos conjuntos difusos. Las entradas a este bloque son
valores concretos de las variables de entrada y las salidas son grados de pertenencia o valores de membresa a los conjuntos difusos
considerados.
Reglas: Los sistemas difusos emplean reglas, las cuales combinan
uno o ms conjuntos difusos de entrada (antecedentes o premisas)
y le asocian un conjunto difuso de salida (consecuente o consecuencia). Las reglas son afirmaciones del tipo SI-ENTONCES. Los
conjuntos difusos del antecedente se asocian mediante operadores
difusos (AND,OR,NOT,etc.).
Inferencia: En este bloque se utilizan mecanismos de inferencia
para relacionar conjuntos difusos de entrada y salida mediante las
reglas que rigen al sistema. Las entradas de este bloque son conjuntos difusos a los que les corresponde un valor de membresa, y las
salidas son de igual forma conjuntos difusos, asociados a la variable
de salida.
1

Desfusificador: Bloque en el cual a partir del conjunto difuso

obtenido en el mecanismo de inferencia y mediante los mtodos
matemticos de desfusificacin se obtiene un valor concreto de la
variable de salida.

2.
2.1.

Implementacin del Sistema Difuso en

Arduino
Hardware del Sistema Difuso

Se dise un sistema difuso que se compone de dos entradas y una salida. Las entradas consisten en dos fotorresistencias, las cuales poseen una
resistencia variable debido a la variacin de la luz del entorno que las
rodea, y que por medio de un divisor de voltaje envan seales analgicas
al Arduino. La salida es el ngulo del eje de rotacin de un servomotor
(de 0 a 180 grados), que actuar de acuerdo a las reglas que se hayan establecido. La salida se maneja por uno de los puertos de Arduino del tipo
PWM. Se presenta el diagrama esquemtico del sistema implementado:

Figura 2: Diagrama esquemtico

Las siguientes figuras muestran el sistema implementado de una manera ms ilustrativa, con el propsito de dar un mayor entendimiento del
funcionamiento del sistema.

Figura 3: Diagrama ilustrativo de conexiones

Figura 4: Implementacin fsica del sistema

2.2.

Software del Sistema Difuso

Esta parte del sistema es la que nos concierne, ya que aqu es donde se
emplean los conceptos de lgica difusa. A continuacin se enumeran y
explican de manera concisa las funciones creadas para el Sistema Difuso
implementado.
3

Funciones de Calibracin:
Calibracin mnima: Funcin que se encarga de girar el mecanismo 180 grados en sentido anti-horario para detectar el
valor de entrada de luz mnimo.
Calibracin mxima: Funcin que se encarga de girar el mecanismo 180 grados en sentido horario para detectar el valor
de entrada de luz mximo.
Funciones de Base de Datos:
Normalizacin: Toma como argumento de entrada el valor mnimo y mximo de un rango de valores y los mapea en un rango
de 0 a 1.
Desnormalizacin: Mapea un rango de valores de 0 a 1 a el
rango de valores de x a y, donde x es el valor mnimo original
y y el valor mximo original.
Funciones del Sistema Difuso (Tipo I):
Funcin general: Funcin que acta como un sistema difuso en
general, llevando a cabo los procesos de fusificacin, inferencia
y desfusificacin haciendo uso de las reglas propuestas.
Subfuncin trapezoidal: Se utiliza en la fusificacin para
calcular los grados de membresa de los valores lingsticos
de los extremos (muy bajo y muy alto).
Subfuncin triangular: Se utiliza en la fusificacin para
calcular los grados de membresa de los valores lingsticos
intermedios (bajo, medio y alto).

2.3.

Experimentacin

Se presentan los datos numricos obtenidos desde el monitor serial de la

interfaz de Arduino.

Intensidad
de luz
(Entrada 1)

Intensidad
de luz
(Entrada 2)

186
153
123
303
55
84
113
263
339
305
229
153
128
65
50
76
105
134
323
330
294
226
357
163
145
118
297
51
68
78
115
247
125
197
133

92
153
415
43
308
239
192
168
60
46
62
102
262
386
329
251
192
192
99
42
39
51
33
91
135
374
56
306
228
213
186
70
27
25
161

Diferencia
en la intensidad de
luz
94
0
-292
260
-253
-155
-79
95
279
259
167
51
-134
-321
-279
-175
-87
-58
224
288
255
175
324
72
10
-256
241
-255
-160
-135
-71
177
98
172
-28

Posicin angular
(Salida)
45
90
171
3
149
135
126
51
16
33
45
69
129
180
159
135
130
117
26
21
38
45
0
56
87
168
6
148
135
135
124
45
75
45
107

Cuadro 1: Datos de experimentacin

3.

Conclusiones

A partir de los datos anteriores se puede concluir lo siguiente acerca del

sistema difuso y las reglas implementadas:
Entre ms pequeo sea el valor absoluto de la diferencia en la in5

tensidad de luz entre ambas entradas, el ngulo del servomotor se

aproxima a los 90 grados.
Entre ms grande sea la diferencia en las entradas y est diferencia
sea positiva, el ngulo del servomotor se aproxima a los 0 grados.
Entre ms grande sea la diferencia en las entradas y est diferencia
sea negativa, el ngulo del servomotor se aproxima a los 180 grados.

4.
4.1.

Anexos
Reglas del Sistema Difuso
Intensidad
de luz
(Entrada 1)
1
2
3
4
5
1
2
2
3
3
4
4
5
1
3
2
4
3
5
1
4
2
5
1
5

Intensidad
de luz
(Entrada 2)
1
2
3
4
5
2
1
3
2
4
3
5
4
3
1
4
2
5
3
4
1
5
2
5
1

Posicin angular
(Salida)
3
3
3
3
3
4
2
4
2
4
2
4
2
4
2
4
2
4
2
5
1
5
1
5
1

Cuadro 2: Datos de experimentacin

donde los nmeros del 1 al 5 representan los siguientes valores lingsticos:
1: Luz muy baja (entradas) / ngulo del eje de rotacin muy bajo
(salida)
6

2: Luz baja (entradas) / ngulo del eje de rotacin bajo (salida)

3: Luz media (entradas) / ngulo del eje de rotacin medio (salida)
4: Luz alta (entradas) / ngulo del eje de rotacin alto (salida)
5: Luz muy alta (entradas) / ngulo del eje de rotacin muy alto
(salida)

4.2.
1

Cdigo implementado en Arduino

#i n c l u d e <Servo . h>
Servo myServo ; // i n i t i a l i z e Servo : myServo
// C o n s t a n t s
c o n s t i n t num_inputs =2; // number o f i n p u t s
c o n s t i n t num_outputs =1; // number o f o u t p u t s
c o n s t i n t num_rules =25; // number o f r u l e s

11

13

15

17

19

21

23

25

27

29

// G l o b a l v a r i a b l e s
i n t c a l i b m i n _ r e a d y =0; // c a l i b r a t i o n min i s not ready
i n t calibmax_ready =0; // c a l i b r a t i o n max i s not ready
i n t v_min=0; // s a v e s t h e min v a l u e o f l i g h t
i n t v_max=0; // s a v e s t h e max v a l u e o f l i g h t
i n t input_1 =0; // o b t a i n s t h e l i g h t l e v e l o f LDR1 ( Range :
0 -1023)
i n t input_2 =0; // o b t a i n s t h e l i g h t l e v e l o f LDR2 ( Range :
0 -1023)
d o u b l e norm_in1 =0; // s a v e s t h e input_1 c o n v e r t e d i n a
n o r m a l i z e d v a l u e ( Range : 0 - 1 )
d o u b l e norm_in2 =0; // s a v e s t h e input_2 c o n v e r t e d i n a
n o r m a l i z e d v a l u e ( Range : 0 - 1 )
d o u b l e l i g h t _ l e v e l [ 2 ] ; // s a v e s norm_in1 and norm_in2 i n an
input vector
d o u b l e output =0; // s a v e s t h e output o f t h e Fuzzy System Type
I ( Range : 0 - 1 )
i n t s e r v o _ a n g l e =0; // s a v e s t h e output c o n v e r t e d i n a
d e n o r m a l i z e d v a l u e ( Range : 0 - 1 8 0 )
// Rules
i n t DataBase [ num_rules ] [ num_inputs+num_outputs ]={
{ 1 , 1 , 3 } , // 1
{ 2 , 2 , 3 } , // 2
{ 3 , 3 , 3 } , // 3
{ 4 , 4 , 3 } , // 4
{ 5 , 5 , 3 } , // 5

31

33

35

37

39

41

43

45

47

49

{ 1 , 2 , 4 } , // 6
{ 2 , 1 , 2 } , // 7
{ 2 , 3 , 4 } , // 8
{ 3 , 2 , 2 } , // 9
{ 3 , 4 , 4 } , // 10
{ 4 , 3 , 2 } , // 11
{ 4 , 5 , 4 } , // 12
{ 5 , 4 , 2 } , // 13
{ 1 , 3 , 4 } , // 14
{ 3 , 1 , 2 } , // 15
{ 2 , 4 , 4 } , // 16
{ 4 , 2 , 2 } , // 17
{ 3 , 5 , 4 } , // 18
{ 5 , 3 , 2 } , // 19
{ 1 , 4 , 5 } , // 20
{ 4 , 1 , 1 } , // 21
{ 2 , 5 , 5 } , // 22
{ 5 , 2 , 1 } , // 23
{ 1 , 5 , 5 } , // 24
{ 5 , 1 , 1 } // 25
};

51

55

void setup ( ) {
S e r i a l . b e g i n ( 4 8 0 0 ) ; // I n i t i a l i z e S e r i a l Port COM
myServo . a t t a c h ( 9 ) ; // Servo c o n n e c t e d i n p i n 9
}

57

void loop ( ) {

53

59

61

63

65

67

69

71

73

75

// C a l i b r a t i o n ( o b t a i n i n g min and max v a l u e s )

i f ( c a l i b m i n _ r e a d y==0){
v_min=calib_min ( ) ;
}
c a l i b m i n _ r e a d y =1;
i f ( calibmax_ready==0){
v_max=calib_max ( ) ;
myServo . w r i t e ( 9 0 ) ;
}
calibmax_ready =1;
// N o r m a l i z a t i o n
input_1=analogRead (A0) ; // r e a d i n g LDR1 v a l u e
input_2=analogRead (A1) ; // r e a d i n g LDR2 v a l u e
l i g h t _ l e v e l [ 0 ] = n o r m a l i z e ( input_1 , v_min , v_max) ; // input_1
normalized
l i g h t _ l e v e l [ 1 ] = n o r m a l i z e ( input_2 , v_min , v_max) ; // input_2
normalized

// f o r v a l u e s l e s s than z e r o a f t e r n o r m a l i z i n g , t a k e them a s
zero .
i f ( l i g h t _ l e v e l [0] <0) {
light_level [0]=0;
}
i f ( l i g h t _ l e v e l [1] <0) {
light_level [1]=0;
}

77

79

81

83

// f o r v a l u e s g r e a t e r than one a f t e r n o r m a l i z i n g , t a k e them

a s one .
i f ( l i g h t _ l e v e l [0] >1) {
light_level [0]=1;
}
i f ( l i g h t _ l e v e l [1] >1) {
light_level [1]=1;
}

85

87

89

91

95

// Fuzzy System ( Type 1 )

output=FuzzySysT1 ( l i g h t _ l e v e l , DataBase , num_inputs , num_rules
);
s e r v o _ a n g l e=d e n o r m a l i z e ( output , 0 , 1 8 0 ) ;

97

myServo . w r i t e ( s e r v o _ a n g l e ) ;

93

Serial
Serial
Serial
Serial
Serial
Serial
Serial
Serial
Serial
Serial
Serial

99

101

103

105

107

109

111

. p r i n t ( input_1 ) ;
. print ( " & " ) ;
. p r i n t ( input_2 ) ;
. print ( " & " ) ;
. print ( servo_angle ) ;
. print ( " " ) ;
. write (92) ;
. write (92) ;
. print ( " " ) ;
. write (92) ;
. println ( " hline " ) ;

// d e l a y ( 2 0 0 ) ;

113

115

117

119

i n t calib_min ( ) {
myServo . w r i t e ( 0 ) ;
i n t lim_min1=analogRead (A0) ; // s u p p o s e t h e f i r s t v a l u e o f
i n 1 i s t h e min v a l u e
i n t lim_min2=analogRead (A1) ; // s u p p o s e t h e f i r s t v a l u e o f
i n 2 i s t h e min v a l u e
f o r ( i n t i =1; i <=180; i ++){
myServo . w r i t e ( i ) ;

i n t sensor_1=analogRead (A0) ;
i n t sensor_2=analogRead (A1) ;

121

123

i f ( sensor_1<lim_min1 ) {
lim_min1=sensor_1 ;
}

125

127

i f ( sensor_2<lim_min2 ) {
lim_min2=sensor_2 ;
}
delay (50) ;

129

131

133

135

137

139

}
i n t lim_min=min ( lim_min1 , lim_min2 ) ; // o b t a i n i n g t h e min
v a l u e between both s e n s o r s
r e t u r n lim_min ;

i n t calib_max ( ) {
myServo . w r i t e ( 1 8 0 ) ;
i n t lim_max1=analogRead (A0) ; // su p p o s e t h e f i r s t v a l u e o f
i n 1 i s t h e max v a l u e
i n t lim_max2=analogRead (A1) ; // su p p o s e t h e f i r s t v a l u e o f
i n 2 i s t h e max v a l u e

141

f o r ( i n t i =1; i <=180; i ++){

myServo . w r i t e ( 1 8 0 - i ) ;
i n t sensor_1=analogRead (A0) ;
i n t sensor_2=analogRead (A1) ;

143

145

i f ( sensor_1>lim_max1 ) {
lim_max1=sensor_1 ;
}

147

149

i f ( sensor_2>lim_max2 ) {
lim_max2=sensor_2 ;
}
delay (50) ;

151

153

155

157

}
i n t lim_max=max( lim_max1 , lim_max2 ) ; // o b t a i n i n g t h e max
v a l u e between both s e n s o r s
r e t u r n lim_max ;

159

161

163

d o u b l e n o r m a l i z e ( i n t val , i n t l_min , i n t l_max ) {

d o u b l e norm_val ;
norm_val = ( d o u b l e ( v a l ) - d o u b l e ( l_min ) ) / ( d o u b l e ( l_max ) d o u b l e ( l_min ) +0.000001) ;
r e t u r n norm_val ;
}

10

165

167

169

i n t d e n o r m a l i z e ( d o u b l e norm_val , i n t l_min , i n t l_max ) {

int val ;
v a l = round ( norm_val ( l_max - l_min +0.000001)+l_min ) ;
return val ;
}

171

173

175

177

179

double trapezoidmf ( double x , double a , double b , double c , double

d){
d o u b l e mf=max( min ( min ( ( x - a ) / ( b - a +0.000001) , 1 ) , ( d - x ) / ( d - c
+0.0000001) ) , 0 ) ;
r e t u r n mf ;
}
double t r i a n g l e m f ( double x , double a , double b , double c ) {
d o u b l e mf=max( min ( ( x - a ) / ( b - a +0.000001) , ( c - x ) / ( c - b +0.000001) )
,0) ;
r e t u r n mf ;
}

181

d o u b l e f u z z i f i c a t i o n ( d o u b l e x , i n t n , d o u b l e V [ ] ) { // Obtains
membresy v a l u e f o r a l i n g u i s t i c v a l u e ; x : Normalized i n p u t
; n : L i n g u i s t i c v a l u e t o be e v a l u a t e d ; V [ ] : Parameters f o r
t r i a n g l e s and t r a p .
183

185

187

189

191

double
double
double
double

a=V [ 0 ] ;
b=V [ 1 ] ;
c=V [ 2 ] ;
mf ;

i f ( n==1){
mf=t r a p e z o i d m f ( x , a - 0 . 1 6 6 6 , a , b , c ) ;
r e t u r n mf ;
}

193

195

197

199

201

i f ( n==2){
mf=t r i a n g l e m f ( x , a , b , c ) ;
r e t u r n mf ;
}
i f ( n==3){
mf=t r i a n g l e m f ( x , a , b , c ) ;
r e t u r n mf ;
}

203

205

207

i f ( n==4){
mf=t r i a n g l e m f ( x , a , b , c ) ;
r e t u r n mf ;
}

11

i f ( n==5){
mf=t r a p e z o i d m f ( x , a , b , c , c +0.1666) ;
r e t u r n mf ;
}

209

211

213

215

217

i f ( n==0){
mf=1;
r e t u r n mf ;
}

219

d o u b l e FuzzySysT1 ( d o u b l e X [ ] , i n t DB [ ] [ 3 ] , i n t i n p u t s , i n t
rules ){
221

223

225

227

d o u b l e PARAM[ 5 ] [ 3 ] = {
{0 ,0.1666 ,0.3333} ,
{0.1666 ,0.3333 ,0.5} ,
{0.3333 ,0.5 ,0.6666} ,
{0.5 ,0.6666 ,0.8333} ,
{0.6666 ,0.8333 ,1}
};

229

double V [ 3 ] ;
231

d o u b l e AC[ 5 ] = { 0 , 0 . 2 5 , 0 . 5 , 0 . 7 5 , 1 } ; // Output Height Fuzzy S e t

233

d o u b l e Fo [ 2 5 ] ;
235

237

239

241

243

245

247

249

f o r ( i n t r =0; r <=(r u l e s - 1 ) ; r++){ // f o r each r u l e ( row )

d o u b l e sumin =1; // v a r i a b l e t h a t s a v e s t h e minimum v a l u e
f o r each r u l e .
int n;
f o r ( i n t i =0; i <=(i n p u t s - 1 ) ; i ++){ // f o r each i n p u t ( column )
n=DB[ r ] [ i ] - 1 ; // -1 b e c a u s e i n Arduino , p o s i t i o n z e r o
e x i s t s i n Arrays
i f ( n> -1) {
V[ 0 ] =PARAM[ n ] [ 0 ] ;
V[ 1 ] =PARAM[ n ] [ 1 ] ;
V[ 2 ] =PARAM[ n ] [ 2 ] ;
}
d o u b l e mf=f u z z i f i c a t i o n (X[ i ] , ( n+1) ,V) ;
sumin=min ( sumin , mf ) ;
}
Fo [ r ] = sumin ;
}

251

253

// h e i g h t d e f u z z i f i e r
d o u b l e sum1=0;

12

255

257

259

261

d o u b l e sum2 = 0 . 0 0 0 0 0 0 0 1 ;
f o r ( i n t r =0; r <=(r u l e s - 1 ) ; r++){ // changed r u l e s f o r r u l e s - 1
sum1=(sum1+(Fo [ r ] AC[DB[ r ] [ 2 ] - 1 ] ) ) ;
sum2=(sum2+Fo [ r ] ) ;
}
d o u b l e y=sum1/sum2 ;
return y ;

Referencias
[1] Mendel, Jerry M. Fuzzy Logic Systems for Engineering: A Tutorial, Fellow, IEEE, 1995.

13