BENEMRITA UNIVERSIDAD AUTNOMA DE

PUEBLA
FACULTAD DE CIENCIAS DE LA ELECTRNICA

REPORTE PROYECTO FINAL

Levitador

Alumnos:
Salazar Snchez Marco Antonio 200836235
Mendoza Hernndez Felipe 201014611
Contreras De La Llave Yair 200819392

ASIGNATURA:
INTELIGENCIA ARTIFICIAL

PROFESOR:
Dra. Leticia Gmez Esparza

Puebla de Zaragoza, 24 de Abril de 2014

Objetivo:
El problema definido para la elaboracin del proyecto consiste en el desarrollo de un
controlador difuso para un sistema levitador.
Este consta de dada una distancia especfica, automticamente mantener un objeto a
dicha distancia, sin importar las perturbaciones a las que se someta el sistema.

Metodologa:
Para la elaboracin del levitador se utiliz el siguiente material:

1 bola de unicell
1 tubo de acrlico de 70 cm
1 ventilador de 12v a 0.4A
2 Abrazaderas
4 tornillos
8 tuercas
1 caja de bocina para montar el tubo y el ventilador

Para el control del dispositivo se utiliz un PIC18F4550 en el cual se hace todo el

procesamiento de la seal que se le enva al motor y la seal de retroalimentacin, el
programa fue hecho en lenguaje C, debido a la mayor familiaridad que tenemos con este
tipo de lenguaje, al principio se tena pensado usar un arduino por su fcil manejo, pero no
pudimos acoplarlo bien con el sensor, as que para no meternos en problemas cambiamos
al pic, el cual nos dio problemas con la corriente de salida, el cual se resolvi mediante el
uso de una etapa de potencia.
La seal de salida del microcontrolador fue direccionado a una etapa de potencia, que
consta de un puente H para aumentar la corriente que da la salida del pic y sea la
suficiente para alimentar al ventilador.
Para la retroalimentacin del sistema se utiliz un sensor ultrasnico, el cual manda una
onda sonora atreves del tubo, la cual al revotar con la pelota de unicell, hace que sea
posible saber su posicin en este.

Desarrollo:
Etapa de Control
PIC18F4550
Los PIC son una familia de microcontroladores tipo RISC fabricados por Microchip
Technology Inc. y derivados del PIC1650, originalmente desarrollado por la divisin de
microelectrnica de General Instrument.
El nombre actual no es un acrnimo. En realidad, el nombre completo es PICmicro,
aunque generalmente se utiliza como Peripheral Interface Controller (controlador de
interfaz perifrico).
El PIC original se dise para ser usado con la nueva CPU de 16 bits CP16000. Siendo en
general una buena CPU, sta tena malas prestaciones de entrada y salida, y el PIC de 8
bits se desarroll en 1975 para mejorar el rendimiento del sistema quitando peso de E/S a
la CPU. El PIC utilizaba microcdigo simple almacenado en ROM para realizar estas

tareas; y aunque el trmino no se usaba por aquel entonces, se trata de un

diseo RISC que ejecuta una instruccin cada 4 ciclos del oscilador.
En 1985 la divisin de microelectrnica de General Instrument se separa como compaa
independiente que es incorporada como filial (el 14 de diciembre de 1987 cambia el
nombre a Microchip Technology y en 1989 es adquirida por un grupo de inversores) y el
nuevo propietario cancel casi todos los desarrollos, que para esas fechas la mayora
estaban obsoletos. El PIC, sin embargo, se mejor con EPROM para conseguir
un controlador de canal programable. Hoy en da multitud de PICs vienen con varios
perifricos incluidos (mdulos de comunicacin serie, UARTs, ncleos de control de
motores, etc.) y con memoria de programa desde 512 a 32.000 palabras
(una palabra corresponde a una instruccin en lenguaje ensamblador, y puede ser de 12,
14, 16 32 bits, dependiendo de la familia especfica de PICmicro).
La arquitectura del PIC es sumamente minimalista. Est caracterizada por las siguientes
prestaciones:

