Memoria Final Tesis

UNIVERSIDAD TECNOLOGICA DE CHILE
INACAP
INGENIERIA AUTOMATIZACION Y CONTROL INDUSTRIAL
TRABAJO DE TITULACION PARA OBTENER EL TITULO DE INGENIERO

EN AUTOMATIZACION Y CONTROL INDUSTRIAL
VELOCIRAPTOR
SEGUIDOR DE LINEA
Profesor Gua:
- Hernn Segundo Pimentel Torrejn
- Joel David Vega Caro
- Cesar Antonio Uribe Mendoza
NOMBRE DEL AUTOR O AUTORES

Juan Manuel Glvez Castro
Italo Inostroza Burgos
Pgina
1
AO EN QUE SE PRESENTA EL TRABAJO
2015
Agradecimientos
Italo Fabian Inostroza Burgos
Bueno, durante el tiempo transcurrido en la carrera he conocido mucha gente tal vez no todas
han sido un aporte, pero s estuvieron cuando se requera cosa que me sorprenda cada vez que pasaba
ya que no lo esperaba, por lo que creo que es necesario dar las gracias de alguna manera a ellos.
Es primordial tambin dar las gracias a mi compaero de tesis, el que ha sido un factor
importante en todo esto. Opino que lo logrado con el Velociraptor no hubiera sido capaz con otro
compaero, ya que con Juan tenemos un mtodo de trabajo bastante similar pero a la vez diferente, lo
que nos lleva a complementar nuestra programacin y el funcionamiento de todo esto. Gracias
compadre, lejos el mejor equipo.
Principalmente dar las gracias a mi familia en general cada uno ha cumplido con factores
importantes en todo esto, cada uno me ha ayudado a su manera. Mi hermana con su apoyo
incondicional. Mi padre que siempre me quito tiempo pero me dio el pie ganar experiencia y eso lo
valoro bastante, ya que l es el motivo de que yo me incline por esta rea y por supuesto mi madre,
siempre acompandome a su manera, mimndome, preocupndose de que duerma, que descanse, que
me alimente y mucho ms... gracias a todos sin ustedes no estara aqu.
Pgina
2
Juan Manuel Glvez Castro
Primero que todo quisiera agradecer a cada uno de mis compaeros que he conocido en esta
etapa de mi vida, ya que el hecho de estudiar juntos me ha fortalecido en la parte acadmica, pero en
especial a Italo ya que como dijimos una vez siempre supimos que haramos la tesis juntos, he
aprendido hartas cosas de l y yo s que l tambin ha aprendido cosas de m, pero a lo que conlleva
esta situacin de agradecimiento a mi mejor amigo en la universidad es que en el encontr confianza y
comprensin, dos cualidades que hoy en da es difcil de encontrar y ms que por el trabajo que
logramos juntos quiero agradecer a l por ser una gran persona y un excelente amigo.
La otra persona que quiero agradecer es a mi madre ya que ella es la nica persona que estuvo
conmigo comparti mis logros y mis derrotas, ella siempre estuvo cuando ms la necesite siempre
estuvo conmigo y s que siempre lo estar.
Y tambin quisiera agradecer a nuestro profesor don Hernn Pimentel por confiar en nosotros
ya que nos pidi a nosotros este desafo ya que recuerdo que con la experiencia del ao pasado no
quera ms seguidores de lnea hasta que le presentamos el Velociraptor, gracias por sus lecciones y
consejos gracias por motivarnos en esta carrera y por su apoyo junto a Joel Vega.
Pgina
3
Resumen
En el presente trabajo se llevara a cabo un proyecto de implementacin de inteligencia artificial

lgica difusa, aplicada al movimiento de un vehculo, con el fin de participar y ganar la competencia
de robtica de la universidad Federico Santa Mara, la competencia consta de tres categoras:
1. Categora open.
2. Categora velocidad categora a participar.
3. Categora sumo.
En la categora que se asign por la institucin es la categora de velocidad ya que en la

competencia pasada se particip no logrando ningn podio, tomando en cuenta dicha experiencia, se
mejor el prototipo tanto de forma electrnica como mecnica, esta categora consta de dos desafos:
1. Seguir lnea en pista de velocidad.
2. Resolver un laberinto con la mayor velocidad posible.
La pista de melanina consta de una ruta negra de 19mm de espesor en la cual en cada ronda
cambiaba su ruta para demostrar que los vehculos no llevan rutas programadas, en el primer desafo
consta de 3 rondas es decir son tres pistas diferentes a seguir, en el segundo desafo consta de 3
laberintos diferentes a resolver, donde los jueces toman la mejor vuelta en velocidad y la mejor vuelta
en laberinto donde se saca un promedio dependiendo del factor de calificacin de robot presentado el
tiempo mximo asignado en la ronda y el tiempo menor realizado por el robot.
La competencia se realiz en los das 21 - 22 23 de Octubre del presente ao en la sede central

de la Universidad Federico Santa Mara ubicada en Valparaso (Ubicada en Avenida Espaa 1680,
Valparaso) donde se tuvo que perfeccionar el software implementado en Santiago, ya que la pista a
utilizar en competencia tena menos adherencia que nuestra pista y mejorar fallas mecnicas por
aerodinmica.
En este texto se ver el desarrollo, componentes, diagramas y cdigo que fueron necesarios para
llegar a la final de la competencia que fue el da 23 de Octubre del presente ao se realiz la ceremonia
de premiacin y se entregaron va online la tabla de posiciones de todas las categoras, y se entreg a
los competidores de la Universidad INACAP el premio y reconocimiento del PRIMER LUGAR EN
LA CATEGORIA VELOCIDAD.
Pgina
4
INDICE
Contenido
Resumen......................................................................................................................................4
INDICE........................................................................................................................................5
Captulo 1.....................................................................................................................................9
Introduccin a la competencia.................................................................................................9
Introduccin.........................................................................................................................9
1.1 Antecedentes..........................................................................................................10
Primer Desafo: Seguidor de Lneas..............................................................................10
Segundo Desafo: Laberinto..........................................................................................12
1.2 Planteamiento de la solucin.................................................................................14
Placa electrnica............................................................................................................15
Tarjeta de desarrollo: Baby Orangutn B-328p.............................................................16
Actuador motor DC con caja reductora.........................................................................19
Rueda solarbotics RW2i rueda (tornillo de fijacin interna).........................................20
Soporte motor reductor..................................................................................................21
Batera lipo 500mA/h....................................................................................................21
Sensor infrarrojo QTR-8A.............................................................................................23
Prototipo Montado.........................................................................................................26
Captulo 2...................................................................................................................................27
Etapa de control.....................................................................................................................27
Introduccin.......................................................................................................................27
Control PID....................................................................................................................28
Control FUZZY.............................................................................................................31
Algoritmo TREMAUX..................................................................................................42
Algoritmo por REGLA DE LA MANO DERECHA.....................................................43
Captulo 3...................................................................................................................................47
Evaluacin Econmica..........................................................................................................47
Informacin Adicional.......................................................................................................47
Pgina
5
Flujo de caja.......................................................................................................................47
Captulo 4...................................................................................................................................48
Conclusin y Anlisis............................................................................................................48
En competencia..................................................................................................................48
Anlisis..............................................................................................................................50
Conclusin.........................................................................................................................51
Captulo 5...................................................................................................................................52
Referencias............................................................................................................................52
Pginas web.......................................................................................................................52
Anexo.....................................................................................................................................53
Seguidor de Lnea con PD.................................................................................................53
Lgica difusa con una entrada...........................................................................................57
Lgica difusa con dos entradas (error - delta error)..........................................................64
Algoritmo laberinto...........................................................................................................71
ndice de figura
Fig.1.1 Representativa del escenario 1......................................................................................10

Fig.1.2 Representativa del escenario 2......................................................................................11
Figura (1.3) auto representativo Formula 1...............................................................................13
Figura (1.4) placa electrnica en software.................................................................................14
Figura (1.5) placa electrnica ya impresa..................................................................................14
Figura (1.6) Baby Orangutn B-328p........................................................................................15
Figura (1.7) Baby Orangutn B-328p esquemtico...................................................................18
Figura (1.8) motor HP DC con caja reductora 10:1...................................................................19
Figura (1.9) Rueda de goma RW2i............................................................................................20
Figura (1.10) Soporte motorreductor.........................................................................................20
Figura (1.11) Batera Lipo.........................................................................................................21
Figura (1.12) Cargador de batera Lipo.....................................................................................21
Figura (1.13) Sensor QTR-8A...................................................................................................22
Figura (1.14) Sensor QTR-8A esquemtico..............................................................................23
Figura (1.15) Sensor QTR-8A salida de distancia de una base blanca......................................24
Figura (1.16) Sensor QTR-8A salida de distancia de una base negra........................................24
Figura (1.17) Ensamblado de vehculo......................................................................................25
Figura (1.18) Peso de vehculo..................................................................................................25
Figura (1.19) Vehculo terminado..............................................................................................27
Pgina
6
Figura (2.1) variables de control PID........................................................................................30
Figura (2.2) lneas de programacin PID..................................................................................30
Figura (2.2) respuesta del control PID con velocidad al 31,37%..............................................31
Figura (2.4) Esquema del control difuso por Matlab.................................................................33
Figura (2.5) Variable de entrada del control difuso por Matlab.................................................33
Figura (2.6) variables de salida del control difuso por Matlab..................................................34
Figura (2.6) Reglas del control difuso por Matlab....................................................................34
Figura (2.7) Inclusin de las libreras........................................................................................35
Figura (2.8) Declaracin de las funciones de membreca..........................................................35
Figura (2.9) ejemplo de declaracin de las reglas.....................................................................36
Figura (2.10) regla difusa declarada..........................................................................................36
Figura (2.11) Fusificacion y desfusificacion en cdigo.............................................................37
Figura (2.11) Error de entrada difuso (distancia).......................................................................37
Figura (2.12) Control difuso con derivada del error..................................................................38
Figura (2.13) Variables lingsticas para control difuso con dos entradas................................39
Figura (2.14) Variables lingsticas de la derivada del error.....................................................39
Figura (2.15) Reglas establecidas para control difuso con 2 entradas.......................................40
Figura (2.16) Surface para motor izquierdo..............................................................................41
Figura (2.17) Surface para motor derecho.................................................................................41
Figura (2.18) reglas en cdigo c para control difuso de dos entradas.......................................41
Figura (2.19) Respuesta del error con control difuso delta error...............................................42
Figura (2.20) Algoritmo de resolucin de laberinto parte I.......................................................44
Figura (2.21) Algoritmo de resolucin de laberinto parte II......................................................45
Figura (2.22) algoritmo de resolucin de laberinto en cdigo C++..........................................45
Figura (2.23) condicin de final de laberinto............................................................................46
Figura (2.24) funcin de arreglo................................................................................................46
Figura (2.25) funcin arreglo completo.....................................................................................47
Figura (2.26) representacin del arreglo....................................................................................47
Figura (4.0) tabla de tiempos generales.....................................................................................49
Figura (4.1) tabla de factor de competencia..............................................................................49
Figura (4.2) tabla final de posiciones........................................................................................50
Pgina
7
Captulo 1
Introduccin
En el presente captulo se dar a conocer los antecedentes, objetivos y la solucin para la