rea de cdigo y de datos separadas (Arquitectura Harvard).

Un reducido nmero de instrucciones de longitud fija.
Implementa segmentacin de tal modo que la mayora de instrucciones duran 1
tiempo de instruccin (o 4 tiempos de reloj). Pueden haber instrucciones de dos
tiempos de instruccin (saltos, llamadas y retornos de subrutinas y otras) o
inclusive con ms tiempo de instruccin en PICs de gama alta. Esto implica que el
rendimiento real de instrucciones por segundo del procesador es de al menos 1/4
de la frecuencia del oscilador.
Un solo acumulador (W), cuyo uso (como operador de origen) es implcito (no est
especificado en la instruccin).
Todas las posiciones de la RAM funcionan como registros de origen y/o de destino
1
de operaciones matemticas y otras funciones.
Una pila de hardware para almacenar instrucciones de regreso de funciones.
Una relativamente pequea cantidad de espacio de datos direccionable
(tpicamente, 256 bytes), extensible a travs de manipulacin de bancos de
memoria.
El espacio de datos est relacionado con el CPU, puertos, y los registros de los
perifricos.
El contador de programa est tambin relacionado dentro del espacio de datos, y
es posible escribir en l (permitiendo saltos indirectos).
A diferencia de la mayora de otros CPU, no hay distincin entre los espacios de
memoria y los espacios de registros, ya que la RAM cumple ambas funciones, y
esta es normalmente referida como "archivo de registros" o simplemente, registros.

HC-SR04
El HC-SR04 es un sensor ultrasnico de bajo costo que no slo puede detectar si un
objeto se presenta, como un sensor PIR (Passive Infrared Sensor), sino que tambin
puede sentir y transmitir la distancia al objeto.
Tienen dos transductores, bsicamente, un altavoz y un micrfono. Ofrece una excelente
deteccin sin contacto (remoto) con elevada precisin y lecturas estables en un formato fcil
de usar. El funcionamiento no se ve afectado por la luz solar o el material negro como
telmetros pticos (aunque acsticamente materiales suaves como telas pueden ser
difciles de detectar). La velocidad del sonido en el aire (a una temperatura de 20C) es de
343 m/s. (por cada grado centgrado que sube la temperatura, la velocidad del sonido
aumenta en 0,6 m/s.

Caractersticas tcnicas:
Los mdulos incluyen transmisores ultrasnicos, el receptor y el circuito de control.
Nmero de pines:
VCC: Alimentacin +5V (4.5V min 5.5V mx.)
TRIG: Trigger entrada (input) del sensor (TTL)
ECHO: Echo salida (output) del Sensor (TTL)

GND
Corriente de reposo: < 2mA

Corriente de trabajo:15mA

ngulo de medicin: 30

ngulo de medicin efectivo: < 15

Deteccin de 2cm a 400cm o 1" a 13 pies (Sirve a ms de 4m, pero el fabricante

no garantiza una buena medicin).

Resolucin La precisin puede variar entre los 3mm o 0.3cm.

Dimensiones: 45mm x 20mm x 15mm

Frecuencia de trabajo: 40KHz

Etapa de Potencia
ULN2003
Debido a la pequea potencia que suministran los microcontroladores, slo podemos hacer
funcionar directamente unos LED y poco ms. Por este motivo es necesario amplificar las
salidas en funcin de las cargas que vayamos a controlar. Un mtodo sencillo y econmico
es emplear el integrado ULN2003, que es un conjunto de Darlington (Darlington Array)
montados en un chip con el que podemos controlar cargas de hasta medio amperio. El chip
lleva diodos de proteccin contra las sobretensiones producidas por cargas inductivas.
Caractersticas tcnicas:

7 Darlington por paquete

Corriente de salida 500mA por pata (600mA pico)
Voltaje de salida 50v
Diodos de supresin integrados para cargas inductivas
Salidas pueden ser paralelas para mayor corriente
Entradas compatibles TTL / CMOS / PMOS / DTL
Los pines de entrada y de salida estn acomodados opuestamente para simplificar
la salida
Rango de operacin de -20C a 85C