peticin de esta institucin de participar y ganar la competencia de robtica 2015 en la Universidad
Federico Santa Mara.
En los antecedentes se ver las bases de la competencia 2015, ya que todos los aos la
competencia cambia los requisitos y objetivos de cada categora.
En los objetivos se ver en gran aspecto los objetivos a cumplir para primeramente entrar en
competencia y luego estar presente los tres das de dicha competencia, cabe sealar que se tiene que
tener en conocimiento los hechos que son causales de descalificacin, ya sea por ronda o la categora
completa
En la solucin cabe sealar que se tom el proyecto anterior y se desech toda la tecnologa
implementada en la competencia de robtica 2014, se presenta el prototipo de auto ya fabricado ante
los profesores guias, tambin se presenta las dos estrategias de control implementado en cdigo C++,
cabe recordar de que en competencia el robot tiene que ser totalmente autnomo sin comunicacin del
exterior mientras se compite.
Las lgicas de control a presentar sos:

PID.
LOGICA DIFUSA
Estas lgicas fueron basadas en una plataforma matemtica MATLAB, donde se obtuvieron
datos aproximados para comenzar a experimentar en velocidad, cabe sealar que en la etapa de
laberinto se aplican algoritmos de solucin de este, en este caso se usara la lgica de la mano derecha,
este algoritmo se usara para reconocer el laberinto desde el inicio hasta cuadrado negro el final
punto verde en pista, para la obtencin de la solucin del laberinto desde el final hasta el inicio se
presenta la siguiente solucin.
Algoritmo de eliminacin de ruta.
Pgina
8
1.1 Antecedentes
Para el presente proyecto se present un desafo en la cual consista en participar y ganar la

competencia de robtica de la Universidad Federico Santa Mara, siguiendo con la misma categora de
nuestros compaeros en la oportunidad pasada en el ao 2014.
La Robtica siempre busca mejorar los tiempos en que las mquinas realizan trabajos, por ende el
concepto de velocidad se vuelve importante a la hora del diseo e implementacin. La velocidad es una
capacidad que depende de 4 factores importantes: fuerza, resistencia, versatilidad y flexibilidad. No es
tan sencillo conjugar estos factores, por lo que se requiere de un trabajo profesional y detallista para
realizar las tareas con la mayor eficiencia posible. La Organizacin de la XIII Competencia Robtica
presenta un desafo para encontrar el mejor Robot velocista que cumpla con estos tres factores.
Objetivos Generales de la Categora
Construir un Robot con la finalidad de completar los objetivos de los 2 desafos propuestos de esta
categora: velocidad y Laberinto.
Restricciones de los Robots
Debe ser totalmente autnomo. ***

En ningn momento sus dimensiones pueden exceder a las de un cubo de
150[mm] de lado.*
Debe ser capaz de iniciar sus actividades con un slo toque.
No puede comunicarse con el exterior del escenario. ***
*causal de descalificacin en la ronda, equivalente a una no presentacin.

***causal de descalificacin de la categora, no pudiendo competir en esta.
Primer Desafo: Seguidor de Lneas.
Objetivo: Recorrer una lnea negra en el menor tiempo posible.

Escenario 1:
El escenario consiste en una lnea curva de 19 [mm] de ancho. sta se encuentra dentro de una
superficie lisa (melanina) con forma rectangular de 2000[mm] de largo y 1000 [mm] de ancho.
Pgina
9
El recorrido de la lnea es cerrado.
Existir un tramo de partida en lnea recta de 200[mm] de largo en el cual se ubicarn sensores
infrarrojos dirigidos en forma paralela a la superficie y perpendicular a la lnea recta.
El trayecto de este desafo es aleatorio.
Fig.1.1 Representativa del escenario 1.
Modalidad
Un representante por equipo deber posicionar el robot en el tramo de partida de tal manera
que no active el sensor de proximidad. Dicho sensor ser utilizado para medir el tiempo en que el robot
se demora en recorrer la lnea negra.
El rbitro verificar que cumpla con las reglas establecidas e indicar el momento para que el
representante del equipo inicie la actividad de su robot.
El Robot debe seguir la lnea negra en un solo sentido y concluyendo dos vueltas.
Visto desde arriba, el robot debe estar siempre posicionado sobre la lnea negra. Si el robot
est completamente al costado izquierdo o derecho de la lnea negra, ser retirado del escenario,
obteniendo el tiempo mximo *.
Para las curvas se define un radio mnimo de 100 mm con un mximo de 180 grados. (Valores
aproximados).
Rondas
Los equipos tendrn 3 oportunidades (Rondas) para desarrollar el desafo.
Pgina
10
Por cada ronda se lanzar una moneda para sortear el sentido en que se debe recorrer la lnea.
El tiempo elegido en este desafo ser el mejor de los tiempos obtenidos en las rondas.
*Tiempo Mximo*: corresponde al mayor de los tiempos entre todos los tiempos elegidos. (Ver
punto 3 Rondas).
Segundo Desafo: Laberinto.
Objetivo: Resolver un laberinto en el menor tiempo posible.

Escenario 2:
El escenario consiste en un laberinto construido en base a rectas negras de 19[mm] de espesor dentro
de un rectngulo de melanina de 2000[mm] x 1800[mm].
El lugar de partida se encuentra demarcado por un cuadrado de 200[mm] de lado por el cual cruza
una recta.
El final del laberinto est demarcado por un crculo verde. De 50[mm] de radio.
El trayecto de laberinto vara en cada ronda.
Se ubicarn sensores infrarrojos dirigidos en forma paralela a la superficie y perpendicular a la lnea

en el lugar de partida para medir el tiempo. Imagen 3 representativa del escenario 2.
Imagen 4 representativa del escenario 2.
Fig.1.2 Representativa del escenario 2.
Pgina
11
Modalidad
Para dar inicio a la actividad al Robot, uno de los representantes del equipo debe posicionar
su Robot en el lugar de partida y esperar la indicacin del juez.
Una vez dada la indicacin, el Robot debe seguir las lneas con el objetivo de encontrar el
crculo verde que marca el final del laberinto.
En caso de que el Robot deje de seguir la trayectoria, tiene 3 segundos para retomar la
trayectoria, de lo contrario marcar el tiempo mximo*.
No puede saltarse los trayectos (cada lnea recta que compone el recorrido).
Una vez que el Robot encuentre el final del laberinto debe volver al punto de partida en el
menor tiempo posible siguiendo las lneas negras sin saltarse trayectos.
Rondas
Los equipos tendrn 3 oportunidades (Rondas) para desarrollar el desafo.

El tiempo elegido en este desafo ser el mejor de los tiempos obtenidos en las rondas.
*Tiempo Mximo*: corresponde al mayor de los tiempos entre todos los tiempos elegidos. (Ver
punto 2 Rondas).
Sistema de Puntuacin.
Para decidir los equipos ganadores de esta categora se utilizar la siguiente ecuacin que entregar un
puntaje, siendo el ganador el que obtenga el menor valor:
(1.1)
Donde,
Ki es un factor asignado por la organizacin el cual pondera el puntaje del desafo i.
Ti es el tiempo obtenido por el robot en el desafo i.
Ti, mx. Es el tiempo mximo en el desafo i.
Los Factores Ki sern asignados en base a los videos solicitados en las bases generales y sern
publicados antes de iniciar el evento.
Pgina
12
1.2 Planteamiento de la solucin
Para realizar estos desafos se busca en la tesis y experiencia anterior para tener algunos parmetros
de fabricacin, se puede observar que el vehculo presentado se encuentra dentro del lmite de
dimensin obligatoria en la presente competencia 2015 y se puede observar que el robot es muy
pesado, por conclusin, no tiene el concepto de velocidad, se desecha el prototipo (2014) y se piensa en
crear un prototipo de auto, pensado en la aerodinmica, peso y rendimiento electromecnico.
Cabe sealar que el tiempo lmite de construccin y para demostrar el funcionamiento es hasta el 14
de septiembre de 2015, esta es la fecha lmite que la Universidad Federico Santa Mara estipulo para
preseleccionar a los competidores, por lo tanto se busca por medio de la herramienta internet diseos de
autos aerodinmicamente conocidos, donde se lleg a la competencia de autos frmula 1, se analiz los
comportamientos en velocidad de los autos y se decide implementar el chasis y diseo aerodinmico y
se lleva a placa electrnica.
Figura (1.3) auto representativo Formula 1
Para lograr la construccin de este prototipo pensado, se tiene que ampliar el mercado, ya que en el
mercado nacional no existen componentes electrnicos y mecnicos similares a los requeridos, donde
se lleg al mercado de Colombia, y se encuentran mejores elementos a los pensados inicialmente.
Pgina
13
En el mercado colombiano se encuentra una diversidad de componentes, donde se encuentra la
empresa POLOLU que trabaja con tarjetas de desarrollo simplificadas, en esta empresa encontramos
todos los materiales necesarios para poder crear nuestro vehculo.
Los componentes que se decidieron implementar son:
Pgina
14
Placa electrnica
Para la planificacin de la placa electrnica se utilizara el software PCB Wizard y se ver la

dimensiones a medida en que se fabrica la placa electrnica, ya que recordemos que no nos podemos
exceder de las dimensiones de un cubo de 15cm.
El diseo de la placa electrnica queda de la siguiente forma:
Figura (1.4) placa electrnica en software
Pgina
15
Figura (1.5) placa electrnica ya impresa
Tarjeta de desarrollo: Baby Orangutn B-328p
Esta tarjeta de desarrollo tiene la ventaja de trabajar en la plataforma de Arduino a travs de un

parche que la empresa Pololu nos facilita, y su plataforma natal de AVR que es el AtmelStudio, en esta
plataforma se puede programar toda la familia de chips Atmel.
La particularidad que tiene esta tarjeta, es que puede ser totalmente configurable a todas las
necesidades que se requieran.
El baby Orangutn B-328p es un controlados muy compacto pero completo, tiene un chip
ATmega328P AVR microcontrolador (con 32 KB de memoria y 2 KB de RAM) y dos canales de
accionamiento de motor tipo puente H con un conjunto de 18 pines configurables de forma
independiente, se pueden conectar sensores y motores de forma directa y tambin puede ser
complemento de un controlador ms grande.
Figura (1.6) Baby Orangutn B-328p
El Baby Orangutn es una solucin de control completa para pequeos espacios, todo est
incluido en un pequeo encapsulado DIP de 24 de pines con un dimensionado de 1.2x 0.7, este
Pgina
16
diseo compacto elimina los componentes ms voluminosos como la pantalla LCD y los interruptores,
conservando las caractersticas ms esenciales de la lnea de control.
Esta tarjeta de desarrollo tiene un puente H doble, para el control directo de dos motores de
corriente continua (DC).
Contiene dos led indicadores, un led verde que indica que el dispositivo esta energizado y un
led rojo que nos indica estados internos de la tarjeta de desarrollo como comunicacin serial,
interrupciones o estados de programacin externa, abordo contiene un potencimetro de ajuste para la
salida AD7, adems tiene un resonador de 20 MHz con protecciones electrnicas de retorno de
corriente.
La eliminacin de los componentes grandes permite un precio accesible en comparacin a las

otras tarjetas de desarrollo.
El baby orangutn se basan en la familia AVR de Atmel, tiene un soporte de desarrollo libre,
como el Atmel Studio IDE y el compilador GCC WinAVR c /c++ y los programadores de bajo costo
como el programador Pololu AVR USB.
La comparacin de los procesadores ATmega48, ATmega168, ATmega328, las principales

diferencias entre mega 48 y mega 328p son el tamao de memoria, el apoyo gestor de arranque,
adems de las frecuencias de trabajo.
Tabla 1.1 Comparacin de ATmega