Sistema Difuso

El diseo de un controlador difuso implica la definicin de cada uno de los cuatro mdulos,
se asume que en algn sentido, antes de comenzar la especificacin de cada uno de ellos
en detalle, ya se conoce (o se ha definido) aproximadamente la forma que tendr. Esto es
debido a que existe una estrecha interdependencia entre todos ellos; por un lado, a medida
que se van definiendo los parmetros de un mdulo y se avanza hacia la especificacin de
los otros, un proceso de iteracin es requerido; por otro lado, el proceso puede empezar a
partir de establecer cualquiera de ellos y avanzar en el diseo, ya sea hacia delante o
hacia atrs, en la determinacin de los dems. Por ejemplo, no es posible establecer la
forma en la que la informacin medida ser convertida en difusa sin conocer previamente
la forma en la que se obtendran las reglas de control. Por ejemplo, si las reglas son
obtenidas a partir del conocimiento heurstico de un operador experto, es muy posible que
el ingeniero de control decida la seleccin del nmero de clases o valores lingsticos de
cada variable difusa en funcin del conocimiento expresado por el experto. Por el contrario,
cuando no se cuenta con informacin heurstica para describir los criterios de operacin de
la planta, se fijara un nmero aproximado de clases y la definicin de las reglas debera de
limitarse al nmero predefinido. Si el comportamiento del controlador no es el adecuado, es
posible que un aumento en el nmero de clases permita aumentar tambin la resolucin
del controlador. Las ideas de interdependencia y de un proceso de prueba y error deben
ser mantenidas en mente durante la descripcin de la arquitectura general de los
controladores difusos que se da a continuacin. El orden de exposicin no es el orden de
diseo; ms bien, es el orden que sigue el flujo de informacin a medida que las seales
de entrada son procesadas para encontrar una seal de control como respuesta.
Tabla de reglas
E
NG
Np
Z
Pp
PG

dE

NG
PG
PG
PG
Pp
Z

Np
PG
Pp
Pp
Z
Np

Z
PG
Pp
Z
Np
NG

Pp
Pp
Z
Np
Np
Np

PG
Z
Np
NG
Np
NG

Con base a la anterior tabla de reglas se defini lo siguiente:

Positivo Grande. Establecido en un rango de 26 a 6 centmetros.

Positivo pequeo. Establecido en un rango de 20 a 31 centmetros.
Zero. Establecido en un rango de 30 a 42 centmetros.
Negativo pequeo. Establecido en un rango de 48 a 52 centmetros.
Negativo Grande. Establecido en un rango de 45 a 66 centmetros.

Ancho del pulso.

Se estableci como salida el control de la velocidad del motor de corriente directa del
ventilador de manera que reaccione a la diferencia de distancia y corrija el error entre la
distancia deseada y la distancia medida con una velocidad directamente proporcional al
error. Se estableci lo siguiente:

Ancho del pulso Positivo Grande.

Ancho del pulso Positivo pequeo.
Ancho del pulso Zero.
Ancho del pulso Negativo pequeo.
Ancho del pulso Negativo Grande.

Base de reglas.

Se establecieron las siguientes condiciones:

IF distancia es Negativo Grande THEN Ancho del pulso Positivo Grande.
IF distancia es Negativo pequeo THEN Ancho del pulso Positivo pequeo.
IF distancia es altura deseada THEN Ancho del pulso Zero.
IF distancia es Positivo pequeo THEN Ancho del pulso Negativo pequeo.
IF distancia es Positivo Grande THEN Ancho del pulso Negativo Grande.
Funciones de pertenencia

Simulacin

Resultados
Se hicieron varias pruebas y se tuvieron dificultades con el sensor, el cual se corrigi
cambiando el arduino por un pic, con el cual funciono bien el sensor, pero por la corriente
de salida del pic se tuvo que implementar una etapa de potencia.
Al final se logr que la planta funcionara de manera ptima despus de varios ajustes en el
estado inicial del programa.
Conclusiones

En el presente trabajo se present el diseo de un controlador difuso, aplicado a un

sistema no lineal, el levitador, el cual se construy para las pruebas fsicas y cuyo
desempeo fue mostrado fsicamente y mediante simulacin.
Durante el desarrollo del software difuso, que es la parte modular del proyecto, para
garantizar el buen funcionamiento y estabilidad del sistema, se tuvieron algunos
contratiempos, principalmente en la parte de la modulacin, pues el mdulo de CCP del
PIC (mdulo de captura, comparacin y modulacin) tiene una frecuencia mnima de
operacin, establecida y dependiente de la frecuencia de trabajo del microcontrolador
(cristal externo), luego entonces para garantizar el trabajo del ventilador se requiere una
frecuencia de trabajo del orden de kilohertz, lo cual provoca un nivel de procesamiento de
las instrucciones demasiado lenta, siendo que lo comn es tener una frecuencia de
megahertz. A partir de este contratiempo se opt por utilizar el Timer interno del PIC para
generar los tiempos de modulacin requerida por el motor.
Para poder observar la estabilidad del sistema se utilizaron tres formas de pruebas distintas,
que coincidieron en resultado y por lo cual se determin que el sistema fue estable: La
primera fue la simulacin, la cual nos anticipa posibles resultados, en nuestro caso, el
sistema se controla con un mtodo difuso; para la simulacin se utiliz MATLAB, se
conect el modulo del control difuso de acuerdo a nuestra experiencia para controlar el
prototipo y el mdulo matemtico que rige al sistema, mostrando estabilidad al igualarse el
setpoint con la seal de salida.
La segunda prueba fue el diseo fsico, en donde se program en lenguaje C, en un
microcontrolador y despus se conect al prototipo, logrando el control de la posicin de
la pelota. Adems de que el tiempo de reaccin fue aceptable.

Programa
#include <18f4550.h>
#fuses
XTPLL,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,NOVR
EGEN,NOPBADEN,NOBROWNOUT
#device adc=10
#use delay(clock=4000000)
#byte
#byte
#byte
#byte
#byte

porta = 0xf80
portb = 0xf81
portc = 0xf82
portd = 0xf83
porte = 0xf84