mega48 mega168 mega328p
Flash 4k Bytes 16k Bytes 32k Bytes
RAM 512 Bytes 1024 Bytes 2048 Bytes
Eeprom 256 Bytes 512 Bytes 1024 Bytes
tamao de los 1 vector de 2 vector de 2 vector de
vectores de interrupcin/W interrupcin/W interrupcin/W
interrupcin ord ord ord
128, 256, 256, 512,
512, o 1024, o
seccin 1024words 2048words
no aplica
bootloader (256, 512, (512, 1024,
1024, o 2048, o
2048 bytes) 4096 bytes)
Pgina
17
Tabla 1.2 Descripcin de B-328p
Especificaciones generales de mega328p
Atmega 328p @
Procesador 20MHz
RAM 2048 bytes
Memoria de programa 32 Kbytes
Motor driver TB6612FNG
Canales de motores 2
Pines de I/O 18
Max. corriente por pin 40mA
Min. voltaje de operacin 5V
Max. voltaje de operacin 13.5V
Corriente de salida por canal 1A
Peak de corriente de salida por canal 3A
Max. PWM frecuencia 80 KHz
Proteccin de voltaje inverso si
Programador externo si
LCD NO
Pgina
18
Pgina
19
Figura (1.7) Baby Orangutn B-328p esquemtico
Actuador motor DC con caja reductora
Este motor reductor es de una alta potencia en miniatura constituido de un motor de corriente
continua con una caja de engranajes de 9.96:1, tiene una seccin transversal de 10 x 12 mm y un eje de
salida del reductor en forma de D, es de 9mm de largo y 3 mm de dimetro.
La especificacin clave es que a los 6v tenemos 3000rpm y 120 mA sin carga, 0.3kg-cm y 1.6
A en la parada.
Estos diminutos motores reductores de CC estn destinados para su uso continuo en 6V aunque
en general, este tipo de motores pueden funcionar a tensiones por encima y por debajo de este voltaje
nominal, por lo que deben operar cmodamente en el rango de 3-9V. Tensiones ms bajas podran no
ser prcticas y voltajes ms altos podran comenzar a afectar negativamente a la vida del motor.
Los motores reductores de metal estn disponibles en una amplia gama de engranajes ratios de 5:1
hasta 1000:1 y con cuatro motores diferentes:
De alta potencia con escobillas de carbn de toda la vida(HPCB)

De alta potencia con la vida ms corta cepillos de metal(HP)
De potencia media (MP)
Baja potencia
Figura (1.8) motor HP DC con caja reductora 10:1
Rueda solarbotics RW2i rueda (tornillo de fijacin interna)
Pgina
20
La rueda de goma RW2i cuenta con un tornillo de fijacin interna ideal para diseos con
limitaciones de espacio. La rueda tiene un dimetro de 1.1
Descripcin
Esta rueda tiene un cubo de aluminio anodizado grueso para la mxima traccin (ideal para mini
sumos robots o robot de seguimiento de lnea, que necesiten traccin para las curvas muy cerradas).
Esta rueda cuenta con un tornillo de fijacin interna oculta debajo de la llanta. Esto ahorra un
valioso espacio en el diseo del robot ya que se necesita ahorrar la mayor cantidad de espacio
posible por el lmite de espacio requerido en la competencia de robtica 2015.
Figura (1.9) Rueda de goma RW2i
Tiene un dimetro de 1,1 (28mm) y es de 0.5 (12.7mm) de ancho. El buje de aluminio se

perfora para un eje de 3mm.
Soporte motor reductor
Este soporte compacto permite el montaje conveniente de motor reductor metlico, este soporte
es de plstico y encierra los engranajes expuestos al exterior.
Pgina
21
Figura (1.10) Soporte motorreductor
Batera lipo 500mA/h
Este tipo de bateras son de alto rendimiento y es siempre una excelente idea para poder
alimentar robots de competencia ya que estn constituidas por polmero de litio (lipo).
La batera consta de 2celdas y su salida es de 7.4V y tiene un almacenamiento de carga de

500mA/h debido a que es un paquete de bateras.
Figura (1.11) Batera Lipo

Pgina
22
Dimensiones:
56mm x 30mm x 9mm.
Peso:
29 g
Este tipo de bateras necesita de un cargador especial para poder cargar las celdas de forma
homognea ya que al existir un diferencial de carga en las celdas no se asegura el correcto
funcionamiento de la batera.
Figura (1.12) Cargador de batera Lipo
Sensor infrarrojo QTR-8A
Este es un mdulo de sensor que contiene 8 IR LED, montados en una placa electrnica
diseada por fabricante por lo cual es una gran ventaja por espacio y gran versatilidad en el
seguimiento de la lnea, estos IR LED estn conectados en serie para reducir el consumo de corriente a
la mitad (segn el fabricante) y un MOSFET permite que los IR LED se enciendan fuera de las
opciones de deteccin. Cada sensor proporciona una salida de voltaje anlogo por separado.
Pgina
23
Figura (1.13) Sensor QTR-8A
Descripcin funcional
El sensor QTR-8A est pensado como sensor de lnea, pero puede ser utilizado como una
proximidad de propsito general o un sensor de reflexin de luz infrarroja. El modulo es un portador
conveniente para emisor y receptor (fototransistor) de pares de 8IR espaciados uniformemente en
9.525mm. Cada fototransistor est conectado a una resistencia PULL-UP para formar un divisor de
tensin que produce una salida de tensin anloga entre 0V y Vin (que generalmente es de 5V) como
una funcin de la IR reflejada. Una baja indicacin de salida indica una mayor reflexin.
Las salidas son todas independientes, pero los Leds estn dispuestos en pares para reducir a la
mitad el consumo de corriente, estos leds estn controlados por un MOSFET con una puerta
normalmente alta, permitiendo que los leds a ser apagados mediante el establecimiento de la puerta
MOSFET a una tensin baja. Volviendo los leds off podra ser ventajoso para limitar el consumo de
energa cuando los sensores no estn en uso o para variar el brillo eficaz de los leds a travs del control
PWM.
Los resistores limitadores de corriente del led estn para una operacin de 5V estn dispuestos
en dos etapas, esto permite una sencilla derivacin de una etapa a habilitar la operacin en el 3.3V. El
led es de aproximadamente 20 a 25 mA, por lo que el consumo se muestra a continuacin:
Pgina
24
Figura (1.14) Sensor QTR-8A esquemtico
Caractersticas:
Dimensiones 2.95x 0.5 x 0.125
Tensin de funcionamiento 3.3-5V
Corriente de alimentacin 100 mA
Formato de salida 8 tensiones anlogas
Rango de voltaje de salida 0V a la tensin suministrada
Optima distancia de deteccin 3mm
Mxima distancia de deteccin recomendada 6 mm
Peso si pines de cabecera 3.09g
Interfaz con las salidas QTR-8A
Hay varias maneras que se pueden interactuar con las salidas QTR-8A
Utilizar conversin anlogo-digital de un microcontrolador (ADC) para medir voltajes.
Utilizar un comparador con umbral ajustable para convertir cada tensin analgica en
una digital(es decir: blanco / negro) de la seal que se puede leer por la lnea I/O digital
de un microcontrolador.
Conectar la salida del sensor directamente a una lnea de entrada / salida de un
microcontrolador y confiar en el comportamiento interno.
Este ltimo mtodo funcionara si es capaz de obtener una alta reflexin de la superficie de
blanco (Figura 1.13), pero probablemente fallara si tiene un perfil de seal de menor reflexin
(Figura 1.14).
Pgina
25
Figura (1.15) Sensor QTR-8A salida de distancia de una base blanca
Figura (1.16) Sensor QTR-8A salida de distancia de una base negra

Pgina
26
El fabricante proporciona una librera AVR con funciones que hacen que sea fcil el uso de este
sensor con el controlador B-328P.
Pgina
27
Prototipo Montado
Una vez adquiridos todos los materiales previamente mencionados, comenz el montaje fsico
del Velociraptor pasando por 3 etapas de diseo
1. l diseo final del Velociraptor tuvo una variacin importante. La que costa con el cambio de
la posicin de la batera, con el fin de cambiar su centro de estabilidad an ms hacia la parte
trasera, a causa que aun mostraba pequeas levitaciones al aumentar la velocidad, lo que llevaba
al raptor al despiste.
Figura (1.19) Esquema de vehculo
Pgina
28
Figura (1.20) Vehculo terminado
Pgina
29
Captulo 2
Etapa de control
Introduccin
En este captulo se ver las lgicas de control aplicadas a este proyecto las cuales sern:
PID
Lgica difusa
Algoritmo de Tremaux
Cada lgica ser evaluada segn las respuestas requeridas a la situacin, cabe recordar que para
la competencia se escoger la lgica que pueda mantener el error 0 en la mayor velocidad posible, en el
paso siguiente se estudiara el control PID de forma rpida, por el simple hecho de que el auto tiene que
estar funcionando y ser grabado para una evaluacin de seleccin, por ende mientras ms rpido se
termine ms rpido se podr estudiar el algoritmo de Tremaux para la resolucin del laberinto.
El control por lgica difusa se va a comparar en dos aspectos, primero se estudiara de forma
visual en pista para ver comportamiento en tiempo real del auto, y segundo se ver las curvas de
respuesta para una sintonizacin ms fina de las variables lingsticas para poder llevar a el error igual
a 0 lo ms rpido posible.
Pgina
30
Control PID
Qu es el control PID?
El control PID es un mecanismo de control que a travs de un lazo de retroalimentacin permite

regular la velocidad, temperatura, presin y flujo entre otras variables de un proceso en general. El
controlador PID calcula atravez de la diferencia entre nuestra variable real contra la variable deseada
un valor que llevara la variable real al valor obtenido, es decir elimina el error
Control PID a utilizar
Por decisin del equipo, hablando de la programacion decidimos no usar librerias que incluyeran un
control directo de PID, por lo que lo agregamos de una forma matematica para que se aprecie paso a
paso el funcionamiento de este y su aplicacin.
Figura
(2.0) lazo cerrado con control PID.
Lo principal en el programa es acotar el funcionamiento de este. Es decir limitar la velocidad

mxima que en nuestro programa esta con los valores referenciales de la librera de los motores que les
crea una escala de -255 a 255, que es proporcional a una escala de voltaje que va desde los -7v a 7v.
Los valores negativos son a causa del puente H interno que posee nuestro controlador, y la forma de
llamar la funcin de est, es utilizando valores negativos para obtener un giro en direccin contraria a
la establecida por la polaridad entregada al motor
Pgina
31
Figura (2.1) variables de control PID.
Aplicacin de PID
La integracin del PID como fue mencionado. En esta oportunidad fue como es su expresin
matemtica correspondiente
Figura (2.2) lneas de programacin PID
Y la curva de respuesta para nuestro control en velocidad baja (31,37%) este valor para poder
obtener una respuesta ms clara de estas seales.
Pgina
32
Figura (2.2) respuesta del control PID con velocidad al 31,37%
Esta respuesta nos entrega el comportamiento oscilatorio de nuestro sistema y que tambin se ve
reflejado en forma visual, en la curva se puede apreciar de que el error toma el valor de 0 muchas
veces, al principio se puede ver que es el tramo de la recta porque es el tramo del error menos
oscilatorio y las desviaciones ms grandes son las curvas, mientras ms grande es el error ms cerrada
es la curva.
Pgina
33
Control FUZZY
Las computadoras manejan datos precisos que se reducen a cadenas de unos (1) y ceros (0) y
proposiciones que son ciertas y falsas. El cerebro humano puede razonar con informacin que
involucra incertidumbre o juicios de valor como: el auto va lento o la velocidad es rpida. Adems,
las personas tienen un sentido comn que les permite razonar en un mundo donde las cosas son
parcialmente ciertas.
La lgica difusa es una rama de la IA que le permite a una computadora analizar informacin
del mundo real en una escala entre lo falso y verdadero. Los matemticos dedicados a la lgica en la
dcada de 1920 definieron un concepto clave: todo es cuestin de grado. La lgica difusa
manipula conceptos vagos como lento o rpido y permite a los ingenieros construir televisores,
acondicionadores de aire, lavadores y otros dispositivos que juzgan informacin difcil de definir. Los
sistemas difusos son una alternativa a las nociones de pertenencia y lgica que se iniciaron en la Grecia
antigua.
El lenguaje natural maneja conceptos no precisos como hace fro o el precio es alto.
Cuando se traduce el lenguaje humano al contexto de la lgica clsica se pierde la riqueza del
significado, prdida que puede ser importante si estamos diseando un sistema experto. Suponiendo
que se disea un sistema experto en reproducir la capacidad de diagnstico de un mdico, el ingeniero
sabe que el mdico se basa en medidas exactas, pero el diagnstico y la receta de las medicinas estn
llenos de razonamiento difuso.
Cuando los matemticos carecen de algoritmos que dictan cmo un sistema debe responder a
ciertas entradas, la lgica difusa puede controlar o describir el sistema usando reglas de sentido comn
que se refieren a cantidades indefinidas. Los sistemas difusos frecuentemente tienen reglas tomadas de
expertos, pero cuando no hay experto los sistemas difusos adaptivos aprenden las reglas observando
cmo la gente manipula sistemas reales.
Para poder lograr el objetivo de tener la mayor velocidad se establecern las variables de:
Derecha
Centro
Izquierda
Esto es para saber en qu posicin se encuentra el vehculo y la compensacin de los motores se

establecer de la siguiente forma:
Lento
Medio
Rpido
Pgina
34
En primera instancia se trabajara directamente con la posicin del vehculo, es decir con el
error, para esto de los datos anteriores se obtiene el rango del error, para lograr sus definiciones.
Figura (2.4) Esquema del control difuso por Matlab.
Donde D representa la distancia, MI motor izquierdo y MD motor derecho, la idea principal es

detectar la posicin de los sensores sobre la lnea y por medio del diferencial de velocidad de los
motores para cambiar la posicin a medida que avanza.
Pgina
35
Figura (2.5) Variable de entrada del control difuso por Matlab.
En la figura de arriba se muestra las variables lingsticas, conde se muestra resaltada la

variable de C que representa centro con un rango de [-900 -50 50 900] esto se debe a que cuando el
auto est en el centro no tiene un valor exacto por la posicin de los sensores en la placa.
Las dems variables solo son para poder obtener ms reglas de control as tener una mayor
resolucin ante el actuar de los motores.
Figura (2.6) variables de salida del control difuso por Matlab.
Pgina
36
En esta figura se muestra las variables lingsticas de los motores ambas salidas son iguales por
ende las grficas son las mismas.
Para estas variables se establecen las siguientes reglas:
Figura (2.6) Reglas del control difuso por Matlab
En estas reglas se define principalmente si el errores 0 ambos motores van rpido, si existe
alguna diferencia ya sea para la izquierda o derecha los motores de forma independiente varia su
velocidad segn corresponda.
En el cdigo las funciones de membreca se establecen con las funciones de la librera de

control difuso de Arduino.
Figura (2.7) Inclusin de las libreras
Como toda librera estas tienen que ser incluidas en el programa, en este caso las libreras est
dividida para mejor funcionamiento.
Pgina
37
Figura (2.8) Declaracin de las funciones de membreca
En la figura 2.8 se puede apreciar los valores incluidos desde Matlab y modificados a
travs de la prueba y error en las funciones de membreca de las salidas estn con variables declaradas
con anterioridad ya que ambos motores tienen que tener las mismas variables, en la configuracin de
salida la funcin de membreca de LLI y LLD est considerada para el drift del vehculo en el caso de
que la curva sea muy cerrada.
Figura (2.9) ejemplo de declaracin de las reglas
Pgina
38
En la figura 2.9 se muestra como se configura una regla con las tres libreras
FuzzyRuleAntecedent(); FuzzyRuleConsequent(); FuzzyRule();
FuzzyRuleAntecedent(); con esta funcin se declara la condicin de IF, declarada con

anterioridad en Matlab (figura 2.6), donde la primera regla es :
IF DISTANCIA ES IZQUIERDA THEN MOTOR IZQUIERDO ES LENTO Y MOTOR

DERECHO ES RAPIDO
Y en cdigo seria ifdistanciaIZ.
FuzzyRuleConsequent(); con esta funcin se declaran la salida o consecuencia de la condicin

establecida, como la consecuencia de la distancia es izquierda el motor izquierdo va lento y el motor
derecho va rpido, donde en el cdigo seria:
ThenMOTORILIAndMOTORDRD.
Para luego agregar lo que se estableci en el antecedente y consecuencia en la funcin

FuzzyRule();
Figura (2.10) regla difusa declarada
Figura (2.11) Fusificacin y desfusificacin en cdigo
Pgina
39
En la figura 2.11 se muestra la funcin fuzzyfi(); en la cual toma la seal declarada con
anterioridad setInput(1, error); y fusifica los valores obtenidos, para que la librera fuzzy.c nos
entregue los valores ya desfusificados por medio de la funcin defuzzifi();.
Por medio de la funcin Serial.print(); se obtendrn los valores del error en tiempo real.
Para esta configuracin la respuesta fue la siguiente:
Figura (2.11) Error de entrada difuso (distancia)
En la respuesta anterior se muestra la respuesta oscilatoria de nuestro sistema volvindolo

crticamente inestable, en los tiempos entre 500 y 1500 (ms) se pueden ver siclos un poco ms estables,
esto se debe porque el auto en lneas rectas trata de estabilizar su posicin, cabe sealar que la pista
ocupada para realizar las pruebas son curvas muy cerradas y continuas.
Con esta respuesta nos damos cuenta de que el sistema es ms oscilatorio con esa configuracin
y la solucin para este problema es aplicar ms reglas y para aumentar las reglas necesitamos otra
entrada al sistema, para esto se va a derivar el error obteniendo tres variables lingsticas.
Delta error positivo

Delta error negativo
Delta error cero
Estos deltas se calcularan en cdigo c obteniendo los diferenciales del error, una vez ya
trabajado con el error mismo, ya que cada instruccin en cdigo c se demora 0.05 us tiempo suficiente
para calcular el diferencial del error actual con el anterior.
Pgina
40
Figura (2.12) Control difuso con derivada del error
Por un tema de lmite de la Librera difusa solo se pueden crear 9 reglas por ende las
variables lingsticas son:
Figura (2.13) Variables lingsticas para control difuso con dos entradas
Pgina
41
En esta configuracin solo se discrimina si el robot se encuentra ala derecha, izquierda o centro.
Figura (2.14) Variables lingsticas de la derivada del error
En esta figura se puede apreciar las 3 variables lingsticas que representan la tendencia de la
curva.
POS representa la tendencia de la curva ascendente.
NEG representa la tendencia de la curva decreciente.
CERO representa la tendencia de la curva a mantenerse.
Y las funciones de membreca para la salida de los motores se mantendrn para no cambiar los
valores difusos de estos.
Pgina
42
Figura (2.15) Reglas establecidas para control difuso con 2 entradas
En la figura 2.15 se logra apreciar las 9 reglas definidas por Matlab a continuacin el respectivo
Surface de estas condiciones.
Figura (2.16) Surface para motor izquierdo
Pgina
43
Figura (2.17) Surface para motor derecho
En cdigo c las funciones se ocupan de la misma forma con la diferencia que las condiciones
cambian por ende en el programa se queda de la siguiente forma en el caso de las reglas.
Figura (2.18) reglas en cdigo c para control difuso de dos entradas
La forma de fusificar los valores de entrada se realizan de la misma forma que en el caso
anterior, al igual que la desfusificacin.
La respuesta para este sistema es al principio igual de oscilatoria pero con estabilizacin al final
de la vuelta ya que es una recta.
Pgina
44
Figura (2.19)
Respuesta del
error con control
difuso delta error
Con esta respuesta

se ve que en las
curvas el auto se
comporta de
forma ms agresiva esto
se debe a la variable de freno (FR) que cada motor tiene al final cuando el vehculo entra a la recta se
ve la clara estabilizacin en la pista.
Pgina
45
Algoritmo TREMAUX
Charles Tremaux fue un ingeniero francs del siglo XIX. l fue el que invent este algoritmo
para escapar de un laberinto. Actualmente es el ms eficiente, y nos asegura la escapatoria de
cualquier tipo de laberinto sin importar su forma.
El algoritmo es el siguiente:
De alguna manera debemos de ir marcando el camino que estamos haciendo . Cuando llegamos
a un cruce da igual hacia donde sigamos, siempre que no hayamos pasado antes por ah. Y tambin es
importante que si llegamos a un punto sin salida, volvamos al cruce anterior. Si en dicho cruce ya
hemos hecho todos los posibles caminos, retrocedemos al cruce anterior a ste. Y as sucesivamente.
En resumen, este algoritmo es una forma ordenada de probar todos los caminos posibles para
escapar. Por eso, podemos tener suerte y acertar a la primera, o podemos ir fallando incluso hasta el
ltimo caso. Lo bueno, es que por lo menos no repetiremos ningn camino, y como el laberinto es
finito, llegar un momento en el que salgamos seguro.
Como curiosidad, en un captulo de Los Simpson titulado Alto! O mi perro dispara, en el que
los miembros de la familia juegan a perderse en un laberinto, Lisa utiliza el Algoritmo de Tremaux
para salir sana y salva.
Regla de la mano derecha
Este mtodo es muy sencillito, y se utiliza desde hace cientos de aos para salir de laberintos,
catacumbas o galeras subterrneas en las que es fcil perder la nocin de espacio.
El algoritmo es el siguiente:
Cuando decidimos que queremos salir, ponemos nuestra mano derecha (tambin es anlogo
para la izquierda) apoyada en la pared, y andamos con la mano as hasta que lleguemos a la salida . Es
importante que nunca quitemos la mano de la pared. As nos aseguramos que pasamos por todas las
paredes, y por tanto encontraremos la puerta que estar en una pared.
Simple, verdad? Pero este algoritmo tiene un par de aspectos negativos. El primero es que, al
igual que el algoritmo anterior, la velocidad de escapatoria depender de la suerte por la posicin en
la que empecemos.
La otra pega, ms importante todava, es que pueden existir modelos de laberinto en el que no
sea efectivo este mtodo , y nos quedemos dando vueltas infinitamente. Un ejemplo de un laberinto as
sera uno formado por crculos concntricos, cuya salida est en medio, y nosotros nos quedemos
dando vueltas alrededor de uno de esos crculos.
Pgina
46
Pgina
47
Algoritmo por REGLA DE LA MANO DERECHA
De qu trata?
"En contra de la opinin predominante, salir de un laberinto es extremadamente sencillo;