#include <math.h>
#include <lcd.c>
#include <string.h>
float n;
int16 pulsos;
int16 interrupcion;
int16 valor=0;
int16 valor1=0.0;
int16 comple=0.0;
float x=0.0;
//float x1=0.0;
//float x2=0.0;
float A=0.0;
float A1=0.0;
float A2=0.0;
float A3=0.0;
float A4=0.0;
float y=0.0;
float B=0.0;
float B1=0.0;
float B2=0.0;
float B3=0.0;
float B4=0.0;
float R1=0.0;
float R2=0.0;
float R3=0.0;
float R4=0.0;
float R5=0.0;
float R6=0.0;
float R7=0.0;
float R8=0.0;
float R9=0.0;
float R10=0.0;
float R11=0.0;
float s=0.0;
float s1=0.0;
float Z=0.0;
void fuzzy (void)
{ //////////////////////////////////////////////////////////
//fuzificacion

///Distancia real
//Bajo
if(x<0.4){
A=0.0;
}
if((x>=0.4)&&(x<=0.75)){
A=(0.75-x)/(0.75-0.4);
}
if(x>0.75){
A=0.0;
}
//MedioBajo
if((x<0.7)||(x>0.85)){
A1=0.0;
}
if((x>=0.7)&&(x<=0.8)){
A1=(x-0.7)/(0.8-0.7);
}
if((x>0.8)&&(x<=0.85)){
A1=(0.85-x)/(0.85-0.8);
}
//Medio
if((x<0.8)||(x>0.9)){
A2=0.0;
}
if((x>=0.8)&&(x<=0.85)){
A2=(x-0.8)/(0.85-0.8);
}
if((x>0.85)&&(x<=0.9)){
A2=(0.9-x)/(0.9-0.85);
}
//MedioAlto
if((x<0.85)||(x>1.05)){
A3=0.0;
}
if((x>=0.85)&&(x<=0.95)){
A3=(x-0.85)/(0.95-0.85);
}
if((x>0.95)&&(x<=1.05)){
A3=(1.05-x)/(1.05-0.95);
}
//Alto
if((x<0.95)||(x>2.25)){
A4=0.0;
}
if((x>=0.95)&&(x<=2.25)){
A4=(x-0.95)/(2.25-0.95);
}
/////Distancia Anterior
y=x;
//Bajo
if(y<0.4){
B=0.0;
}
if((y>=0.4)&&(y<=0.75)){

10

B=(0.75-y)/(0.75-0.4);
}
if(y>0.75){
B=0.0;
}
//MedioBajo
if((y<0.7)||(y>0.85)){
B1=0.0;
}
if((y>=0.7)&&(y<=0.8)){
B1=(y-0.7)/(0.8-0.7);
}
if((y>0.8)&&(y<=0.85)){
B1=(0.85-y)/(0.85-0.8);
}
//MMedio
if((y<0.8)||(y>0.9)){
B2=0.0;
}
if((y>=0.8)&&(y<=0.85)){
B2=(y-0.8)/(0.85-0.8);
}
if((y>0.85)&&(y<=0.9)){
B2=(0.9-y)/(0.9-0.85);
}
//MedioAlto
if((y<0.85)||(y>1.05)){
B3=0.0;
}
if((y>=0.85)&&(y<=0.95)){
B3=(y-0.85)/(0.95-0.85);
}
if((y>0.95)&&(y<=1.05)){
B3=(1.05-y)/(1.05-0.95);
}
//Alto
if((y<0.95)||(y>2.25)){
B4=0.0;
}
if((y>=0.95)&&(y<=2.25)){
B4=(y-0.95)/(2.25-0.95);
}
// delay_ms(1000);
}
void base_de_reglas (void)
{
///////////////////////////////////////////////Base de reglas
//SI Dis anterior es bajo y dis real es bajo entonces motor va hacia derecha//R1=
min(A,B)
if(A<=B){
R1=A;}
else{
R1=B;}
//SI Dis anterior es bajo y dis real es medio entonces motor es igual//R2= min(A,B1)
if(A1<=B1){
R2=A1;}

11

else{
R2=B1;}
//SI Dis anterior es bajo y dis real es alto entonces motor va hacia izquierda//R3=
min(A,B3)
if(A1<=B2){
R3=A1;}
else{
R3=B2;}
//SI Dis anterior es bajo y dis real es alto entonces motor va hacia izquierda//R3=
min(A,B3)
if(A1<=B){
R4=A1;}
else{
R4=B;}
//SI Dis anterior es bajo y dis real es alto entonces motor va hacia izquierda//R3=
min(A,B3)
if(A2<=B3){
R5=A2;}
else{
R5=B3;}
//SI Dis anterior es medio y dis real es bajo entonces motor va hacia derecha //R4=
min(A1,B)
if(A2<=B2){
R6=B2;}
else{
R6=A2;}
//SI Dis anterior es medio y dis real es medio entonces motor es igual//R5= min(A1,B1)
if(A2<=B1){
R7=A2;}
else{
R7=B1;}
//SI Dis anterior es medio y dis real es alto entonces motor va hacia izquierda //R6=
min(A1,B2)
if(A3<=B4){
R8=A3;}
else{
R8=B4;}
//SI Dis anterior es medio y dis real es alto entonces motor va hacia izquierda //R6=
min(A1,B2)
if(A3<=B2){
R9=A3;}
else{
R9=B2;}
//SI Dis anterior es alto y dis real es bajo entonces motor va hacia derecha//R7=
min(A2,B)
if(A3<=B3){
R10=A3;}
else{
R10=B3;}
//SI Dis anterior es alto y dis real es medio entonces motor es igual//R8= min(A2,B1)
if(A4<=B4){
R11=A4;}
else{
R11=B4;}
// delay_ms(500);
}