instrucciones:
1. Apoyar la mano derecha en la pared de la derecha.
2. Avanzar manteniendo siempre la mano en contacto con la pared. Ms tarde o ms temprano
se encuentra la salida. Pues los laberintos son espacios cncavos, limitados, cerrados; los corredores,
como el ro Meandro, que parece unas veces avanzar, otras retroceder, segn informa Ovidio, no son
sino complicaciones que no cambian el carcter cerrado del espacio laberntico.
De manera que, recorriendo toda su pared interior, inevitablemente se llegar a la salida."
Una manera de explicarlo es con su Diagrama de Flujo
Pgina
48
Figura (2.20) Algoritmo de resolucin de laberinto parte I
Pgina
49
Figura (2.21) Algoritmo de resolucin de laberinto parte II
El diagrama de flujo muestra la forma correcta para la lectura y toma de decisiones para llegar
al final del laberinto, al poner en prctica el programa para tomar decisiones queda de la siguiente
manera.
Pgina
50
Figura (2.22) algoritmo de resolucin de laberinto en cdigo C++
Posterior a la toma de decisiones hay algo que es de basta importancia. Que se genera al agregar
la siguiente condicin;
Figura (2.23) condicin de final de laberinto
Donde v es un valor previamente medido del color verde, que al marcar todos en verde
genera el recorte del recorrido para volver por el tramo corto del laberinto.
Pgina
51
Figura (2.24) funcin de arreglo
A lo largo del recorrido cada curva fue remplazada por el ngulo de giro correspondiente es
decir si doblo a la derecha se marca como 90
La simplificacin de la ruta de regreso toma como referencia la suma de los grados para obtener
una respuesta de accin
Pgina
52
Figura (2.25) funcin arreglo completo
Si lo ejemplificamos de una manera ms grfica, Despus de girar 90 a la derecha,

180 en la vuelta, y 90 de nuevo a la derecha (90+180+90=360), el efecto es que el robot se dirige en
la direccin original de nuevo. La ruta puede ser simplificada con giro de 0 : un nico S que significa
Pgina
53
que siga su camino derecho.
Figura (2.26) representacin del arreglo
Captulo 3
Evaluacin Econmica
Informacin Adicional
Este proyecto a causa de que fue diseado a modo de estudio o competencia, la proyeccin
de venta no es aplicable de manera directa, a menos que se piense como algo que no es. Es decir un
proyecto pensado para el mercado.
Aun as, es destacable que el programa del Velociraptor si es aplicable a distintos campos
comerciales. A grandes rasgos esto se puede aplicar en sectores que usen vehculos para tramos
definidos, con la finalidad de mejorar tiempos de ejecucin en transporte de materias primas.
Flujo de caja
Tabla 3.1 tabla de costos
PERIODOS
Ingresos MES 1
Pgina
54
$
Inversin Inicial 180.000
Financiamiento
Total Ingresos
Ca MES 1
Egresos nt
HARDWARE
$ $
Placa 1 5.000 5.000
$ $
Conectores 15 500 7.500
$
Ruedas 2 8.000 $ 16.000
$ $
Sensor 1 7.000 7.000
$
Baby Orangutan 1 15.000 $ 15.000
$
Programador AVR 1 15.000 $ 15.000
$
Batera LIPO 2 7.000 $ 14.000
$
Cargador Batera 1 30.000 $ 30.000
$
Motor 2 10.000 $ 20.000
$
Soporte Motor 2 5.000 $ 10.000
$
Envi a Chile 1 30.000 $ 30.000
RRHH valor UF
20 $
Mano de Obra (hrs) 0 25.600 $ 5.120.000
Total Egresos $ 5.289.500
TOTAL PROYECTO $ 5.469.500
Captulo 4
Conclusin y Anlisis
En competencia
Pgina
55
En la competencia principal competencia de robtica 2015 de la universidad Federico Santa
Mara se logr una gran participacin en los tres das ya que el Velociraptor se mantuvo en primer
lugar, esto se debe a las mejoras de calibracin que se hiso en el control.
Figura (4.0) tabla de tiempos generales
Figura (4.1) tabla de factor de competencia
Pgina
56
Figura (4.2) tabla final de posiciones
Pgina
57
Anlisis
Al apreciar el proyecto a nivel de estudio, fuera de la competencia, cabe destacar su amplia

capacidad para mostrar de una manera fsica la diferencia entre cada tipo de programacin disponible
para aplicar a los robot seguidores de lnea.
Si se aplica para la pista un control ON-OFF, es funcional, pero lleva consigo limitaciones de
velocidad considerables, a causa de un muestreo no constante que espera salir de la lnea para corregir
el error.
Al aplicar un control PID, mejora considerablemente y es visible a primera instancia, ya que su

velocidad puede aumentar lo suficiente sin perder estabilidad. Aun as, luego de una cierta cantidad de
vueltas (variables segn la luz solar), llega a un punto de estabilidad crtica, perdiendo de forma brusca
el recorrido.
A diferencia de ambos controles anteriores el control FUZZY se hace notar, por su velocidad de
reaccin. Curvas veloces y precisas. Una velocidad para recorrer la pista considerable frente al resto y
no se pierde del recorrido a pesar de la cantidad de vueltas.
Con respecto al control PID en competencia resulto mejor ya que las variables a modificar son
menores con respecto al control difuso, ya que al cambiar la velocidad de un 31.37% a un 62,3% de la
velocidad mxima se tuvieron que modificar las reglas y las funciones de pertenencias en la cual en
cdigo C son muchas lneas y en competencia cuenta tiempo.
Pgina
58
Conclusin
De una manera excluyente el hecho de trabajar con 8 sensores (anteriormente se trabaj con 4),
es fundamental tener una lectura correcta de la pista para tener una medida proporcional de esta, una
mejora considerable en cuanto a la respuesta en curvas y la estabilidad en pista a mayor velocidad que
la de prueba. Es decir, dentro de un rango de 0 a 255 (escala que refleja el voltaje aplicado al motor de
0v a 7v), pasamos de trabajar a 60 a una velocidad de 170 como lmite en la estabilidad.
El bajo peso del prototipo de competencia en instancias genero poca adherencia a la pista, tema
que fue solucionado mejorando la posicin de los materiales generando un punto de estabilidad certera
y funcional. El peso final fueron 147gr.
En las curvas cuando son muy cerradas, el control PID no es muy eficiente ya que al superar la
velocidad de 62,3% el robot se sala de la pista al contrario del control difuso ya que se logr llegar a la
velocidad 70,4% obtenamos un seguimiento en las curvas muy bueno pero en lneas rectas se
demoraba 2,1 segundos ms en estabilizarse que el control PID, lo cual se observ, que el control PID
el diferencial de velocidad de los motores es menor respecto al control difuso propuesto.
Pgina
59
Captulo 5
Referencias
Pginas web
Qu es el control PID?
https://franklinelinkmx.wordpress.com/2013/09/05/que-es-el-control-pid/
Compra de materiales
https://www.pololu.com/
Alumnos del rea Electricidad y Electrnica de INACAP Santiago Sur destacan con innovador
proyecto en distintas competencias.
http://www.inacap.cl/tportalvp/portal/noticias/noticias-portal/alumnos-del-area-electricidad-y-
electronica-de-inacap-santiago-sur-destacan-con-innovador-proyecto-en-distintas-competencias
Alumnos de INACAP Santiago Sur logran una destacada participacin en la XIII Competencia de
Robtica
http://www.inacap.cl/tportalvp/santiago-sur/noticias/noticias-stgo-sur/alumnos-de-inacap-santiago-
sur-logran-una-destacada-participacion-en-la-xiii-competencia-de-robotica
Competencia de robtica 2015
http://www.competenciarobotica.cl/2015/
Puntajes de la competencia
https://docs.google.com/spreadsheets/d/1Qzw8cUAv0BbqjU9fQr9-
SBISwLV7QMcmxmR6ZUmdZaI/edit#gid=501301399
Pgina
60
Pgina
61
Anexo
Seguidor de Lnea con PD
Para comenzar el programa, es imprescindible agregar las libreras a ocupar

En este caso las llamamos de esta manera
#include <QTRSensors.h> //Librera de los sensores anlogos

#include <OrangutanMotors.h> //Librera interna del Puente en H
#define NUM_SENSORS 6 //Numero de sensores que usa
#define NUM_SAMPLES_PER_SENSOR 5 // Muestras por sensor
#define EMITTER_PIN 2 //Numero de Pines digitales a utilizar
QTRSensorsAnalog qtra ((unsigned char[]) {0,1,2, 3,4,5},
NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
//Posicin en Pin de los sensores Anlogos
Unsigned int sensorValues [NUM_SENSORS];
OrangutanMotors motors; //Activa la funcin del puente H
const int maximum = 20; //El mximo de velocidad a alcanzar

int VPropocional = 1.46; // Valor proporcional
int VDerivarivo = 30; //Valor integral
int VIntegral = 0;
int velcalibrate = 22; //Velocidad de calibracin
Pgina
62
Antes de comenzar el programa necesitamos declarar el Void setup de manera adecuada para
definir pines de trabajo, velocidad de transmisin de datos seriales y calibracin
void setup()
{ //Comienza el ciclo del Setup
//Serial.begin (9600); //Velocidad de comunicacin serial
int start = 10; // Contador para calibracin
int val = 0;
pinMode(9, OUTPUT); //pin 9 y 8 Declarado como salida
pinMode(8, OUTPUT);
pinMode(start, INPUT); //pin 10 declarado Como entrada discreta
val = digitalRead(start);
while (val == HIGH)
{
digitalWrite(9, HIGH);
};
if (val == LOW)
{
digitalWrite(9, LOW);
}
OrangutanMotors::setSpeeds(0, 0); // Motores detenidos
//-------------Instrucciones para Empezar a hacer la Calibracin de Sensores---------------------
delay(1500);
digitalWrite(8, HIGH);// Enciende el leds para indicar que se est calibrando.
for (int counter = 0; counter < 21; counter++)
{
if (counter < 6 || counter >= 15)
Orangutan Motors::setSpeeds(-velcalibrate, velcalibrate);
else
OrangutanMotors::setSpeeds(velcalibrate, -velcalibrate);
qtra.calibrate();
delay(20);
}
digitalWrite(9, LOW); // Apaga el led para indicar que se termin la calibracin.

Pgina
63
OrangutanMotors::setSpeeds(0, 0);
delay(200);
delay(200);
digitalWrite(9, LOW); // Parpadeo para indicar que el robot est listo.
delay(200); // Parpadeo para indicar que el robot est listo.
digitalWrite(8, HIGH); // Parpadeo para indicar que el robot est listo.
delay(200);
delay(200);
//---------------------------Fin Calibracin de
Sensores----------------------------------------------------//
//pinMode(start,INPUT);
//val = digitalRead(start);
while (val == HIGH)

{
};
if (val == LOW)
{
delay(1000); // Retardo X segundos antes de Empezar a andar
};
}
unsigned int last_error = 0;
long integral = 0;
Pgina
64
Para comenzar a trabajar con un control PID necesitamos obtener una derivada del error.
unsigned int last_error = 0;
long integral = 0;
void loop()
{
int position = qtra.readLine(sensorValues); // leemos posicin de la lnea en la variable position

// Serial.println(position);
// Referencia donde seguir la lnea, mitad sensores.
int error = position - 2500;
// Clculos PD
int derivative = error - last_error;
integral += error;
last_error = error;
int power_difference = error * VPropocional + integral / VIntegral + derivative * VDerivarivo;
if (power_difference > maximum)

power_difference = maximum;
if (power_difference < -maximum)
power_difference = -maximum;
if (power_difference < 0)
// {
OrangutanMotors::setSpeeds(maximum, maximum + power_difference);
// digitalWrite(9, LOW);
// digitalWrite(8, HIGH);
// }
else
// {
OrangutanMotors::setSpeeds(maximum - power_difference, maximum);
// digitalWrite(9, HIGH);
// digitalWrite(8, LOW);
// }
Pgina
65
Lgica difusa con una entrada
#include <QTRSensors.h>
#include <OrangutanMotors.h>
#include <Fuzzy.h>
#include <FuzzyComposition.h>
#include <FuzzyInput.h>
#include <FuzzyIO.h>
#include <FuzzyOutput.h>
#include <FuzzyRule.h>
#include <FuzzyRuleAntecedent.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzySet.h>
/********* 7mo INTENTO DE LOGICA DIFUSA ****************/

/********* EXITO!!!!! *****************/
//------------------------------------------------------------------------------------//
/*-----PARAMETIZACION DE SENSOR DE LINEA-------*/
#define NUM_SENSORS 6 // Numero de sensores que usa

#define EMITTER_PIN 2 // emitter is controlled by digital pin 2
// sensors 0 through 5 are connected to analog inputs 0 through 5, respectively
QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3, 4, 5},
unsigned int sensorValues[NUM_SENSORS];
OrangutanMotors motors;
//--------------------------------------------------------------------------------------//
int conta=0;
//Velocidad de Calibracin
int velcalibrate = 20;
//--------------------------------------------------------------------------------------//
//variables de motores
int a=-10-10-10;
int b=0;
int c=30;
int d=50;
int e=60;
Pgina
66
int f=70;
int g=75;
int h=78;
int i=80;
/*iniciacion del FUZZY*/

Fuzzy* fuzzy = new Fuzzy();
//inicializando un objeto en biblioteca
//entrada distancia
FuzzySet* DDD = new FuzzySet(-2500, -2500, -2000, -1000);//variable linguistica izquierdo
FuzzySet* dd = new FuzzySet(-1500, -1000+200, -1000+200, -500+200);
FuzzySet* DER = new FuzzySet(-1000+200, -500+200, -500+200, 0);
FuzzySet* CEN = new FuzzySet(-50, 0, 0, 50);//variable linguistica centro
FuzzySet* IZ = new FuzzySet(0, 500-200, 500-200, 1000-200);
FuzzySet* ii = new FuzzySet(500-200, 1000-200, 1000-200, 1500);
FuzzySet* III = new FuzzySet(1000, 2000, 2500, 2500);//variable linguistica derecho
//SALIDA MOTOR IZQUIERDO

FuzzySet* LLI = new FuzzySet(a, a, a, b);
FuzzySet* LI = new FuzzySet(a, c, c, d);
FuzzySet* MI = new FuzzySet(c, e, e, f);
FuzzySet* RI = new FuzzySet(e, g, g, h);
FuzzySet* RRI = new FuzzySet(g, i, i, i);
//SALIDA MOTOR DERECHO

FuzzySet* LLD = new FuzzySet(a, a, a, b);
FuzzySet* LD = new FuzzySet(a, c, c, d);
FuzzySet* MD = new FuzzySet(c, e, e, f);
FuzzySet* RD = new FuzzySet(e, g, g, h);
FuzzySet* RRD = new FuzzySet(g, i, i, i);
//--------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------//
void setup()
{
Serial.begin(115200);
int inPin = 10;
int val = 0;
pinMode(9, OUTPUT);//LED DE TESTEO
pinMode(inPin,INPUT);
Pgina
67
val = digitalRead(inPin);
while (val == HIGH)
{
digitalWrite(9, HIGH);//LED DE TESTEO
};
if (val == LOW)
{
digitalWrite(9, LOW);//LED DE TESTEO
digitalWrite(8, LOW); //LED DE TESTEO
}
OrangutanMotors::setSpeeds(0,0);// Motores detenidos
//-------------Instrucciones para Empezar a hacer la Calibracin de

Sensores--------------------------------------//
delay(1000);
for (int counter=0; counter<21; counter++)
{
OrangutanMotors::setSpeeds(-velcalibrate, velcalibrate);
else
qtra.calibrate();
delay(20);
}
DigitalWrite(9, LOW); // Apaga el led para indicar que se termin la calibracin.

delay(200);
digitalWrite(9, HIGH); //LED DE TESTEO
delay(200);
Pgina
68
delay(200);
//delay(200);
//---------------------------Fin Calibracin de Sensores----------------------------------------------------//

//--------------------------------------------------------------------------------------//
/* INICIALIZACION DE VARIABLES Y REGLAS DEL FUZZY
*/
//creando las variables lingsticas
FuzzyInput* distancia = new FuzzyInput(1);
//creando el sete del fuzzy en relacin a la distancia
////////////////////////
distancia->addFuzzySet(IZ);//agregar variable linguistica a distancia
distancia->addFuzzySet(DDD);
distancia->addFuzzySet(CEN);//agregar variable linguistica a distancia
distancia->addFuzzySet(III);
distancia->addFuzzySet(DER);//agregar variable linguistica a distancia
distancia->addFuzzySet(ii);
distancia->addFuzzySet(dd);
fuzzy->addFuzzyInput(distancia);
/*No tenemos segunda variable de entrada aunque podemos incluir un

Acelermetro para tener mejor sensibilidad en la pista
*/
/* Creacin de la variable de salida */
FuzzyOutput* MOTORI = new FuzzyOutput(1);
/////////////////////
MOTORI->addFuzzySet(LLI);
MOTORI->addFuzzySet(LI);
MOTORI->addFuzzySet(MI);
MOTORI->addFuzzySet(RI);
MOTORI->addFuzzySet(RRI);
fuzzy->addFuzzyOutput(MOTORI);
/* Creacin de la segunda variable de salida */

Pgina
69
FuzzyOutput* MOTORD = new FuzzyOutput(2);
/////////////////////
MOTORD->addFuzzySet(LLD);
MOTORD->addFuzzySet(LD);
MOTORD->addFuzzySet(MD);
MOTORD->addFuzzySet(RD);
MOTORD->addFuzzySet(RRD);
fuzzy->addFuzzyOutput(MOTORD);
/* Creacin de las reglas

CADA ENTRADA TIENE UNA REGLA ESPECIFICA
*/
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//000001
FuzzyRuleAntecedent* ifdistanciaIZ = new FuzzyRuleAntecedent();
ifdistanciaIZ->joinSingle(IZ);
FuzzyRuleConsequent* thenMOTORILIAndMOTORDRD = new FuzzyRuleConsequent();

thenMOTORILIAndMOTORDRD->addOutput(LI);
thenMOTORILIAndMOTORDRD->addOutput(RD);
FuzzyRule* fuzzyRule01 = new FuzzyRule(1, ifdistanciaIZ, thenMOTORILIAndMOTORDRD);

fuzzy->addFuzzyRule(fuzzyRule01);
//------------------------------------OK------------------------------------------
//000002
FuzzyRuleAntecedent* ifdistanciaCEN = new FuzzyRuleAntecedent();
ifdistanciaCEN->joinSingle(CEN);
FuzzyRuleConsequent* thenMOTORIRRIAndMOTORDRRD = new FuzzyRuleConsequent();

thenMOTORIRRIAndMOTORDRRD->addOutput(RRI);
thenMOTORIRRIAndMOTORDRRD->addOutput(RRD);
FuzzyRule* fuzzyRule02 = new FuzzyRule(2, ifdistanciaCEN,

thenMOTORIRRIAndMOTORDRRD);
Pgina
70
//---------------------------------------OK---------------------------------------
// 000003
FuzzyRuleAntecedent* ifdistanciaDER = new FuzzyRuleAntecedent();
ifdistanciaDER->joinSingle(DER);
FuzzyRuleConsequent* thenMOTORIRIAndMOTORDLD = new FuzzyRuleConsequent();

thenMOTORIRIAndMOTORDLD->addOutput(RI);
thenMOTORIRIAndMOTORDLD->addOutput(LD);
FuzzyRule* fuzzyRule03 = new FuzzyRule(3, ifdistanciaDER, thenMOTORIRIAndMOTORDLD);

//-----------------------------------------OK-------------------------------------
// 000004
FuzzyRuleAntecedent* ifdistanciaDDD = new FuzzyRuleAntecedent();
ifdistanciaDDD->joinSingle(DDD);
FuzzyRuleConsequent* thenMOTORIMIAndMOTORDLLD = new FuzzyRuleConsequent();

thenMOTORIMIAndMOTORDLLD->addOutput(MI);
thenMOTORIMIAndMOTORDLLD->addOutput(LLD);
FuzzyRule* fuzzyRule04 = new FuzzyRule(4, ifdistanciaDDD,

thenMOTORIMIAndMOTORDLLD);
//---------------------------------OK---------------------------------------------
// 000005
FuzzyRuleAntecedent* ifdistanciaIII = new FuzzyRuleAntecedent();
ifdistanciaIII->joinSingle(III);
FuzzyRuleConsequent* thenMOTORILLIAndMOTORDMD = new FuzzyRuleConsequent();
thenMOTORILLIAndMOTORDMD->addOutput(LLI);
thenMOTORILLIAndMOTORDMD->addOutput(MD);
FuzzyRule* fuzzyRule05 = new FuzzyRule(5, ifdistanciaIII, thenMOTORILLIAndMOTORDMD); //
Passband o Antecedent e o Consequent da expression
fuzzy->addFuzzyRule(fuzzyRule05); // Aficionado o FuzzyRule au objector Fuzzy
//--------------------------------OK----------------------------------------------
//000006
Pgina
71
FuzzyRuleAntecedent* ifdistanciaii = new FuzzyRuleAntecedent();
ifdistanciaii->joinSingle(ii);
FuzzyRuleConsequent* thenMOTORIMIAndMOTORDRD = new FuzzyRuleConsequent();
thenMOTORIMIAndMOTORDRD->addOutput(MI);
thenMOTORIMIAndMOTORDRD->addOutput(RD);
FuzzyRule* fuzzyRule06 = new FuzzyRule(6, ifdistanciaii, thenMOTORIMIAndMOTORDRD); //
//----------------------------------OK--------------------------------------------
//000007
FuzzyRuleAntecedent* ifdistanciadd = new FuzzyRuleAntecedent();
ifdistanciadd->joinSingle(dd);
FuzzyRuleConsequent* thenMOTORIRIAndMOTORDMD = new FuzzyRuleConsequent();
thenMOTORIRIAndMOTORDMD->addOutput(RI);
thenMOTORIRIAndMOTORDMD->addOutput(MD);
FuzzyRule* fuzzyRule07 = new FuzzyRule(7, ifdistanciadd, thenMOTORIRIAndMOTORDMD); //
//------------------------------------OK------------------------------------------
//------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------//
}
void loop()
{
/* REVISAR LA VARIABLE DE LOS SENSORES AUNQUE DEVERIA SER sensorValues*/
float position = qtra.readLine(sensorValues); // leemos posicin de la lnea en la variable position
//-------------------------------escalamiento a %-----------------------------------------------------------//
//-----------------------------------------------------------------------------------------------------------//
// Referencia donde seguir la lnea, mitad sensores.(SP)

float error = (int)position - 2500;
/*Serial.print(" posicion: ");
Serial.print(position);
Serial.print(" error: ");
Serial.print(error);
Serial.println(" ");
*/
Pgina
72
Serial.println(error);
// dis = position;
fuzzy->setInput(1, error);
fuzzy->fuzzify();
/*
Serial.print(" izquierdo: ");
Serial.print(IZ->getPertinence());
Serial.print(" centro: ");
Serial.print(CEN->getPertinence());
Serial.print(" derecho: ");
Serial.println(DER->getPertinence());
*/
float motorI = fuzzy->defuzzify(1);
float motorD = fuzzy->defuzzify(2);
OrangutanMotors::setSpeeds(motorI, motorD);
if(motorI>motorD){digitalWrite(9, HIGH);digitalWrite(8, LOW);}

else {digitalWrite(8, HIGH);digitalWrite(9, LOW);}
//if(motorI=motorD){digitalWrite(9, HIGH);digitalWrite(8, HIGH);}
};
Lgica difusa con dos entradas (error - delta error)
#include <QTRSensors.h>
#include <Fuzzy.h>
#include <FuzzyComposition.h>
#include <FuzzyInput.h>
#include <FuzzyIO.h>
#include <FuzzyOutput.h>
#include <FuzzyRule.h>
#include <FuzzyRuleAntecedent.h>
#include <FuzzyRuleConsequent.h>
#include <FuzzySet.h>
/********* 7mo INTENTO DE LOGICA DIFUSA ****************/

/********* EXITO!!!!! *****************/
Pgina
73
//------------------------------------------------------------------------------------//
/*-----PARAMETIZACION DE SENSOR DE LINEA-------*/
#define NUM_SENSORS 6 // Numero de sensores que usa

#define EMITTER_PIN 2 // emitter is controlled by digital pin 2
// sensors 0 through 5 are connected to analog inputs 0 through 5, respectively
QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3, 4, 5},
unsigned int sensorValues[NUM_SENSORS];
OrangutanMotors motors;
//--------------------------------------------------------------------------------------//
int conta=0;
//Velocidad de Calibracion
int velcalibrate = 20;