12

void desfuzzy (void)

{
s=((R1*2.5)+(R2*3.0)+(R3*3.0)+(R4*3.2)+(R5*3.2)+(R6*4.6)+(R7*4.7)+(R8*4.7)+(R9*4.8)+(
R10*4.8)+(R11*4.9));
delay_ms(10);
s1=(R1+R2+R3+R4+R5+R6+R7+R8+R9+R10+R11);
delay_ms(10);
Z=s/s1;
}
void motor (void)
{
valor1=(1023.0*Z)/5.0;
comple=~valor1;
}
//void lcd (void)
//{
//
//
A3=(7.50*x)/2.5;
//
x1=15.0-A3;
//
if(x1>7.55){
//
output_bit(PIN_B6,1);
//
output_bit(PIN_B7,0);
//
}
//
if((x1>=7.49)&&(x1<=7.55)){
//
output_bit(PIN_B6,1);
//
output_bit(PIN_B7,1);
//
}
//
if(x1<7.49){
//
output_bit(PIN_B6,0);
//
output_bit(PIN_B7,1);
//
}
//
lcd_gotoxy(1,1);
//
printf(lcd_putc, "Dis Des 7.50cm ");
//
lcd_gotoxy(1,2);
//
printf(lcd_putc, "Dis Real %fcm ",x1);
// delay_ms(10);
//}
void main (void)
{
setup_timer_0 ( RTCC_INTERNAL | RTCC_DIV_256);
set_rtcc(217);
//10ms -> 10000us -> 10000/256=39,0625 -> 256-39=217
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1);
set_timer1(0);
interrupcion=0;
setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
setup_spi(FALSE);
setup_psp(PSP_DISABLED);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
setup_wdt(WDT_OFF);
//setup_adc_ports(RA0_ANALOG);

13

setup_adc_ports( AN0 || VSS_VDD ); // canal AN0, Vref+ = Vdd, Vref- = Vss//

Inicializacion del ADC
setup_adc(ADC_CLOCK_INTERNAL);
set_adc_channel(0);
delay_ms(10);

set_tris_c(0x00);
set_tris_b(0x00);
output_c(0x00); // Set CCP2 output low
output_b(0x00);//Entrada de pulsos por RC0
setup_ccp1(CCP_PWM);
setup_ccp2(CCP_PWM);
setup_timer_2(T2_DIV_BY_4, 255, 1);
enable_interrupts(GLOBAL);
enable_interrupts(int_RTCC);
lcd_init();
delay_ms(10);
// lcd_gotoxy(1,1);
//printf(lcd_putc, "Control Difuso!!");
//delay_ms(10);
do
{
set_adc_channel(0);
valor=read_adc();
delay_ms(10);
x=(5.0*(valor))/1023.0;
///////////fuzificacion//////////////
fuzzy();
delay_ms(10);
///////////base de reglas////
base_de_reglas();
delay_ms(10);
//////////////desfuzzy/////////////////////////
desfuzzy();
delay_ms(10);
//////////valor en motor//////////////////////
motor();
delay_ms(10);
//////////Mensaje LCD///////////////////
// lcd();
// delay_ms(10);
////////////////////////
pulsos=get_timer1();
//Se entra en la interrupcin cada 10ms
interrupcion++;
if(interrupcion==100)
//10ms 500 = 5s
{
n=pulsos;
interrupcion=0;
set_pwm1_duty(valor1);
set_pwm2_duty(comple);
set_timer1(0);
set_rtcc(217);
}
else

14

{
set_pwm1_duty(valor1);
set_pwm2_duty(comple);
set_rtcc(217);
//Inicializa el TMR0
set_timer1(n);
//Recupera los pulsos
}
// delay_ms(200);
// setup_timer_2(T2_DIV_BY_16,255,1);
//enable_interrupts(global);

// delay_ms(500);
}while(1);
}

15