float Derror=0;
//--------------------------------------------------------------------------------------//
/*iniciacin del FUZZY*/
Fuzzy* fuzzy = new Fuzzy();
//inicializando un objeto en biblioteca
//entrada ERROR
FuzzySet* MEN = new FuzzySet(-2500, -2500, -1800, 0);
FuzzySet* CEN = new FuzzySet(-200, 0, 0, 200);//variable linguistica centro
FuzzySet* MAY = new FuzzySet(0, 1800, 2500, 2500);
//ENTRADA DERIVADA DEL ERROR

FuzzySet* NEG = new FuzzySet(-2.5, -2.5, -0.4, 0);
FuzzySet* CERO = new FuzzySet(-1.0, 0, 0, 1.0);
FuzzySet* POS = new FuzzySet(0, 0.4, 2.5, 2.5);
//SALIDA MOTOR IZQUIERDO

FuzzySet* FRI = new FuzzySet(-10, 0, 0, 20);
FuzzySet* MI = new FuzzySet(25, 57, 57, 80);
FuzzySet* ACCI = new FuzzySet(53, 80, 80, 80);
//SALIDA MOTOR DERECHO

FuzzySet* FRD = new FuzzySet(-10, 0, 0, 20);
FuzzySet* MD = new FuzzySet(25, 57, 57, 80);
FuzzySet* ACCD = new FuzzySet(53, 80, 80, 80);
//--------------------------------------------------------------------------------------//
Pgina
74
//--------------------------------------------------------------------------------------//
void setup()
{
Serial.begin(115200);
int inPin = 10;
int val = 0;
pinMode(inPin,INPUT);
while (val == HIGH)
{
};
if (val == LOW)
{
}
OrangutanMotors::setSpeeds(0,0);// Motores detenidos
//-------------Instrucciones para Empezar a hacer la Calibracion de

Sensores--------------------------------------//
delay(1000);
for (int counter=0; counter<21; counter++)
{
OrangutanMotors::setSpeeds(-velcalibrate, velcalibrate);
else
qtra.calibrate();
delay(20);
}

Pgina
75
delay(200);
delay(200);
delay(200);
//---------------------------Fin Calibracion de Sensores----------------------------------------------------//
//--------------------------------------------------------------------------------------//
/* INICIALIZACION DE VARIABLES Y REGLAS DEL FUZZY
*/
//creando las variables lingsticas
FuzzyInput* ERR = new FuzzyInput(1);
//creando el sete del fuzzy en relacin a la distancia
/////////////////////////////
ERR->addFuzzySet(MEN);
ERR->addFuzzySet(CEN);
ERR->addFuzzySet(MAY);
fuzzy->addFuzzyInput(ERR);
/////////////////////////////
FuzzyInput* DERR = new FuzzyInput(2);
DERR->addFuzzySet(NEG);
DERR->addFuzzySet(CERO);
DERR->addFuzzySet(POS);
fuzzy->addFuzzyInput(DERR);
/*no tenemos segunda variable de entrada aunque podemos incluir un

acelermetro para tener mejor sensibilidad en la pista
*/
/* creacin de la variable de salida */
FuzzyOutput* MOTORI = new FuzzyOutput(1);
Pgina
76
/////////////////////
MOTORI->addFuzzySet(FRI);
MOTORI->addFuzzySet(MI);
MOTORI->addFuzzySet(ACCI);
fuzzy->addFuzzyOutput(MOTORI);
/* Creacin e la segunda variable de salida */

FuzzyOutput* MOTORD = new FuzzyOutput(2);
/////////////////////
MOTORD->addFuzzySet(FRD);
MOTORD->addFuzzySet(MD);
MOTORD->addFuzzySet(ACCD);
fuzzy->addFuzzyOutput(MOTORD);
/* creacin de las reglas

CADA ENTRADA TIENE UNA REGLA ESPECIFICA
*/
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//000001
FuzzyRuleAntecedent* ifERRMAYAndDERRPOS = new FuzzyRuleAntecedent();
ifERRMAYAndDERRPOS->joinWithAND(MAY,POS);
FuzzyRuleConsequent* thenMOTORIACCIAndMOTORDFRD = new FuzzyRuleConsequent();

thenMOTORIACCIAndMOTORDFRD->addOutput(ACCI);
thenMOTORIACCIAndMOTORDFRD->addOutput(FRD);
FuzzyRule* fuzzyRule01 = new FuzzyRule(1, ifERRMAYAndDERRPOS,

thenMOTORIACCIAndMOTORDFRD);
//------------------------------------OK------------------------------------------
//000002
FuzzyRuleAntecedent* ifERRCENAndDERRPOS = new FuzzyRuleAntecedent();
ifERRCENAndDERRPOS->joinWithAND(CEN,POS);
FuzzyRuleConsequent* thenMOTORIFRIAndMOTORDACCD = new FuzzyRuleConsequent();

Pgina
77
thenMOTORIFRIAndMOTORDACCD->addOutput(FRI);
thenMOTORIFRIAndMOTORDACCD->addOutput(ACCD);
FuzzyRule* fuzzyRule02 = new FuzzyRule(2, ifERRCENAndDERRPOS,

thenMOTORIFRIAndMOTORDACCD);
//---------------------------------------OK---------------------------------------
// 000003
FuzzyRuleAntecedent* ifERRMENAndDERRPOS = new FuzzyRuleAntecedent();
ifERRMENAndDERRPOS->joinWithAND(MEN,POS);
/*FuzzyRuleConsequent* thenMOTORIFRIAndMOTORDACCD = new FuzzyRuleConsequent();

*/
FuzzyRule* fuzzyRule03 = new FuzzyRule(3, ifERRMENAndDERRPOS,
//-----------------------------------------OK-------------------------------------
// 000004
FuzzyRuleAntecedent* ifERRMENAndDERRCERO = new FuzzyRuleAntecedent();
ifERRMENAndDERRCERO->joinWithAND(MEN,CERO);
/* FuzzyRuleConsequent* thenMOTORIFRIAndMOTORDACCD = new FuzzyRuleConsequent();

*/
FuzzyRule* fuzzyRule04 = new FuzzyRule(4, ifERRMENAndDERRCERO,
//---------------------------------OK---------------------------------------------
// 000005
FuzzyRuleAntecedent* ifERRMENAndDERRNEG = new FuzzyRuleAntecedent();
ifERRMENAndDERRNEG->joinWithAND(MEN,NEG);
/* FuzzyRuleConsequent* thenMOTORIFRIAndMOTORDACCD = new FuzzyRuleConsequent();

*/
Pgina
78
FuzzyRule* fuzzyRule05 = new FuzzyRule(5, ifERRMENAndDERRNEG,
//--------------------------------OK----------------------------------------------
//000006
FuzzyRuleAntecedent* ifERRCENAndDERRNEG = new FuzzyRuleAntecedent();
ifERRCENAndDERRNEG->joinWithAND(CEN,NEG);
/*
*/
FuzzyRule* fuzzyRule06 = new FuzzyRule(6, ifERRCENAndDERRNEG,
//----------------------------------OK--------------------------------------------
//000007
FuzzyRuleAntecedent* ifERRMAYAndDERRNEG = new FuzzyRuleAntecedent();
ifERRMAYAndDERRNEG->joinWithAND(MAY,NEG);
/*
*/
FuzzyRule* fuzzyRule07 = new FuzzyRule(7, ifERRMAYAndDERRNEG,
//------------------------------------OK------------------------------------------
//000008
FuzzyRuleAntecedent* ifERRMAYAndDERRCERO = new FuzzyRuleAntecedent();
ifERRMAYAndDERRCERO->joinWithAND(MAY,CERO);
/* FuzzyRuleConsequent* thenMOTORIACCIAndMOTORDFRD = new FuzzyRuleConsequent();

*/
FuzzyRule* fuzzyRule08 = new FuzzyRule(8, ifERRMAYAndDERRCERO,
//--------------------------------------OK----------------------------------------
Pgina
79
//000009
FuzzyRuleAntecedent* ifERRCENAndDERRCERO = new FuzzyRuleAntecedent();
ifERRCENAndDERRCERO->joinWithAND(CEN,CERO);
FuzzyRuleConsequent* thenMOTORIMIAndMOTORDMD = new FuzzyRuleConsequent();

thenMOTORIMIAndMOTORDMD->addOutput(MI);
thenMOTORIMIAndMOTORDMD->addOutput(MD);
FuzzyRule* fuzzyRule09 = new FuzzyRule(9, ifERRCENAndDERRCERO,

thenMOTORIMIAndMOTORDMD);
//-----------------------------------OK---------------------------------------------------//
}
void loop()
{
/* REVISAR LA VARIABLE DE LOS SENSORES AUNQUE DEVERIA SER sensorValues*/
float position = qtra.readLine(sensorValues); // leemos posicin de la lnea en la variable position
//-------------------------------escalamiento a %-----------------------------------------------------------//
//-----------------------------------------------------------------------------------------------------------//
// Referencia donde seguir la lnea, mitad sensores.(SP)

float error = (int)position - 2500;
// Serial.print(" posicion: ");Serial.print(position);
//Serial.print(" error: ");Serial.print(error);
//Serial.print(" ");Serial.print(Derror);Serial.println(" ");
Serial.println(error);
// dis = position;
fuzzy->setInput(1, error);
fuzzy->setInput(2, Derror);
fuzzy->fuzzify();
Derror = error/1000;
/*
Serial.print(" izquierdo: ");
Serial.print(IZ->getPertinence());
Serial.print(" centro: ");
Serial.print(CEN->getPertinence());
Serial.print(" derecho: ");
Serial.println(DER->getPertinence());
*/
Pgina
80
float motorD = fuzzy->defuzzify(1);
float motorI = fuzzy->defuzzify(2);
OrangutanMotors::setSpeeds(motorI, motorD);
if(motorI>motorD){digitalWrite(9, HIGH);digitalWrite(8, LOW);}

else {digitalWrite(8, HIGH);digitalWrite(9, LOW);}
//if(motorI=motorD){digitalWrite(9, HIGH);digitalWrite(8, HIGH);}
};
Algoritmo laberinto
const int estandar = 50, giro = 18;

char dir;
const int a1pin = A0;int a1 = 0;
int s1, s2, s3, s4, s5, s6;
int cont=0, cIZQ=0, cDER=0, cV=0, cGEN=0, negro = 300, listo = 0;
// Medida de lectura del negro (depende la luz del ambiente)
char path[100] = "";
unsigned char path_length = 0;
unsigned char found_left, found_straight, found_right;
void seguidor()
{
cont=0;
cDER=0;
cIZQ=0;
if (s1 == 0 && s5 == 0 && (s2 ==1 || s4 ==1)){ OrangutanMotors::setSpeeds(estandar,estandar);//
derecho
digitalWrite(9, HIGH);digitalWrite(8, HIGH);}
if (s1 == 1 && s5 == 0 && (s2 ==1 || s4 ==1)) { OrangutanMotors::setSpeeds(estandar,0);//derecha
Pgina
81
digitalWrite(8, HIGH);digitalWrite(9, LOW);}
if (s1 == 0 && s5 == 1 && (s2 ==1 || s4 ==1)) { OrangutanMotors::setSpeeds(0,estandar);
//izquierda
digitalWrite(8, LOW);digitalWrite(9, HIGH);}
}
void izq()
{
if(cont == 0){
OrangutanMotors::setSpeeds(-10-20-20-30, -20-10-20-30); //detener
OrangutanMotors::setSpeeds(-giro, giro);
delay(200-50-10);
cont=cont+1;
cIZQ=cIZQ+1;
cGEN=cGEN+1;
}
}
void der()
{
if(cont == 0){
OrangutanMotors::setSpeeds(-10-30-20-30-10, -10-30-20-30-10);//detener
OrangutanMotors::setSpeeds(giro, giro);
delay(100-20-10-30);
OrangutanMotors::setSpeeds(giro, -giro);
delay(200);
cDER=cDER+1;
cGEN=cGEN+1;
}
}
void final(){OrangutanMotors::setSpeeds(0,0);delay(1000);
delay(200);
delay(200);
Pgina
82
delay(200);}
void vuelta()
{
if(cDER == 0 && cIZQ == 0){
if(cont == 0){
OrangutanMotors::setSpeeds(-10-30-30-40-70-50, -10-30-30-40-70-50);//detener
delay(5);
OrangutanMotors::setSpeeds(giro, giro);
//delay(10);
OrangutanMotors::setSpeeds( -giro-10,giro);
delay(280);
cont=cont+1;
cV=cV+1;
cGEN=cGEN+1;
}
}
}
void direccion()
{ //xd
switch (dir) {
case 'i':
izq();
break;
case 'd':
der();
break;
case 'l':
seguidor();
break;
case 'v':
vuelta();
break;
case 'f':
final();
break;
}
}
Pgina
83
void turn(char dir)//funcin de direccin
{
switch (dir)
{ case 'L'://vuelta izquierda
izq();
break;
case 'R':// vuelta derecha
der();
break;
case 'B'://vuelta en 180
vuelta();
break;
case 'S':// no hace nada
break;
}
}
void lectura()
{
a1 = analogRead(a1pin); a2 = analogRead(a2pin); a3 = analogRead(a3pin); a4 =
analogRead(a4pin); a5 = analogRead(a5pin); a6 = analogRead(a6pin);
if (a1 >=negro){ s1 = 1;} else{s1 = 0;} //der

if (a2 >=negro){ s2 = 1;} else{s2 = 0;} //SEGUIDOR
if (a3 >=negro){ s3 = 1;} else{s3 = 0;} //cento
if (a4 >=negro){ s4 = 1;} else{s4 = 0;} //SEGUIDOR
if (a5 >=negro){ s5 = 1;} else{s5 = 0;} //izq
//seguir lnea
if (s2 == 0 && s4 == 0 && ( s3 ==1)) { dir = 'l';}
else if ( s5 == 1 && s4 == 1 && s3 == 1 && s2 == 1 && s1 == 1) { dir = 'd';}//t
else if ( s5 == 0 && s4 == 0 && s3 == 0 && s2 == 0 && s1 == 0) { dir = 'v';}//final de lnea
else if ( s5 == 1 && s4 == 1 && s3 == 1 && s2 == 1 && s1 == 1) { dir = 'f';}
//derecha
if ( s5 == 1 && s4 == 1 && s3 == 1 && s2 == 1 && s1 == 1 && s6 == 1) { dir = 'd';}
else if (s2 == 0 && s5 == 0 && s3 ==1 ) { dir = 'l';}
else if (s1 == 1 && s2 == 1 && s3 == 1 && s5==0 && s6==0 ) { dir = 'd';}
Pgina
84
//izquierda
if (s6 == 1 && s5 == 1 && s4==1 && s2 == 0&& s1 == 0) { dir = 'i';} // izquierda
}
// Get the angle as a number between 0 and 360 degrees.

total_angle = total_angle % 360;
// Replace all of those turns with a single one.

switch(total_angle)
{
case 0:
path[path_length - 3] = 'S';
break;
case 90:
path[path_length - 3] = 'R';
break;
case 180:
path[path_length - 3] = 'B';
break;
case 270:
path[path_length - 3] = 'L';
break;
}
path_length -= 2;
}
char select_turn(unsigned char found_left, unsigned char found_straight, unsigned char found_right){
//esta funcin toma la decisin de donde seguir la lnea del laberinto
if (found_left)
return 'L';
else if(found_straight)
return 'S';
else if(found_right)
return 'R';
else
return 'B';
//estos valores se usan en la funcin turn
}
void setup()
{
Pgina
85
//Serial.begin(9600);
int start = 10;
int val = 0;
pinMode(9, OUTPUT);
pinMode(8, OUTPUT);
pinMode(start, INPUT);
while (val == HIGH)

{
};
if (val == LOW)
{

delay(200);
delay(200);
delay(200);
delay(200);
}
OrangutanMotors::setSpeeds(0, 0); // Motores detenidos
OrangutanMotors::setSpeeds(estandar, estandar+5);
delay(150);
//OrangutanMotors::setSpeeds(0, 0); // Motores detenidos
}
Pgina
86
void loop()
{
lectura();
direccion();/*
unsigned char dir = select_turn(found_left, found_straight, found_right);
turn(dir);
path[path_length] = dir;
path_length ++;
simplify_path();*/
}
Pgina
87

Memoria Final Tesis

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Memoria Final Tesis

Hochgeladen von

Copyright:

Verfügbare Formate

UNIVERSIDAD TECNOLOGICA DE CHILE

INGENIERIA AUTOMATIZACION Y CONTROL INDUSTRIAL

TRABAJO DE TITULACION PARA OBTENER EL TITULO DE INGENIERO

NOMBRE DEL AUTOR O AUTORES

Italo Fabian Inostroza Burgos

En el presente trabajo se llevara a cabo un proyecto de implementacin de inteligencia artificial

En la categora que se asign por la institucin es la categora de velocidad ya que en la

La competencia se realiz en los das 21 - 22 23 de Octubre del presente ao en la sede central

Fig.1.1 Representativa del escenario 1......................................................................................10

En el presente captulo se dar a conocer los antecedentes, objetivos y la solucin para la

Las lgicas de control a presentar sos:

Algoritmo de eliminacin de ruta.

Para el presente proyecto se present un desafo en la cual consista en participar y ganar la

Objetivos Generales de la Categora

Restricciones de los Robots

Debe ser totalmente autnomo. ***

*causal de descalificacin en la ronda, equivalente a una no presentacin.

Primer Desafo: Seguidor de Lneas.

Objetivo: Recorrer una lnea negra en el menor tiempo posible.

Fig.1.1 Representativa del escenario 1.

Segundo Desafo: Laberinto.

Objetivo: Resolver un laberinto en el menor tiempo posible.

El trayecto de laberinto vara en cada ronda.

Se ubicarn sensores infrarrojos dirigidos en forma paralela a la superficie y perpendicular a la lnea

Fig.1.2 Representativa del escenario 2.

Los equipos tendrn 3 oportunidades (Rondas) para desarrollar el desafo.

Figura (1.3) auto representativo Formula 1

Los componentes que se decidieron implementar son:

Para la planificacin de la placa electrnica se utilizara el software PCB Wizard y se ver la

El diseo de la placa electrnica queda de la siguiente forma:

Figura (1.4) placa electrnica en software

Tarjeta de desarrollo: Baby Orangutn B-328p

Esta tarjeta de desarrollo tiene la ventaja de trabajar en la plataforma de Arduino a travs de un

Figura (1.6) Baby Orangutn B-328p

La eliminacin de los componentes grandes permite un precio accesible en comparacin a las

La comparacin de los procesadores ATmega48, ATmega168, ATmega328, las principales

Tabla 1.1 Comparacin de ATmega

Actuador motor DC con caja reductora

De alta potencia con escobillas de carbn de toda la vida(HPCB)

Figura (1.8) motor HP DC con caja reductora 10:1

Rueda solarbotics RW2i rueda (tornillo de fijacin interna)

Figura (1.9) Rueda de goma RW2i

Tiene un dimetro de 1,1 (28mm) y es de 0.5 (12.7mm) de ancho. El buje de aluminio se

Soporte motor reductor

Batera lipo 500mA/h

La batera consta de 2celdas y su salida es de 7.4V y tiene un almacenamiento de carga de

Figura (1.11) Batera Lipo

Figura (1.12) Cargador de batera Lipo

Sensor infrarrojo QTR-8A

Interfaz con las salidas QTR-8A

Figura (1.16) Sensor QTR-8A salida de distancia de una base negra

Figura (1.19) Esquema de vehculo

El control PID es un mecanismo de control que a travs de un lazo de retroalimentacin permite

Control PID a utilizar

Lo principal en el programa es acotar el funcionamiento de este. Es decir limitar la velocidad

Figura (2.2) lneas de programacin PID

Esto es para saber en qu posicin se encuentra el vehculo y la compensacin de los motores se

Figura (2.4) Esquema del control difuso por Matlab.

Donde D representa la distancia, MI motor izquierdo y MD motor derecho, la idea principal es

En la figura de arriba se muestra las variables lingsticas, conde se muestra resaltada la

Figura (2.6) variables de salida del control difuso por Matlab.

Para estas variables se establecen las siguientes reglas:

Figura (2.6) Reglas del control difuso por Matlab

En el cdigo las funciones de membreca se establecen con las funciones de la librera de

/* 7mo INTENTO DE LOGICA DIFUSA ********/

/-----PARAMETIZACION DE SENSOR DE LINEA-------/

/iniciacion del FUZZY/

/* 7mo INTENTO DE LOGICA DIFUSA ********/

/-----PARAMETIZACION DE SENSOR DE LINEA-------/