Guia Seguidor de Linea

ESCUELA TCNICA SUPERIOR DE INGENIEROS
INDUSTRIALES Y DE TELECOMUNICACIN
Titulacin:
INGENIERO INDUSTRIAL
Ttulo del proyecto:
DISEO Y CONSTRUCCIN DE UN ROBOT SIGUE

LNEAS CONTROLADO A DISTANCIA CON
INTERFAZ ANDROID
Jos Luis Prez Motos

Javier Goicoechea Fernndez
Pamplona, 21 de febrero
NDICE
Captulo 1.
Introduccin y objetivos ......................................................................... 19
1.1.
Introduccin ................................................................................................... 19
1.2.
Objetivos ........................................................................................................ 20
Captulo 2.
2.1.
Robot sigue lneas................................................................................... 21
Reglamento robots rastreadores ..................................................................... 24
2.1.1.
Requisitos del robot ................................................................................ 24
2.1.2.
Pista ........................................................................................................ 24
2.1.3.
Pruebas de rastreador .............................................................................. 26
2.2.
Antecendetes .................................................................................................. 27
2.2.1.
Robot seguidor de lneas de la upna ....................................................... 27
2.2.2.
Pololu 3pi................................................................................................ 28
2.2.3.
n00b0t ..................................................................................................... 30
2.2.4.
Pocketbot 2 ............................................................................................. 31
2.2.5.
Conclusiones........................................................................................... 33
2.3.
Robots rastreadores para usos domsticos e industriales............................... 34
2.3.1.
Roomba................................................................................................... 34
2.3.2.
Kiva ........................................................................................................ 35
2.3.3.
Robot transporta medicamentos ............................................................. 36
Captulo 3.
Eleccin de componentes ....................................................................... 38
3.1.
Microcontrolador ........................................................................................... 38
3.1.1.
Qu es arduino? .................................................................................... 40
ii
3.1.2.
Ventajas .................................................................................................. 40
3.1.3.
Partes de una placa arduino .................................................................... 41
3.1.4.
Lenguaje de programacin ..................................................................... 43
3.1.5.
Modelos de Arduino ............................................................................... 46
3.1.6.
Eleccin del microcontrolador ............................................................... 49
3.2.
Ruedas ............................................................................................................ 51
3.2.1.
Configuracin de ruedas ......................................................................... 51
3.2.2.
Modelos de ruedas .................................................................................. 54
3.2.3.
Eleccin .................................................................................................. 55
3.3.
Motores .......................................................................................................... 56
3.3.1.
Motores paso a paso ............................................................................... 57
3.3.2.
Motores de corriente continua ................................................................ 59
3.3.3.
Clculo de la velocidad .......................................................................... 60
3.3.4.
Eleccin motor........................................................................................ 60
3.4.
Actuador electrnico ...................................................................................... 62
3.4.1.
Qu es un puente en H? ........................................................................ 62
3.4.2.
ULN2803 ................................................................................................ 66
3.4.3.
L298N ..................................................................................................... 68
3.4.4.
L6205N ................................................................................................... 69
3.4.5.
Pruebas L6205N ..................................................................................... 72
3.5.
Sensores infrarrojos ....................................................................................... 76
3.5.1.
QTR-8RC ............................................................................................... 78
3.5.2.
Pruebas QTR-8RC .................................................................................. 80
3.6.
Bluetooth ........................................................................................................ 83
3.6.1.
Configuracin ......................................................................................... 85
iii
3.6.2.
3.7.
Pruebas ................................................................................................... 86
Alimentacin .................................................................................................. 88
3.7.1.
Estudio de los componentes ................................................................... 88
3.7.2.
Eleccin: pilas frente a bateras LiPo ..................................................... 89
3.8.
Resumen......................................................................................................... 90
Captulo 4.
Diseo ..................................................................................................... 92
4.1.
Aspectos generales ......................................................................................... 93
4.2.
Arduino Pro Mini ........................................................................................... 96
4.3.
Programador y bluetooth ............................................................................... 98
4.4.
L6205N y motores ......................................................................................... 99
4.5.
Bola loca, QTR-8RC y pila.......................................................................... 101
4.6.
Resultado final ............................................................................................. 102
Captulo 5.
Construccin del robot ......................................................................... 111
Captulo 6.
Pruebas de los componentes del robot.................................................. 117
6.1.
Sensores infrarrojos ..................................................................................... 118
6.2.
Motores ........................................................................................................ 119
6.3.
Bluetooth ...................................................................................................... 121
6.3.1.
Conexin robot - ordenador.................................................................. 122
6.3.2.
Conexin robot mvil android........................................................... 126
Captulo 7.
Sigue lneas ........................................................................................... 129
7.1.
Declaracin de variables .............................................................................. 130
7.1.1.
Asignacin de pines .............................................................................. 130
7.1.2.
Variables de los sensores infrarrojos .................................................... 130
7.1.3.
Parmetros del PID ............................................................................... 130
7.1.4.
Variables para el clculo de la posicin ............................................... 131

iv
7.1.5.
Variables para el movimiento de los motores ...................................... 131
7.1.6.
Otras variables ...................................................................................... 131
7.2.
Configuracin del robot ............................................................................... 132
7.3.
Calibracin de los sensores infrarrojos ........................................................ 132
7.4.
Seguimiento de la lnea ................................................................................ 134
7.5.
PID ............................................................................................................... 137
7.5.1.
Qu es un controlador PID? ................................................................ 138
7.5.2.
Segundo mtodo de ziegler-nichols...................................................... 144
7.5.3.
Obtencin de los parmetros PID del robot ......................................... 145
7.5.4.
Comparativa de parmetros .................................................................. 150
7.6.
Salida del trazado ......................................................................................... 155
Captulo 8.
8.1.
Control remoto del robot ...................................................................... 156
Aplicacin Android...................................................................................... 157
8.1.1.
Declaracin de variables ....................................................................... 160
8.1.2.
Configuracin ....................................................................................... 162
8.1.3.
Conexin bluetooth .............................................................................. 162
8.1.4.
Configuracin de los acelermetros ..................................................... 164
8.1.5.
Lectura de los acelermetros ................................................................ 166
8.1.6.
Envo y recepcin de datos ................................................................... 168
8.1.7.
Representacin grfica ......................................................................... 169
8.1.8.
Nombre de la aplicacin e icono .......................................................... 173
8.2.
Programacin del robot ................................................................................ 174
8.2.1.
Recepcin de datos ............................................................................... 175
8.2.2.
Envo de datos ...................................................................................... 176
Captulo 9.
Telemetra ............................................................................................. 177

v
Captulo 10. Presupuesto.......................................................................................... 180

10.1.
Coste de la mano de obra ......................................................................... 180
10.1.1. Salario .................................................................................................. 180

10.1.2. Cargas sociales ..................................................................................... 180
10.1.3. Coste de mano de obra ......................................................................... 180
10.2.
Coste de materiales .................................................................................. 181
10.3.
Gastos varios ............................................................................................ 182
10.4.
Gastos generales ....................................................................................... 182
10.5.
Importe total del proyecto ........................................................................ 183
Captulo 11. Puntos fuertes y futuras mejoras del robot .......................................... 184
11.1.
Puntos fuertes del robot ............................................................................ 184
11.1.1. Tamao................................................................................................. 184

11.1.2. Peso ...................................................................................................... 185
11.1.3. Velocidad ............................................................................................. 185
11.1.4. Comunicacin ...................................................................................... 185
11.2.
Posibles mejoras ....................................................................................... 186
11.2.1. Disposicin de los sensores.................................................................. 186

11.2.2. Coste..................................................................................................... 186
11.2.3. Conexin mdulo bluetooth ................................................................. 187
11.2.4. Programa Android ................................................................................ 188
Captulo 12. Conclusiones ....................................................................................... 189
Bibliografa ................................................................................................................. 190
Recursos bibliogrficos .......................................................................................... 190
Recursos electrnicos ............................................................................................. 190
ANEXO A: Cdigos ................................................................................................... 193
vi
ANEXO A.1: Prueba de funcionamiento del L6205N ........................................... 193

ANEXO A.2: Prueba de funcionamiento del QTR-8RC ........................................ 193
ANEXO A.3: Configuracin del mdulo bluetooth ............................................... 195
ANEXO A.4: Prueba de funcionamiento del mdulo bluetooth ............................ 196
ANEXO A.5: Prueba de funcionamiento en el robot del QTR-8RC ...................... 197
ANEXO A.6: Prueba de funcionamiento en el robot de los LEDs delanteros y de los
motores........................................................................................................................... 199
ANEXO A.7: Prueba de la conexin bluetooth entre robot y ordenador. Arduino 201
ANEXO A.8: Prueba de la conexin bluetooth entre robot y ordenador. Matlab .. 202
ANEXO A.9: Prueba de la conexin bluetooth entre robot y dispositivo android . 203
ANEXO A.10: Funcionamiento como robot sigue lneas ...................................... 204
ANEXO A.11: Obtencin de los parmetros del controlador PID ......................... 212
ANEXO A.12: Control remoto del robot. Arduino ................................................ 213
ANEXO A.13: Control remoto del robot. Android ................................................ 215
ANEXO A.14: Telemetra ...................................................................................... 223
ANEXO B: Planos ...................................................................................................... 229
ANEXO B.1: Diseo del PCB ................................................................................ 229
ANEXO B.2: Esquema elctrico del robot ............................................................. 229
vii
Lista de figuras
Figura 1-1: Diagrama de todo el sistema ...................................................................... 19

Figura 2-1: Imagen de un circuito tipo laberinto .......................................................... 21
Figura 2-2: Imagen de un circuito para robots velocistas ............................................. 22
Figura 2-3: Imagen de un circuito para robots rastreadores ......................................... 23
Figura 2-4: Dimensiones de la pista y de las marcas de bifurcacin ............................ 25
Figura 2-5: Esquema de las bifurcaciones .................................................................... 25
Figura 2-6: ngulos mximos que pueden aparecer .................................................... 26
Figura 2-7: Robot seguidor de lnea desarrollado en otro proyecto de la UPNA ......... 27
Figura 2-8: Trayectoria que sigue el robot ................................................................... 28
Figura 2-9: Pololu 3Pi ................................................................................................... 29
Figura 2-10: n00b0t ...................................................................................................... 30
Figura 2-11: Disposicin de los sensores de n00b0t .................................................... 31
Figura 2-12: Prueba del reducido tamao del Pocketbot 2 ........................................... 32
Figura 2-13: Interfaz grfica de la aplicacin de ordenador del Pocketbot 2 ............... 33
Figura 2-14: Roomba .................................................................................................... 34
Figura 2-15: Trayectoria seguida por un robot Roomba para limpiar una habitacin .. 35
Figura 2-16: Almacn de Amazon ................................................................................ 36
Figura 2-17: Hospital Nemocnice Na Homolce de Praga ............................................ 37
Figura 3-1: Logotipo de Arduino .................................................................................. 40
viii
Figura 3-2: Esquema del modelo Arduino UNO rev3 .................................................. 41

Figura 3-3: Programacin de un Arduino UNO a travs de otro dispositivo ............... 42
Figura 3-4: Interfaz del IDE de Arduino ...................................................................... 44
Figura 3-5: Diferentes modelos de Arduino a escala. Fila superior de izquierda a
derecha: Mega, Pro Mini y LilyPad. Fila inferior de izquierda a derecha: UNO, Micro y
Leonardo .............................................................................................................................. 46
Figura 3-6: Arduino Mega ............................................................................................ 47
Figura 3-7: Arduino UNO ............................................................................................ 48
Figura 3-8: Arduino Pro Mini ....................................................................................... 48
Figura 3-9: Comparativa a escala del tamao ............................................................... 50
Figura 3-10: De izquierda a derecha: Arduino UNO, Arduino Pro Mini y conversor
Serie USB FTDI232.......................................................................................................... 51
Figura 3-11: Giros con una configuracin diferencial .................................................. 52
Figura 3-12: Giros con una configuracin triciclo ....................................................... 53
Figura 3-13: Giros con una configuracin Ackerman .................................................. 54
Figura 3-14: Tamiya Ball Caster Kit ............................................................................ 56
Figura 3-15: Rueda de goma 32x7mm (2 und) ............................................................. 56
Figura 3-16: Relacin velocidad-torque-corriente........................................................ 57
Figura 3-17: Funcionamiento motor paso a paso ......................................................... 58
Figura 3-18: Funcionamiento motor de corriente continua .......................................... 59
Figura 3-19: Motor Micro Metal DC con reductora 30:1 ............................................. 61
ix
Figura 3-20: Funda protectora para motor micro metal (2 und) ................................... 62
Figura 3-21: Esquema de un puente en H ..................................................................... 63
Figura 3-22: Giro en un sentido del motor ................................................................... 63
Figura 3-23: Giro en el otro sentido del motor ............................................................. 64
Figura 3-24: Situaciones no posibles ............................................................................ 64
Figura 3-25: Relacin entre el voltaje y la velocidad del motor en funcin del tiempo
............................................................................................................................................. 65
Figura 3-26: Esquema del ULN2803 ............................................................................ 66
Figura 3-27: Posible solucin para el ULN2803 .......................................................... 67
Figura 3-28: Esquema del L298N ................................................................................. 68
Figura 3-29: L298N ...................................................................................................... 69
Figura 3-30: Esquema del L6205N ............................................................................... 70
Figura 3-31: Relacin de pines del L6205N ................................................................. 70
Figura 3-32: Esquema de conexin del L6205N .......................................................... 72
Figura 3-33: Montaje para la prueba del L6205N ........................................................ 74
Figura 3-34: Resultado obtenido en la prueba .............................................................. 75
Figura 3-35: Matriz de sensores Pololu Zumo ............................................................. 76
Figura 3-36: Disposicin de los sensores de n00b0t .................................................... 77
Figura 3-37: QTR-8RC ................................................................................................. 77
Figura 3-38: Esquema de funcionamiento del QTR-8RC ............................................ 78
Figura 3-39: Divisin de la matriz QTR-8RC en dos ................................................... 79
x
Figura 3-40: Conexin para la prueba de funcionamiento del QTR-8RC .................... 81

Figura 3-41: Comprobacin de que los sensores infrarrojos se encuentran funcionando
............................................................................................................................................. 81
Figura 3-42: Esquema del sketch empleado para la prueba del QTR-8RC .................. 82
Figura 3-43: Resultado de la prueba del QTR-8RC ..................................................... 82
Figura 3-44: microSD Shield ........................................................................................ 83
Figura 3-45: dongle bluetooth USB .............................................................................. 84
Figura 3-46: Mdulo bluetooth ..................................................................................... 84
Figura 3-47: Conexin para la prueba de funcionamiento del mdulo bluetooth ........ 87
Figura 3-48: Diagrama del sketch empleado para la prueba de funcionamiento del
mdulo bluetooth ................................................................................................................. 87
Figura 3-49: Pantalla obtenida en el dispositivo Android ............................................ 88
Figura 3-50: Batera de 11V ......................................................................................... 89
Figura 3-51: Pilas recargables de 9V ............................................................................ 90
Figura 3-52: Elementos que compondrn el robot ....................................................... 91
Figura 4-1: Logotipos de Eagle y DesignSpark ............................................................ 93
Figura 4-2: Conexin entre programador y Arduino Pro Mini..................................... 94
Figura 4-3: Boceto del diseo a realizar ....................................................................... 95
Figura 4-4: Diferentes representaciones del Arduino Pro mini. De izquierda a derecha:
Eagle, DesignSpark, realidad ............................................................................................... 96
Figura 4-5: Problema de alimentacin del QTR-8RC .................................................. 97
xi
Figura 4-6: Conexionado entre el Arduino Pro Mini y el L6205N y el QTR-8RC ...... 98
Figura 4-7: Conexin entre Arduino Pro Mini y programador y mdulo bluetooth .... 99
Figura 4-8: Esquema en Eagle del L6205N y los componentes que necesita ............ 100
Figura 4-9: Conexin entre el L6205N y sus componentes........................................ 101
Figura 4-10: Disposicin de los taladros de la rueda loca y conexin entre Arduino Pro
Mini y L6205N .................................................................................................................. 102
Figura 4-11: Resultado final del PBC ......................................................................... 103
Figura 4-12: Resultado final con plano de masa ........................................................ 103
Figura 4-13: Representacin 3D del diseo. Vista isomtrica 1 ................................ 104
Figura 4-14: Representacin 3D del diseo. Vista isomtrica 2 ................................ 104
Figura 4-15: Representacin 3D del diseo vista de alzado ....................................... 105
Figura 4-16: Representacin 3D del diseo. Vista posterior ...................................... 105
Figura 4-17: Impresin del PBC ................................................................................. 106
Figura 4-18: Prototipo. Vista ismetrica .................................................................... 106
Figura 4-19: Prototipo. Vista de alzado. Comparacin con un boli Bic ..................... 107
Figura 4-20: Prototipo. Vista posterior ....................................................................... 107
Figura 4-21: PBC. Izquierda vista posterior. Derecha vista de alzado ....................... 108
Figura 4-22: Esquema unifilar final del robot ............................................................ 109
Figura 5-1: Colocacin de los motores ....................................................................... 111
Figura 5-2: Colocacin de los conectores hembras y machos .................................... 112
Figura 5-3: Colocacin de los LEDs delanteros y los componentes del L6205N ...... 113
xii
Figura 5-4: Colocacin de la bola loca ....................................................................... 113

Figura 5-5: Colocacin del QTR-8RC ........................................................................ 114
Figura 5-6: Colocacin del Arduino Pro Mini y del L6205N .................................... 114
Figura 5-7: Colocacin de soporte para pila y pila ..................................................... 115
Figura 5-8: Resultado final. Vista isomtrica 1 .......................................................... 115
Figura 5-9: Resultado final. Vista isomtrica 2 .......................................................... 116
Figura 6-1: Conexin del conversor FTDI232 ........................................................... 117
Figura 6-2: Diagrama del sketch empleado para la prueba de funcionamiento del QTR8RC .................................................................................................................................... 118
Figura 6-3: Valores obtenidos en funcin de la posicin relativa del robot con respecto
a la lnea ............................................................................................................................. 118
Figura 6-4: Diferentes seales PWM .......................................................................... 119
Figura 6-5: Movimientos que puede realizar el robot ................................................ 120
Figura 6-6: Esquema de comunicacin para la prueba del mdulo bluetooth ............ 122
Figura 6-7: Diagrama del sketch empleado para la prueba de conexin entre robot y
ordenador ........................................................................................................................... 123
Figura 6-8: Vinculacin entre ordenador y mdulo bluetooth ................................... 123
Figura 6-9: Comprobacin del puerto serie que se debe emplear .............................. 124
Figura 6-10: Resultado de la prueba ........................................................................... 126
Figura 6-11: Diagrama del sketch empleado para la prueba de funcionamiento de la
conexin entre robot y Android ......................................................................................... 127
Figura 6-12: Resultado obtenido en el dispositivo Android ....................................... 128
xiii
Figura 7-1: Diagrama del sketch empleado por el robot para seguir lneas ................ 129
Figura 7-2: Diagrama del sketch para calibrar los sensores infrarrojos ...................... 133
Figura 7-3: Diferencia entre los valores devueltos por los sensores infrarrojos con y sin
mapear ................................................................................................................................ 134
Figura 7-4: Deteccin de las marcas de bifurcacin ................................................... 135
Figura 7-5: Valores de los pesos que tiene cada sensor .............................................. 136
Figura 7-6: Obligacin de giro del robot segn las marcas de bifurcacin ................ 137
Figura 7-7: Diagrama de bloques de un controlador PID ........................................... 138
Figura 7-8: Representacin del tiempo de pico, del pico de sobreoscilacin y del
tiempo de estabilizacin..................................................................................................... 139
Figura 7-9: Resultados ante diferentes parmetros ..................................................... 143
Figura 7-10: Comprobacin de los signos al aplicar el PWM en el robot .................. 146
Figura 7-11: Circuito que se emplear para la prueba ................................................ 147
Figura 7-12: Efecto deseado en la prueba ................................................................... 147
Figura 7-13: Resultados de la prueba. De izquierda a derecha y de arriba abajo: Kp=1,
Kp=3, Kp=5, Kp=7, Kp=8, Kp=9 ......................................................................................... 149
Figura 7-14: Resultado de la prueba para Kp=10........................................................ 150
Figura 7-15: Resultados empleando los parmetros obtenidos en el mtodo de ZieglerNichols. Arriba se representa el error y abajo los PWM de los motores ........................... 151
Figura 7-16: Resultados empleando Kp=15. Arriba se representa el error y abajo los
PWM de los motores.......................................................................................................... 152
xiv
Figura 7-17: Resultados empleando Ki=250. Arriba se representa el error y abajo los
Figura 7-18: Resultados empleando Kd=1. Arriba se representa el error y abajo los
Figura 7-19: Salida del trazado del robot.................................................................... 155
Figura 8-1: Diagrama del funcionamiento del control remoto del robot. A la izquierda
se representa el sketch del robot. A la derecha se representa la aplicacin Android ......... 156
Figura 8-2: Logo de Basic4Android ........................................................................... 157
Figura 8-3: Logo de Amarino ..................................................................................... 158
Figura 8-4: Logo de Processing .................................................................................. 159
Figura 8-5: Conexin Processing y Eclipse ................................................................ 159
Figura 8-6: Exportacin de proyectos Android en Processing ................................... 160
Figura 8-7: Ventana de permisos de Eclipse .............................................................. 162
Figura 8-8: Interfaz de la aplicacin Android de seleccin de dispositivo a conectar 163
Figura 8-9: Representacin de los ejes de los acelermetros en un dispositivo Android
........................................................................................................................................... 165
Figura 8-10: Valores de los acelermetros en dos instantes consecutivos estando el
dispositivo Android en reposo sobre la mesa .................................................................... 167
Figura 8-11: Valores que puede tomar el acelermetro del eje x. Representacin de 9
........................................................................................................................................... 167
Figura 8-12: Problema de formatos entre Arduino y Android.................................... 168
Figura 8-13: Origen de coordenadas y dimensiones mximas en una pantalla de un
dispositivo Android............................................................................................................ 170
xv
Figura 8-14: Fondo de la representacin de los acelermetros .................................. 171

Figura 8-15: Representacin de los acelermetros. En este caso el robot ira marcha
atrs y hacia la derecha ...................................................................................................... 172
Figura 8-16: Interfaz final de la aplicacin Android. En este caso el robot estara
trazando una circunferencia en sentido contrario a las agujas del reloj ............................. 173
Figura 8-17: Lugar que ocupa el archivo strings.xml ................................................. 173
Figura 8-18: Nombre de la aplicacin ........................................................................ 174
Figura 8-19: Logo de la aplicacin Robot Control Remoto .................................... 174
Figura 9-1: Diagrama del funcionamiento de la telemetra del robot. A la izquierda se
representa el sketch del robot. A la derecha se representa la aplicacin Android ............. 177
Figura 9-2: Telemetra de Bruno Senna (Williams-Renault) en el Gran Premio de la
India 2012 .......................................................................................................................... 178
Figura 9-3: Interfaz de la aplicacin de telemetra ..................................................... 179
Figura 11-1: Comparativa de tamao con un boli Bic ................................................ 184
Figura 11-2: Comunicacin en tiempo real ................................................................ 185
Figura 11-3: Cambio de disposicin de los sensores .................................................. 186
Figura 11-4: Representacin de los costes segn componentes quitando los
componentes que no incluye el Pololu 3Pi ........................................................................ 187
Figura 11-5: Posible interfaz de la aplicacin ............................................................ 188
xvi
Lista de tablas
Tabla 3.1: Comparativa entre diferentes modelos ........................................................ 50

Tabla 3.2: Ruedas motrices........................................................................................... 55
Tabla 3.3: Ruedas locas ................................................................................................ 55
Tabla 3.4: Motores ........................................................................................................ 61
Tabla 3.5: Estados de los motores en funcin de los estados de los interruptores ....... 65
Tabla 3.6: Componentes empleados ............................................................................. 73
Tabla 3.7: Tabla de la verdad del L6205N ................................................................... 74
Tabla 3.8: Tabla de seleccin de velocidad de transmisin .......................................... 85
Tabla 3.9: Estudio de voltajes de cada componente ..................................................... 89
Tabla 3.10: Elementos que compondrn el robot ......................................................... 90
Tabla 4.1: Asignacin de pines por funcin ............................................................... 110
Tabla 4.2: Asignacin de pines por pin ...................................................................... 110
Tabla 7.1: Efectos en el sistema que tiene el aumento de cada uno de los parmetros
........................................................................................................................................... 142
Tabla 7.2: Mtodo de Ziegler-Nichols ........................................................................ 145
Tabla 10.1: Salario ...................................................................................................... 180
Tabla 10.2: Cargas sociales ........................................................................................ 180
Tabla 10.3: Coste de mano de obra ............................................................................ 180
Tabla 10.4: Coste de materiales .................................................................................. 182
xvii
Tabla 10.5: Gastos varios ........................................................................................... 182

Tabla 10.6: Gastos generales ...................................................................................... 182
Tabla 10.7: Importe total del proyecto ....................................................................... 183
xviii
Robot rastreador con interfaz Bluetooth/Android
CAPTULO 1.
J. L. Prez Motos
INTRODUCCIN Y OBJETIVOS
1.1. INTRODUCCIN
El presente proyecto abarca el diseo, construccin y configuracin de un robot
sigue lneas, as como la configuracin de una va de comunicacin inalmbrica
mediante un enlace Bluetooth y un dispositivo Android. Como su propio nombre indica,
un robot sigue lneas es un dispositivo mvil capaz de seguir una trayectoria marcada en
el suelo de forma autnoma.
El robot deber contar con una serie de sensores para deducir en qu posicin se
encuentra el robot en relacin al camino que debe seguir. Para ello el sistema ser
gobernado por un microcontrolador, el cual tendr un algoritmo de control que ser el
encargado de variar la velocidad de los motores para corregir la posicin del robot.
Como se ha comentado anteriormente, el robot se podr comunicar con otros
dispositivos a travs de tecnologa bluetooth.
Figura 1-1: Diagrama de todo el sistema
Pgina 19 de 231
J. L. Prez Motos
1.2. OBJETIVOS
El objetivo ltimo es dotar al robot de lo necesario para que pueda seguir una
trayectoria sin desviarse de ella. Para ello se debern conseguir otros objetivos:
1.
2.
3.
4.
5.
Manipulacin de sensores.
Control de motores.
Diseo de un algoritmo de control.
Programacin de un microcontrolador.
Comunicacin entre el sistema y dispositivos externos mediante bluetooth.
Pgina 20 de 231
CAPTULO 2.
J. L. Prez Motos
ROBOT SIGUE LNEAS
En las competiciones de robots existen tres modalidades distintas de robots sigue

lneas. Todas ellas comparten la forma en la que se presenta la trayectoria: el camino
que debe seguir el robot est marcado por una lnea negra sobre un fondo blanco. Sin
embargo, se diferencian en el tipo de trayectoria que deben seguir los robots as como
del objetivo final que debe alcanzar. Por lo tanto, tanto las caractersticas como la
programacin del robot difieren de una modalidad a otra. A continuacin se va a
describir cada una de estas modalidades:
Laberinto
En esta modalidad los robots deben resolver un laberinto lo antes posible. Para
ello se les permite dar dos vueltas. La primera de ellas es de reconocimiento. En ella
el robot deber grabar en su memoria interna los giros que debe de realizar para que
en la segunda vuelta complete el recorrido en el menor tiempo posible.
Figura 2-1: Imagen de un circuito tipo laberinto
Como se puede ver en la imagen anterior estos circuitos se caracterizan porque

todos los giros que presenta la trayectoria son de 90. Esto hace que la programacin
del robot sea ms sencilla ya que solamente habr que programarlo para que realice
giros de 90 y de 180.
Pgina 21 de 231
J. L. Prez Motos
Por otro lado, el punto interesante de esta modalidad, en cuanto a programacin

se refiere, est en cmo almacenar la informacin del camino correcto que debe
tomar el robot.
Velocistas
En esta modalidad los robots realizan una carrera de persecucin por parejas
dentro de un circuito cerrado. Los robots comienzan en puntos opuestos del trazado y
ambos avanzan en el mismo sentido. La prueba acaba cuando uno de los dos llega a
contactar con el otro.
Generalmente existe una primera ronda en la que los participantes recorren el
circuito en solitario y solo los que consigan mejor tiempo pasarn a la siguiente fase
de la competicin.
Figura 2-2: Imagen de un circuito para robots velocistas
Como se observa en la imagen anterior el este circuito es bastante diferente al

laberinto. En este circuito no hay intersecciones, pero s que presenta curvas, por lo
que, en este sentido, la programacin del robot ser ms compleja que en el caso del
laberinto ya que se deber de regular la velocidad de los motores para tomar las
curvas de forma correcta.
Pgina 22 de 231
J. L. Prez Motos
Los robots velocistas no estn obligados a mantenerse sobre una lnea, sino que
los robots pueden elegir por cul de cualquiera de las dos lneas ir o incluso pueden ir
entre ambas. El robot quedar descalificado si toca cualquier lnea roja.
Rastreadores
Esta modalidad es una mezcla de las dos anteriores. Los robots debern
completar un circuito lo antes posible, pero este circuito est lleno de curvas y
bifurcaciones.
Figura 2-3: Imagen de un circuito para robots rastreadores
Si se observa la imagen anterior se pueden apreciar una serie de pequeas

marcas en los lados del circuito. Estas lneas marcan la direccin que deber tomar el
robot en la siguiente interseccin. Si antes de la interseccin se encuentra una marca
a la izquierda del trayecto en la siguiente interseccin deber girar a la izquierda.
Anlogamente, si se encuentra la marca a la derecha, en la siguiente interseccin
deber girar a la derecha. Sin embargo, si se encuentran marcas en ambos lados de la
trayectoria en la siguiente interseccin deber continuar recto.
De esta forma esta modalidad recoge las dificultades de las otras dos, ya que el
robot debe seguir una determinada direccin en las intersecciones y adems debe
poder regular la velocidad de los motores debido a que el circuito presenta curvas.
Una vez analizadas las tres modalidades existentes de robots sigue lneas se escogi
la modalidad de rastreador. Como ya se ha explicado, rene caractersticas de la
modalidad de laberinto y de velocista, por lo que la modalidad de rastreador requiere
Pgina 23 de 231
J. L. Prez Motos
robots ms completos ya que deben combinar una gran capacidad de deteccin, un buen
seguimiento del camino y ejecutar con rapidez las maniobras.
En los siguientes apartados se pasar a analizar en profundidad las caractersticas
que tienen las pruebas de rastreadores y diferentes modelos de rastreadores ya
existentes.
2.1. REGLAMENTO ROBOTS RASTREADORES

En este apartado se comentarn las principales normas que debe cumplir todo
robot que quiera participar en la prueba de rastreadores[11].
2.1.1. REQUISITOS DEL ROBOT
Los robots rastreadores debern ser autnomos. No podrn recibir datos que
alteren su comportamiento. La organizacin permite que los robots enven datos
siempre y cuando se informe a los jueces y homologadores de dicha
caracterstica. Como excepcin se permite que los robots dispongan de un
sistema de detencin a distancia, ya sea por infrarrojos o radiofrecuencia, dicho
sistema podr ser controlado por un juez de pista o miembro del equipo.
El robot deber tener unas dimensiones tales que quepan dentro de una caja de
20x20 cm con los sensores de contacto (microrruptores) plegados en caso de que
fuera necesario. Su altura podr ser cualquiera. No se permite disear el robot de
forma que cuando comience la carrera se separe en diferentes piezas.
El peso mximo de los robots ser de 2000 gramos incluyendo todas las partes.
2.1.2. PISTA
Las pistas consistirn en una superficie de color blanco con una lnea negra
(camino a seguir) de una anchura de 202mm. Las marcas estarn formadas del
mismo material que la lnea del circuito, su anchura ser la misma que la del
camino a seguir y su longitud ser de 405mm. El espacio entre marcas
equivaldr a 203mm.
Pgina 24 de 231
J. L. Prez Motos
Figura 2-4: Dimensiones de la pista y de las marcas de bifurcacin
El camino a seguir tendr tantas ramificaciones como la organizacin crea

convenientes.
El robot deber seguir siempre una de las lneas de las que conste el camino. En
caso de salirse dispondr de 15 segundos para reincorporarse al circuito a una
distancia inferior a 100 mm desde el punto en el que se sali. Si pasado este
tiempo no se ha reincorporado o lo ha hecho en otro lugar de la pista, el
responsable del equipo tiene la opcin de situar el robot en el inicio de la pista
sin para el tiempo. En caso contrario quedar eliminado.
Antes de una bifurcacin se marcar el camino que debe tomar el robot con una
marca en los laterales del camino.
Figura 2-5: Esquema de las bifurcaciones
Partiendo de una situacin correcta, en una bifurcacin podrn coexistir

como mximo 3 posibles caminos, formando entre ellos los siguientes ngulos:
Pgina 25 de 231
J. L. Prez Motos
Figura 2-6: ngulos mximos que pueden aparecer
2.1.3. PRUEBAS DE RASTREADOR
En el caso de que dos robots compitan en pistas simtricas, cada uno recorrer
una de las dos pistas, luego los robots se cambiarn de pista y se sumarn los
tiempos de cada turno. De cada carrera e dos robots se clasificar el ms rpido.
Quedar a decisin de la organizacin, segn el nmero de robots inscritos, si el
sistema de competicin ser estilo liguilla o campeonato con eliminacin de la
competicin de los robots no clasificados.
En caso de que solo se habilite una pista, se permitir hacer varias rondas (a
definir por la organizacin), ofreciendo as la posibilidad de mejorar los tiempos
marcados. Se contabilizar el mejor tiempo de los obtenidos. La clasificacin
ser por tiempo.
Pasado un tiempo mnimo de tres minutos desde el inicio del asalto los jueces
podrn parar y finalizar la carrera cuando lo consideren oportuno. Quedar bajo
criterio del juez el robot ganador de la carrera, teniendo en cuenta los siguiente
parmetros de decisin:
1. Ser el nico robot que permanezca en movimiento.
2. Mxima proximidad a la llegada.
3. No haber perdido la lnea en ninguna ocasin durante la carrera.
Pgina 26 de 231
J. L. Prez Motos
4. Si todos los robots de la carrera se quedan parados o colgados, quedar

a decisin del juez clasificar a un robot de otra carrera que haya demostrado ser
ms competente. La decisin del juez ser inapelable en ambos casos.
2.2. ANTECENDETES
A continuacin se proceder a describir diferentes robots rastreadores que se han
ido encontrando en la bibliografa. Con este anlisis se pretende recoger ideas para el
diseo del robot, as como analizar las fortalezas y debilidades de estos diseos previos.
2.2.1. ROBOT SEGUIDOR DE LNEAS DE LA UPNA

Este robot fue el resultado de otro Proyecto Final de Carrera realizado por
estudiantes de la Universidad Pblica de Navarra[6].
Figura 2-7: Robot seguidor de lnea desarrollado en otro proyecto de la UPNA
Como microcontrolador emplea un Arduino Duemilanove y emplea dos motores de

corriente continua que son controlados por una tarjeta controladora (Motor Shield)
especialmente diseada para ser usado por placas Arduino. As que en este proyecto no
se aborda la parte del control de potencia de los motores, sino que esa parte del proyecto
descansa en una tarjeta comercial Para detectar la lnea emplea una matriz de seis
sensores. Cuenta con una rueda loca que sirve como tercer punto de apoyo para darle
estabilidad al robot. Por ltimo, todo el sistema est alimentado con dos bateras de lipo
de 2000 mAh.
Pgina 27 de 231
J. L. Prez Motos
En este proyecto se analizan distintas configuraciones del vehculo autnomo,

incluso empleando un sensor de distancia, consiguiendo que el robot detecte y esquive
obstculos en su camino. Una de las variantes estudiada es un robot rastreador sigue
lneas anlogo al que se construir en este proyecto.
Sin embargo, tras analizar videos y el cdigo de este robot se puede concluir que no
aplica ningn tipo de control avanzado sobre los motores. Simplemente cuando los
sensores detectan que el robot se encuentra muy desviado de la lnea se fuerza un giro
del robot alternando la proporcin de giro de las ruedas izquierda y derecha. Se trata de
un tipo de control Todo/Nada, sin accin de control regulada de forma continua. Esto
hace que el error de posicin nunca sea nulo, es decir, en ningn momento el robot va
completamente recto, sino que avanza oscilando sobre la lnea de referencia.
Figura 2-8: Trayectoria que sigue el robot
Por otro lado, al incluir en el diseo del robot una carcasa hace que este resulte
mucho ms robusto, aunque tambin lo hace ms pesado, lo que tendr repercusiones en
el consumo de energa elctrica y la autonoma del robot.
2.2.2. POLOLU 3PI

El Pololu 3Pi es un robot comercializado por la empresa estadounidense Pololu
diseado para competiciones de rastreadores y de laberinto[12]. El precio del robot es
de 100 y necesita un programador externo[13].
Pgina 28 de 231
J. L. Prez Motos
Figura 2-9: Pololu 3Pi
El microcontrolador de este robot es un ATmega328, el mismo que emplean

diversas placas Arduino como la Arduino UNO y la Arduino Pro Mini. Los motores son
de corriente continua y emplea cinco sensores infrarrojos situados en diferentes puntos
de la periferia del robot para detectar la lnea. Dispone de una pantalla LCD que aporta
numerosos datos sobre el estado del robot, tales como nivel de batera, velocidad o
lectura de los sensores. Por ltimo, la alimentacin del todo el sistema se realiza
mediante cuatro pilas AAA.
El control de la velocidad y de la desviacin de la lnea de este robot es muy
avanzado. El sistema emplea un control PID para regular la velocidad de los motores en
funcin de las lecturas de los sensores. Adems el robot Pololu 3Pi tiene un tamao
muy reducido y poco peso, lo que lo hace extremadamente maniobrable y rpido. De
esta forma puede alcanzar velocidades de hasta 1m/s.
Por todas estas caractersticas el Pololu 3Pi se va a convertir en una gran
referencia a la hora de desarrollar diferentes partes del proyecto, poniendo este robot
como ejemplo a superar.
Pgina 29 de 231
J. L. Prez Motos
2.2.3. N00B0T
Este robot fue desarrollado en el foro de la Asociacin de Robtica y Domtica de
Espaa[14] por el usuario dip6, por lo que fue totalmente diseado y construido por
hobby. Como se puede ver en la siguiente imagen, el diseo externo est muy
influenciado por el Pololu 3Pi.
Figura 2-10: n00b0t
Al igual que el Pololu 3Pi monta un ATmega328, los motores son de corriente
continua, y tiene en diferentes puntos de la periferia del robot 5 sensores infrarrojos para
detectar la lnea y emplea cuatro pilas AAA para alimentar a todo el sistema. A
diferencia del Pololu 3Pi incluye dos sensores infrarrojos extras, uno a cada lado, que
tienen como finalidad leer las marcas que aparecen en los circuitos de los rastreadores
para indicar qu camino deben tomar.
Pgina 30 de 231
J. L. Prez Motos
Figura 2-11: Disposicin de los sensores de n00b0t
Sin embargo la programacin del n00b0t difiere mucho de la programacin del

Pololu 3Pi. El cdigo, disponible en el blog del creador del n00b0t[15], es muy claro y
conciso a diferencia del Pololu 3Pi. Adems, para el control de velocidad del robot
emplea un control PD que, segn los videos que se han podido ver, ofrece grandsimos
resultados.
Sin lugar a dudas el n00b0t es un gran robot que aporta bastantes ideas que se
podrn emplear en el diseo del robot que se aborda en el presente proyecto.
2.2.4. POCKETBOT 2
El PocketBot 2 es un robot diseado y construido por Ondej Stank, estudiante
checo que present este robot como Proyecto Final de Carrera[16]. La principal
caracterstica de este robot son sus dimensiones, ya que, como el propio Ondej Stank
dice, es un robot que cabe dentro de una caja de cerillas.
Pgina 31 de 231
J. L. Prez Motos
Figura 2-12: Prueba del reducido tamao del Pocketbot 2
Adems de las diminutas dimensiones del robot ya comentadas (48 x 32 x 12 mm)

pesa tan solo 20 gramos (incluida la batera) y alcanza velocidades de hasta 70m/s.
Emplea un ATxmega128A3 como microcontrolador y motores de corriente continua.
Adems emplea una matriz de ocho sensores para detectar la lnea que debe seguir. Para
alimentar todo el sistema el robot cuenta con una batera de lipo de 190mAh.
Otras caractersticas de este robot es que emplea un sensor de ngulo de giro de las
ruedas, de tipo encoder que le permite calcular la posicin del robot en funcin de la
posicin inicial de este; dispone de sensores de proximidad para variar la trayectoria del
robot en el caso de que haya obstculos delante de l; cuenta con un sensor RGB con el
que en funcin del color de la lnea puede variar la velocidad del robot; dispone de un
acelermetro de tres ejes y puede comunicarse con otros dispositivos mediante
tecnologa bluetooth.
Adems de todas estas grandes caractersticas el robot tambin cuenta con una
buena programacin. Todo el robot est programado en java, lo que, unido al uso de
tecnologa bluetooth, le permite una gran interaccin con ordenadores y telfonos
mviles. Por ltimo, al igual que el n00b0t, emplea un control PD para controlar la
velocidad del robot y al igual que aquel, a la vista de los videos disponibles en su blog,
los resultados son excelentes.
Pgina 32 de 231
J. L. Prez Motos
Figura 2-13: Interfaz grfica de la aplicacin de ordenador del Pocketbot 2
El PocketBot 2 es otro gran robot que puede ser de gran utilidad sobre todo en
temas de conectividad.
2.2.5. CONCLUSIONES
Todos los robots estudiados incluyen elementos comunes en sus diseos que habr
que tener en cuenta a la hora de elegir los componentes que tenga el robot.
Microcontrolador:
la
mayora
de
los
robots
estudiados
emplean
microcontroladores de la familia ATmega. Esto puede ser debido a su bajo coste

y sencillez de programacin, unido a que esta aplicacin en particular no
presenta unos requerimientos especiales en cuanto a complejidad de clculo o de
velocidad.
Motores: aunque todos los modelos estudiados empleen motores de corriente

continua tambin existen gran cantidad de modelos que emplean motores paso a
paso. Generalmente esta opcin permite un mejor control de la posicin (ngulo)
de las ruedas, pero son bastante ms lentos que los motores de corriente continua
con reductora.
Sensores infrarrojos: es el sistema que emplean todos los modelos para

detectar la lnea. Estos sensores lo que hacen es variar la seal que envan al
Pgina 33 de 231
J. L. Prez Motos
microcontrolador segn si lo que ven es ms claro o ms oscuro. Existen

diferentes variantes, ya que pueden estar en forma de matriz o dispersos por
diferentes zonas del robot.
Alimentacin: la alimentacin en este tipo de robots suele ser a travs de pilas o

de bateras de LiPO (Li-Polmero).
Control velocidad: los modelos ms avanzados emplean controles PID o PD,

aunque se han encontrado otras aproximaciones ms sencillas que emplean
controles de tipo Todo/Nada.
2.3. ROBOTS RASTREADORES PARA USOS DOMSTICOS E

INDUSTRIALES
Adems de los robots sigue lneas explicados con anterioridad cuyo principal
criterio de diseo es participar en competiciones de robots, existen diferentes modelos
que se emplean en otras aplicaciones. En este apartado se presentarn diferentes robots
que siguen el mismo principio que los robots seguidores de lnea pero que su utilidad
est fuera del de las competiciones de robots.
2.3.1. ROOMBA
Quizs sea el robot rastreador ms conocido de todo el mundo. La finalidad de este
robot es la de limpiar la casa de forma autnoma.
Figura 2-14: Roomba
Pgina 34 de 231
J. L. Prez Motos
Para cumplir con su finalidad dispone de una serie de sensores de proximidad

que le permiten delimitar una habitacin de la casa. Despus con un programa interno
crea una ruta que le permite limpiar la habitacin de forma ptima. El robot es capaz de
cubrir con rutas aparentemente aleatorias toda la superficie de la habitacin, y adems
recordar su posicin relativa respecto de la base de carga de bateras. Cuando termina el
programa de limpieza, o se va quedando sin batera, Roomba retorna de forma
autnoma a su base para recargarse[17].
Figura 2-15: Trayectoria seguida por un robot Roomba para limpiar una habitacin
2.3.2. KIVA
Este robot es fabricado por Kiva Systems[18] y tiene como finalidad la de organizar
almacenes. Multitud de grandes compaas como Amazon, Toys R Us, Staples o GAP
emplean robots Kiva en sus almacenes.
Pgina 35 de 231
J. L. Prez Motos
Figura 2-16: Almacn de Amazon
Como se puede apreciar en la imagen anterior, los robots tienen marcados en el

suelo una serie de trayectorias. En realidad se trata de cables conductores enterrados en
el suelo, y el sistema de deteccin y seguimiento en lugar de ser ptico se basa en
sensores inductivos. Segn a donde tengan que llevar la carga que llevan ese momento,
el programa interno decidir que caminos tomar. Pero estos robots no trabajan solos,
sino que puede haber una gran cantidad de ellos para controlar un solo almacn. Es por
ello por lo que se necesita una gran sincronizacin entre todos ellos. As, estos robots
adems de incluir sensores para detectar las trayectorias del suelo incluyen diversos
sensores para poder comunicarse con el resto de robots. Adems, un ordenador central
controlado por un operario controla el buen funcionamiento de todo el sistema.
2.3.3. ROBOT TRANSPORTA MEDICAMENTOS

En el hospital Nemocnice Na Homolce[19] de Praga emplean robots seguidores de
lnea para transportar las medicinas a los pacientes.
Pgina 36 de 231
J. L. Prez Motos
Figura 2-17: Hospital Nemocnice Na Homolce de Praga
Como si de un seguidor de lneas normal y corriente se tratara, estos robots tienen

marcados a lo largo de todo el hospital marcas en el suelo con las trayectorias que deben
seguir. De nuevo, al ser un sistema que implica a varios robots, necesita de un
ordenador central que organice a todos los robots.
Pgina 37 de 231
CAPTULO 3.
J. L. Prez Motos
ELECCIN DE COMPONENTES
En los siguientes apartados se van a exponer las razones por las que se eligieron los
diferentes componentes que forman el robot. En todo momento se tuvieron en cuenta
una serie de caractersticas que definan al robot. Estas caractersticas son:
1. Pequeo tamao: se pens que el robot fuera ms pequeo que el Pololu 3Pi,
el cual abarca una superficie de unos 70cm2.
2. Ligero: de nuevo se pens que el robot fuera ms ligero que el Pololu 3Pi,
que tiene un peso de 243gr con pilas[20].
3. Veloz: se puso como meta superar los 70cm/s del PocketBot 2.
4. Barato: se intent que el coste total del robot fuera inferior a los 100 del
Pololu 3Pi.
3.1. MICROCONTROLADOR
Un microcontrolador es un circuito integrado que est formado por las tres unidades
funcionales de un ordenador: microprocesador, memoria y perifricos de entrada y
salida[4].
La forma en la que funciona un microcontrolador se determina por el programa
almacenado en su memoria. Este programa se puede disear y escribir en diferentes
lenguajes de programacin y tras una compilacin, se descarga en la memoria interna
del microcontrolador en lenguaje ejecutable. Esto, unido a su alta flexibilidad, hacen
que los microcontroladores se empleen en multitud de aplicaciones: automatizacin,
robtica, domtica, medicina, aeronutica, automocin, telecomunicaciones, etc.
Las principales caractersticas de los microcontroladores son:
Microprocesador: tpicamente de 8 bits, pero existen versiones de 4, 32 y hasta

64 bits con arquitectura Harvard, con memoria/bus de datos separada de la
Pgina 38 de 231
J. L. Prez Motos
memoria/bus de instrucciones de programa, o arquitectura de von Neumann con

memoria/bus de datos y memoria/bus de programa compartida.
Memoria de Programa: puede ser una memoria ROM (Read Only Memory),
EPROM
(Electrically
Programable
ROM),
EEPROM
(Electrically
Erasable/Programable ROM) o Flash. Es la encargada de almacenar el cdigo

del programa que ejecutar el microprocesador.
Memoria de Datos: es una memoria RAM (Random Access Memory) que

tpicamente puede ser de 1, 2, 4, 8, 16 o 32 kilobytes.
Generador de Reloj: cristal de cuarzo que produce unos impulsos con una
determinada frecuencia y genera una seal oscilante. Esta frecuencia suele ir
desde 1 a 40 MHz.
Interfaz de Entrada/Salida: puertos paralelos, seriales (UARTs, Universal

Asynchronous Receiver/Transmitter), I2C (Inter-Integrated Circuit), Interfaces
de perifricos seriales (SPIs, Serial Peripheral Interfaces), Red de rea de
Controladores (CAN, Controller Area Network), USB (Universal Serial Bus),
etc.
Otras opciones:
- Conversores Analgicos-Digitales (A/D, analog-to-digital) para convertir
un nivel de voltaje en un cierto pin a un valor digital manipulable por el
programa del microcontrolador. Estos conversores A/D suelen tener una
resolucin tpica de 10 bits, aunque existen versiones de 12, 16 o 32 bits.
- Moduladores por Ancho de Pulso (PWM, Pulse Width Modulation) para
generar ondas cuadradas de frecuencia fija pero con ancho de pulso
variable. Aunque cualquier salida digital del microcontrolador puede ser
programada para hacer esta funcin mediante el uso de interrupciones y
temporizadores, muchos microcontroladores incluyen algunas salidas
especialmente dedicadas a este efecto, lo cual simplifica su uso.
Para este proyecto desde un primer momento se decidi que el microcontrolador a

usar fuera un Arduino ya que se amoldaba perfectamente a las caractersticas del
proyecto. En los siguientes apartados se realizar una explicacin ms exhaustiva de las
razones por las que se eligi Arduino.
Pgina 39 de 231
J. L. Prez Motos
3.1.1. QU ES ARDUINO?
Arduino[21] es una plataforma de hardware y software open source que est basado
en una placa que permite conectar sensores y actuadores mediante entradas y salidas
analgicas y digitales y en un entorno de desarrollo basado en el lenguaje de
programacin Processing.
Figura 3-1: Logotipo de Arduino
Al ser open source tanto su diseo como su distribucin es libre. Es decir, puede
utilizarse libremente para desarrollar cualquier tipo de proyecto sin tener que adquirir
ningn tipo de licencia. El texto de la referencia de Arduino est publicado bajo la
licencia Creative Commons Reconocimiento-Compartir bajo la misma licencia 3.0. Los
ejemplos de cdigo de la referencia estn liberados al domino pblico.
3.1.2. VENTAJAS
Las razones por las que se eligi Arduino como plataforma sobre la que desarrollar
el proyecto fueron cuatro:
Barato: por apenas 20 se puede conseguir una placa Arduino completamente

funcional incluyendo un mdulo de interfaz Serie-USB.
Popular: la plataforma Arduino es ampliamente conocida por miles de

desarrolladores en todo el mundo, desde profesionales hasta personas que
desarrollan aplicaciones por hobby. Adems existen tutoriales y foros que
facilitan notablemente diferentes apartados de los proyectos.
Verstil: una misma placa de Arduino puede servir para proyectos de domtica,
robtica, control de sistemas o como programador de otros microcontroladores.
Pgina 40 de 231
J. L. Prez Motos
Open source: se encuentran en la misma pgina web de Arduino los planos y

esquemas de las diferentes placas, por lo que se puede modificar cualquier
componente como se prefiera.
3.1.3. PARTES DE UNA PLACA ARDUINO

Para explicar las principales partes que componen una placa Arduino se va a
utilizar como modelo la Arduino UNO rev3. Las principales partes son:
Figura 3-2: Esquema del modelo Arduino UNO rev3
Pines:
- Terminales de alimentacin y de referencia (naranja): a travs de estos
pines se puede alimentar a la placa al mismo tiempo que sirven como
referencia de tensin para los circuitos.
- Terminales digitales (azul, rojo, morado y verdes): estos pines tomarn
los valores de 0s y 1s. Se pueden configurar como pines de entrada o de
salida. Las entradas analgicas tambin se pueden configurar como
digitales.
- Terminales PWM (azul): mediante estos pines se pueden generar
seales PWM. El ciclo de trabajo de la seal se puede ajustar con una
resolucin de 1 byte (desde 0 hasta 255).
Pgina 41 de 231
J. L. Prez Motos
- Terminales puerto serie (morado): estos pines permiten enviar recibir

datos de otros dispositivos mediante el puerto serie.
- Terminales
analgicos
(verde):
estos
terminales
cuentan
con
generalmente
los
conversores A/D de 10 bits (desde 0 hasta 1023).
Microcontrolador:
las
placas
Arduino
emplean
microcontroladores ATmega328 y ATmega2560. Son chips sencillos y de bajo

coste que permiten el desarrollo de mltiples diseos
Terminal ICSP microcontrolador: permite programar el bootloader del

microcontrolador ATmega y poder cargar los programas directamente en el
microcontrolador sin tener que necesitar programadores externos.
Figura 3-3: Programacin de un Arduino UNO a travs de otro dispositivo
El bootloader es un conjunto mnimo de instrucciones que permanece

almacenado en la memoria Flash del microcontrolador. Le permite interactuar
con la interface de Arduino, interpretar los programas que se le cargan, recibir y
enviar datos por los diferentes puertos o generar seales de control y permite la
comunicacin USB.
LED encendido: LED que indica si la placa tiene alimentacin suficiente como
para funcionar.
LEDs comunicacin serial: estos LEDs se encienden cuando hay una

comunicacin por el puerto serie de la placa. Si recibe un dato se encender el
LED RX (receive) y si transmite un dato se encender el LED TX (transmit).
LED: este LED est unido mediante una resistencia interna (resistencia pull-up)
al terminal 13. Permite comprobar el correcto funcionamiento de la salida digital
Pgina 42 de 231
J. L. Prez Motos
13 sin necesidad de conectar ningn elemento externo a esta para limitar la

corriente proporcionada por esta salida.
ICSP USB: permiten emplear la placa de Arduino como un programador de

otros microcontroladores.
Reset: sirve para resetear el microcontrolador.
Convertidor Serie USB: este dispositivo permite la conversin de los datos

que llegan por el USB a datos entendibles por el microcontrolador, es decir,
transforma los datos a serie. Permite la programacin directa del Arduino desde
el ordenador.
Terminal USB: permite tanto alimentar la placa como programarla.
Cristal de cuarzo: dispositivo que permite que los microcontroladores operen a

una cierta frecuencia. En Arduino esta frecuencia es de 8 o 16 MHz.
Regulador de tensin: sirve para independientemente de la tensin de

alimentacin de la placa cada elemento interno de la placa obtenga o bien 33 V
5 V.
Alimentacin externa: permite alimentar la placa desde un dispositivo externo

sin emplear un cable USB.
3.1.4. LENGUAJE DE PROGRAMACIN

Las placas Arduino se programan mediante un lenguaje propio basado en el
lenguaje de alto nivel Processing, aunque tambin es posible emplear otros lenguajes de
programacin y aplicaciones como C++, Java, Matlab o Python, y luego programarse
mediante un compilador AVR (Alf (Egil Bogen) and Vegard (Wollans)s RISC
processor), el cual corresponde con la familia de microcontroladores de Atmel que
incluyen las placas de Arduino.
Sin embargo, uno de los principales atractivos de Arduino es su interfaz de
programacin. El equipo de Arduino ha desarrollado una aplicacin en el lenguaje
Processing (que a su vez est basado en Java), que permite una programacin muy
sencilla a travs de un lenguaje en pseudocdigo. Esto hace que el diseador pueda
desentenderse de aspectos engorrosos de la programacin del microcontrolador y
concentrarse en otros aspectos del proyecto.
Pgina 43 de 231
J. L. Prez Motos
Figura 3-4: Interfaz del IDE de Arduino
La imagen anterior es la pantalla del entorno de desarrollo de Arduino. En la parte

de ms arriba se encuentran las tpicas opciones de todos los programas. En la siguiente
fila se tienen elementos propios de Arduino como son verificar, cargar, nuevo, abrir,
guardar y monitor serial. Este ltimo sirve para ver qu datos se escriben en el puerto
serie.
Despus se encuentra el nombre del sketch (en este caso Blink) y el sketch
propiamente dicho. Un sketch es como se denomina en Arduino a un programa. En la
parte inferior hay una consola que informa de los errores producidos a la hora de
compilar el cdigo. Por ltimo se muestra el modelo de placa sobre el que se va a volcar
el sketch y el puerto en el que est conectada al ordenador.
Pgina 44 de 231
J. L. Prez Motos
Todo sketch est formado por tres partes. Para explicar estas partes se va a utilizar
como ejemplo un sencillo sketch que permite encender y apagar el LED que incorpora
la placa[3].
Declaracin de variables
Lo primero que se debe hacer al empezar a escribir un sketch es definir las variables
y constantes que formarn el sketch.
En este caso se ha definido la variable LED como un entero y de valor 13.
Configuracin de la placa
Tras declarar las variables y constantes que va a emplear el sketch se procede a

configurar la placa. Para ello se emplea la sintaxis void setup(). Las funciones ms
empleadas aqu son dos. Por un lado est la funcin pinMode que permite definir los
terminales como entradas o como salidas. Y por otro lado est la funcin Serial.Begin
que establece la velocidad de datos en bits por segundo (baudios) para la transmisin de
datos en serie.
En este caso se ha definido el pin 13 (ya que se haba declarado la variable LED
con el valor de 13) como un pin de salida.
Bucle del programa principal
Una vez configurada la placa se llega al bucle del sketch, es decir, lo que va a estar
continuamente ejecutndose. Se emplea la sintaxis void loop(). Aqu las funciones ms
utilizadas son las funciones de lectura y de escritura de pines: digitalWrite, digitalRead,
analogRead, analogWrite.
Pgina 45 de 231
J. L. Prez Motos
En este caso en primer lugar se escribe un 1 lgico en el pin 13, despus se espera 1
segundo, despus se escribe un 0 lgico en el pin 13 y se vuelve a esperar 1 segundo.
Este bucle se estara repitiendo indefinidamente mientras no reseteemos la placa o le
quitemos la alimentacin.
De esta forma en apenas 10 lneas ha sido posible controlar el LED interno de la
placa Arduino. Una vez que se ha comprendido como se enciende y como se apaga un
LED es posible poder manipular otros dispositivos como por ejemplo sensores o
motores.
3.1.5. MODELOS DE ARDUINO

En la actualidad existen infinidad de modelos Arduino: UNO, Leonardo, Mega,
LilyPad, Micro, Pro Mini
Figura 3-5: Diferentes modelos de Arduino a escala. Fila superior de izquierda a derecha: Mega,
Pro Mini y LilyPad. Fila inferior de izquierda a derecha: UNO, Micro y Leonardo
Tras una primera criba se decidi se iba a estudiar a fondo tres modelos de ellos:
Mega, UNO y Pro Mini.
Pgina 46 de 231
J. L. Prez Motos
Arduino Mega
El Arduino Mega es un microcontrolador basado en el ATmega2560. Dispone de

54 terminales digitales (14 de ellos se pueden emplear como salidas PWM), 16
terminales analgicos y 4 puertos serie.
Figura 3-6: Arduino Mega
Posee una memoria interna de tipo flash de 256 KB que permite guardar cdigos
realmente extensos (8 KB son empleados por el bootloader). Adems cuenta con 8 KB
de SRAM y 4 KB de EEPROM, al cual se puede acceder desde la librera EEPROM.
Todo esto hace que este modelo sea el ms apropiado para los proyectos ms
complejos en los que se necesiten multitud de entradas y salidas o ms memoria. Por
otro lado se trata del Arduino de mayor tamao.
Arduino UNO
El Arduino UNO es un microcontrolador basado en el ATmega328. Dispone de 14

terminales digitales (6 de ellos se pueden emplear como salidas PWM), 6 terminales
analgicos y un puerto serie.
Pgina 47 de 231
J. L. Prez Motos
Figura 3-7: Arduino UNO
Posee una memoria interna de 32 KB (05 kB son empleados por el bootloader).

Adems cuenta con 2 KB de SRAM y 1 KB de EEPROM, al que tambin se puede
acceder desde la librera EEPROM.
Este modelo es el ms apropiado para proyectos en los que no se necesiten muchas
entradas y salidas y el tamao no sea un problema ya que es el modelo ms econmico.
Arduino Pro Mini
El Arduino Pro Mini es un microcontrolador que cuenta con las mismas

caractersticas que el Arduino UNO: mismo microcontrolador, mismo nmero de
entradas y salidas digitales y analgicas y misma memoria.
Figura 3-8: Arduino Pro Mini
Pgina 48 de 231
J. L. Prez Motos
La gran diferencia del Arduino Pro Mini con respecto al Arduino UNO es su
tamao, ya que en muy poco espacio se dispone de prcticamente todas las opciones
que ofrece el Arduino UNO. Esto hace que sea el modelo ms apropiado a la hora de
realizar proyectos en los que el tamao sea un factor clave. Es necesario destacar que
por razones de coste esta placa no incorpora el circuito integrado de interfaz Serie-USB,
con lo cual ser necesario disponer de hardware adicional para programarlo.
3.1.6. ELECCIN DEL MICROCONTROLADOR

Las caractersticas de los tres modelos estudiados se resumen en la siguiente
tabla:
Modelo
Arduino Mega
Arduino UNO
Arduino Pro Mini
Micro
ATmega2560
ATmega328
ATmega328
Tensin de
funcionamiento
5V
5V
5V
Tensin recomendada
7 - 12 V
7 - 12 V
7 - 12 V
Tensiones lmite
6 - 20 V
6 - 20 V
6 - 20 V
Corriente pines
entrada/salida
40 mA
40 mA
40 mA
Pines digitales
54 (14 PWM)
16 (6 PWM)
16 (6 PWM)
Pines analgicos
16
Puertos serie
Memoria interna
256 KB (8 KB bootloader)
32 KB (0'5 KB bootloader)
32 KB (0'5 KB bootloader)
SRAM
8 KB
2 KB
2 KB
EEPROM
4 KB
1 KB
1 KB
Frecuencia
16 MHz
16 MHz
16 MHz
Ventajas
Gran cantidad de entradas

y salidas y mucha memoria
Econmico
Reducido tamao
Pgina 49 de 231
Desventajas
Gran tamao
J. L. Prez Motos
Hay que soldar los pines y

no dispone de conversor
USB - SERIE
Tabla 3.1: Comparativa entre diferentes modelos
Tras este anlisis se desech el modelo Arduino Mega. Para este proyecto no se
van a emplear multitud de sensores, por lo que se desaprovecharan gran cantidad de
entradas y salidas. Por el contrario, se dese desde un principio que el robot fuera lo
ms pequeo posible, por lo que los 55 x 110 mm del Arduino Mega hicieron que
finalmente se desechara la opcin de este modelo.
Figura 3-9: Comparativa a escala del tamao
Finalmente se decidi hacer el proyecto empleando el Arduino Pro Mini debido a

su reducido tamao. Las desventajas que suponen tener que soldar los pines a la placa y
Pgina 50 de 231
J. L. Prez Motos
tener que comprar un dispositivo externo para poder programarlo son compensadas con
la diferencia de tamao que tiene este modelo con respecto a los otros dos.
Como ya se ha explicado, el Arduino Pro Mini carece de conversor Serie USB,
por lo que para poder programarlo se adquiri el conversor Serie - USB FTDI232.
Figura 3-10: De izquierda a derecha: Arduino UNO, Arduino Pro Mini y conversor Serie USB
FTDI232
3.2. RUEDAS
3.2.1. CONFIGURACIN DE RUEDAS

A continuacin se va a realizar un estudio sobre las diferentes configuraciones
posibles que puede presentar el robot en cuanto a disposicin de sus ruedas.
Pgina 51 de 231
J. L. Prez Motos
Configuracin Diferencial
Consta de dos ruedas paralelas entre s con traccin independiente. En teora esta es
la mecnica ms fcil de construir ya que nicamente se necesitan ruedas de traccin, ya
que los giros se consiguen con la diferencia de velocidades y sentidos de ambas ruedas.
Figura 3-11: Giros con una configuracin diferencial
Para darle estabilidad al conjunto se suelen usar una o dos ruedas locas que
aguantarn el peso del robot impidiendo que este se incline y entre en contacto con la
pista. Sin embargo pueden dar problemas en pistas irregulares ya que se puede perder
traccin.
De esta forma su principal ventaja es que es muy fcil de construir. Manipulando
las velocidades de ambas ruedas se puede conseguir que el robot se desplace y adems
gire sin tener que manipular otro elemento. Adems permite que el robot pueda girar
sobre punto medio del eje formado por ambas ruedas. Esto permite que el robot
responda mejor en ruedas cerradas.
Sin embargo esta disposicin presenta varios inconvenientes. La principal de ellas
es que las ruedas de traccin no pueden ir a la mxima velocidad siempre. Por ejemplo
en las curvas la rueda interior deber frenar o incluso invertir el sentido de giro para que
el robot pueda girar. Adems, para asegurar el movimiento rectilneo del robot se deber
comprobar que ambas ruedas giran a la misma velocidad.
Pgina 52 de 231
J. L. Prez Motos
Configuracin en Triciclo
Esta configuracin est compuesta de tres ruedas que forman un tringulo. La

delantera proporciona la direccin y las dos traseras, paralelas entre s, son las de
traccin.
Figura 3-12: Giros con una configuracin triciclo
Su principal ventaja es que las ruedas traseras pueden ir siempre a la mxima

velocidad siempre que el radio de la curva sea lo suficientemente grande. Adems,
debido a que ambas ruedas no giran d forma independiente, con esta configuracin es
ms fcil que el robot vaya recto.
El principal problema del triciclo son los giros. El radio mnimo que pueda girar el
robot sin problemas depender de la distancia que exista entre las ruedas de traccin y la
rueda de direccin.
Configuracin Ackerman
Es la configuracin que tienen los coches, es decir, cuatro ruedas siendo dos de
ellas de direccin y dos de traccin. Pueden existir diferentes configuraciones segn
donde se encuentren las ruedas de traccin.
Pgina 53 de 231
J. L. Prez Motos
Figura 3-13: Giros con una configuracin Ackerman
En un coche las ruedas de direccin generalmente son las delanteras ya que son las
ruedas ms cercanas al conductor. Sin embargo, en un robot estas pueden sin ningn
tipo de problema las traseras. Las ruedas de traccin tambin suelen ser las delanteras.
Sin embargo en robots las ruedas de traccin suelen ser distintas a las de direccin para
simplificar el diseo.
La ventaja de la traccin delantera es que se aprovecha mucho mejor la energa en
curva porque la fuerza se transmite en la direccin de esta por lo que sern ms fciles
de controlar. Sin embargo, si la potencia es elevada se hace difcil de manejar el
vehculo de esta manera ya que tienden a subvirar.
Las principales ventajas que ofrece la configuracin Ackerman son que las ruedas
de traccin pueden ir a mxima velocidad siempre que el radio de giro sea lo
suficientemente grande y que ofrece una gran estabilidad.
Por otro lado, el radio de giro en esta configuracin no es muy pequeo, por lo que
se ha de frenar antes de entrar en una curva.
3.2.2. MODELOS DE RUEDAS

Al mismo tiempo que se analizaban las diferentes configuraciones que poda tomar
el robot en cuanto al nmero y disposicin de las ruedas se compararon las diferentes
ruedas que estaban disponibles en el mercado:
Pgina 54 de 231
Imagen
J. L. Prez Motos
Modelo
Dimetro
Precio
Pololu Wheel 32x7mm Pair - White
32 mm
5'95
Pololu Wheel 42x19mm Pair
42 mm
5'90
Pololu Wheel 60x8mm Pair - Black
60 mm
6'90
Modelo
Altura mx
Precio
Pololu Ball Caster 3/8" Metal Ball
1 cm
3'15
TAMIYA BALL CASTER KIT (2 UND.)
3 cm
5'10
Tabla 3.2: Ruedas motrices
Imagen
Tabla 3.3: Ruedas locas
3.2.3. ELECCIN
Tras este anlisis se eligi el sistema diferencial. Es el sistema ms sencillo de
implementar adems de que al estar formado por nicamente dos ruedas es el que
permite que el diseo del robot sea lo ms pequeo posible.
Ya que se seleccion el sistema diferencial se necesitaba una rueda loca que diera
estabilidad al sistema. De las estudiadas se seleccion la TAMIYA que adems de
ofrecer una altura mxima mayor, esta se puede ajustar con diferentes aadidos que trae
el kit.
Pgina 55 de 231
J. L. Prez Motos
Figura 3-14: Tamiya Ball Caster Kit
En cuanto a las ruedas de traccin se escogieron las Pololu de 32 mm ya que eran

las ruedas de menor tamao y se adaptaban mejor al objetivo de que el robot fuera lo
ms pequeo posible.
Figura 3-15: Rueda de goma 32x7mm (2 und)
3.3. MOTORES
Un motor elctrico es una mquina que transforma la energa elctrica en
movimiento, y generalmente en movimiento rotativo. Hay muchos tipos diferentes, pero
los ms empleados en robtica son los motores paso a paso y los motores de corriente
continua pudiendo estos ltimos encontrarse en su variante con escobillas (la
tradicional) o sin escobillas (brushless).
Pgina 56 de 231
J. L. Prez Motos
Los parmetros principales que describen las caractersticas de un motor son la

velocidad, medida en rpm, y el par, medido en mNm o gcm. La unidad del par muestra
la dependencia que hay entre la fuerza y la distancia a la que se aplica. Por ejemplo, un
motor con 2 mNm de par puede producir una fuerza de 2 mN con una palanca de 1
metro conectada a su eje, 1 mN con una palanca de 2 metros, 05 mN con una palanca
de 4 metros, etc.
Todo motor tiene una velocidad mxima (cuando no se aplica fuerza sobre su eje) y
un par mximo (cuando se aplica una fuerza en su eje y esta para el motor). Estos
parmetros se denominan free-running speed y stall torque (Ts).
El motor consume menos corriente cuando no se aplica fuerza sobre su eje y la
corriente aumenta a medida que la fuerza aplicada sobre su eje aumenta, hasta llegar al
punto de mximo par (Ts)[2]. Esta relacin es directa, pero puede no ser lineal
dependiendo del tipo de motor que se emplee.
Figura 3-16: Relacin velocidad-torque-corriente
En los siguientes apartados se describirn los diferentes tipos de motores y se

determinar la velocidad que deben dar estos motores.
3.3.1. MOTORES PASO A PASO

Un motor paso a paso (o stepper del ingls) es un dispositivo que produce una
rotacin en ngulos iguales, denominados pasos, por cada impulso digital que llega a su
Pgina 57 de 231
J. L. Prez Motos
entrada. Por ejemplo, si en el caso de un motor un pulso produce un giro de 3, entonces

120 pulsos producirn una rotacin de 360. Adems poseen la peculiaridad de que se
pueden enclavar en una cierta posicin. Estos motores son los ms apropiados para
aplicaciones en las que la precisin en la posicin angular del eje sea un requisito
esencial de diseo[22].
Existen diversos tipos de motores paso a paso, entre los que destacan los de
reluctancia variable, los de imn permanente y el hbrido.
Bsicamente un motor paso a paso est formado por una parte mvil, el rotor, y una
parte fija, el estator. El rotor suele ser un imn permanente o un inducido
ferromagntico. En el estator se ubican las bobinas por las que se har circular la
corriente que inducirn un campo magntico. La corriente se va alternando por las
diferentes bobinas, lo que provoca que se cree un campo magntico giratorio, el cual
seguir el rotor, producindose de este modo el giro del rotor.
Figura 3-17: Funcionamiento motor paso a paso
De esta forma, si se consigue que la corriente circule por las bobinas en el orden y
con la frecuencia adecuada se podr conseguir que el motor avance un paso en uno u
otro sentido.
La principal ventaja que presenta este tipo de motores se la precisin en el giro, por
lo que le movimiento del robot ser ms preciso. Cuanto menor sea el paso del motor
mayor ser la precisin. Adems un motor paso a paso responde a pulsos de entrada
digitales, lo que permite un control en lazo abierto, haciendo un control ms simple.
Pgina 58 de 231
J. L. Prez Motos
3.3.2. MOTORES DE CORRIENTE CONTINUA

Un motor de corriente continua proporciona un par de giro proporcional a la
corriente inyectada en su armadura Por este motivo su control de par requiere de un lazo
cerrado de control de corriente, sin embargo, para aplicaciones sencillas donde la carga
del motor permanece casi constante, se puede asumir que esta corriente controlar la
velocidad de giro del motor. Tienen velocidades de giro muy altas, por lo que es
necesario utilizar cajas reductoras para adaptar la velocidad a un rango utilizable.
Un motor de este tipo est formado por un estator, el cual da soporte mecnico al
sistema y posee una cavidad en el centro de este, y un rotor al que le llega la corriente
procedente del estator a travs de escobillas.
El principio de funcionamiento de este tipo de motores est basado en la Ley de
Lorentz, por la que al introducir un conductor por el que circula una corriente elctrica
en un campo magntico este sufrir una fuerza perpendicular al plano formado por el
campo magntico y la corriente.
Figura 3-18: Funcionamiento motor de corriente continua
Donde F es la fuerza en newtons, B es la densidad de flujo en teslas, l es la

longitud del conductor en metros e I es la corriente que circula por el conductor en
amperios.
El rotor tiene varios devanados repartidos por la periferia. A medida que gira, la
corriente se activa en el conductor apropiado. De esta forma, el sentido de giro de un
motor de corriente continua depender del sentido relativo de las corrientes circulantes
por los devanados inductor e inducido. Si se desea invertir el sentido de giro del motor
se deber invertir el sentido del campo magntico o de la corriente del inducido.
Pgina 59 de 231
J. L. Prez Motos
La ventaja principal de este tipo de motores reside en su fcil adaptacin a las

diferentes situaciones que puede presentar el sistema, permitiendo ajustar o variar la
velocidad, el par y el sentido de rotacin.
El problema principal es el mantenimiento de las escobillas. Debido a que es una
superficie que est en continuo rozamiento con otra superficie estas se desgastan a largo
plazo y es necesario realizar operaciones de mantenimiento peridicas. Esto es de
especial importancia en aplicaciones industriales donde el ambiente puede ser
especialmente agresivo. El contacto entre estas dos superficies es clave para el correcto
funcionamiento del motor, por lo que habr que asegurarse que no existe ningn
problema. En aplicaciones de robtica pequeas o de juguetera, no suele haber ningn
problema con estos componentes durante el periodo de vida del motor.
3.3.3. CLCULO DE LA VELOCIDAD

Como objetivo se va a fijar que el motor se mueva aproximadamente a 1 m/s. Para
determinar las rpm que debe tener el motor se aplica la siguiente frmula:
Tal que V viene en m/s, R en m y N en rpm. Teniendo en cuenta que el radio de las
ruedas escogidas es de 16 mm se tiene:
3.3.4. ELECCIN MOTOR

Tras analizar cada uno de los motores se opt por emplear motores de corriente
continua. Este tipo de motor se adapta mejor a las necesidades del robot, ya que se
necesita que el motor sea capaz de cambiar su velocidad cuanto ms rpido mejor, y en
ese aspecto los motores de corriente continua son ms apropiados que los de paso a
paso. Adems el control de la velocidad de los motores de corriente continua ofrece ms
posibilidades que el control de motores paso a paso.
Pgina 60 de 231
J. L. Prez Motos
Los motores que ms se aproximaban a la velocidad necesaria eran dos:

Imagen
Modelo
Reductora
Torque
Velocidad sin carga Consumo sin carga
Precio
10:1 Micro Metal Gearmotor
10:1
0,2 kgcm
1250 rpm
40 mA (Max: 360 mA)
13'20
30:1 Micro Metal Gearmotor
30:1
0,3 kgcm
440 rpm
40 mA (Max: 360 mA)
13'20
Tabla 3.4: Motores
Segn las ruedas escogidas de 16 mm de radio los motores ofreceran una velocidad
de 2 m/s el modelo con reductora de 10:1 y de 074 m/s el modelo con reductora de
30:1. Debido a que el robot no va a ser un velocista sino un rastreador, por lo que al fin
y al cabo la velocidad no es el punto ms importante en el diseo del robot, se escogi
el modelo con una reductora de 30:1 ya que ofreca un par mejor.
Figura 3-19: Motor Micro Metal DC con reductora 30:1
Por ltimo, para poder fijar los motores se adquirieron un par de fundas protectoras
para este tipo de motores.
Pgina 61 de 231
J. L. Prez Motos
Figura 3-20: Funda protectora para motor micro metal (2 und)
3.4. ACTUADOR ELECTRNICO

Como se ha especificado en el apartado anterior, los motores seleccionados
necesitan de al menos 40 mA para funcionar. Si se recuerdan las especificaciones del
Arduino Pro Mini cualquier lnea de salida de este puede proporcionar hasta un mximo
de 40 mA, por lo que se necesita de otro componente que pueda alimentar a los
motores.
Adems, si se desea que la velocidad de giro de los motores sea variable y adems
que se pueda producir en ambos sentidos se hace ms evidente la necesidad de otro
componente.
De entre las diferentes tipologas de actuadores electrnicos de potencia, en este
proyecto se emplear la conocido como etapa conmutada en puente en H. Este
componente se denomina puente en H. Es una de las partes crticas del robot, ya que un
mal funcionamiento o un mal montaje de este provocarn que el robot no funcione
como se espera de l. En los siguientes apartados se va a proceder a explicar los motivos
de su eleccin, su funcionamiento y a analizar los diferentes modelos de circuitos
integrados que se estudiaron para su implementacin en este proyecto.
3.4.1. QU ES UN PUENTE EN H?
Un puente en H es un circuito electrnico de potencia que est formado por una
serie de transistores, los cuales permitirn pasar o cortar la corriente en un determinado
Pgina 62 de 231
J. L. Prez Motos
sentido[1]. Como se acaba de comentar, los puntos de trabajo de los transistores sern el
de corte (OFF) o saturacin (ON), y estos puntos de trabajo sern controlados mediante
sus terminales de Base (en el caso de transistores BJT) o de Puerta (en el caso de
transistores MOSFET).
Para el caso unipolar, la etapa se compone de cuatro transistores que actan como
interruptores, los cuales pueden estar en dos estados, abierto (ON) y cerrado (OFF).
Cuando un interruptor est abierto no permite el paso de corriente a travs de l, en
cambio cuando est cerrado s lo permitir.
Figura 3-21: Esquema de un puente en H
Variando los puntos de trabajo de los interruptores se puede conseguir que el motor
gire en un sentido u otro, o que se quede parado al fijar los dos terminales del motor a
una misma tensin.
Si el puente en H tiene los interruptores 1 y 4 cerrados mientras que los
interruptores 2 y 3 permanecen abiertos, se permite el paso de la corriente de izquierda a
derecha. De esta forma el motor gira en un sentido.
Figura 3-22: Giro en un sentido del motor

Pgina 63 de 231
J. L. Prez Motos
Si se invierte el estado de los interruptores la corriente circula en sentido contrario.

De esta forma variando entre estas dos posiciones se consigue que el motor gire en uno
o en otro sentido.
Figura 3-23: Giro en el otro sentido del motor
Tambin hay que tener en cuenta que no todas las combinaciones son correctas, ya
que algunas posiciones crean cortocircuitos. Es decir, los interruptores de una misma
rama (1-3 y 2-4) no podrn estar cerrados al mismo tiempo.
Figura 3-24: Situaciones no posibles
Por ltimo, si los interruptores 1 y 2 estuvieran cerrados y los interruptores 3 y 4

abiertos tendran ambos terminales del motor el mismo voltaje, con lo que el motor se
parara rpidamente, ms incluso que si se cortase la alimentacin. A este modo se le
llama Fast stop.
En la siguiente tabla se resumen todas las combinaciones posibles de los
interruptores y el resultado que tienen sobre el motor:
Pgina 64 de 231
J. L. Prez Motos
Estado
I1
I2
I3
I4
Resultado
Abierto
Abierto
Abierto
Abierto
El motor se detiene bajo su inercia
Cerrado
Abierto
Abierto
Cerrado
El motor gira en avance
Abierto
Cerrado
Cerrado
Abierto
El motor gira en retroceso
Cerrado
Cerrado
Abierto
Abierto
Fast stop
Tabla 3.5: Estados de los motores en funcin de los estados de los interruptores
Una de las principales ventajas del actuador en puente en H es que permite

controlar de forma precisa el valor promedio de tensin que se aplica en su carga. Es
decir, que no es un actuador Todo/Nada como pudiera parecer debido al funcionamiento
en forma de interruptor de sus transistores, sino que es posible obtener valores
intermedios controlables de tensin en la carga. Esto permite controlar la corriente que
se inyecta en los motores y, en ltima instancia, la velocidad a la que gira.
Esto se consigue mediante la tcnica de Modulacin de Ancho de Pulsos o PWM de
sus siglas en ingls (Pulse Width Modulation). Esta tcnica consiste en un sencillo
principio que consiste en alternar el estado de conduccin del puente a una frecuencia
alta, mucho mayor que la constante de tiempos del motor alimentado. De esta manera,
el motor no percibe las bruscas variaciones de tensin, sino que las ve como un valor
promedio. Como el voltaje que ve el motor es una serie de pulsos de ancho variable, a
este mtodo se denomina Modulacin de Anchos de Pulsos.
Figura 3-25: Relacin entre el voltaje y la velocidad del motor en funcin del tiempo
Pgina 65 de 231
J. L. Prez Motos
El principal concepto importante de entender es el conocido como ciclo de trabajo.

Este se define como la fraccin del periodo de conmutacin en que la seal se encuentra
en estado activo:
Donde D es el ciclo de trabajo, es la duracin en la que la seal se encuentra en

estado activo y T el periodo de la seal.
En la grfica se puede ver un ejemplo de PWM. En un principio el ciclo de trabajo
es del 100 %, por lo que el motor gira al 100 % de su velocidad nominal. Sin embargo,
cuanto ms bajo es el ciclo de trabajo menor es la velocidad a la que gira el motor, hasta
llegar al 0 %.
A continuacin se van a estudiar tres componentes que se plantearon para usarlos
como puentes en H del robot.
3.4.2. ULN2803
El ULN2803 es un circuito integrado que contiene 8 transistores en configuracin
Darlington con sus respectivos diodos de retroceso.
Figura 3-26: Esquema del ULN2803

Pgina 66 de 231
J. L. Prez Motos
Se pens en utilizar este circuito integrado ya que lo recomendaba el fabricante de

los motores. Las etapas de tipo Darlington son muy adecuadas ya que suelen ser capaces
de manejar valores de corriente bastante elevados.
Cada una de sus salidas puede ofrecer hasta 500 mA, pero adems se pueden
conectar en paralelo para ofrecer una corriente mayor. Est optimizado para trabajar con
voltajes comprendidos entre 6 y 15 V, por lo que en principio podran ser perfectos para
alimentar los motores.
Se pens en usar cada uno de los inversores de los que est formado el ULN2803
como interruptores para la construccin del puente en H. Sin embargo, al analizar ms
en profundidad el ULN2803 se comprob que este solo podra funcionar en medio
puente, es decir, solo permitira girar a los motores en un sentido. Esto es debido a que
es un circuito integrado especialmente diseado para el control de displays y de LEDs,
por lo que todos sus canales estn internamente conectados con la configuracin de
ctodo comn. Como ya se especific en el 3.2, al disponer de una configuracin
diferencial se necesita que ambas ruedas puedan girar en ambos sentidos y por ello se
deben proporcionar corrientes en los dos sentidos de la carga, por lo que en principio
este integrado no nos es til.
Se pens una solucin para poder usar este integrado como un puente completo.
Esta consisti en aadir un par de transistores PNP, los cuales permitiran construir un
puente completo con el ULN2803[23].
Figura 3-27: Posible solucin para el ULN2803

Pgina 67 de 231
J. L. Prez Motos
Finalmente se desech esta opcin debido a que existen opciones comerciales en el

que el circuito integrado ya integra todo el sistema de control dentro de l.
3.4.3. L298N
El L298N es un circuito integrado formado por dos puentes en H separados.
Cada uno de estos puentes permite obtener hasta 2 A (o 4 A si se conectan en paralelo
ambos puentes), por lo que se pueden utilizar para alimentar a los motores.
Figura 3-28: Esquema del L298N
Se emple este circuito integrado ya que se dispona de l en el laboratorio y

cumpla los requerimientos de los motores.
Sin embargo, tras diversas pruebas con l, se desech esta opcin por tres motivos.
El primero de ellos es su tamao. De nuevo el requerimiento de construir un robot lo
ms pequeo posible influy en la eleccin de un componente. Este circuito integrado
tiene unas medidas exageradas en comparacin a otros circuitos integrados que ofrecen
las mismas posibilidades.
Pgina 68 de 231
J. L. Prez Motos
Figura 3-29: L298N
La segunda razn es que se present un excesivo calentamiento. Aun hacindole

pasar apenas un poco ms de 100mA el disipador que incorpora aumentaba mucho su
temperatura, tanto que haba que esperar varios minutos para volver a manipularlo una
vez terminada una prueba Esto podra solucionarse mediante el uso de un radiador, pero
aumentara an ms el tamao del actuador. Se pens tambin en utilizar el plano de
masa de la tarjeta de circuito integrado como radiador.
La tercera razn, relacionada con la anterior, es que el L298N no incluye ningn
elemento de proteccin contra sobretensiones inversas (problema muy frecuente cuando
se alimentan cargas de componente inductiva), por lo que haba que aadirle un total de
ocho diodos (4 para cada motor) para su perfecto funcionamiento y evitar que algn
pico de tensin inversa pudiera daar algn transistor. Estos diodos suelen conocerse
como diodos de libre circulacin. Esto haca de nuevo que el tamao ocupado por este
circuito integrado fuera demasiado grande en comparacin con otras opciones.
3.4.4. L6205N
El L6205N es un circuito integrado formado por 2 puentes en H completos. En el
mismo empaquetado se incluyen tambin los diodos de libre circulacin[24].
Sus principales caractersticas son que funciona con tensiones de alimentacin
desde los 8 V hasta los 52 V y puede ofrecer corrientes de salida de hasta 28 A. Por lo
Pgina 69 de 231
J. L. Prez Motos
que puede ser utilizado para alimentar los motores. Este integrado emplea transistores
de tipo MOSFET en lugar de los BJT del L298N
Figura 3-30: Esquema del L6205N
A continuacin se va a estudiar cada conexin del circuito integrado:
Figura 3-31: Relacin de pines del L6205N
1. IN1A: Entrada lgica 1 del Puente A.

2. IN2A: Entrada lgica 2 del Puente A.
Pgina 70 de 231
J. L. Prez Motos
3. SENSEA: Pin de medida del Puente A. Se deber conectar a tierra si no se desea

usar este pin.
4. OUT1A: Salida 1 del Puente A.
5. GND: Tierra.
6. GND: Tierra.
7. OUT1B: Salida 1 del Puente B.
8. SENSEB: Pin de medida del Puente B. Se deber conectar a tierra si no se desea
usar este pin.
9. IN1B: Entrada lgica 1 del Puente B.
10. IN2B: Entrada lgica 2 del Puente B.
11. ENB: Enable del Puente B. Un nivel bajo en este pin apagar todos los
transistores que forman el Puente B. Si no se va a emplear se deber conectar a +5 V a
travs de una resistencia.
12. VBOOT: Tensin para que empiecen a funcionar los transistores de ambos
puentes.
13. OUT2B: Salida 2 del Puente B.
14. VSB: Alimentacin del Puente B. Debe estar conectada a la fuente de
alimentacin junto a VSA.
15. GND: Tierra.
16. GND: Tierra.
17. VSA: Alimentacin del Puente A. Debe estar conectada a la fuente de
alimentacin junto a VSB.
18. OUT2A: Salida 2 del Puente A.
19. VCP: Voltaje del multiplicador del oscilador.
Pgina 71 de 231
J. L. Prez Motos
20. ENA: Enable del Puente A. Un nivel bajo en este pin apagar todos los
transistores que forman el Puente A. Si no se va a emplear se deber conectar a +5 V a
travs de una resistencia.
3.4.5. PRUEBAS L6205N

Antes de probar el L6205N se estudiaron sus hojas de caractersticas. Estas
recomendaban emplear el siguiente esquema para hacer funcionar el circuito integrado:
Figura 3-32: Esquema de conexin del L6205N
En este esquema se pueden apreciar diferentes componentes que se van a proceder

a explicar a continuacin:
C1 y C2: la funcin de estos condensadores es doble. Por un lado filtra altas

frecuencias en la alimentacin del L6205N; es decir, impedir que llegue ruido al
circuito integrado y de esta forma asegurar que siempre que se desee el L6205N
se encuentre alimentado de forma estable. Por otro lado tambin reduce los
transitorios generados al encender y apagar los transistores.
RENA, CENA, RENB y CENB: la funcin de estos componentes es la de crear

un filtro de paso de bajo. De esta forma se consigue evitar que los puentes se
desactiven por errores debido a interferencias.
Pgina 72 de 231
J. L. Prez Motos
CBOOT, CP, RP, D1 y D2: estos componentes tienen como funcin la de

preparar la onda que requiere el oscilador interno del L6205N. Esta debe de ser
una seal cuadrada de 600 kHz de frecuencia y 10 V de amplitud.
Siguiendo las recomendaciones del fabricante y ajustando los valores, se escogieron

los siguientes componentes:
Componente
Valor
C1
120nF
C2
120nF
CBOOT
220nF
CP
15nF
CENA
6'8nF
CENB
6'8nF
D1
1N4148
D2
1N4148
RENA
100k
RENB
100k
RP
120
Tabla 3.6: Componentes empleados
De esta forma para realizar las pruebas se emplearon:
Un L6205N.
Un Arduino UNO para generar los PWM y activar los puentes.
Dos motores.
Placa de prototipos.
Osciloscopio.
Cables y componentes.
Pgina 73 de 231
J. L. Prez Motos
Figura 3-33: Montaje para la prueba del L6205N
A la hora de programar el Arduino se pensaron diferentes tcnicas. En primer lugar

se pens en mandar los pulsos PWM a travs de los enables (uno para cada puente) para
que de esta forma solo se empleasen dos pines PWM de la placa de Arduino. Sin
embargo, al poner en LOW el puente no se conseguan 0 V a la salida, sino 3 V. Esto
tambin repercuta en el PWM que vean las salidas. Se llegaba al mximo con 165
(sobre 255 es un 64%, por lo que la precisin dejaba mucho que desear). De esta forma
se opt por controlar de forma individual cada una de las entradas. De esta forma se
necesitaran cuatro pines PWM de la placa Arduino.
Tabla 3.7: Tabla de la verdad del L6205N
Pgina 74 de 231
J. L. Prez Motos
En cuanto a la programacin, se pens que sera mejor dejar ambos enables siempre
en H, de esta forma desde Arduino se mandaran las seales PWM a cada input. As, si
tras los clculos el valor es positivo se manda el PWM al IN1 y se manda un 0 al IN2.
SI el valor fuera negativo se manda el PWM al IN2 y se manda un 0 al IN1.
Finalmente se comprob el perfecto funcionamiento de ambos puentes:
Figura 3-34: Resultado obtenido en la prueba
El programa que se ejecut en Arduino fue el siguiente (ANEXO A.1):

/***********************************************************
*
Prueba funcionamiento L6205N
*
***********************************************************/
int enA = 3;
// enable del Puente A
int enB = 4;
// enable del Puente B
int in1A = 5;
// entrada 1 del Puente A
int in2A = 6;
int in1B = 10;
// entrada 1 del Puente B
int in2B = 11;
int pwmA = 50;
// valor PWM del Puente A
int pwmB = 150;
// valor PWM del Puente B
void setup() {
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
pinMode(in1A, OUTPUT);
pinMode(in1B, OUTPUT);
}
void loop() {
digitalWrite(enA, HIGH);
digitalWrite(enB, HIGH);
analogWrite(pwmA, in1A);
analogWrite(0, in2A);
analogWrite(pwmB, in1B);
analogWrite(0, in2B);
}
Pgina 75 de 231
J. L. Prez Motos
3.5. SENSORES INFRARROJOS

Los sensores infrarrojos van a ser el nico medio a travs del cual el robot reciba
informacin de su entorno cuando se encuentre funcionando en modo rastreador.
Primero se tiene que determinar qu informacin necesita obtener el robot sobre su
entorno o sobre s mismo.
Lo nico que necesita conocer el robot sobre su entorno es la situacin de la lnea
negra que tiene que seguir. Para ello se emplean los sensores infrarrojos. Estos pueden
leer el nivel de oscuridad del suelo en puntos concretos, por lo que es importante a la
hora de disear el robot elegir bien el nmero y la distribucin de estos.
Lo ms comn es situar estos sensores en la parte delantera del robot para que de
esta manera se pueda anticipar antes la llegada de una curva. Ahora bien, existen
diferentes configuraciones posibles. La primera de ellas consiste en adquirir una matriz
de sensores infrarrojos. Esta matriz est compuesta por una serie de sensores infrarrojos
dentro de un mismo circuito integrado. El nmero de estos sensores puede variar. La
principal ventaja que tienen es su reducido tamao mientras que su desventaja est en
que no se puede colocar cada sensor donde quieras.
Figura 3-35: Matriz de sensores Pololu Zumo
Tambin es posible adquirir cada sensor infrarrojo por separado y colocar cada uno
de ellos donde ms le convenga al robot. El sensor por excelencia es el CNY70, del cual
se puede encontrar multitud de informacin por internet. La principal ventaja de esta
configuracin es que puedes ser ms creativo con la distribucin de los sensores y
colocarlos de la forma ms eficiente posible. Sin embargo, estas configuraciones
requieren una cantidad de espacio generosa, ya que se necesita montar circuitera
Pgina 76 de 231
J. L. Prez Motos
adicional como resistencias y transistores para hacer funcionar correctamente a los

sensores.
Figura 3-36: Disposicin de los sensores de n00b0t
Otro factor importante a tener en cuenta a la hora de elegir los sensores infrarrojos
es su distancia al suelo. Esta viene determinada por el tipo de sensor y por el tipo de
lectura que se realiza. En la mayora de las ocasiones la lectura es digital, es decir, se
leen 0s y 1s. En general, cuanto ms pegado est el sensor al suelo mejores lecturas
realizar.
Por ltimo es importante determinar la distancia que hay entre los sensores y el eje
de los motores. Cuanto ms alejados estn los sensores del eje de los motores antes se
anticipar la llegada de una curva, pero, sin embargo, los motores debern de hacer ms
fuerza para mover o corregir el robot, por lo que en principio responder peor. De esta
forma hay que encontrar un equilibrio entre la distancia a la que se encuentran los
motores entre s y la distancia que existe entre los sensores y el eje de los motores.
Finalmente se eligi como sensor infrarrojo el QTR-8RC Reflectance Sensor Array.
Las razones por las que se eligi este sensor son las ya explicadas con respecto a una
matriz de sensores infrarrojos.
Figura 3-37: QTR-8RC

Pgina 77 de 231
J. L. Prez Motos
3.5.1. QTR-8RC
La matriz de sensores infrarrojos QTR-8RC est diseada especficamente para la
utilidad que se le va a dar en este robot, es decir, para detectar lneas, aunque se puede
emplear para otros propsitos como por ejemplo sensor de proximidad.
Est formada por ocho parejas de emisores infrarrojos y de receptores
(fototransistores) espaciados entre s 95 mm. Cada fototransistor emplea un circuito de
descarga de un condensador, el cual permite que un pin digital del microcontrolador
analice la cantidad de luz que le llega al sensor segn el tiempo que tarde en descargarse
el condensador. Cuanta ms rpida sea la descarga del condensador mayor ser la
reflectividad del objeto al que mira el sensor. Mayor reflectividad implica mayor
cantidad de luz en la base del fototransistor, lo que inmediatamente provoca un
incremento en la corriente de colector, que descarga ms rpidamente el
condensador[25].
Figura 3-38: Esquema de funcionamiento del QTR-8RC
Pgina 78 de 231
J. L. Prez Motos
Todas las salidas son independientes, pero los LEDs estn dispuestos en parejas
para reducir a la mitad el consumo. Los LEDs se controlan mediante un transistor
MOSFET, cuya puerta normalmente est en alto, permitiendo apagar los LEDs al poner
en bajo la puerta del MOSFET. Se puede reducir el consumo del sensor apagando los
LEDs cuando no se est usando el sensor o ajustando el brillo de los LEDs mediante un
PWM.
Las resistencias que componen la matriz hacen que esta funcione a 5V, con un
consumo de cada LED de 20 25mA, haciendo un consumo total de la matriz de
100mA. Aadir que la matriz se puede dividir en dos submatrices, dejando en una seis
sensores y en la otra dos.
Figura 3-39: Divisin de la matriz QTR-8RC en dos
Dimensiones: 759 cm x 127 cm x 032 cm
Voltaje de funcionamiento: 33 5 V
Consumo de corriente: 100 mA
Formato de las salidas: digital
Distancia ptima: 3 mm
Mxima distancia recomendad: 95 mm
Peso: 309 g
Pgina 79 de 231
J. L. Prez Motos
3.5.2. PRUEBAS QTR-8RC

Al igual que el L6205N, la matriz de sensores es una de las piezas clave del robot,
por lo que se le realizaron una serie de pruebas antes de su montaje en el robot. En
primer lugar hay que entender cmo funciona el QTR-8RC antes de probarlo. La
secuencia que debe seguir cada sensor es la siguiente:
1. Encender el LED infrarrojo.
2. Configurar la va de comunicacin del sensor como salida.
3. Dejar tiempo suficiente para que el condensador se cargue. Segn el fabricante,
con 10 microsegundos es suficiente.
4. Configurar la va de comunicacin del sensor como entrada.
5. Medir el tiempo que tarda el condensador en descargarse.
6. Apagar el LED infrarrojo.
Cuando haya una alta reflectividad, como por ejemplo cuando el sensor est sobre
una superficie blanca, el tiempo de descarga ser de unos pocos microsegundos; con una
baja reflectividad, como por ejemplo cuando el sensor est sobre una superficie negra,
el tiempo de descarga ser de unos pocos milisegundos.
Tras haber entendido el funcionamiento del sensor se llev a cabo su montaje y se
comprob que los sensores funcionaban:
Pgina 80 de 231
J. L. Prez Motos
Figura 3-40: Conexin para la prueba de funcionamiento del QTR-8RC
Figura 3-41: Comprobacin de que los sensores infrarrojos se encuentran funcionando
Despus se realiz el sketch para comprobar el funcionamiento de los sensores.

Como se ha indicado, hay que realizar una serie de pasos para que los sensores tomen
medidas de forma correcta. Aprovechando que este sensor incluye una librera, se
emple la funcin qtrrc.read de la librera QTRSensors. El diagrama del sketch que se
emple (ANEXO A.2) es el siguiente:
Pgina 81 de 231
J. L. Prez Motos
Figura 3-42: Esquema del sketch empleado para la prueba del QTR-8RC
Es necesario hacer notar que es necesario calibrar los sensores. Cada sensor tiene
diferentes valores mximos y mnimos, por lo que a menos de que se guarden los
valores en la memoria EEPROM, cada vez que se acceda a los sensores habr que
calibrarlos.
A continuacin se muestra la pantalla del puerto serie. En vez de realizarlo sobre
una superficie blanca y con una pista negra, se ha empleado el dedo para ir tapando los
sensores:
Figura 3-43: Resultado de la prueba del QTR-8RC
En la primera lnea se muestran los valores mximos que ha visto cada sensor. En la
segunda lnea estn los valores mnimos. Despus, al haber mapeado los valores entre 0
y 9, se muestra el camino que ha ido siguiendo el dedo (all por donde pasaba el dedo se
Pgina 82 de 231
J. L. Prez Motos
muestra un 0). Como los resultados de la prueba resultaron satisfactorios, se concluy

que el sensor funcionaba de forma correcta y estaba listo para su utilizacin en el robot.
3.6. BLUETOOTH
Desde un primer momento uno de los objetivos ms ambiciosos del proyecto fue el
tema de la comunicacin del robot con un ordenador. Un robot sigue lneas no es como
por ejemplo un brazo robtico que tiene su base siempre fija en el mismo sitio, si no que
este se encuentra en movimiento, por lo que la conexin con el ordenador a travs de
cables se desech desde un primer momento.
Primero se pens en guardar los datos dentro de una tarjeta SD y despus volcar los
datos a un ordenador ya que existen shields[26] para Arduino los cuales permiten grabar
y leer datos desde una tarjeta SD. Se desech esta opcin por dos razones. La primera
de ellas era que se buscaba un sistema ms directo en el que se pudiera comprobar el
funcionamiento del robot en vivo. La segunda de ellas, una vez ms, fue el tamao de
estos shields ya que son bastante grandes.
Figura 3-44: microSD Shield
Tras desechar la opcin de emplear un microSD Shield se pens en utilizar

tecnologa bluetooth para comunicar el robot con diferentes perifricos como por
ejemplo poda ser un ordenador o un telfono mvil.
Pgina 83 de 231
J. L. Prez Motos
Primero se pens en poner directamente un dongle bluetooth USB mediante un

puerto USB comunicado con el Arduino. Pero no se pudo llevar a cabo esta idea ya que
la placa Arduino Pro Mini carece de conversor Serie-USB, por lo que no se podra
llevar a cabo dicha comunicacin.
Figura 3-45: dongle bluetooth USB
Como alternativa se pens en utilizar un shield que transforma la seal USB a

Serial, pero su elevado coste, adems de que supona utilizar muchos pines de la placa
Arduino, se desech esta opcin.
Por lo tanto, si se quera que el sistema se comunicara mediante bluetooth se
necesitara un bluetooth especfico. Se busc en las principales pginas de proveedores
y todos tenan un precio que oscilaban entre los 35 - 50 $, precio bastante elevado, por
lo que se consider la opcin de utilizar un bluetooth genrico chino. Estos tienen
precios que oscilan entre 8 15 $. Finalmente se opt por uno de estos y que tuviera el
envo ms rpido.
El modelo elegido es el JY MCU V1.06[27]. Sus principales caractersticas son
que su tamao es muy reducido (44 cm x 16 cm x 07 cm), est formado por cuatro
pines (Vcc, Tierra, TXD y RXD) y posee internamente un regulador de tensin, por lo
que se puede alimentar a los 5 V que aporta el Arduino.
Figura 3-46: Mdulo bluetooth

Pgina 84 de 231
J. L. Prez Motos
3.6.1. CONFIGURACIN
El mdulo bluetooth vena sin configurar, por lo que lo primero que se hizo fue
configurarlo. Para poder configurarlo se deben emplear comandos AT[28]. Los pasos
para configurar el bluetooth son los siguientes:
1. Asegurarse de que el mdulo no est vinculado a ningn dispositivo, esto es,
que la luz roja del mdulo est parpadeando.
2. Dejar libres los pines de la comunicacin Serial de la placa Arduino, pines TX
y RX.
3. Cargar el programa.
4. Cuando se indique conectar el TX del mdulo bluetooth con el RX de la placa
Arduino y el RX del mdulo bluetooth con el TX de la placa Arduino.
5. Empezar la comunicacin con el mdulo (AT).
6. Cambiar el nombre del mdulo (AT+NAME).
7. Ajustar la velocidad de comunicacin (AT+BAUD):
AT+BAUD
Velocidad Transmisin
(Baudios)
1200
2400
4800
9600
19200
38400
57600
115200
Tabla 3.8: Tabla de seleccin de velocidad de transmisin
8. Configurar el pin de asociacin (AT+PIN)

A continuacin se ejecut el siguiente programa (ANEXO A.3):
Pgina 85 de 231
J. L. Prez Motos
/*********************************************************************************
*
Cambio de la configuracin del mdulo bluetooth
*
*
mediante comandos AT
*
*********************************************************************************/
//Variable para control de configuracin
boolean conf = false;
int espera = 1000;
void setup(){
pinMode(13,OUTPUT);
Serial.begin(57600);
digitalWrite(13, LOW);
}
// Pin13 para control del proceso

// Velocidad del mdulo bluetooth
// Apagamos el LED 13
void loop(){
if (conf){
// Parpadeo para verificar su funcionamiento
digitalWrite(13, HIGH);
// Enciende el LED
delay(espera);
// Espera
// Apaga el LED
delay(espera);
// Espera
}
else{
digitalWrite(13, HIGH); // Empieza el tiempo de espera para reconectar
Serial.println("Configuracin del mdulo bluetooth");
Serial.println("Conecte el TX del mdulo BT al RX del Arduino y el RX del
mdulo BT al TX del Arduino");
delay(15000);
// Espera de 15 segundos (se puede cambiar)
digitalWrite(13, LOW); // Tiempo de espera agotado para reconectar
Serial.print("AT");
delay(espera);
// Empieza la comunicacin por el mdulo BT

// Espera para el envo de comandos
Serial.print("AT+NAMEBTarduino"); // Nombre del dispositivo

delay(espera);
Serial.print("AT+BAUD7");
delay(espera);
Serial.print("AT+PIN4242");
delay(espera);
// Establecemos la velocidad en 57600

// Establecemos el pin de vinculacin
//En este punto debe estar configurado

digitalWrite(13, HIGH); // Todo ha funcionado segn lo esperado
conf = true;
// Para no volver a configurarlo, salvo que se resetee
}
}
Con esta configuracin el nombre del mdulo bluetooth ser BTarduino, funcionar
a 57600 baudios y el pin de vinculacin ser 4242.
3.6.2. PRUEBAS
Tras la configuracin del mdulo bluetooth se pas a probar el mdulo. Para ello se
ide un sketch a travs del cual se manejara el LED de una placa Arduino UNO. Segn
el valor que se recibiera se encendera el LED, se apagara o parpadeara. Para poder
realizar la comunicacin con la placa Arduino se emple la aplicacin BlueTerm[29]
para Android que est disponible en su Play Store. Esta aplicacin lo que hace es enviar
Pgina 86 de 231
J. L. Prez Motos
y recibir datos entre el mvil y el dispositivo con el que est vinculado. As se emple el
siguiente montaje y se volc el siguiente cdigo en la placa de Arduino (ANEXO A.4).
Figura 3-47: Conexin para la prueba de funcionamiento del mdulo bluetooth
Figura 3-48: Diagrama del sketch empleado para la prueba de funcionamiento del mdulo
bluetooth
Pgina 87 de 231
J. L. Prez Motos
Como el resultado result ser satisfactorio, se consider que el mdulo bluetooth

ya estaba listo para ser utilizado en el robot.
Figura 3-49: Pantalla obtenida en el dispositivo Android
3.7. ALIMENTACIN
3.7.1. ESTUDIO DE LOS COMPONENTES

A continuacin se va a representar en una tabla las tensiones que requieren cada
uno de los componentes que van a conformar el robot:
Pgina 88 de 231
Componente
J. L. Prez Motos
Voltaje mnimo Voltaje mximo
Arduino Pro Mini
20
Voltaje
recomendado
Consumo (mA)
De 7 a 12
Motor
360
L6205N
52
De 8 a 52
10
QTR-8RC
3'3
100
Bluetooth
3'3
Tabla 3.9: Estudio de voltajes de cada componente
Tras un breve anlisis se puede llegar a la conclusin de que tanto al bluetooth

como al QTR-8RC los puede alimentar las salidas Vcc del Arduino, ya que esta ofrece 5
V. Del resto el voltaje mnimo ms alto es el del L6205N (8 V) mientras que el voltaje
mximo ms bajo es el del motor (9 V). Por lo tanto, la fuente que alimente a todo el
sistema debe de estar comprendida entre 8 y 9 V.
3.7.2. ELECCIN: PILAS FRENTE A BATERAS LIPO

En primer lugar se pens en utilizar bateras de tipo LiPo ya que ofrecen una gran
autonoma y una elevada capacidad de descarga en relacin con su peso. Pero todas las
que se encontraron tenan un tamao y un peso excesivo para este proyecto, adems de
que el pack batera + cargador resultaba caro. Incluso, segn el modelo, llegaban a ser
ms grandes y pesadas que todo el resto del robot. Por lo que finalmente se desech el
uso de bateras.
Figura 3-50: Batera de 11V
Tras rechazar el uso de bateras inmediatamente se pens en emplear pilas de 9 V.

Estas tienen un tamao y un peso reducido y su coste es relativamente pequeo, adems
de aportar el voltaje que se necesita para el proyecto. El gran inconveniente de estas
Pgina 89 de 231
J. L. Prez Motos
pilas es su duracin. As que para solventar este problema, finalmente se emplearon

pilas recargables de 9 V de Ni-MH (Niquel-Metal Hidruro).
Figura 3-51: Pilas recargables de 9V
3.8. RESUMEN
En la siguiente tabla se detalla la lista de componentes empleados en el sistema:
Cantidad
Componente
Descripcin
Arduino Pro Mini
Microcontrolador
Conversor SERIE-USB FTDI232
Programador
Pololu Wheel 32x7 mm White
Ruedas de traccin
Tamiya Ball Caster Kit
Rueda de apoyo
Motores
30:1 Micro Metal Gear motor

Funda protectora para Metal Gear
motor
L6205N
Controlador motores
QTR-8RC
Matriz de sensores infrarrojos
JY - MCU V1.06
Mdulo bluetooth
Soporte motores
Pila 9V recargable
Alimentacin del sistema
Condensador 120 nF
Condensadores de polister
Condensador 220 nF
Condensador de polister
Condensador 15 nF
Condensador cermico
Condensador 6'8 nF
Condensadores cermicos
1N4148
Diodos
Resistencia 100 k
Resistencias
Resistencia 120
Resistencia
Tabla 3.10: Elementos que compondrn el robot
Pgina 90 de 231
J. L. Prez Motos
Figura 3-52: Elementos que compondrn el robot
Pgina 91 de 231
CAPTULO 4.
J. L. Prez Motos
DISEO
Tras seleccionar todos los componentes que formaran el robot se pas a disear
propiamente el robot. Para unir todos los componentes se pensaron dos mtodos. El
primero de ellos, el ms sencillo, consista en utilizar una placa de topos para montar en
ella la mayora de los elementos y despus emplear una base para colocar las diferentes
ruedas que componen el robot. El segundo mtodo consista en disear una tarjeta de
circuito impreso (PBC, Printed Circuit Board) que diera sustento tanto a los elementos
elctricos como a los mecnicos.
La principal ventaja que ofrece el primer mtodo sobre el segundo es que le da al
robot ms versatilidad. Si se desea construir un robot para que realice diferentes tareas
es ms interesante esta opcin ya que cambiando la base sobre la que va el motor se
puede conseguir que este funcione de una forma o de otra. Por otro lado, la principal
ventaja que ofrece el segundo mtodo sobre el primero es que se pueden conseguir
diseos realmente pequeos. Al eliminar conexiones entre placa y base del robot se
gana en espacio, por lo que el diseo del robot resulta ms compacto.
Finalmente se escogi la opcin de disear un PBC en el que se incluyeran todos
los componentes del robot. Se estaba intentando realizar el robot ms pequeo posible,
por lo que esta opcin era la ms idnea, adems de que le daba al robot un aspecto
mucho ms profesional.
En los siguientes apartados se desarrollar cmo se llev a cabo el diseo del robot.
Destacar que se fue realizando en paralelo tanto el diseo elctrico como el diseo en s
del PBC. Esto se debi a que hasta no ver fsicamente como quedaban los componentes
en relacin a los dems no se eligieron las conexiones.
Como programas de diseo se emple para el diseo elctrico Eagle[30] y para el
diseo del PBC DesignSpark[31]. El primero de ellos tiene unas libreras con multitud
de componentes, adems de ser ms llamativo visualmente hablando, por lo que se
pens en l como software para diseo elctrico. El gran inconveniente de este
programa es que es se necesita adquirir una licencia para poder exprimir al mximo el
programa. De todas formas, la versin Freeware permite realizar esquemas elctricos,
Pgina 92 de 231
J. L. Prez Motos
por lo que en este aspecto no supone ninguna restriccin. El segundo nos permite de una
forma muy intuitiva disear PBCs, adems de ser un software libre. Por lo que se
decidi que fuera este el encargado del diseo del PBC. La conexin entre ellos permite
convertir archivos de Eagle a archivos de DesignSpark, pero no a la inversa.
Figura 4-1: Logotipos de Eagle y DesignSpark
4.1. ASPECTOS GENERALES

Lo primero que se pens al iniciar el diseo del PBC fue la forma de este. Se baraj
la opcin de que fuera circular ya que era ms atractivo visualmente. Sin embargo, a la
hora de encajar los componentes, sera ms eficiente que el PBC fuera de forma
rectangular. De esta forma se decidi que el diseo del PBC fuera rectangular.
Despus se analizaron las conexiones que deban de existir entre las diferentes
partes que iban a formar el robot.
Programador: este viene diseado especialmente para aprovechar los pines de

la parte superior del Arduino Pro Mini, por lo que emplearan los seis pines
superiores del Arduino Pro Mini. Para realizar la conexin de forma correcta
solo hay que asegurarse que ambos pines de los extremos se unen con sus pines
del mismo nombre (cables amarillos).
Pgina 93 de 231
J. L. Prez Motos
Figura 4-2: Conexin entre programador y Arduino Pro Mini
Mdulo bluetooth: comparte los cuatro pines centrales del programador, por lo
que se pens en utilizar los mismos pines.
L6205N y sus componentes: tanto el circuito integrado como los componentes

auxiliares que necesita para funcionar necesitan diversas conexiones a la
alimentacin. Adems, se deben conectar cuatro pines PWM y dos pines
digitales del Arduino Pro Mini. Por ltimo, se deber conectar a cada motor
mediante dos pines.
QTR-8RC: adems de la alimentacin, necesita siete pines digitales del Arduino

Pro Mini, sin importar si pueden ofrecer PWM.
Tras este anlisis, se observ que sobraba algn pin del Arduino Pro Mini, por lo
que se pens en aprovechar dos ellos aadiendo al sistema dos diodos LED que servirn
para ofrecer informacin en forma de luz, como por ejemplo que haya terminado cierto
proceso, o que el robot debe girar. Para evitar que el diodo se queme se incluirn junto a
ellos dos resistencias de 220 para limitar as la corriente a unos 20 mA.
Adems, al necesitarse un total de 13 pines digitales, y al estar siendo utilizados los
pines digitales 0 y 1 (TX0 y RX1 respectivamente) se necesitaran configurar al menos
dos pines analgicos como digitales.
Despus se hizo un primer boceto en el que se colocaron todos los componentes y
que sirvi para hacerse una primera idea del diseo final que se buscaba.
Pgina 94 de 231
J. L. Prez Motos
Figura 4-3: Boceto del diseo a realizar
Lo primero que se situ fue el Arduino Pro Mini. Es el componente que ms

conexiones tiene, por lo que se pens situarlo en la parte central del PBC para que fuera
ms accesible al resto de componentes.
Como ya se ha explicado, tanto el programador como el bluetooth comparten las
conexiones de la parte superior del Arduino Pro Mini, por lo que se pens en que
estuvieran situados justo en ese lateral del Arduino Pro Mini.
Para anticipar los movimientos que deber hacer el robot se situ el QTR-8RC en la
parte delantera del robot para que detecte cuanto antes un cambio en la lnea.
Se situaron las ruedas de traccin en la parte posterior del PBC mientras que la
rueda loca se situ en la parte delantera del mismo. De esta forma, al tener tres puntos
de apoyo lo suficientemente lejanos se conseguira dar al robot toda la estabilidad que
necesitase.
Pgina 95 de 231
J. L. Prez Motos
El L6205N tiene diversas conexiones tanto con el Arduino como con los motores,
por lo que se pens situarlo en una zona intermedia de ambos componentes. Los
componentes que necesita este circuito integrado se colocaran en los alrededores de l.
Se pens en colocar la pila en la parte superior del PBC que dejasen libre tanto la
bola loca como el QTR-8RC y de esta forma ahorrar espacio. Estos dos elementos irn
por debajo del PBC mientras que la pila ir en la parte superior.
Por ltimo se pens que todo el plano del PBC formara un plano de masa, de esta
forma dara ms estabilidad elctrica al conjunto.
4.2. ARDUINO PRO MINI

Ya se ha indicado que lo primero que se iba a fijar iba a ser el Arduino Pro Mini.
Se fijar su posicin y despus se colocarn el resto de elementos en funcin de l. Es el
cerebro del robot por lo que es su parte ms importante, por lo que habr que tomar
especial cuidado en su colocacin.
Figura 4-4: Diferentes representaciones del Arduino Pro mini. De izquierda a derecha: Eagle,
DesignSpark, realidad
Para poder realizar los diferentes diseos se han empleados los esquemas que hay
disponibles en la pgina de Arduino. El esquema elctrico era demasiado detallado, por
Pgina 96 de 231
J. L. Prez Motos
lo que se ha modificado y se ha simplificado. Para el diseo del PBC se ha empleado tal

cual y no se ha hecho ninguna modificacin.
Segn el boceto realizado se situar entre el QTR-8RC y el L6205N. Este ltimo
necesita cuatro conexiones PWM. Las salidas PWM del Arduino Pro Mini son las
salidas digitales 3, 5, 6, 9, 10 y 11; por lo que el lado izquierdo del Arduino Pro Mini
tiene ms salidas PWM. De esta forma se decidi que este lado fuera el que estuviera en
el lado del L6205N.
Al otro lado del Arduino Pro Mini se encuentra el QTR-8RC. La posicin de
este tambin estaba fijada si se quera que los sensores estuvieran lo ms adelante
posible. Pero tal y como estaba situado el Arduino con respecto a l, las lneas de Vcc y
de GND tenan que dar mucha vuelta, es por ello por lo que se decidi girar el Arduino
sobre s mismo para que los pines Vcc y GND quedaran ms accesibles. De esta forma,
visualmente el Arduino Pro Mini quedara boca abajo.
Figura 4-5: Problema de alimentacin del QTR-8RC
Pgina 97 de 231
J. L. Prez Motos
Figura 4-6: Conexionado entre el Arduino Pro Mini y el L6205N y el QTR-8RC
De esta forma se fij la posicin relativa del Arduino Pro Mini con respecto al
L6205N y al QTR-8RC.
4.3. PROGRAMADOR Y BLUETOOTH

Tanto el programador como el mdulo bluetooth comparten la disposicin de los
pines con la parte superior del Arduino Pro Mini, as que determinar su posicin una
vez habiendo fijado la del Arduino fue muy sencillo.
Pgina 98 de 231
J. L. Prez Motos
Figura 4-7: Conexin entre Arduino Pro Mini y programador y mdulo bluetooth
Solo habra que tener especial cuidado en que en el mdulo bluetooth los terminales
Vcc y GND estn al revs.
4.4. L6205N Y MOTORES

Tanto el L6205N, como sus componentes y los motores fueron las partes del robot
que ms se tard en encajar. Al ser un gran nmero de elementos, result difcil
encontrar una combinacin de disposiciones para que ninguna lnea se cruzara. Junto a
esta parte tambin se incluy el interruptor que gobierna el sistema.
Pgina 99 de 231
J. L. Prez Motos
Figura 4-8: Esquema en Eagle del L6205N y los componentes que necesita
En primer se situaron los motores. Se determin que la anchura de ambos motores

puestos en lnea era mayor que la anchura de la matriz de sensores, por lo que estos
determinaran el ancho del robot. Tambin se determin que estuvieran en la parte
superior del PBC. Su parte inferior era de metal, por lo que si se colocaban en la parte
inferior del PBC podran causar un cortocircuito con el plano de masa. De esta forma se
midieron los motores y sus fundas y se cre un bloque para poder tener sus dimensiones
en el programa. Una vez determinada la posicin de los motores quedaba un hueco libre
entre ellos, el cual se emple para situar el interruptor. Despus se fueron aadiendo los
diferentes componentes del L6205N de tal forma que se fuera ocupando el menor
espacio posible.
Tras multitud de pruebas, se lleg a la siguiente configuracin.
Pgina 100 de 231
J. L. Prez Motos
Figura 4-9: Conexin entre el L6205N y sus componentes
4.5. BOLA LOCA, QTR-8RC Y PILA

Despus se aadi la bola loca. Esta se une al PBC a travs de tres tornillos, pero se
hicieron pruebas y la bola quedaba lo suficientemente ajustada con solo dos tornillos.
De esta forma se consigui ahorrar en espacio al suprimir uno de los tornillos.
Pero al incluir estos tornillos haba que aadir unos taladros en el PBC que
interferan con la conexin entre el Arduino Pro Mini y el QTR-8RC, por lo que hubo
que redisear la conexin. Adems se pens en ajustar al mximo posible las distancias
de la bola loca y del QTR-8RC, por lo que, como inicialmente se haba pensado, no
entrara la pila en el hueco dejado en la parte superior del PBC. As que se pens que la
Pgina 101 de 231
J. L. Prez Motos
pila ira en una plataforma superior. Tras varias pruebas, se lleg a la siguiente
configuracin:
Figura 4-10: Disposicin de los taladros de la rueda loca y conexin entre Arduino Pro Mini y
L6205N
4.6. RESULTADO FINAL

Por ltimo se aadieron cuatro taladros para poder incluir la plataforma para la
pila, adems de aadir los LEDs.
Pgina 102 de 231
J. L. Prez Motos
Figura 4-11: Resultado final del PBC
Y se aadi el plano de masa.
Figura 4-12: Resultado final con plano de masa

Pgina 103 de 231
J. L. Prez Motos
De esta forma se consigui que no hiciera falta aadir ningn cable externo adems
de los que conectan los motores con el L6205N. Adems se realiz un 3D del diseo:
Figura 4-13: Representacin 3D del diseo. Vista isomtrica 1
Figura 4-14: Representacin 3D del diseo. Vista isomtrica 2
Pgina 104 de 231
J. L. Prez Motos
Figura 4-15: Representacin 3D del diseo vista de alzado
Figura 4-16: Representacin 3D del diseo. Vista posterior

Pgina 105 de 231
J. L. Prez Motos
Tras esto se mont un prototipo para comprobar que todos los componentes
encajaban:
Figura 4-17: Impresin del PBC
Figura 4-18: Prototipo. Vista ismetrica

Pgina 106 de 231
J. L. Prez Motos
Figura 4-19: Prototipo. Vista de alzado. Comparacin con un boli Bic
Figura 4-20: Prototipo. Vista posterior

Pgina 107 de 231
J. L. Prez Motos
Y finalmente, el PBC construido:
Figura 4-21: PBC. Izquierda vista posterior. Derecha vista de alzado
Por ltimo se complet el esquema elctrico:
Pgina 108 de 231
J. L. Prez Motos
Figura 4-22: Esquema unifilar final del robot

Pgina 109 de 231
J. L. Prez Motos
De esta forma la asignacin de pines del Arduino Pro Mini qued como sigue:
Funcin
Pin Arduino
Comunicacin con el programador
pines digitales 0, 1
Comunicacin mdulo bluetooth
Leds delanteros
Entradas digitales del QTR-8RC
entradas digitales 11, 12, 14, 15, 17, 18
Control led QTR-8RC
pin digital 19
Enables de los puentes del L6205N
PWM de los puentes del L6205N
pines digitales PWM 3, 5, 6, 9
Tabla 4.1: Asignacin de pines por funcin
Pin Arduino
Funcin
digital 0
Recepcin de datos (RX) del programador y del bluetooth
digital 1
Envo de datos (TX) al programador y al bluetooth
digital 2
digital 3 (PWM)
Entrada 2 del puente A del L6205N
digital 4
digital 5 (PWM)
Entrada 1 del puente A del L6205N
digital 6 (PWM)
Entrada 1 del puente B del L6205N
digital 7
Enable del puente B del L6205N
digital 8
Enable del puente A del L6205N
digital 9 (PWM)
Entrada 2 del puente B del L6205N
digital 10
Led izquierdo
digital 11
QTR-8RC sensor 3
digital 12
QTR-8RC sensor 5
digital 13
Control led interno Arduino Pro Mini
digital 14
QTR-8RC sensor 4
digital 15
QTR-8RC sensor 2
digital 16
Led derecho
digital 17
QTR-8RC sensor 0
digital 18
QTR-8RC sensor 1
digital 19
Control led QTR-8RC
Tabla 4.2: Asignacin de pines por pin
Pgina 110 de 231
CAPTULO 5.
J. L. Prez Motos
CONSTRUCCIN DEL ROBOT
Despus de disponer de todos los componentes que iban a formar el robot se

procedi a su construccin. Para ello se hizo primero un anlisis de los elementos por
separado.
En primer lugar se colocaron los motores. Es de suma importancia que ambos
motores se encuentren posicionados de forma correcta, por lo que se pens que la mejor
manera de trabajar con el PBC y los motores era cuando aquel no tuviera todava sobre
l ningn componente
Figura 5-1: Colocacin de los motores
Despus se pusieron los diferentes conectores. Desde un primer momento se

desech la opcin de soldar los componentes ms importantes a la placa, tales como el
Arduino Pro Mini, el L6205N, el programador, el mdulo bluetooth y los pines de
alimentacin. Adems, por temas de diseo, fue imposible incluir en el diseo del PBC
las pistas que unen los motores con el L6205N, por lo que tambin se tuvieron que
incluir dichos conectores.
Pgina 111 de 231
J. L. Prez Motos
Los conectores se colocaron antes que el resto de componentes ya que requieren

que se coloquen lo ms vertical posibles, por lo que, al igual que con los motores,
cuando mejor se iba a poder operar con el PBC era cuando este contara con el menor
nmero de componentes sobre l.
Figura 5-2: Colocacin de los conectores hembras y machos
Una vez colocados todos los conectores se soldaron a la placa los diferentes
componentes, tales como los LEDs delanteros, los componentes que conforman el
circuito del L6205N y el interruptor que controla la alimentacin.
Pgina 112 de 231
J. L. Prez Motos
Figura 5-3: Colocacin de los LEDs delanteros y los componentes del L6205N
Despus se atornill al PBC la rueda loca. Esta se encuentra muy prxima al QTR8RC, por lo que se prefiri montar este componente antes que la matriz de sensores
infrarrojos.
Figura 5-4: Colocacin de la bola loca
Pgina 113 de 231
J. L. Prez Motos
Tras esto se soldaron unos pines al QTR-8RC y se soldaron al PBC. La distancia

al suelo a la que se decidi poner los sensores fue de 4mm, ya que el fabricante
recomienda que estos se siten a una distancia del suelo de entre 3 y 9mm.
Figura 5-5: Colocacin del QTR-8RC
Despus se pusieron sobre sus conectores al Arduino Pro Mini y al L6205N.
Figura 5-6: Colocacin del Arduino Pro Mini y del L6205N

Pgina 114 de 231
J. L. Prez Motos
Por ltimo se atornill en la parte superior del robot una superficie para ofrecer
sustento a la pila. La pila se colocar sobre la parte delantera del robot para darle a este
ms estabilidad.
Figura 5-7: Colocacin de soporte para pila y pila
Figura 5-8: Resultado final. Vista isomtrica 1
Pgina 115 de 231
J. L. Prez Motos
Figura 5-9: Resultado final. Vista isomtrica 2
Pgina 116 de 231
CAPTULO 6.
PRUEBAS
DE
J. L. Prez Motos
LOS
COMPONENTES
DEL
ROBOT
En este apartado se van a desarrollar las diferentes pruebas a las que se someti al
robot para comprobar su perfecto funcionamiento.
Como ya se ha explicado con anterioridad, el Arduino Pro Mini carece de conversor
Serie USB, por lo que hay que emplear un conversor externo para programar el
Arduino. Para este proyecto se emple el conversor FTDI232[32].
Figura 6-1: Conexin del conversor FTDI232
Las pruebas que se van a realizar son las siguientes:
Sensores infrarrojos.
Motores y LEDs.
Bluetooth.
Pgina 117 de 231
J. L. Prez Motos
6.1. SENSORES INFRARROJOS

Al igual que como se hizo en el apartado 3.5.2 se va a probar el funcionamiento de
los sensores del QTR-8RC. Para ello se va a emplear el mismo programa que entonces,
cambiando nicamente los pines (ANEXO A.5). Si se recuerda el esquema del cdigo:
Figura 6-2: Diagrama del sketch empleado para la prueba de funcionamiento del QTR-8RC
Para poder mostrar los valores de forma clara, en primer lugar se calibran los
sensores para obtener los valores mximos y mnimos de cada sensor para despus
poder mapearlos. Adems se incluye un filtro para evitar valores indeseados. De esta
forma se consigue que los sensores que estn justo encima de la lnea muestren un valor
distinto de cero mientras que los sensores situados fuera de la lnea muestran cero.
Figura 6-3: Valores obtenidos en funcin de la posicin relativa del robot con respecto a la lnea
Pgina 118 de 231
J. L. Prez Motos
Al llevar a cabo esta prueba se detectaron dos importantes caractersticas

geomtricas del robot:
El nmero mnimo de sensores que pueden detectar la lnea negra al mismo

tiempo, en recta y sin bifurcaciones, son dos. Esta caracterstica se emplear
cuando haya que obtener la posicin del robot con respecto a la lnea negra.
El nmero mximo de sensores que pueden detectar la lnea negra al mismo

tiempo, en recta y sin bifurcaciones, son tres. Esta caracterstica del robot se
emplear para detectar bifurcaciones en el camino.
Como los resultados obtenidos fueron satisfactorios, se pas a probar los motores.
6.2. MOTORES
Una vez comprobados los sensores infrarrojos se probaron los motores y los LEDs.
Conviene recordar del apartado 3.2 que se escogi que el robot empleara un sistema
diferencial. Esto quiere decir que para que el robot gire se deben aplicar diferentes
velocidades a cada rueda.
Adems, como se explic en el apartado 3.4, para controlar tanto la velocidad de
giro como el sentido de giro de las ruedas se va a emplear el circuito integrado L6205N.
Este permite que las ruedas giren como uno desee en funcin de las entradas de control
que reciba. Estas entradas de control se las proporciona el Arduino Pro Mini en forma
de pulsos PWM. Las seales PWM son seales cuadradas que mantienen constante su
periodo pero varan el tiempo que la seal est a nivel alto.
Figura 6-4: Diferentes seales PWM

Pgina 119 de 231
J. L. Prez Motos
De esta forma, las salidas PWM del Arduino Pro Mini ofrecen seales de 490Hz y
se controlan mediante un byte, es decir, valores de 0 a 255. As, para frenar el motor se
le dar al valor de control un 0, mientras que para hacer que vaya a su mxima
velocidad se le dar un 255[10].
Para probar los motores y los LEDs lo que se hizo fue programar que el robot
siguiera ciertas trayectorias y emplear los LEDs a modo de intermitentes: si el robot iba
recto se encenderan los dos LEDs, si giraba a la derecha que se encendiera el LED
derecho y si giraba a la izquierda que se encendiera el LED izquierdo.
Figura 6-5: Movimientos que puede realizar el robot
De esta forma, se program que el robot realizara todas las posibles situaciones
(ANEXO A.6):
Marcha adelante.
Marcha atrs.
Giro a la izquierda.
Giro a la derecha.
Giro en el sitio a la izquierda.
Giro en el sitio a la derecha.

En esta parte se dise la funcin que mueve los motores. Se le llam motor y
cuenta con dos entradas, una para cada motor. La funcin en s consiste en analizar cada
una de las entradas por separado. Primero se comprueba si el valor es mayor o menor
Pgina 120 de 231
J. L. Prez Motos
que cero. Si es mayor o igual que cero se lleva el valor correspondiente a la entrada 1
del puente. Sin embargo, si la entrada es negativa se lleva a la entrada 2 del puente. De
esta forma se consigue controlar el sentido de giro de los motores.
Adems, como ya se ha explicado, los valores estn limitados entre 0 y 255. De
esta forma se emplea la funcin constrain, que lo que hace es estudiar si un valor est
entre dos lmites. Si el valor es mayor que el lmite superior, el valor tomar el valor del
lmite superior. Si el valor es inferior que el lmite inferior, el valor tomar el valor del
lmite inferior.
/*
********************************************************
*
Funcin para mover los motores segn el PWM
*
********************************************************
*/
void motor(int out1, int out2){
if (out1 >= 0){
analogWrite(in1A, constrain(abs(out1), 0, vMax));
analogWrite(in2A, 0);
}
else{
}
if (out2 >= 0){
analogWrite(in1B, constrain(abs(out2), 0, vMax));
analogWrite(in2B, 0);
}
else{
}
}
Como los resultados fueron los esperados, se pas a comprobar el mdulo

bluetooth.
6.3. BLUETOOTH
Por ltimo se comprob que el bluetooth funcionara de forma correcta. Adems se
aprovech esta prueba para estudiar el comportamiento del robot al mezclar diferentes
componentes. As, en primer lugar se comprob la conectividad por bluetooth entre el
robot y el ordenador y despus la conectividad por bluetooth entre el robot y un mvil
Android.
Pgina 121 de 231
J. L. Prez Motos
Sealar que al emplear tanto el mdulo bluetooth como el conversor los mismos
pines para enviar y recibir datos no podrn estar conectados al mismo tiempo. De esta
forma cada vez que se quiera programar el robot habr que desconectar el mdulo
bluetooth y una vez cargado el programa en el robot volver a conectar el bluetooth. Esta
accin se podra haber facilitado mediante la inclusin de un interruptor que
desconectara el mdulo bluetooth del interfaz serie durante la programacin y as no
hara falta separar fsicamente el mdulo bluetooth del robot para programarlo.
6.3.1. CONEXIN ROBOT - ORDENADOR

Desde un primer momento se pens que una buena utilidad del bluetooth sera la
comprobacin de diferentes variables del robot en un ordenador. Este era el principal
objetivo de esta prueba. De esta forma se pens que una de las variables ms fciles de
analizar sera el estado de los sensores infrarrojos. Para no mostrar solamente nmeros
por pantalla se pens que se podra representar en alguna forma de grfico el estado de
los sensores y qu mejor herramienta para mostrar grficas que Matlab. As que se
decidi que para comprobar la conexin robot ordenador se enviara por bluetooth el
estado de los sensores infrarrojos al ordenador y este mediante Matlab representara el
estado de estos en un grfico de barras.
Figura 6-6: Esquema de comunicacin para la prueba del mdulo bluetooth
En primer lugar se realiz el sketch que ejecutara el robot. Para evitar que cada vez
que se iniciase el cdigo se calibrasen los sensores, se realizaron un par de medidas
sobre la pista que posteriormente se utilizara para observar los resultados para obtener
los valores mximos y mnimos de cada sensor.
Despus hubo que obtener el tiempo que tardaba Matlab en procesar los datos.
Matlab no realiza los clculos instantneamente, sino que presenta un pequeo retardo,
Pgina 122 de 231
J. L. Prez Motos
y si no se tiene en cuenta no se puede conseguir una sincronizacin correcta entre el

robot y Matlab. Tras sucesivas pruebas, se obtuvo que este tiempo era de 10ms, por lo
que al final del sketch se introdujo un delay de 10ms. El diagrama del sketch (ANEXO
A.7) es el siguiente:
Figura 6-7: Diagrama del sketch empleado para la prueba de conexin entre robot y ordenador
Una vez configurado el robot se enviarn los datos por bluetooth, pero simulando
un puerto serie que se debe conocer. Para ello se debe vincular el ordenador con el
mdulo bluetooth. Lo que hay que hacer es que el ordenador detecte el mdulo
bluetooth y despus introducir la contrasea que este tiene asociada, en este caso 4242:
Figura 6-8: Vinculacin entre ordenador y mdulo bluetooth
Despus hay que hacer clic con el secundario en el icono del bluetooth del rea de
notificacin y hacer clic en Abrir configuracin. Por ltimo en la pestaa Puertos COM
Pgina 123 de 231
J. L. Prez Motos
est el puerto que se debe utilizar. El puerto que se tiene que utilizar es el que en el
nombre tenga la extensin Dev B, en este caso es el puerto COM6:
Figura 6-9: Comprobacin del puerto serie que se debe emplear
Una vez obtenido el puerto asociado al bluetooth del robot se empieza a realizar el
programa de Matlab (ANEXO A.8). En primer lugar se crea un objeto serie en Matlab y
se abre para empezar a leer[33]:
%borrar previos
delete(instrfind({'Port'},{'COM6'}));
%crear objeto serie
s = serial('COM6','BaudRate',57600,'Terminator','CR/LF');
%abrir puerto
fopen(s);
Como se puede ver, la primera lnea de cdigo lo que hace es eliminar cualquier
aplicacin que est usando el puerto COM6. Despus se crea el objeto serie. En este
caso se va a denotar con s. En este punto habr que indicarle los baudios a los que
Pgina 124 de 231
J. L. Prez Motos
funciona el mdulo bluetooth, en este caso 57600. Por ltimo se abre el puerto con la
funcin fopen.
%Tiempo que dura la medicin en segundos
tmax = 20;
%Inicializar
t = 0;
Despus hay que definir el tiempo total en el que va a estar funcionando la

conexin robot ordenador. Para esta prueba se pens que sera suficiente con 20
segundos. Despus se inicializa un contador t a cero que servir para medir el tiempo
que lleva ejecutndose el programa.
%Ejecutar bucle cronometrado
tic
%Con tic y toc mide el tiempo que hay entre ellos
while t<tmax
t = toc;
%Leer del puerto serie
puerto = fscanf(s,'%d %d %d %d %d %d')';
%Dibujar el diagrama de barras
bar(puerto);
%Actualizar el diagrama
drawnow
end
El ncleo del programa es el bucle de medida, en el cual iremos leyendo del puerto
serie los datos en el formato que hemos especificado en la funcin fscanf. En este caso,
desde el robot se est enviando el estado de los seis sensores de forma consecutiva
separando cada valor mediante un espacio. Despus se emplea la funcin bar para
dibujar el diagrama de barras en funcin de los valores de los sensores y con la funcin
drawnow se muestra por pantalla el diagrama de barras. Si no se incluyera solo se
mostrara el ltimo resultado. Aclarar tambin el funcionamiento de tic y toc. Son dos
variables internas que usa Matlab. Con tic se empieza a ejecutar un reloj interno y con
toc se puede acceder al valor de este reloj. De esta forma, si se le va dando en cada ciclo
a t el valor de toc se podr conocer cundo se ha alcanzado el tiempo mximo.
clc;
%% Cerrar y eliminar el puerto creado
fclose(s);
delete(s);
clear s;
Por ltimo, si el resultado ha sido satisfactorio, se limpiar la pantalla principal

de Matlab y se cerrar y eliminar el puerto creado. As, se obtiene la siguiente figura:
Pgina 125 de 231
J. L. Prez Motos
Figura 6-10: Resultado de la prueba
En el grfico en el eje de abscisas se representa cada sensor infrarrojo por separado

y en el eje de ordenadas el valor en ese instante de cada sensor. Si el sensor est situado
sobre la lnea negra mandar un 9, mientras que si no lo est mandar un 0. Si el sensor
no est totalmente situado sobre la lnea negra se enviar un dato intermedio. En este
caso, el sensor 3 se encontraba totalmente situados sobre la lnea negra mientras que el
sensor 2 solo estaba un poco situado sobre esta. Los dems sensores ninguno estaba
sobre la lnea negra.
Como los resultados obtenidos fueron satisfactorios, se pas a realizar la ltima
prueba al robot antes de comenzar con la programacin del sigue lneas.
6.3.2. CONEXIN ROBOT MVIL ANDROID

Para realizar esta prueba se emple la misma tcnica que en el apartado 3.6.2.
Mediante la aplicacin disponible en el Play Store de Android llamada BlueTerm se
enviarn datos al robot y este segn los valores que obtenga ejecutar una u otra accin.
El diagrama del sketch (ANEXO A.9) es el siguiente:
Pgina 126 de 231
J. L. Prez Motos
Figura 6-11: Diagrama del sketch empleado para la prueba de funcionamiento de la conexin
entre robot y Android
Como los resultados obtenidos fueron satisfactorios, se concluy que todas las
partes del robot funcionaban correctamente y se empez a programar el sigue lneas.
Pgina 127 de 231
J. L. Prez Motos
Figura 6-12: Resultado obtenido en el dispositivo Android
Pgina 128 de 231
CAPTULO 7.
J. L. Prez Motos
SIGUE LNEAS
En esta parte del proyecto se va a desarrollar el funcionamiento del robot como un

seguidor de lneas. A continuacin se muestra el diagrama de todo el sketch (ANEXO
A.10).
Figura 7-1: Diagrama del sketch empleado por el robot para seguir lneas
En l se pueden distinguir diferentes partes.
Declaracin de variables.
Configuracin del robot.
Calibracin de los sensores.
Seguimiento de la lnea.
Algoritmo PID.
Salida del trazado.
En los siguientes apartados se proceder a desarrollar cada una de estas partes.
Pgina 129 de 231
J. L. Prez Motos
7.1. DECLARACIN DE VARIABLES

En primer lugar se deben declarar las variables que emplear el robot. Para poder
manipularlas ms adelante con facilidad se agrupan en conjuntos segn cul sea su
finalidad.
7.1.1. ASIGNACIN DE PINES

En este conjunto de variables se definen los pines del Arduino Pro Mini que le
corresponden a las diferentes partes del robot. De esta forma no hace falta ir recordando
a que pin le corresponde por ejemplo el LED delantero derecho, sino que con una
variable podemos manipular el LED y olvidarnos de qu pin del Arduino Pro Mini le
corresponde.
En este tipo de variables tambin estn las entradas y los enables que manipulan el
L6205N, los pines a los que estn conectados los sensores infrarrojos y los ya
mencionados LEDs delanteros.
7.1.2. VARIABLES DE LOS SENSORES INFRARROJOS

Estas variables tienen como finalidad la de manipular los datos que se reciben de
los sensores infrarrojos. De esta forma, todas las variables de este tipo son de tipo
vector, ya que se necesita manipular la informacin de seis sensores.
En este tipo de variables est las variables donde se guardan las lecturas de los
sensores, donde se guardan los pesos de los sensores (que ms adelante se emplearn
para calcular la posicin), las variables para poder calibrar los sensores y las variables
para mostrar los resultados de los sensores de una forma ms clara.
7.1.3. PARMETROS DEL PID

Aqu se definen las variables que se emplearn para llevar a cabo el control PID.
Como se explicar en el apartado 7.5, aqu se definen las variables de la parte
Pgina 130 de 231
J. L. Prez Motos
proporcional, de la parte integral y de la parte derivativa del control, adems de otras

variables para poder realizar todos los clculos que se necesitan.
7.1.4. VARIABLES PARA EL CLCULO DE LA POSICIN

Como su nombre indica, la finalidad de estas variables son las de poder obtener en
qu posicin se encuentra el robot en relacin a la lnea negra. As, se necesita una
variable que defina el camino que debe seguir el robot, otra que almacene su posicin y
de otras variables que se emplearn cuando el robot se encuentre ante una bifurcacin o
cuando se haya salido del trazado.
7.1.5. VARIABLES PARA EL MOVIMIENTO DE LOS MOTORES

Con estas variables se controla el movimiento de los motores. Se necesitan dos
variables para definir la velocidad de los motores (una por cada motor), adems de otra
para definir la velocidad mxima que pueden alcanzar y una ltima variable que es la
que define la velocidad del robot en lnea recta, es decir, cuando el robot se encuentra
totalmente centrado en la lnea negra.
En un primer momento se puede pensar en poner esta velocidad igual a la mxima
velocidad, pero si se recuerda el apartado 6.2 los motores tienen limitadas sus
velocidades entre 0 y 255. De esta forma, si se ajustara que el robot fuera a la mxima
velocidad en recta y se encontrara una curva su capacidad de maniobrar se ver
drsticamente reducida. Por lo que hay que elegir una velocidad que vaya los
suficientemente rpido en recta y que permita al robot funcionar perfectamente en las
curvas.
7.1.6. OTRAS VARIABLES

Aqu se engloban al resto de variables, tales como las de tiempo o las que controlan
el brillo de los LEDs.
Pgina 131 de 231
J. L. Prez Motos
7.2. CONFIGURACIN DEL ROBOT

Una vez definidas todas las variables del robot se procede a su configuracin. En
primer lugar se define la velocidad de datos en bits por segundo (baudios) para la
transmisin de datos en serie. Para ello se emplea la funcin Serial.begin. Debido a que
el mdulo bluetooth se ha configurado a una velocidad de 57600 baudios, esta ser
tambin la velocidad que emplear el robot.
Despus se definen cmo van a funcionar los pines del Arduino Pro Mini con la
funcin pinMode. Un pin puede funcionar como pin de salida o de entrada. Por defecto
todos los pines estn configurados como pines de entrada, por lo que solo hay que
configurar los pines de salida, aunque siempre es recomendable configurar tambin los
pines de entrada para que quede un cdigo ms claro. En el caso del robot, como se ha
empleado la estructura QTRSensorsRC incluida en la librera QTRSensors.h ya se define
dentro de esa estructura los pines correspondientes como pines de entrada. Por otro
lado, se definen como pines de salida los pines que controlan el L6205N y los pines que
controlan los LEDs delanteros.
Por ltimo se prepara al robot para entrar en fase de calibracin. Para ello en primer
lugar se ponen todas las salidas que controlan al L6205N a nivel bajo para asegurar que
el robot empieza en posicin de reposo. Despus se activan ambos puentes en H del
L6205N poniendo a nivel alto los enables de ambos puentes. Tambin se apagan los
LEDs para reducir el consumo. De esta forma el robot ya se puede empezar con la
calibracin de los sensores infrarrojos con la funcin calibracion.
7.3. CALIBRACIN DE LOS SENSORES INFRARROJOS

En realidad la calibracin de los sensores infrarrojos forma parte de la
configuracin del robot, pero debido a su importancia se ha pensado en dedicarle un
apartado solo a l para analizarlo ms en profundidad.
Las razones por las que se pens en introducir una fase de calibracin fueron dos:
Todos los sensores no presentan las mismas lecturas ante una misma situacin.
De esta forma, al realizar una calibracin inicial se pueden detectar cules son
Pgina 132 de 231
J. L. Prez Motos
las mximas y las mnimas medidas que realiza cada sensor y despus ponderar
las medidas en funcin de estos valores. De otra forma lo que para un sensor
puede significar estar sobre la lnea negra para otro simplemente puede
significar estar parcialmente sobre la lnea negra.
Se puede emplear el robot para que siga la lnea negra sobre otras superficies
que no sean necesariamente blancas. Cuando se empez a realizar pruebas con el
robot era bastante laborioso tener que estar usando solo superficies blancas. De
esta forma se puede emplear cualquier color, evitando evidentemente el negro.
As, simplemente utilizando cinta aislante negra y el parqu de tu casa uno se
puede construir su propio trazado.
A continuacin se muestra el diagrama de la calibracin de los sensores infrarrojos

del robot:
Figura 7-2: Diagrama del sketch para calibrar los sensores infrarrojos
Una vez entrado en la fase de calibracin, lo primero que se hace es encender los
dos LEDs delanteros para indicar que el robot est en la fase de calibracin. Despus se
fuerza al robot a girar sobre s mismo a una determinada velocidad y durante dos
segundos los sensores realizan mediciones. Estas mediciones se comparan con las
mximas y mnimas medidas que ha presentado cada sensor hasta ese momento con la
Pgina 133 de 231
J. L. Prez Motos
funcin minmax. Si la medida es mayor al mximo, la medida pasar a ser el nuevo

mximo. Si la medida es menor que el mnimo, la medida pasar a ser el nuevo mnimo.
Tras haber calibrado los sensores el propio robot, de forma autnoma, se sita de
forma correcta sobre la lnea. Para ello de nuevo se le hace girar al robot a una
determinada velocidad hasta el robot se encuentre centrado sobre la lnea. El cmo se
calcula la posicin relativa del robot con respecto a la lnea se explica ms adelante.
Una vez que el robot se ha situado correctamente sobre la lnea se apagan los LEDs
delanteros y se da por concluida la calibracin de los sensores infrarrojos.
7.4. SEGUIMIENTO DE LA LNEA

Tras la calibracin de los sensores infrarrojos empieza el bucle del programa. Lo
primero que se realiza es la medida de los sensores infrarrojos. Para ello se emplea la
funcin qtrrc.read de la librera QTRSensor[34].
Tras la lectura de los sensores se realiza un mapeado de los valores entre 0 y 9 en
funcin de los valores mximos y mnimos que se han obtenido en la fase de
calibracin. De esta forma se consigue que los valores que ofrezca cada sensor sea
independientemente del sensor que sea. Se ve ms claro en la siguiente imagen:
Figura 7-3: Diferencia entre los valores devueltos por los sensores infrarrojos con y sin mapear
Al mapear los valores de los sensores se consigue una medida ms fidedigna con la
realidad. Sin mapear es posible que un sensor que est sobre la lnea negra ofrezca una
medida menor a la que ofrece un sensor que no est sobre la lnea negra.
Pgina 134 de 231
J. L. Prez Motos
Tras mapear los sensores se filtran estos valores con la funcin filtro. Es posible
que por el motivo que sea los sensores ofrezcan una medida que se salga de los lmites
establecidos. Este filtro evita que eso suceda. Adems, este filtro permite contabilizar
cuntos sensores estn sobre la lnea. Si resulta que no hay ningn sensor sobre la lnea
negra es que el robot se ha salido del trazado. Este caso se tratar en el apartado 7.6. Por
otro lado, si al menos un sensor ve lnea se ejecuta la funcin si_linea.
Con esta funcin lo que se pretende es barajar las opciones posibles existentes si el
robot est sobre la lnea. Lo primero que hace esta funcin es detectar si hay marcas de
bifurcaciones en los laterales del trazado. Si se recuerda del apartado 2.1.2, se marca en
los laterales del trazado con pequeas marcas la direccin que deber tomar el robot en
la siguiente bifurcacin.
Figura 7-4: Deteccin de las marcas de bifurcacin
As, lo que hace esta funcin es detectar si el robot se encuentra en alguna de estas
posiciones. Si se encuentra en alguna de ellas se ejecuta la funcin si_marca, la cual
guarda qu marca era y obliga al robot a seguir recto. Por otro lado, si el robot no se
encuentra en ninguna de esas posiciones ejecuta la funcin calculo_posicion.
Esta funcin es la que permite determinar la posicin del robot en relacin a la lnea
negra. Para ello aplica la siguiente ecuacin:
Pgina 135 de 231
J. L. Prez Motos
)
)
Figura 7-5: Valores de los pesos que tiene cada sensor
En ella se tiene en cuenta tanto el valor de cada sensor como el peso que tiene
asociado cada sensor. De esta forma, el valor que tiene que seguir el robot para ir
completamente recto es 25.
Tras obtener la posicin relativa del robot con respecto a la lnea, se estudia si el
robot est en una bifurcacin. Como se explic en el apartado 6.1, el nmero mximo de
sensores que pueden detectar la lnea negra al mismo tiempo es tres. Por lo tanto, en el
momento en el que ms de tres sensores detecten lnea es que hay presente una
bifurcacin. De esta forma, para obligar al robot a tomar una cierta direccin se cambia
el valor que tiene que seguir el robot a 0, a 25 o a 50 en funcin de si tiene que ir a la
izquierda, seguir recto o ir a la derecha. As se consigue que el robot site la mayora de
sus sensores sobre la direccin que debe tomar y cuando vuelva a seguir el camino de
forma normal (consigna de 25) ya estar sobre el camino a seguir.
Pgina 136 de 231
J. L. Prez Motos
Figura 7-6: Obligacin de giro del robot segn las marcas de bifurcacin
Tras detectar las posibles bifurcaciones se calcula el error. Para calcularlo se aplica
la siguiente ecuacin:
(
Adems se almacena el ltimo error que ha tenido el robot por si este se sale de la
trayectoria y de esta forma poder volver a la lnea.
Una vez repasadas todas las posibles configuraciones que pueden aparecer si el
robot est sobre la lnea se aplica el control PID. Debido a su importancia se explicar
en el siguiente apartado.
7.5. PID
Cuando se estudiaron los diferentes robots sigue lneas ya existentes prcticamente
la totalidad de ellos empleaban un control PID para corregir la posicin del robot y
hacer que este siga la trayectoria de forma correcta. Pero ninguno de ellos contaba con
ninguna herramienta para obtener los valores ptimos de las constantes que forman este
control, sino que simplemente iban probando diferentes valores hasta que consideraban
que el robot segua lo suficientemente bien la lnea.
Pgina 137 de 231
J. L. Prez Motos
En los siguientes apartados se har una breve introduccin sobre el control PID,
despus se describir una herramienta para obtener valores ptimos de las constantes y
por ltimo se aplicar esta herramienta en el robot.
7.5.1. QU ES UN CONTROLADOR PID?

Un controlador PID (proporcional, integral, derivativo) es un mecanismo de control
retroalimentado en bucle cerrado ampliamente utilizado en sistemas de control
industrial[8]. Un controlador PID calcula el error como la diferencia entre el valor
actual del sistema y un valor de referencia objetivo.
Figura 7-7: Diagrama de bloques de un controlador PID
En el clculo del controlador PID intervienen tres parmetros, los cuales pueden ser
interpretados en funcin del tiempo. La parte proporcional P depende del error actual, la
parte integral I depende de la suma de todos los errores pasados y la parte derivativa D
es la prediccin de errores futuros, basndose en la tasa de cambio actual. La suma
ponderada de los tres trminos permiten ajustar un proceso mediante un elemento de
control como por ejemplo la velocidad que debe alcanzar un motor de corriente
continua.
Mediante el ajuste de estas tres constantes del algoritmo de control PID, el

controlador es capaz de proporcionar acciones de control especficas a los
Pgina 138 de 231
J. L. Prez Motos
requerimientos de un sistema. La efectividad del controlador se puede medir con tres

parmetros. El ajuste estos parmetros se logra mediante el anlisis del sistema.
Tiempo de pico tp: es el tiempo que tarda la seal de salida del sistema en
alcanzar el pico mximo de sobreoscilacin.
Pico de sobreoscilacin Mp: expresa cunto se eleva la evolucin temporal de

la seal de salida del sistema respecto al valor final. Es por lo tanto la amplitud
del primer pico y se suele medir en porcentaje respecto al valor final.
Tiempo de estabilizacin ts: tiempo que tarda la seal de salida del sistema en
entrar en la banda del 5% alrededor del valor final y ya no vuelve a salir de ella.
Figura 7-8: Representacin del tiempo de pico, del pico de sobreoscilacin y del tiempo de
estabilizacin
Estos parmetros estn intrnsecamente relacionados unos con otros. Un ejemplo de

esto es que, por ejemplo, si se desea una respuesta muy rpida esto provocar que el
sistema presente oscilaciones. En un ejemplo prctico esto es que un motor alcance una
determinada posicin y que debido a la inercia se pase de la referencia y oscile entorno
a ella hasta llegar a la posicin determinada por la referencia. Es claramente un efecto
negativo ya que por intentar disminuir el tiempo de estabilizacin se ha provocado una
sobreoscilacin y como consecuencia se ha ralentizado la respuesta.
Pgina 139 de 231
J. L. Prez Motos
Es necesario aclarar que el uso de un controlador PID no garantiza un control

ptimo ni estabiliza todos los sistemas. Hay sistemas, como los de fase no mnima, que
no se estabilizan con el mero hecho de aadir un controlador PID en ese sistema.
Algunas aplicaciones slo requieren el uso de uno o dos parmetros para
proporcionar un control apropiado al sistema. Para no usar un parmetro simplemente se
debe poner la ganancia de ese parmetro a cero. Dependiendo de los parmetros activos,
los controladores se llaman PI, PD, P o I. Los controladores PI son muy comunes ya que
la accin derivativa D es sensible al ruido. Por otro lado, la ausencia de la accin
integral puede evitar que el sistema llegue al valor deseado.
7.5.1.1.
TRMINO PROPORCIONAL
El trmino proporcional modifica la salida proporcionalmente con el error actual.

La respuesta proporcional se puede ajustar multiplicando el error por una constante Kp,
conocida como ganancia proporcional.
( )
Siendo e el error en un instante de tiempo, cuanto mayor sea este error ms rpida
ser la respuesta y viceversa.
Un controlador proporcional no siempre alcanzar su valor objetivo, ya que no se
eliminar el error de estado estacionario. Para eliminarlo hay que emplear el trmino
integral.
7.5.1.2.
TRMINO INTEGRAL
El trmino integral es proporcional a la magnitud del error y a la duracin del error.

Es decir, la suma de todos los errores en cada instante de tiempo o, como indica su
nombre, la integracin de todos los errores. Esta suma compensa la diferencia que
debera haber sido corregida anteriormente. El error acumulado se multiplica por la
ganancia integral Ki que indicar la cantidad de accin integral respecto de toda la
accin de control.
Pgina 140 de 231
J. L. Prez Motos
( )
Al usar la integral junto al proporcional se acelera el movimiento del sistema

llegando antes al valor deseado, es decir, menor tiempo de respuesta. Adems elimina el
error estacionario que se produce al usar un controlador proporcional. Sin embargo el
trmino integral tiene en cuenta los errores acumulados en el pasado y puede hacer que
el valor actual sobrepase el valor deseado, lo cual crear un error en el otro sentido,
creando oscilaciones alrededor del valor deseado. Para evitarlo se emplea el trmino
derivativo.
7.5.1.3.
TRMINO DERIVATIVO
El trmino derivativo calcula la variacin del error mediante la pendiente del error
en cada instante de tiempo, es decir, la primera derivada con respecto al tiempo y
multiplica esa variacin del error con la ganancia derivativa Kd, la cual indica la
cantidad de accin derivativa respecto de toda la accin de control.
( )
El trmino derivativo ralentiza la tasa de cambio de la salida del controlador y

cunto ms cerca est del valor deseado, se hace an ms lento. Por lo tanto, el uso del
trmino derivativo sirve para disminuir las oscilaciones producidas por el trmino
integral y mejorar as la estabilidad del proceso. Uno de los inconvenientes de emplear
el trmino derivativo es que amplifica el ruido, por lo que se puede inestabilizar el
sistema con ms facilidad.
7.5.1.4.
ECUACIN DEL CONTROLADOR DE FORMA DISCRETA
Los trminos proporcional, integral y derivativo son sumados para hallar la salida
del controlador PID, sabiendo que u(t) es la salida, la ecuacin que define al algoritmo
es la siguiente:
Pgina 141 de 231
( )
( )
J. L. Prez Motos
( )
( )
Sin embargo un microcontrolador solo es capaz de procesar valores discretos y

finitos, as que para poder implementar el algoritmo de controlador PID es necesario
discretizar la ecuacin del controlador PID. La ecuacin discreta del controlador para
poder ser implementada en un microcontrolador se puede expresar mediante la siguiente
ecuacin:
( )
( )
( )
Donde e(t) es el error de la respuesta del sistema en el instante t, T es el periodo de

muestreo de la seal y Kp, Ki y Kd son la ganancia proporcional, integral y derivativa
del controlador, respectivamente.
A continuacin se muestra en una tabla los efectos que provocan en el sistema si se
aumenta cada parmetro por separado y se dejan los dems constantes:
Estabilidad
Parmetro
Kp
Aumenta
Aumenta
Aumenta
Disminuye
Disminuye
Ki
Disminuye
Aumenta
Aumenta
Lo elimina
Disminuye
Aumenta
Disminuye
Disminuye
No afecta
Aumenta
Kd
Tiempo de
Sobreoscilacin
estabilizacin
Error en
estado
estacionario
Tiempo de
pico
Tabla 7.1: Efectos en el sistema que tiene el aumento de cada uno de los parmetros
Pgina 142 de 231
J. L. Prez Motos
Figura 7-9: Resultados ante diferentes parmetros
Pgina 143 de 231
J. L. Prez Motos
7.5.2. SEGUNDO MTODO DE ZIEGLER-NICHOLS

Muchas veces no se conoce el modelo de un sistema e interesa regularlo en lazo
cerrado sin necesidad de identificarlo, como es el caso de este robot. En estos casos son
muy tiles las reglas de sintonizacin de Ziegler-Nichols. Estas reglas permiten el ajuste
emprico de diversos controladores, incluido el PID.
Existen dos mtodos de sincronizacin de Ziegler-Nichols, los cuales intentan
asegurar una sobreoscilacin del orden del 25% ante una entrada escaln[5]. El primero
de ellos solo es aplicable a sistemas estables en lazo abierto, por lo que, al ser el sistema
formado por el robot un sistema inestable, se desech.
El segundo mtodo de Ziegler-Nichols realiza el ajuste de los parmetros
empleando los datos que se obtienen de la respuesta en lazo cerrado del sistema ante
una entrada escaln. Este mtodo no puede ser utilizado en sistemas que no se
conviertan en marginalmente estables para ninguna ganancia. Dicho en otras palabras,
que todas sus ramas del Lugar de las Races estn siempre en el semiplano complejo
izquierdo, lo que supone la prctica mayora de los sistemas de segundo orden, excepto
los de fase no mnima. Para poder llevar a cabo este mtodo hay que seguir los
siguientes pasos:
i. Ajustas las ganancias integral y derivativa a cero.
ii. Partiendo de un valor bajo de la ganancia proporcional Kp se va aumentando
esta gradualmente hasta conseguir una oscilacin no amortiguada.
iii. Esta ganancia ser la ganancia crtica Kc y el periodo de oscilacin ser Tc.
iv. Por ltimo se ajustan los valores del controlador segn los valores de la tabla.
Pgina 144 de 231
J. L. Prez Motos
Controlador
Kp
Ki
Kd
Kc/2
PI
Kc/2'2
1'2Kp/Tc
PID
0'6Kc
2Kp/Tc
KpTc/8
Tabla 7.2: Mtodo de Ziegler-Nichols
De esta forma en el siguiente apartado se mostrar cmo se aplic el segundo

mtodo de Ziegler-Nichols en el robot para obtener as los parmetros del controlador
PID.
7.5.3. OBTENCIN DE LOS PARMETROS PID DEL ROBOT

La metodologa que se va a proceder para obtener los parmetros PID del robot es
la siguiente. En primer lugar se programar el robot para que enve el estado de los
sensores al ordenador. En el ordenador, para poder interpretar los resultados, se dibujar
una grfica con la ayuda de Matlab que representar la posicin del robot con respecto a
la lnea a seguir. De esta forma, se igualarn a cero tanto Ki como Kd y empezando
desde 1 se ir aumentando el valor de Kp hasta que se obtenga una oscilacin no
amortiguada.
Para poder llevar a cabo el mtodo de Ziegler-Nichols lo que se hizo en primer
lugar fue escribir la frmula del controlador PID en forma discreta, apartado 7.5.1.4, de
forma que la entendiera el Arduino Pro Mini. La frmula est formada por cuatro
trminos. El primero de ellos es el determinar la velocidad de los motores cuando el
error sea cero. El segundo trmino es el correspondiente a la parte proporcional del
controlador. Esta parte estar formada por una constante de proporcionalidad, Kp, que
multiplicar al error. El tercer trmino es el trmino integral. Est formado por una
constante, Ki, y un trmino integral. Para obtener este trmino hay que aadir el error en
cada instante de tiempo. Aunque parezca una frmula abstracta, posee unidades. Debido
a que los retrasos de tiempo en Arduino se miden en milisegundos, hay que aadir un
trmino que convierta los milisegundos en segundos. El ltimo trmino es el trmino
derivativo. Est formado por una constante, Kd, y un trmino derivativo. Este se obtiene
Pgina 145 de 231
J. L. Prez Motos
como la diferencia entre el error actual y el error anterior en cada instante de tiempo. Al
igual que en la parte integral, hay que aadir un trmino que convierta los milisegundos
en segundos. De esta forma se obtiene:
Como se puede observar, el resultado que se obtiene se lleva a cada motor. Sealar
que a cada motor se le aplica la correccin del controlador PID con signos diferentes.
De esta forma se consigue que cuando se produzca un error el robot tienda a volver a la
posicin correcta. Para entenderlo mejor se va a suponer el siguiente supuesto:
}
Debido a que el robot presenta un error actual inferior al error anterior est
acercndose a la posicin central. Adems, como este error es positivo, recordando los
pesos que se le da a cada sensor del apartado 7.4, la lnea se encuentra en la parte
derecha del robot. As, para que el robot se vuelva a centrar este necesita girar a la
derecha. Para conseguir eso debe ir ms rpido su rueda izquierda, el motor B. Por lo
tanto, en principio, los signos asignados a cada motor estn bien escogidos.
Figura 7-10: Comprobacin de los signos al aplicar el PWM en el robot

Pgina 146 de 231
J. L. Prez Motos
Tras obtener la expresin que emplear el Arduino Pro Mini para ejecutar el
controlador PID se procedi a pensar en el circuito que se emplear en la prueba. En el
mtodo de Ziegler-Nichols se debe someter al sistema a una entrada escaln. En este
caso se pens que se podra emplear el siguiente circuito:
Figura 7-11: Circuito que se emplear para la prueba
En un primer lugar el robot encuentra una zona recta sin perturbaciones. Despus
encuentra el escaln. Y por ltimo vuelve a una zona recta sin perturbaciones. Es
importante que en ningn momento el robot deje de detectar la lnea, por lo que el
escaln no debe ser muy grande. De esta forma, segn el mtodo de Ziegler-Nichols, lo
que se pretende es que tras el escaln el robot empiece a oscilar de una forma constante:
Figura 7-12: Efecto deseado en la prueba
Adems, para evitar que el robot tuviera que calibrarse cada vez que iniciaba la
prueba, se hicieron varias medidas sobre el circuito y se hizo una media con los valores
mximos y mnimos obtenidos para cada sensor.
Tambin se realiz un programa en Matlab para interpretar los datos (ANEXO
A.11). En primer lugar, al igual que en el apartado 6.3.1, se cre un objeto serie y se
abri. Tambin se defini el tiempo mximo, as como el nmero de muestras que se
toma por segundo.
%borrar previos
%crear objeto serie
warning('off','MATLAB:serial:fscanf:unsuccessfulRead');
%abrir puerto
fopen(s);
% parmetros de medidas
tmax = 10; % tiempo de captura en s
rate = 33; % resultado experimental
Pgina 147 de 231
J. L. Prez Motos
Despus se prepar la figura que representara los resultados y se inicializaron las

diferentes variables que se emplearan ms adelante.
% preparar la figura
f = figure('Name','Captura');
a = axes('XLim',[0 tmax],'YLim',[0 2]);
l1 = line(nan,nan,'Color','r','LineWidth',2);
l2 = line(nan,nan,'Color','b','LineWidth',1);
xlabel('Tiempo (s)')
ylabel('Error')
title('Captura de posicin en tiempo real con Arduino')
grid on
hold on
% inicializar
v1 = zeros(1,tmax*rate);
i = 1;
t = 0;
Tras esto, de nuevo con la ayuda de las variables tic y toc, se ejecuta el bucle de
toma de datos.
% ejecutar bucle cronometrado
tic
while t<tmax
t = toc;
% leer del puerto serie
puerto = fscanf(s,'%d %d')';
v1(i)=puerto(1)/25;
v2(i)=puerto(2)/25;
% dibujar en la figura
x = linspace(0,i/rate,i);
set(l1,'YData',v1(1:i),'XData',x);
drawnow
% seguir
i = i+1;
end
En primer lugar se lee el puerto serie que se ha creado al inicio del programa y se le
indica la forma en la que le llegan los datos. El primer dato es el error, mientras que el
segundo es la referencia que sigue, en este caso se busca que el error sea 0. Tras esto se
dibujan los resultados. De esta forma se obtuvieron las siguientes grficas:
Pgina 148 de 231
J. L. Prez Motos
Figura 7-13: Resultados de la prueba. De izquierda a derecha y de arriba abajo: Kp=1, Kp=3,
Kp=5, Kp=7, Kp=8, Kp=9
Para finalmente obtener:
Pgina 149 de 231
J. L. Prez Motos
Figura 7-14: Resultado de la prueba para Kp=10
En esta ltima grfica se puede observar como el sistema tras la primera oscilacin
el sistema sigue oscilando de forma constante. De esta forma, los resultados que se
obtuvieron fueron:
As, una vez definidos los parmetros del PID se tena prcticamente completo el
sketch. Para finalizarlo se trat qu debera realizar el robot en caso de salirse del
trazado.
7.5.4. COMPARATIVA DE PARMETROS

A continuacin se va a estudiar el comportamiento del robot si se varan los
parmetros del controlador PID. En primer lugar se va estudiar el comportamiento del
robot con los parmetros obtenidos por el mtodo de Ziegler-Nichols.
Pgina 150 de 231
J. L. Prez Motos
Figura 7-15: Resultados empleando los parmetros obtenidos en el mtodo de Ziegler-Nichols.

Arriba se representa el error y abajo los PWM de los motores
Se puede observar que con el PID obtenido por el mtodo de Ziegler-Nichols que,
aunque aparece una sobreoscilacin del 40%, el tiempo de estabilizacin es de tan solo
03 segundos. Adems se puede apreciar en la grfica de los motores que se encuentran
prcticamente todo el rato girando a la velocidad nominal (en este caso 100). Por lo que
se puede concluir que este controlador es muy apropiado para la finalidad de este robot.
Pgina 151 de 231
J. L. Prez Motos
Figura 7-16: Resultados empleando Kp=15. Arriba se representa el error y abajo los PWM de los
motores
Al aumentar la Kp hasta 15 se puede observar que el sistema se vuelve muy

inestable ya que, como ya se haba comentado, al aumentar Kp la sobreoscilacin
aumenta y la estabilidad del sistema disminuye. El sistema nunca llega a estabilizarse y
los motores se encuentran girando a sus velocidades mximas.
Pgina 152 de 231
J. L. Prez Motos
Figura 7-17: Resultados empleando Ki=250. Arriba se representa el error y abajo los PWM de
los motores
Si se aumenta la Ki hasta 250 se observa como el sistema llega a estabilizarse pero

tarda mucho ms tiempo que con los parmetros obtenidos por el mtodo de ZieglerNichols. De esta forma, aparece una sobreoscilacin del 92% y el tiempo de oscilacin
asciende hasta los 176 segundos. Adems, tras la perturbacin se puede ver como los
movimientos de los motores son bruscos durante un largo periodo de tiempo.
Pgina 153 de 231
J. L. Prez Motos
Figura 7-18: Resultados empleando Kd=1. Arriba se representa el error y abajo los PWM de los
motores
Al aumentar la Kd hasta 1, una vez ms, se obtienen los resultados esperados. El

sistema no consigue estabilizarse e incluso se puede apreciar como la seal del error
posee cierta componente de una seal de alta frecuencia. Como ya se haba comentado,
la parte derivativa lo que hace es amplificar el ruido del sistema. As, se puede ver en la
grfica de los motores que en todo momento se encuentran en sus velocidades mximas.
De esta forma, se concluye que los parmetros para el controlador PID obtenidos
por el mtodo de Ziegler-Nichols son muy buenos y se escogen como parmetros
finales del robot.
Pgina 154 de 231
J. L. Prez Motos
7.6. SALIDA DEL TRAZADO

Tras explicar los pasos que sigue el robot para seguir la lnea se va a explicar qu
hace el robot cuando se sale del trazado. La principal causa de que se salga el robot, por
no decir la nica, es que se produzca un giro demasiado brusco. De esta forma, se
forzar al robot a girar sobre s mismo para volver al trazado por el punto que haba
perdido la lnea.
Como se ha explicado en el punto 7.4, si al menos un sensor detecta lnea se ejecuta
la funcin si_linea. Sin embargo, si ningn sensor detecta lnea se ejecuta la funcin
no_linea.
Esta funcin lo que hace es forzar unas velocidades de giro al robot segn la ltima
posicin en la que se detect la lnea. De esta forma si se vio la lnea por ltima vez a la
izquierda se fuerza a que el robot gire a la izquierda, si se vio la lnea por ltima vez a la
derecha se fuerza a que el robot gire a la derecha y si se vio en el centro se obliga a ir
marcha atrs.
Figura 7-19: Salida del trazado del robot
Pgina 155 de 231
CAPTULO 8.
J. L. Prez Motos
CONTROL REMOTO DEL ROBOT
La idea de poder controlar el robot como si fuera un coche de radiocontrol naci

cuando, gracias a la aplicacin BlueTerm, se consigui controlar los motores del robot.
De esta forma, en los siguientes apartados se desarrollar cmo se realiz la aplicacin
Android y la programacin del robot. El diagrama de todo el sistema es el siguiente:
Figura 8-1: Diagrama del funcionamiento del control remoto del robot. A la izquierda se
representa el sketch del robot. A la derecha se representa la aplicacin Android
Pgina 156 de 231
J. L. Prez Motos
Se puede ver que el sistema est formado por dos partes. Por un lado el robot (a la
izquierda) (ANEXO.A.12) y por otro lado la aplicacin Android (ANEXO A.13). En
primer lugar se va a explicar cmo se realiz la aplicacin Android y despus el
programa del robot.
8.1. APLICACIN ANDROID

En primer lugar se pens el lenguaje que se iba a utilizar para realizar la aplicacin.
Antes de comenzar con el proyecto solo conoca Visual Basic y C, por lo que se
investig si era posible desarrollar una aplicacin Android a travs de esos lenguajes de
programacin.
Tras una breve bsqueda se lleg a un programa llamado Basic4Android[35]. Este
es un entorno para el desarrollo de aplicaciones para Android que permite programar de
la misma forma que se hace en Visual Basic. Esto quiere decir que se tiene un entorno
grfico en donde se pueden aadir botones, ventanas y otros componentes en apenas
unos cuntos clicks. Adems cuenta con una amplia variedad de libreras para trabajar
con bases de datos, bluetooth, GPS, cmara,
Figura 8-2: Logo de Basic4Android
Pero la gran desventaja de este programa es que no es software libre, por lo que hay
que pagar una licencia para poder utilizar el programa en plenas condiciones. Existe una
versin de prueba, pero no permite cargar ningn tipo de librera, por lo que est muy
Pgina 157 de 231
J. L. Prez Motos
limitado. El precio de esta licencia oscila entre 50 y 500, por lo que se desech esta
opcin.
Buscando ms se lleg a dar con Amarino[36]. Amarino est formado por una
librera de Arduino junto a una aplicacin Android. De esta forma se puede comunicar
de una forma sencilla un dispositivo Android con una tarjeta de Arduino. As, mediante
una conexin bluetooth, se pueden controlar los diferentes pines del Arduino: nombrar
los pines como pines de entrada o salida, controlar los pines digitales PWM,
Figura 8-3: Logo de Amarino
Su principal ventaja es que es software libre y adems existen bastantes recursos

por internet. Pero al igual que se haba desechado desde un primer momento usar
directamente la aplicacin BlueTerm, se buscaba realizar una aplicacin entera, incluida
la interfaz, y esto no lo permita Amarino.
Despus se pens en programar directamente en Java con la ayuda del SDK de
Android[37]. Su gran ventaja, y a la vez desventaja, segn como se mire, es la cantidad
de informacin que hay disponible por internet. Esto requera un gran trabajo de
documentacin; eso sin contar que desconoca por completo java, por lo que tendra que
aprender a programar en este lenguaje. De esta forma se desech esta opcin.
Tras desechar la opcin de programar directamente en java se pens en utilizar
Processing[38]. Processing es un lenguaje de programacin y entorno de desarrollo
integrado de cdigo abierto basado en Java.
Pgina 158 de 231
J. L. Prez Motos
Figura 8-4: Logo de Processing
La principal ventaja de emplear este lenguaje es que este es el lenguaje empleado

por Arduino, por lo que gran parte del aprendizaje ya se tena. Adems, la pgina oficial
del programa cuenta con una gran cantidad de ejemplos y tutoriales que facilitan su
aprendizaje. Por otro lado, cuando ya me puse a programar la aplicacin en s, me di
cuenta de que muchos conceptos no los tena bien asimilados en este lenguaje de
programacin, por lo que los errores de compilacin eran frecuentes y el programa no
era nada explcito en cuanto a cules eran las causas de estos errores.
Finalmente se decidi emplear una mezcla entre las dos ltimas opciones
estudiadas. Se program usando como lenguaje de programacin Processing, pero se
emple como IDE Eclipse y se instal el SDK de Android. De esta forma, pude trabajar
en un lenguaje que conoca, Processing, y Eclipse me iba advirtiendo de los errores que
se iban produciendo en el programa.
Figura 8-5: Conexin Processing y Eclipse

Pgina 159 de 231
J. L. Prez Motos
La conectividad entre Processing y Eclipse es muy buena. Para poder pasar el

cdigo realizado en Processing se debe ir en el propio Processing a File -> Export
Android Project:
Figura 8-6: Exportacin de proyectos Android en Processing
Tras esto se debe abrir Eclipse y seguir la siguiente ruta: File -> New -> Project ->
Android Project from Existing Code. Tras esto se elige la ruta donde ha exportado
Processing el cdigo y ya se tiene disponible el cdigo en Eclipse.
Una vez comprobada la conexin entre Processing y Eclipse se pas a desarrollar la
aplicacin Android.
8.1.1. DECLARACIN DE VARIABLES

En este apartado del cdigo se declaran las variables que se van a emplear a lo largo
de todo el programa, entre las que destacan las relacionadas con el manejo de los
acelermetros y del control del bluetooth.
Pgina 160 de 231
8.1.1.1.
J. L. Prez Motos
VARIABLES DEL ACELERMETRO
Para poder manipular los acelermetros se van a necesitar cuatro variables[39].

Estas son:
mSensorManager: esta variable de tipo SensorManager es la permite acceder a

los diferentes sensores que posee un telfono Android.
accSensorEventListener: esta variable de tipo MySensorEventListener es la

encargada de recibir la informacin que le envan los sensores.
acc_sensor: esta variable de tipo Sensor permite elegir el tipo de sensor que se
quiere emplear. En la actualidad existen multitud de tipos de sensores en los
dispositivos Android, tales como acelermetros, de temperatura, giroscopios, de
luz, magnticos...
acc_values: esta variable es un vector de variables tipo float que ser la

encargada de almacenar los valores de los acelermetros.
8.1.1.2.
VARIABLES DE LA COMUNICACIN BLUETOOTH
Para poder realizar la comunicacin bluetooth entre el telfono Android y el robot

de forma correcta se van a necesitar seis variables[40].
dispositivos: esta variable es un vector de variables tipo BluetoothDevice que

servir para almacenar los dispositivos bluetooth que encuentre el telfono.
bttelefono: esta variable de tipo BluetoothAdapter representa el bluetooth del

telfono.
dispositivo: esta variable de tipo BluetoothDevice representa el bluetooth de los

dispositivos ajenos al telfono.
socket: esta variable de tipo BluetoothSocket es la encargada de establecer la

conexin entre el telfono y el robot.
ins: esta variable de tipo InputStream permite recibir datos del robot. El formato
de estos datos es el byte.
ons: esta variable de tipo OutputStream permite enviar datos al robot. El formato
de estos datos es el byte.
Pgina 161 de 231
J. L. Prez Motos
8.1.2. CONFIGURACIN
En la funcin setup se declaran diferentes propiedades de la aplicacin. Con la
funcin size se obtiene el ancho y alto de la pantalla del telfono. Esto ser de gran
utilidad a la hora de querer representar cosas por pantalla ya que no todos los
dispositivos Android tienen las mismas dimensiones. As, al asignar el ancho y el alto
de la pantalla a unas variables se podrn ofrecer datos por pantalla en relacin a estas
medidas.
Tambin se fijar que la posicin de la pantalla sea apaisada con la funcin
orientation y que el tipo de fuente que emplee la aplicacin sea la que emplea por
defecto el telfono. Adems se evitar que la pantalla se apague mientras se est
ejecutando la aplicacin al emplear el flag FLAG_KEEP_SCREEN_ON.
Por ltimo se instancian dos variables, pwmA y pwmB, y se definen todas sus
variables para ms adelante poder representar el estado de los motores.
8.1.3. CONEXIN BLUETOOTH

Tras realizarse la configuracin general de la aplicacin se establece la conexin
bluetooth. La primera funcin que ejecuta la aplicacin es la funcin onStart. En ella se
detecta el estado del bluetooth. Si el telfono no dispone de bluetooth mostrar un
mensaje de error y saldr de la aplicacin. Por otro lado, si el telfono dispone de
bluetooth pero no est activado se le pedir al usuario que lo active. De esta forma habr
que darle a la aplicacin permisos para manipular el bluetooth del telfono. Para eso
habr que ir al AndroidManifest.xml y despus a la pestaa Permissions y una vez aqu
aadir los permisos para manipular el bluetooth.
Figura 8-7: Ventana de permisos de Eclipse
Pgina 162 de 231
J. L. Prez Motos
Despus se ejecuta la funcin empieza. Esta funcin aade los dispositivos

bluetooth que estn vinculados con el telfono a una lista para posteriormente mostrarlo
por pantalla mediante la funcin listaDispositivos.
dispositivos = new ArrayList<BluetoothDevice>();
for (BluetoothDevice dispositivo : bttelefono.getBondedDevices()){
dispositivos.add(dispositivo);
}
Para mostrar los dispositivos de una forma en la que se puedan escoger de forma
sencilla, se mostrar de cada dispositivo tanto el nombre como como la direccin mac
del dispositivo.
Figura 8-8: Interfaz de la aplicacin Android de seleccin de dispositivo a conectar
Despus mediante la funcin compruebaEleccion se verifica que se haya pulsado la

pantalla en un lugar correspondiente a un dispositivo y se procede a la conexin
bluetooth entre el telfono y el robot mediante la funcin conectaDispositivo.
Para conectar ambos dispositivos en primer lugar se crea socket para que pueda
existir dicha conexin. Para ello se emplea la codificacin UUID. Un UUID (del ingls,
Universally Unique IDentifier) es un identificador estndar usado en el desarrollo de
software. Lo que intentan los UUID es proporcionar un identificador de informacin
nico a cada tipo de dispositivo. De esta forma, si se consulta el SDK de Android este
indica que el UUID del bluetooth es:
Pgina 163 de 231
J. L. Prez Motos
Sin embargo, la conexin que se va a realizar no es una conexin al uso, sino que se
va a simular un puerto serie. Para ello hay que variar los primeros trminos. As se
obtiene que el UUID para realizar una conexin bluetooth simulando un puerto serie es
el siguiente[41]:
Una vez definido correctamente el UUID solo queda conectar el socket e indicar
cul ser la forma de recibir y enviar datos. Para ellos se emplean las extensiones
getInputStream y getOutputStream, respectivamente. De esta forma, la conexin queda
establecida.
socket = dispositivo.createRfcommSocketToServiceRecord(UUID.fromString("000011010000-1000-8000-00805F9B34FB"));
Method m = dispositivo.getClass().getMethod("createRfcommSocket", new Class[] {
int.class });
socket = (BluetoothSocket) m.invoke(dispositivo, 1);
socket.connect();
ins = socket.getInputStream();
ons = socket.getOutputStream();
8.1.4. CONFIGURACIN DE LOS ACELERMETROS

Cuando se pens en controlar el robot a travs de un dispositivo Android enseguida
se pens que los acelermetros eran los sensores ms indicados. Un acelermetro es un
sensor que mide la aceleracin relativa, tomando como referencia la de cada libre, es
decir, en la Tierra la referencia ser
. Por lo tanto, la medida que ofrece
un acelermetro es[42]:
Esto quiere decir que, si el dispositivo Android se encuentra en reposo, la media del
acelermetro ser
como medida
. Sin embargo, si sufre una cada libre se obtendr

.
En un dispositivo Android el sistema de coordenadas es relativo a la pantalla y no

cambia con los cambios de orientacin[7]:
Pgina 164 de 231
Eje x: es horizontal y apunta a la derecha.
Eje y: es vertical y apunta hacia arriba.
Eje z: es la normal saliente de la pantalla del dispositivo.
J. L. Prez Motos
Figura 8-9: Representacin de los ejes de los acelermetros en un dispositivo Android
La lectura de los acelermetros no es algo que se realice de forma puntual, sino que
es un proceso que se va a estar realizando continuamente en segundo plano. Es por ello
por lo que la configuracin del acelermetro se incluye dentro de la funcin onResume.
En primer lugar lo que se debe hacer es definir el SensorManager, ya que es el
encargado de permitir los accesos a los sensores del telfono:
mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
Despus se debe crear una variable que recoja los datos que le enven los sensores.
Esta ser la variable que recoja las variaciones de los acelermetros:
accSensorEventListener = new MySensorEventListener();
Despus se eligen los sensores de los que se quiera extraer informacin. En este
caso solo se tendrn en cuenta los acelermetros. Si se deseara algn otro sensor solo
habra que cambiar el TYPE:
acc_sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
Pgina 165 de 231
J. L. Prez Motos
Por ltimo se asocia el SensorEventListener, junto al sensor tipo de sensor que hace
referencia y al SensorManager empleado. Adems tambin hay que indicar el tipo de
delay
que
se
le
quiere
dar
la
aplicacin.
Existen
cuatro
tipos:
SENSOR_DELAY_FASTEST, para obtener los datos de los sensores lo ms rpido

posible;
SENSOR_DELAY_GAME,
velocidad
recomendada
para
juegos;
SENSOR_DELAY_NORMAL, es la recomendada para cambios en la pantalla principal

del telfono y SENSOR_DELAY_UI, velocidad utilizada por la interfaz d usuario. Tras
diversas pruebas, el que ofreci mejores resultados fue el SENSOR_DELAY_GAME:
mSensorManager.registerListener(accSensorEventListener, acc_sensor,
SensorManager.SENSOR_DELAY_GAME);
Tras esto el acelermetro quedara configurado y ya se podran obtener sus lecturas.
8.1.5. LECTURA DE LOS ACELERMETROS

Para poder leer los acelermetros correctamente primero hay que tener en cuenta
tres aspectos de los acelermetros:
Los datos de los acelermetros quedan recogidos en la variable acc_sensor. Esta

variable es un vector de tres componentes, en el que la primera es el valor del
acelermetro del eje x, la segunda es el valor del acelermetro del eje y la
tercera es el valor del acelermetro del eje z.
Estos valores, recordando la frmula anterior, deberan estar acotados por
por lo que habr que incluir algn filtro para evitar lecturas no deseadas.
Por ltimo estos valores tienen mucho ruido, por lo que habr que incluir otro
filtro para filtrar este ruido.
Lo primero en lo que se da cuenta uno cuando empieza a manipular los

acelermetros es en su inestabilidad. Los valores que ofrecen los acelermetros son
nmeros reales que incluso dejando el telfono en reposo sobre la mesa cambian varias
veces por segundo en la primera cifra decimal. Si se llevara este nmero tal cual al robot
se producira en este un movimiento nervioso nada deseable.
Pgina 166 de 231
J. L. Prez Motos
Figura 8-10: Valores de los acelermetros en dos instantes consecutivos estando el dispositivo
Android en reposo sobre la mesa
De esta forma se llevan a cabo tres filtros dentro de la funcin muestraDatos. El

primero de ellos, y quizs el ms grande, es el de limitar los valores de los
acelermetros a nmeros enteros. Se puede pensar que se pierde gran parte de
informacin, pero no es as. Al estar limitados los valores de los acelermetros entre
, se disponen de 20 posiciones posibles. Adems, al disponer los sensores de
simetra con respecto a sus ejes, estos solo tienen 180 efectivos. Esto hace que se
dispongan de 9 de sensibilidad para manipular el robot, ms que suficientes para
controlar el robot de una forma ptima.
Figura 8-11: Valores que puede tomar el acelermetro del eje x. Representacin de 9
Pgina 167 de 231
J. L. Prez Motos
El segundo filtro que se realiza es para evitar que el ruido haga que se tome una
mala medida. Para ello lo que se hace es tomar como dato que se enviar al robot la
media de las dos ltimas medidas.
El ltimo filtro, el de limitar los valores para que estn entre
, se llevar a cabo
en el propio robot. Es el filtro que menos acta, ya que es raro que un acelermetro
ofrezca como resultado ms de 10. As que tras realizar diversas pruebas se obtuvieron
mejores resultados cuando este filtro lo realizaba directamente el robot.
8.1.6. ENVO Y RECEPCIN DE DATOS

Tras haber filtrado los valores de los acelermetros se procede al envo de estos al
robot. En este caso se va a emplear el acelermetro del eje x para manipular la
velocidad de avance del robot y el acelermetro del eje y para manipular el giro del
robot.
Tanto la funcin que se va a emplear para enviar datos como para recibirlos, write y
read respectivamente, utilizan como datos bytes. En primera instancia se pens que no
supondra mayor problema, pero tras empezar a realizar pruebas s surgieron problemas.
En java un byte permite manipular nmeros enteros desde -128 hasta 127, ambos
incluidos[43]. Sin embargo, en Arduino un byte permite manipular nmeros desde 0
hasta 255, ambos incluidos[44]. Esto hace que en ambas plataformas un byte permita
manipular 256 nmeros, pero cada plataforma ofrece unos lmites distintos, ya que por
ejemplo Arduino no puede procesar de forma correcta un byte que representa un
nmero negativo. Para solventar esto, antes de enviar los datos al robot se suma 10 a los
valores de los acelermetros. De esta forma no pueden aparecer valores negativos y
Arduino puede entender de forma correcta los nmeros que se le van a enviar.
Figura 8-12: Problema de formatos entre Arduino y Android

Pgina 168 de 231
J. L. Prez Motos
De forma anloga, los valores que recibir el dispositivo Android sern los PWM
de los motores del robot. En Arduino estos valores oscilarn entre 0 y 255, por lo que de
nuevo hay que procesar los datos para que ambas plataformas se entiendan.
Una vez que los datos son procesados se procede al envo y recepcin de datos.
Para el envo de datos se emplea la variable ons, que es de tipo OutputStream, y la
funcin write de la siguiente forma:
ons.write(valor,0,valor.length);
As, se escribe en el puerto serie los datos que hay en la variable valor (vector de
dos componentes que almacena los valores de los acelermetros filtrados), desde la
posicin 0 del vector y se le indica la longitud total que tiene que enviar[45].
Anlogamente, para recibir datos del robot se emplea la variable ins, que es de tipo
InputStream, y la funcin read de la siguiente forma:
while(ins.available() > 0){
ins.read(ardu,0,ardu.length);
}
De esta forma, lee cuntos bytes hay en el InputStream y los coloca en el vector
ardu (vector de cuatro componentes que almacena los PWM y los signos de los motores
del robot), desde la posicin 0 y hasta la longitud total del vector ardu.
8.1.7. REPRESENTACIN GRFICA

Lo ltimo que queda es la representacin grfica de los resultados en la pantalla del
dispositivo Android. Como se especific en el punto 8.1.2 toda la representacin grfica
se lleva a cabo en relacin a las dimensiones de la pantalla en la que se est ejecutando
la aplicacin. Si se pusieran las medidas de los diferentes elementos en coordenadas
absolutas, segn el dispositivo, la representacin grfica sera defectuosa. En cambio, al
poner todas las medidas en coordenadas relativas al ancho y a la altura de la pantalla del
dispositivo todos los elementos estn relacionados unos con otros.
Pgina 169 de 231
J. L. Prez Motos
Figura 8-13: Origen de coordenadas y dimensiones mximas en una pantalla de un dispositivo

Android
En primer lugar se pens qu se quera realizar. Por un lado se quera mostrar en un

grfico la informacin que envan los acelermetros. Y por otro lado se quera mostrar
en otro grfico la informacin de los motores que se recibe del robot.
Para representar la informacin de los acelermetros se pens en emplear un crculo
que representase dichos valores. Este crculo se mover en relacin a los valores de los
acelermetros dentro de unos rangos. As, en segundo lugar se defini el fondo de la
aplicacin. Se pens en una serie de crculos concntricos que representasen la fuerza de
los acelermetros:
background(0);
strokeWeight(1);
fill(31,91,76);
stroke(92,214,166);
ellipse(width/2,height/2,(float)(0.98*height),(float) (0.98*height));
noFill();
for (i = 1; i*50 < l/2; i++){
ellipse(width/2,height/2,100*i,100*i);
}
Pgina 170 de 231
J. L. Prez Motos
Figura 8-14: Fondo de la representacin de los acelermetros
En tercer lugar se desarroll el movimiento del crculo. Este estara relacionado con
los acelermetros. Adems se pens que para que fuera ms visual la transparencia del
crculo fuera variando tambin cuanto ms se alejase de la situacin de reposo. Como ya
se ha explicado, al final result ms complicado obtener las relaciones matemticas que
lo que es dibujar el crculo en s:
strokeWeight(2);
stroke(2,52,77);
fill(0, 255, 255, 10 + sqrt(ax*ax+ay*ay)*245/15);
ellipse(constrain(map(ax,
-10,
10,
width/2-l/2+width/40,
width/2+l/2-width/40),
width/2-l/2+width/20, width/2+l/2-width/20),
constrain(map(ay, -10, 10, height/2-l/2+width/40, height/2+l/2-width/40), height/2l/2+width/20, height/2+l/2-width/20),width/20, width/20);
Pgina 171 de 231
J. L. Prez Motos
Figura 8-15: Representacin de los acelermetros. En este caso el robot ira marcha atrs y hacia
la derecha
De esta forma se dio por concluida la representacin de los acelermetros. Para

representar los PWM de los motores se pens en emplear un grfico de barras. Este
representara que los motores estn girando marcha adelante si la barra es verde y que
los motores estn girando marcha atrs si la barra es roja. Para ello, se modific el
cdigo realizado disponible en el C.I.r.E (Club de Informtica, robtica y
Electrnica)[46] y se obtuvo el resultado final de la representacin grfica:
Pgina 172 de 231
J. L. Prez Motos
Figura 8-16: Interfaz final de la aplicacin Android. En este caso el robot estara trazando una
circunferencia en sentido contrario a las agujas del reloj
8.1.8. NOMBRE DE LA APLICACIN E ICONO

Una vez terminada la interfaz grfica se procedi a darle un nombre a la aplicacin
y un logotipo. Para ponerle nombre a la aplicacin se debe crear un archivo con el
nombre strings.xml dentro de la carpeta values que se encuentra dentro de la carpeta res.
Figura 8-17: Lugar que ocupa el archivo strings.xml
Dentro de este archivo se deber aadir una variable de tipo string cuyo nombre sea
app_name y el nombre de la aplicacin. En este caso se le va a llamar Robot Control
Remoto.
Pgina 173 de 231
J. L. Prez Motos
Figura 8-18: Nombre de la aplicacin
Para esta aplicacin se ha decidido emplear como logo el diagrama que representa a
los acelermetros. De esta forma, se debe guardar el logo que se haya creado dentro de
la ruta res/drawable, res/drawable-hdpi y res\drawable-ldpi desde el explorador de
archivos.
Figura 8-19: Logo de la aplicacin Robot Control Remoto
De esta forma se da por concluida la aplicacin Android. En el apartado siguiente

se explicar el cdigo que emplea el robot.
8.2. PROGRAMACIN DEL ROBOT

Como todo sketch, en primer lugar se realiza la declaracin de variables y la
configuracin del robot. Para poder manipular este robot hay dos tipos de variables. Por
un lado, al igual que en el modo sigue lneas, estn las variables de asignacin de pines.
Por otro lado estn las variables que llevarn la velocidad a los motores. Para ello se
declaran dos variables, una para que el robot avance y otra para que el robot gire.
En cuanto a la configuracin, en primer lugar hay que configurar el robot para que
enve datos a 57600 baudios, obligado por el mdulo bluetooth. En segundo lugar se
Pgina 174 de 231
J. L. Prez Motos
deben configurar los diferentes pines que controlan el puente en H como pines de salida
y en tercer lugar preparar los motores. Para ello se ponen todas las entradas a nivel bajo
y se activan los enables de ambos puentes. Adems se apagan ambos LEDs delanteros
del robot.
En los apartados siguientes se describir cmo recibe y enva datos el robot.
8.2.1. RECEPCIN DE DATOS

Mediante la funcin while se estudia si se ha establecido la conexin bluetooth con
el mvil. Si se ha establecido se realizarn los siguientes clculos. En primer lugar se
lee el puerto serie. Si se recuerda el apartado 8.1.6 los datos que llegan al robot estn
codificados. Esto es debido a que la codificacin es diferente entre Android y Arduino.
De esta forma lo primero que se hace es recoger los datos de los acelermetros,
descodificarlos y guardarlos en variables diferentes. Para la velocidad del robot se
emplearn los datos del acelermetro del eje x y para el giro se emplearn los datos del
acelermetro del eje y. Adems, se lleva a cabo el filtro para evitar que los valores
sobrepasen los lmites
.
giro = Serial.read() - 10;
vel = Serial.read() - 10;
filtro(vel, -10, 10);
filtro(giro, -10, 10);
Una vez obtenidos los valores se mapean para poder traducirlos en velocidades de
los motores. Hay que recordar que estos estn acotados desde 0 hasta 255. Tambin hay
que tener en cuenta que la direccin del acelermetro del eje x es inversa con respecto al
movimiento del robot. Esto quiere decir que un valor positivo de este acelermetro
corresponde con que el robot vaya marcha atrs. Para solucionar esto, la variable de la
velocidad se mape con los lmites cambiados Adems, tras diversas pruebas, se ajust
para que el giro mximo fuera solo de un 20%. Giros mayores hacan que el robot se
controlase peor.
Pgina 175 de 231
J. L. Prez Motos
if (vel >= 0){

velm = map(vel, 0, 10, 0, -255);
}
else{
velm = map(vel, -10, 0, 255, 0);
}
if (giro >= 0){
girom = map(giro, 0, 10, 0, 50);
}
else{
girom = map(giro, -10, 0, -50, 0);
}
Por ltimo, tras haber obtenido las velocidades de ambos motores, se llevan estas a
los motores. Hay que tener en cuenta que para que el robot gire adecuadamente los
signos de giro debern ser distintos en ambos motores.
motor(velm - girom, velm + girom);
8.2.2. ENVO DE DATOS

De nuevo para poder establecer una correcta comunicacin entre Android y
Arduino se deben codificar los datos que se quieren mandar. En este caso se quieren
mandar las velocidades de ambos motores. Si se recuerda del apartado 8.1.6, en Android
un byte va desde -128 hasta 127, mientras que en Arduino un byte va desde 0 hasta 255.
De esta forma se enviar el dato que maneja cada motor -128. As no habr que
preocuparse por incompatibilidades. Adems se enviarn dos datos ms, uno por cada
motor, que indicarn si los motores estn girando hacia adelante o haca atrs.
Serial.write(byte(constrain(abs(velm-girom),0,vMax)-128));
if (velm-girom >=0){
Serial.write(byte(1));
}
else{
}
Serial.write(byte(constrain(abs(velm+girom),0,vMax)-128));
if (velm+girom >=0){
}
else{
}
De esta forma se da por concluida la programacin del robot.
Pgina 176 de 231
CAPTULO 9.
J. L. Prez Motos
TELEMETRA
Tras terminar la aplicacin Android que permite controlar el robot de forma remota,
se pens en realizar una aplicacin que permitiera recoger datos en tiempo real del robot
mientras se encuentra siguiendo la lnea. De esta forma se podra comprobar el
funcionamiento tanto de los sensores como de los motores.
Figura 9-1: Diagrama del funcionamiento de la telemetra del robot. A la izquierda se representa
el sketch del robot. A la derecha se representa la aplicacin Android
El sketch que emplea el robot es el mismo que el que empleaba el robot para seguir
la lnea, pero se han aadido las siguientes lneas de cdigo para enviar los datos al
dispositivo Android, sin olvidar que hay que codificar los datos antes de enviarlos:
Pgina 177 de 231
J. L. Prez Motos
Serial.write(byte(constrain(abs(motorA),0,vMax)-128));
if (motorA >= 0){
}
else{
}
Serial.write(byte(constrain(abs(motorB),0,vMax)-128));
if (motorB >= 0){
}
else{
}
Serial.write(byte(posicion));
De esta forma se envan al dispositivo Android cinco valores: los PWM de los
motores, los signos que tienen estos PWM y la posicin relativa del robot con respecto a
la lnea.
Para la representacin grfica de los resultados se pens en utilizar una interfaz
similar a la que se emplea en la Frmula1.
Figura 9-2: Telemetra de Bruno Senna (Williams-Renault) en el Gran Premio de la India 2012
Pgina 178 de 231
J. L. Prez Motos
Para realizar esta aplicacin se emple gran parte del cdigo de la otra aplicacin
(ANEXO A.14). Para que los datos se representen de forma continua en la pantalla del
dispositivo se van a emplear vectores de longitud igual al ancho de la pantalla. Despus,
en cada iteracin se guardar el valor de Xi en Xi-1. En primer lugar se crean las
variables donde se van a guardar los valores.
pwmA = new int[width];
pwmB = new int[width];
posicion = new int[width];
Despus se guardan los valores en las variables.

if (ardu[1]==1){
pwmA[i-1]=ardu[0]+128;
}
else if (ardu[1]==2){
pwmA[i-1]=-1*(ardu[0]+128);
}
if (ardu[3]==1){
pwmB[i-1]=ardu[2]+128;
}
pwmB[i-1]=-1*(ardu[2]+128);
}
posicion[i-1]=ardu[4];
Despus se mapean los resultados para que queden las diferentes grficas de una
forma ordenada. De esta forma, el resultado final es el siguiente:
Figura 9-3: Interfaz de la aplicacin de telemetra
Pgina 179 de 231
J. L. Prez Motos
CAPTULO 10. PRESUPUESTO
10.1. COSTE DE LA MANO DE OBRA
10.1.1. SALARIO
Ingenieros
Meses
Sueldo/mes
1.705,00
Total
Total
10.230,00
10.230,00
Tabla 10.1: Salario
10.1.2. CARGAS SOCIALES

Concepto
Porcentaje
Contingencias Generales
28,30%
Desempleo, fondo de garanta salarial y

formacin profesional
8,90%
Accidentes
0,99%
Total
38,19%
38,19% del salario (10.230)
3.906,84
Tabla 10.2: Cargas sociales
10.1.3. COSTE DE MANO DE OBRA

Concepto
Importe
Salario
10.230,00
Cargas sociales
3.906,84
Total
14.136,84
Tabla 10.3: Coste de mano de obra
Pgina 180 de 231
J. L. Prez Motos
10.2. COSTE DE MATERIALES

Microcontrolador
Unidades
Precio unitario Total
Arduino Pro Mini
19,00
19,00
Conversor Serie - USB FTDI232
15,13
15,13
Ruedas
Unidades
34,13
Total
Tamiya Ball Caster Kit
6,17
6,17
Rueda de goma 32x7mm (2 und)
7,20
7,20
Motores
Unidades
13,37
Total
Motor Micro Metal DC con reductora 30:1
15,97
31,94
Funda protectora para motor micro metal (2 und)
5,08
5,08
Controlador motores
L6205N
Sensores infrarrojos
Array de sensores infrarrojos QTRC-8RC
Comunicacin
Mdulo bluetooth JY-MCU
Alimentacin
Unidades
37,02
Total
Unidades
14,06
14,06
Total
Unidades
14,40
14,40
14,40
Total
Unidades
14,06
14,05
14,05
14,05
Total
Pilas 9V recargable
7,08
14,16
Cargador
20,20
20,20
Componentes electrnicos
Unidades
34,36
Total
Condensador poliester 120nF
0,04
0,08
Condensador poliester 220nF
0,10
0,10
Condensador cermico 15nF
0,03
0,03
Condensador cermico 6,8nF
0,02
0,04
Diodo 1N4148
0,01
0,02
Resistencia 100k
Resistencia 120
0,01
0,02
0,01
0,01
Leds
0,02
0,04
Interruptor deslizante de dos posiciones
0,04
0,04
Soporte
PCB
Unidades
0,38
Total
0,0044
100,00
Total
Total
0,44
0,44
162,21
Pgina 181 de 231
J. L. Prez Motos
Tabla 10.4: Coste de materiales
10.3. GASTOS VARIOS

Concepto
Importe
Material de oficina, fotocopias,

encuadernacin, cinta aislante
75,00
Total
75,00
Tabla 10.5: Gastos varios
10.4. GASTOS GENERALES

Son los concernientes al equipamiento empleado para medidas y pruebas en
concepto de amortizacin de los equipos y gastos de energa. Se han estimado como el
10% de los apartados 10.1, 10.2 y 10.3.
Concepto
Coste de mano de obra
Coste de materiales
Gastos varios
Importe
Porcentaje
14.136,84
162,21
75,00
10%
1.413,68
10%
16,22
10%
7,50
Total
Importe
1.437,40
Tabla 10.6: Gastos generales
Pgina 182 de 231
J. L. Prez Motos
10.5. IMPORTE TOTAL DEL PROYECTO

Concepto
Coste de mano de obra
Importe
14.136,84
Coste de materiales
162,21
Gastos varios
Gastos generales
Subtotal
1.437,40
15.811,45
I.V.A. (21%)
Subtotal
75,00
3.320,40
19.131,86
Tabla 10.7: Importe total del proyecto
El importe total del proyecto realizado asciende a DIECINUEVE MIL CIENTO

TREINTA Y UN EUROS Y OCHENTA Y SEIS CNTIMOS.
Pgina 183 de 231
J. L. Prez Motos
CAPTULO 11. PUNTOS FUERTES Y FUTURAS MEJORAS DEL

ROBOT
A continuacin se van a desarrollar posibles mejoras que se le pueden aplicar al

robot para mejorar su funcionamiento. Para ello en primer lugar se analizarn los
principales puntos fuertes del robot y despus se comentarn las posibles mejoras que se
le pueden realizar al diseo.
11.1. PUNTOS FUERTES DEL ROBOT
11.1.1. TAMAO
El primer punto fuerte del robot es su tamao. Se ha conseguido que en 58x76mm
integrar todo un sistema capaz de seguir lneas y de ser controlado a distancia mediante
un dispositivo Android. Cuando se inici el diseo del robot se puso como uno de los
objetivos a conseguir el hacerlo ms pequeo que el Pololu 3Pi. Este abarca una
superficie de 70cm2, mientras que nuestro robot abarca 44cm2, es decir, es un 37% ms
pequeo. Este logro ha sido posible gracias al estudio pormenorizado de cada uno de los
componentes que forman el robot y al aprovechamiento mximo del espacio disponible.
Figura 11-1: Comparativa de tamao con un boli Bic
Pgina 184 de 231
J. L. Prez Motos
11.1.2. PESO
El segundo punto fuerte es su peso. Todo el conjunto pesa apenas 135g, frente a los
243g que pesa el Pololu 3Pi, incluidas las pilas. El hecho de que la mayora de piezas
sean de plstico ha facilitado lograr este objetivo que tambin se fij al inicio del diseo
del robot.
11.1.3. VELOCIDAD
El tercer punto fuerte es su velocidad. Haciendo pruebas en circuitos sin apenas
curvas se han alcanzado velocidades de hasta 72cm/s, por lo que supera velocidad del
Pocketbot 2 que se haba puesto como objetivo, 70cm/s.
11.1.4. COMUNICACIN
El ltimo punto fuerte del robot es el de la comunicacin. Hasta la fecha pocos
robots de estas caractersticas incluyen algn tipo de conexin inalmbrica. Adems, el
hecho de poder recoger datos y de controlarlo a distancia es un punto muy a tener en
cuenta para proyectos similares que se realicen en el futuro.
Figura 11-2: Comunicacin en tiempo real
Pgina 185 de 231
J. L. Prez Motos
11.2. POSIBLES MEJORAS
11.2.1. DISPOSICIN DE LOS SENSORES

La mejora ms evidente que se podra llevar a cabo es la de cambiar la disposicin
de los sensores infrarrojos. La disposicin de matriz no es la ms indicada para un robot
rastreador. Sera mucho ms acertado emplear una disposicin en V invertida o de
media luna ya que se podra detectar antes la presencia de una curva, por lo que el robot
podra funcionar a una mayor velocidad. Adems se podran incluir otros dos sensores
infrarrojos, uno a cada lado del robot, para detectar las marcas de bifurcacin presentes
en el circuito.
Figura 11-3: Cambio de disposicin de los sensores
11.2.2. COSTE
Otro de los objetivos marcados al inicio del proyecto fue que el robot costara menos
de los 100 que cuesta el Pololu 3Pi. Este no incluye ni programador ni pilas, por lo que
quitando esa parte del presupuesto nuestro robot costara producirlo 11228.
Pgina 186 de 231
J. L. Prez Motos
Microcontrolador
Ruedas
Motores
Controlador motores
Sensores infrarrojos
Comunicacin
Componentes electrnicos
Soporte
Figura 11-4: Representacin de los costes segn componentes quitando los componentes que no
incluye el Pololu 3Pi
En el grfico se puede ver que prcticamente un tercio del valor del robot es el
coste asociado a los motores, por lo que podra ser interesante buscar otras opciones que
ofrezcan las mismas caractersticas pero por un precio menor.
Tambin se podra ahorrar algo de dinero en el controlador de los motores. Existen
otras opciones, como los L293N, que por la mitad de dinero ofrecen las mismas
caractersticas que el L6205N empleado en este robot.
11.2.3. CONEXIN MDULO BLUETOOTH

Tanto el mdulo bluetooth como el programador emplean los mismos pines
digitales para realizar sus funciones. Esto imposibilita que ambos dispositivos se
encuentren conectados al mismo tiempo en el robot. De esta forma, cada vez que se
tiene que programar el robot primero se debe de desconectar el mdulo bluetooth y
despus se tiene que conectar el programador. Si se quiere volver a establecer de nuevo
la conexin bluetooth se debe realizar el camino inverso, primero desconectar el
programador y despus conectar el mdulo bluetooth. Esto hace que el proceso de
Pgina 187 de 231
J. L. Prez Motos
pruebas, como por ejemplo las pruebas realizadas para calibrar los parmetros PID,
requieran un tiempo excesivo.
Para solventar este problema Arduino posee una librera llamada SoftwareSerial[9].
Por defecto la comunicacin serie en un Arduino Pro Mini se realiza por los pines
digitales 0 y 1. Esta librera permite que la comunicacin serie se realice a travs de
otros pines. De esta forma es posible tener mltiples puertos series por software y no
hara falta desconectar dispositivos.
11.2.4. PROGRAMA ANDROID

En la actualidad el robot ejecuta dos sketch distintos. Uno para seguir lneas y otro
para que sea controlado por un dispositivo Android. Se podra desarrollar una aplicacin
Android que a travs de un men se seleccionara en qu modo debe funcionar el robot.
Figura 11-5: Posible interfaz de la aplicacin
Pgina 188 de 231
J. L. Prez Motos
CAPTULO 12. CONCLUSIONES
El principal objetivo con el que se inici este proyecto fue el de profundizar en la

programacin de microcontroladores, ya que durante toda la carrera solamente se haba
tratado en una de ellas y result ser una de las asignaturas que ms me gustaron. De esta
forma, gracias a la robtica se pudo profundizar en la programacin de
microcontroladores de una forma entretenida e incluso, segn el momento, divertida.
Adems, con la realizacin de este proyecto se han tratado diversos temas.
Documentacin: se ha tenido que leer multitud de hojas de caractersticas de

componentes para conseguir que todos los elementos que formasen el robot
fueran compatibles.
Diseos electrnicos: se ha empleado software para el diseo de sistemas

electrnicos tales como Eagle o DesignSpark que hasta antes de la realizacin
del proyecto eran desconocidos para m.
Electrnica: se ha tenido que escoger elementos como resistencias y

condensadores para que todo el sistema funcione de forma ptima.
Sistemas de comunicacin: tema totalmente desconocido para m hasta antes de

empezar a manipular el mdulo bluetooth y los puertos serie tanto de los
Arduino como de los ordenadores.
Programacin: se ha tenido que aprender a programar en dos lenguajes. Por un

lado se ha aprendido a programar tarjetas Arduino y, por otro lado, se ha
aprendido a programar aplicaciones para dispositivos Android.
Control de sistemas: con la implantacin del controlador PID se ha profundizado

de una forma prctica en el control de sistemas.
Para concluir, espero que ms estudiantes opten por realizar Proyectos Finales
de Carrera apoyndose en la robtica y que este proyecto sirva para futuros proyectos.
Pgina 189 de 231
J. L. Prez Motos
BIBLIOGRAFA
RECURSOS BIBLIOGRFICOS
[1]
Barbadillo Villanueva, Guillermo. Proyecto Arduino: Sumo robtico. Proyecto
Final de Carrera. Universidad Pblica de Navarra. Pamplona, 2012.

[2]
Daz, Pedro A. Artificial Intelligence In Vehicle. Proyecto Final de Carrera.
Universitat Oberta de Catalunya. Barcelona, 2011.

[3]
Evans, Brian W. Beginning Arduino Programming. Apress. 2011.
[4]
Galbarra Goi, David. Electrnica Digital y de Microprocesadores. Universidad
Pblica de Navarra. Pamplona, 2011.

[5]
Galvn Herrera, Jos B. Control Analgico de Sistemas Lineales. Ulzama
digital. Pamplona, 2009.

[6]
Iriarte Pastor, Aitor; Zuazu Ayesa, Carlos. Proyecto Arduino UPNA. Proyecto
Final de Carrera. Universidad Pblica de Navarra. Pamplona, 2011.

Karvinen, Kimmo; Karvinen, Tero. Make: Arduino Bots and Gadgets. OReilly
[7]
Media. 2011.
[8]
Lera Carreras, Gabriel. Control Automtico. Universidad Pblica de Navarra.
Pamplona, 2010.
[9]
Margolis, Michael. Arduino Cookbook. OReilly Media. 2011.
[10]
McRoberts, Michael. Beginning Arduino. Apress. 2011.
RECURSOS ELECTRNICOS
[11]
Normativa AESSBOT 2012 Rastreadores:
http://aess.upc.es/aessbot/documentacion/normativa_aessbot2012_rastreadores_esp.pdf
[12]
Gua de usuario del robot Pololu 3Pi:
http://www.pololu.com/file/0J137/Pololu3piRobotGuiaUsuario.pdf
[13]
Precio Pololu 3Pi:
http://www.bricogeek.com/shop/robotica/106-seguidor-de-lineas-pololu-3pi.html
Pgina 190 de 231
[14]
Asociacin
de
Robtica
J. L. Prez Motos
Domtica
de
Espaa.
Proyecto
n00b0t:
http://foro.webdearde.com/viewtopic.php?f=6&t=3404&sid=d927e9812f6e45440f4b7b
c2e682743a
[15]
Blog n00b0t: http://n00b0t.tikitake.com/index-es.html
[16]
Blog PocketBot 2: http://ostan.cz/PocketBot2/
[17]
Robot Roomba: http://www.irobot.com/global/es/home.aspx
[18]
Kiva Systems: http://www.kivasystems.com/
[19]
Hospital Nemocnice Na Homolce: http://www.homolka.cz/en-CZ/home.html
[20]
Caractersticas Pololu 3Pi: http://www.pololu.com/catalog/product/975
[21]
Arduino: http://arduino.cc/
[22]
Motores Paso a paso: http://en.wikipedia.org/wiki/Stepper_motor
[23]
Control de motores con ULN2803: http://letsmakerobots.com/node/11772
[24]
Hoja de caractersticas L6205N:
http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERA
TURE/DATASHEET/CD00002345.pdf
[25]
Hoja de caractersticas QTR-8RC: http://www.pololu.com/docs/pdf/0J12/QTR-
8x.pdf
[26]
Shield SD: https://www.sparkfun.com/products/9802
[27]
Mdulo bluetooth JY-MCU:
http://www.hobbycomponents.com/index.php?route=product/product&product_id=116
[28]
Comandos AT:
http://elecfreaks.com/store/download/datasheet/Bluetooth/HC0305%20serail%20module%20AT%20commamd%20set%20201104%20revised.pdf
[29]
Aplicacin BlueTerm:
https://play.google.com/store/apps/details?id=es.pymasde.blueterm&hl=es_419
[30]
Eagle: http://www.cadsoftusa.com/
[31]
DesignSpark: http://www.designspark.com/
[32]
Conversor Serie-USB FTDI232:
http://www.bricogeek.com/shop/295-conversor-serie-usb-ftdi232.html
[33]
Conexin entre Arduino y Matlab:
http://wechoosethemoon.es/2011/07/15/arduino-matlab-adquisicion-de-datos/
[34]
Librera QTRSensor: http://www.pololu.com/docs/0J19/all
[35]
Basic4Android: http://www.basic4ppc.com/
Pgina 191 de 231
[36]
Amarino: http://www.amarino-toolkit.net/
[37]
SDK Android: http://developer.android.com/sdk/index.html
[38]
Processing: http://processing.org/
[39]
SDK Android. Acelermetros:
J. L. Prez Motos
http://developer.android.com/reference/android/hardware/SensorManager.html
[40]
SDK Android. Bluetooth:
http://developer.android.com/guide/topics/connectivity/bluetooth.html
[41]
UUID bluetooth: http://hykrion.com/?q=node/136
[42]
SDK Android. Valores acelermetros:
http://developer.android.com/reference/android/hardware/SensorEvent.html
[43]
Byte en Java: http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Byte.html
[44]
Byte en Arduino: http://arduino.cc/es/Reference/Byte
[45]
Entrada / salida (streams):
http://www.lab.dit.upm.es/~lprg/material/apuntes/io/streams.htm
[46]
Clase BarraInfo: http://webdelcire.com/wordpress/archives/408
Pgina 192 de 231
J. L. Prez Motos
ANEXO A: CDIGOS
ANEXO A.1: PRUEBA DE FUNCIONAMIENTO DEL L6205N

/***********************************************************
*
Prueba funcionamiento L6205N
*
***********************************************************/
int enA = 3;
// enable del Puente A
int enB = 4;
// enable del Puente B
int in1A = 5;
int in2A = 6;
int in1B = 10;
int in2B = 11;
int pwmA = 50;
// valor PWM del Puente A
int pwmB = 150;
// valor PWM del Puente B
void setup() {
// se declaran los pines como salidas:
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
}
void loop() {
digitalWrite(enA, HIGH);
digitalWrite(enB, HIGH);
analogWrite(pwmA, in1A);
analogWrite(0, in2A);
analogWrite(pwmB, in1B);
analogWrite(0, in2B);
}
ANEXO A.2: PRUEBA DE FUNCIONAMIENTO DEL QTR-8RC

#include <QTRSensors.h>
/*
***********************************************************
*
Comprobacin funcionamiento sensores IR
*
***********************************************************
irS[0]
irS[1]
irS[2]
irS[3]
irS[4]
irS[5]
LEDON
DIG17
DIG18
DIG16
DIG15
DIG14
DIG9
DIG19
irS[0]
###
###
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
irS[4]
###
###
irS[5]
###
###
*/
#define NUM_SENSORS
#define TIMEOUT
#define LEDON
6
2500
9
//nmero de sensores usados

//2500 us para apagar cada sensor
//el emisor se controla con el pin 19
//Configuracin de pines
QTRSensorsRC qtrrc((unsigned char[]) {14, 15, 16, 17, 18, 19},
NUM_SENSORS, TIMEOUT, LEDON);
//configuracin de pines y de tiempo para la
Pgina 193 de 231
J. L. Prez Motos
//lectura de los sensores

//Configuracin de los sensores IR
unsigned int irS[NUM_SENSORS];
sensores
long irMax[] = {1, 1, 1, 1, 1, 1};
long irMin[] =
{5000, 5000, 5000, 5000, 5000, 5000};
long irM[] = {0, 0, 0, 0, 0, 0};
long tiempo;
//vector donde se guardan las lecturas de los

//vector para almacenar valores mximos
//vector para almacenar valores mnimos
//vector donde se guardan los valores mapeados
//variable para el tiempo
int i;
/*
===============
=
SETUP
=
===============
*/
void setup()
{
Serial.begin(9600);
pinMode(13, OUTPUT);
//se espera de un segundo para comenzar la calibracin
delay(1000);
//se enciende el LED 13 para indicar que se estn calibrando los sensores
//obtencin de los valores mnimos y mximos de cada sensor
tiempo = millis();
while (millis() - tiempo < 4000)
{
qtrrc.read(irS);
minmax(irS);
}
//se apaga el LED 13 para indicar que se ha terminado la calibracin de los sensores
//se obtienen por pantalla los valores mximos y mnimos para cada sensor
for (i = 0; i < NUM_SENSORS; i++)
{
Serial.print(irMax[i]);
Serial.print(' ');
}
Serial.println(' ');
{
Serial.print(irMin[i]);
Serial.print(' ');
}
}
/*
===============
=
LOOP
=
===============
*/
void loop()
{
//lectura de los sensores y almacenamiento de sus valores
qtrrc.read(irS);
//se mapea cada valor segn su mximo y su mnimo entre 0 y 9 para ver si sigue la
lnea
{
irM[i] = (map(irS[i], irMin[i], irMax[i], 0, 9));
}
//filtro por si hay valores menores o mayores que los medidos durante la calibracin
Pgina 194 de 231
J. L. Prez Motos
{
if (irM[i]
{
irM[i] =
}
if (irM[i]
{
irM[i] =
}
< 0)
0;
> 9)
9;
}
/*se obtiene por pantalla el valor mapeado de cada sensor, para sabes si se detecta
bien o no la lnea.
*/
{
Serial.print(irM[i]);
Serial.print(' ');
}
delay(100);
}
/*
===============
= FUNCIONES =
===============
*/
void minmax(unsigned int val[NUM_SENSORS])
mnimo de los sensores
{
{
if (val[i] > irMax[i])
{
irMax[i] = val[i];
}
if (val[i] < irMin[i])
{
irMin[i] = val[i];
}
}
}
//funcin para detectar el mximo y el
ANEXO A.3: CONFIGURACIN DEL MDULO BLUETOOTH

/***************************************************************
*
Cambio de la configuracion del mdulo bluetooth
*
*
mediante comandos AT.
*
****************************************************************/
//Variable para control de configuracin
boolean conf = false;
int espera = 1000;
void setup(){
pinMode(13,OUTPUT);
}
// Pin13 para control del proceso

// Velocidad del modulo bluetooth
// Apagamos el LED 13
void loop(){
if (conf){
// Parpadeo para verificar su funcionamiento
// Enciende el LED
delay(espera);
// Espera
// Apaga el LED
delay(espera);
// Espera
}
Pgina 195 de 231
J. L. Prez Motos
else{
digitalWrite(13, HIGH); // Empiezael tiempo de espera para reconectar
Serial.println("Configuracion del modulo bluetooth");
Serial.println("Conecte el TX del modulo BT al RX del arduino y el RX del modulo BT
al TX del arduino");
delay(15000);
// Espera de 15 segundos (se puede cambiar)
digitalWrite(13, LOW); // Tiempo de espera agotado para reconectar
Serial.print("AT");
delay(espera);
// Empieza la comunicacin por el modulo BT

// Espera para el envio de comandos
Serial.print("AT+NAMEBTarduino"); // Nombre del dispositivo

delay(espera);
Serial.print("AT+BAUD7");
delay(espera);
Serial.print("AT+PIN4242");
delay(espera);
// Establecemos la velocidad en 57600

// Establecemos el pin de asociacion
//En este punto debe estar configurado

digitalWrite(13, HIGH); // Todo ha funcionado segun lo esperado
conf = true;
// Para no volver a configurarlo, salvo que se resetee
}
}
ANEXO A.4: PRUEBA DE FUNCIONAMIENTO DEL MDULO

BLUETOOTH
/*****************************************************
*
Prueba modulo bluetooth
*
******************************************************/
void setup()
{
//Se configura el pin 13 como salida para poder manipular el LED
pinMode(13,OUTPUT);
//Velocidad del mdulo bluetooth con la que se haya configurado
}
void loop()
{
//Se ejecutar el cdigo mientras est disponible el puerto Serie
while (Serial.available())
{
//Variable enviada desde el mvil
char dato= Serial.read();
//Comprobacin del dato
switch(dato)
{
//Si se recibe una 'w' se enciende el LED 13 y se enva para mostrar en
Blueterm LED encendido
case 'w':
{
digitalWrite(13,HIGH);
Serial.println("LED encendido");
break;
}
//Si se recibe una 'e' se apaga el LED 13 y se enva para mostrar en Blueterm
LED apagado
case 'e':
{
digitalWrite(13,LOW);
Serial.println("LED apagado");
break;
}
//Si se recibe una 'r' se enciende y se apaga el LED y se muestrar en Blueterm
LED intermitente
case 'r':
Pgina 196 de 231
J. L. Prez Motos
{
delay(200);
delay(200);
delay(100);
delay(100);
Serial.println("LED intermitente");
break;
}
}
}
}
ANEXO A.5: PRUEBA DE FUNCIONAMIENTO EN EL ROBOT DEL

QTR-8RC
/*
***********************************************************
*
Comprobacin funcionamiento sensores IR
*
***********************************************************
irS[0]
irS[1]
irS[2]
irS[3]
irS[4]
irS[5]
LEDON
DIG17
DIG18
DIG16
DIG15
DIG14
DIG9
DIG19
irS[0]
###
###
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
irS[4]
###
###
irS[5]
###
###
*/
#define NUM_SENSORS
#define TIMEOUT
#define LEDON
6
2500
19

//2500 us para apagar cada sensor
//lectura de los sensores
sensores
long irMax[] = {1, 1, 1, 1, 1, 1};
long irMin[] =
{5000, 5000, 5000, 5000, 5000, 5000};
long irM[] = {0, 0, 0, 0, 0, 0};
long tiempo;

//variable para el tiempo
int i;
/*
===============
=
SETUP
=
===============
*/
void setup()
{
Serial.begin(9600);
Pgina 197 de 231
J. L. Prez Motos
pinMode(13, OUTPUT);
//se espera de un segundo para comenzar la calibracin
delay(1000);
//se enciende el LED 13 para indicar que se estn calibrando los sensores
tiempo = millis();
while (millis() - tiempo < 4000)
{
qtrrc.read(irS);
minmax(irS);
}
//se apaga el LED 13 para indicar que se ha terminado la calibracin de los sensores
//se obtienen por pantalla los valores mximos y mnimos para cada sensor
{
Serial.print(irMax[i]);
Serial.print(' ');
}
{
Serial.print(irMin[i]);
Serial.print(' ');
}
}
/*
===============
=
LOOP
=
===============
*/
void loop()
{
qtrrc.read(irS);
//se mapea cada valor segn su mximo y su mnimo entre 0 y 9 para ver si sigue la
lnea
{
}
{
if (irM[i] < 0)
{
irM[i] = 0;
}
if (irM[i] > 9)
{
irM[i] = 9;
}
}
/*se obtiene por pantalla el valor mapeado de cada sensor, para sabes si se detecta
bien o no la lnea.
*/
{
Serial.print(' ');
}
delay(100);
Pgina 198 de 231
J. L. Prez Motos
}
/*
===============
= FUNCIONES =
===============
*/
void minmax(unsigned int val[NUM_SENSORS])
mnimo de los sensores
{
{
if (val[i] > irMax[i])
{
irMax[i] = val[i];
}
if (val[i] < irMin[i])
{
irMin[i] = val[i];
}
}
}
//funcin para detectar el mximo y el
ANEXO A.6: PRUEBA DE FUNCIONAMIENTO EN EL ROBOT DE

LOS LEDS DELANTEROS Y DE LOS MOTORES
/*
***********************************************************
*
Prueba motores y LEDs
*
***********************************************************
enableA
enableB
in1A
in2A
in1B
in2B
DIG08
DIG07
DIG05
DIG03
DIG06
DIG09
**
**
LEDi
==== OUTB1
|
MB ===|
|
==== OUTB2
LEDi
LEDd
DIG10
DIG16
**
**
LEDd
OUTA1 ====
|
|=== MA
|
OUTA2 ====
*/
int
int
int
int
int
int
int
int
enableA = 8;
enableB = 7;
in1A = 5;
in2A = 3;
in1B = 6;
in2B = 9;
LEDi = 10;
LEDd = 16;
int vMax = 255;

motores
//pin
//pin
//pin
//pin
//pin
//pin
//pin
//pin
del enable del puente A

del enable del puente B
de la entrada 1 del puente
del LED izquierdo
del LED derecho
A
A
B
B
//constante para limitar la velocidad de los
int i;
/*
===============
Pgina 199 de 231
J. L. Prez Motos
=
SETUP
=
===============
*/
void setup(){
//pinMode
pinMode(enableA, OUTPUT);
pinMode(enableB, OUTPUT);
pinMode(LEDi, OUTPUT);
pinMode(LEDd, OUTPUT);
//se detienen ambos motores
motor(0,0);
//se ponen a cero todas las salidas
digitalWrite(in1A, LOW);
digitalWrite(in1B, LOW);
//se activan ambos puentes
digitalWrite(enableA, HIGH);
digitalWrite(enableB, HIGH);
//se apagan los dos LEDs
digitalWrite(LEDi, LOW);
digitalWrite(LEDd, LOW);
//espera de un segundo para poder posicionar el robot en el suelo
delay(1000);
//se hace una pequea secuencia con los LEDs para indicar que ha iniciado el programa
digitalWrite(LEDi, HIGH);
delay(500);
digitalWrite(LEDd, HIGH);
delay(500);
delay(500);
delay(500);
delay(500);
}
void loop(){
//se lleva la velocidad a los motores
motor(200,200);
delay(2000);
motor(-200,-200);
delay(2000);
motor(100,200);
delay(1000);
motor(200,100);
delay(1000);
motor(-100,100);
delay(1000);
Pgina 200 de 231
J. L. Prez Motos
motor(100,-100);
delay(1000);
}
/*
********************************************************
*
*
********************************************************
*/
if (out1 >= 0){
}
else{
}
if (out2 >= 0){
}
else{
}
}
ANEXO A.7: PRUEBA DE LA CONEXIN BLUETOOTH ENTRE

ROBOT Y ORDENADOR. ARDUINO
/*
***********************************************************
*
Prueba bluetooth pc
*
***********************************************************
irS[0]
irS[1]
irS[2]
irS[3]
irS[4]
irS[5]
LEDON
DIG17
DIG18
DIG15
DIG11
DIG14
DIG12
DIG19
irS[0]
###
###
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
irS[4]
###
###
irS[5]
###
###
*/
#define NUM_SENSORS
#define TIMEOUT
sensor
#define LEDON
6
2500

//espera 2500 us para apagar cada
19
//configuracin de pines y de tiempo
para la lectura de los sensores
de los sensores
//vector donde se guardan las lecturas
Pgina 201 de 231

long irMax[] =
{2500, 2220, 2434, 2500, 2500, 2500};
long irMin[] = {326, 160, 268, 268, 228, 304};
long irM[] = {0, 0, 0, 0, 0, 0};
mapeados
J. L. Prez Motos

//vector donde se guardan los valores
int dt = 10;
long tiempo = 0;
int i;
/*
===============
=
SETUP
=
===============
*/
void setup(){
//obligado por el BT
delay(1000);
}
/*
===============
=
LOOP
=
===============
*/
void loop(){
qtrrc.read(irS);
//mapeamos cada valor segn su mximo y su mnimo entre 0 y 9 para ver si sigue la
lnea
for (i = 0; i < NUM_SENSORS; i++){
}
if (irM[i] < 0){
irM[i] = 0;
}
if (irM[i] > 9){
irM[i] = 9;
}
}
//para obtener resultados
Serial.print(' ');
}
//se incluye un retraso para que matlab pueda procesar los datos
delay(dt);
}

ROBOT Y ORDENADOR. MATLAB
clear all;
clc
%borrar previos
Pgina 202 de 231
J. L. Prez Motos
%crear objeto serie

%abrir puerto
fopen(s);
%Tiempo que dura la medicin en segundos
tmax = 20;
%Inicializar
t = 0;
%Ejecutar bucle cronometrado
tic
%Con tic y toc mide el tiempo que hay entre ellos
while t<tmax
t = toc;
%Leer del puerto serie
puerto = fscanf(s,'%d %d %d %d %d %d')';
%Dibujar el diagrama de barras
bar(puerto);
%Actualizar el diagrama
drawnow
end
clc;
%% Cerrar y eliminar el puerto creado
fclose(s);
delete(s);
clear s;

ROBOT Y DISPOSITIVO ANDROID
/*****************************************************
*
Prueba modulo bluetooh
*
******************************************************/
int LEDi = 10;
int LEDd = 16;
void setup(){
//Se configuran los pines de los LEDs como salida para poder manipularlos
//Velocidad del mdulo bluetooth con la que se haya configurado
//se apagan ambos LEDs
}
void loop(){
//Se ejecutar el cdigo mientras est disponible el puerto Serie
while (Serial.available()){
//Variable enviada desde el mvil
char dato= Serial.read();
//Comprobacin del dato
switch(dato){
//Si se recibe una 'a' se apagan los dos LEDs y se enva para mostrar en
Blueterm LEDs apagados
case 'a':{
Serial.println("LEDs apagados");
break;
}
//Si se recibe una 'r' se enciende el LED izquierdo y se enva para mostrar en
Blueterm LED izquierdo
case 'r':{
Pgina 203 de 231
J. L. Prez Motos
Serial.println("LED izquierdo");
break;
}
//Si se recibe una 'v' se enciende el LED derecho y se muestrar en Blueterm LED
derecho
case 'v':{
Serial.println("LED derecho");
break;
}
//Si se recibe una 'd' se encienden los dos LEDs y se muestrar en Blueterm LEDs
encendidos
case 'd':{
Serial.println("LEDs encendidos");
break;
}
//Si se recibe una 'v' se enciende el LED derecho y se muestrar en Blueterm LED
derecho
case 'i':{
delay(100);
delay(100);
delay(100);
delay(100);
delay(100);
delay(100);
delay(100);
delay(100);
Serial.println("LEDs intermitentes");
}
}
}
}
ANEXO A.10: FUNCIONAMIENTO COMO ROBOT SIGUE LNEAS

/*
***********************************************************
*
Seguidor de lnea
*
***********************************************************
irS[0]
irS[1]
irS[2]
irS[3]
irS[4]
irS[5]
LEDON
**
DIG17
DIG18
DIG15
DIG11
DIG14
DIG12
DIG19
enableA
enableB
in1A
in2A
in1B
in2B
DIG08
DIG07
DIG05
DIG03
DIG06
DIG09
LEDi
LEDd
DIG10
DIG16
**
Pgina 204 de 231
J. L. Prez Motos
**
LEDi
irS[0]
###
###
**
LEDd
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
==== OUTB1
|
MB ===|
|
==== OUTB2
irS[4]
###
###
irS[5]
###
###
OUTA1 ====
|
|=== MA
|
OUTA2 ====
Posicin del sensor i = 10 * i

Valor a seguir = 25
______________________________________________________________
Posicin
50
40
30
20
10
0
Error
-25 -15
-5
5
15
25
*/
#define NUM_SENSORS
#define TIMEOUT
#define LEDON
6
2500
19

//espera 2500 us para apagar cada sensor
//Asignacin de pines
lectura de los sensores
int enableA = 8;
//pin del enable del puente A
int enableB = 7;
//pin del enable del puente B
int in1A = 5;
//pin de la entrada 1 del puente A
int in2A = 3;
//pin de la entrada 2 del puente A
int in1B = 6;
//pin de la entrada 1 del puente B
int in2B = 9;
//pin de la entrada 2 del puente B
int LEDi = 10;
//pin del LED izquierdo
int LEDd = 16;
//pin del LED derecho
//Variables de los sensores IR
unsigned int
sensores
long irP[] =
long irMax[]
{1, 1, 1, 1,
long irMin[]
{5000, 5000,
long irM[] =
irS[NUM_SENSORS];
{50, 40, 30, 20, 10, 0};

=
1, 1};
=
5000, 5000, 5000, 5000};
{0, 0, 0, 0, 0, 0};
//vector de pesos
//Parmetros del PID

int kc = 10;
float tc = 0.18;
//pid
float kp = 0.6 * kc;
float kd = kp * tc / 8;
float ki = 2 * kp / tc;
//parmetros obtenidos experimentalmente
//constante de proporcionalidad
//constante de derivacin
//constante de integracin
float integ = 0;
//parte integral
float deriv = 0;
//parte derivada
long errora = 0;
//variable donde
float toterror = 0;
//variable donde
error
/*
float kp = 7;
float kd = 0;
float ki = 15;
*/
//Variables para el clculo de la posicin
int seg = 25;
del PID
del PID
se guarda el error anterior
se guarda la suma total del
//constante con el valor a seguir
Pgina 205 de 231

long posicion = 0;
long cont = 0;
long error = 0;
char out = 'C';
Centrado; I = Izqda; D = Drcha
char bif = 'C';
Centrado; I = Izqda; D = Drcha
char bifa = 'C';
int ven = 0;
lnea
int vena = 0;
momento anterior
J. L. Prez Motos
//variable
//variable
//variable
//variable
donde se guarda la posicin

para calcular la posicin
donde se guarda el error
para ver si se ha salido. C =
//variable para las bifucarciones. C =

//variable para la bifurcacin anterior.
//variable para la cantidad de sensores que ven
//variable para la cantidad de sensores en el
//Variables para el movimiento de los motores

int motorA = 0;
int motorB = 0;
int velr = 100;
int vell = 50;
int vel = velr;
int vMax = 255;
motores
//velocidad
//velocidad
//velocidad
//velocidad
//velocidad
//constante
controlada del motor A

controlada del motor B
sin errores rpida
sin errores lenta
sin errores
para limitar la velocidad de los
//Variables de tiempo
int dt = 20;
que pasarlo a segundos
unsigned long tiempo;
//delay introducido. En ms, por lo que habr

//variable de tiempo
//LEDs
int brillo = 0;
//encendido de los LEDs delanteros
int i;
/*
===============
=
SETUP
=
===============
*/
void setup(){
//pinMode
motor(0,0);
//espera de un segundo para poder posicionar el siguelineas en el suelo
delay(1000);
calibracion();
delay(1000);
}
/*
===============
=
LOOP
=
===============
*/
void loop(){
Pgina 206 de 231
J. L. Prez Motos

qtrrc.read(irS);
//mapeamos cada valor segn su mximo y su mnimo entre 0 y 9 para ver si sigue la
lnea
}
//filtro por si hay valores menores o mayores que los medidos durante la calibracin y
//obtencin del nmero de sensores que ven lnea
ven = 0;
filtro(irM[i],0,9);
if (irM[i] > 0){
ven++;
}
}
//si el robot se ha salido ningn sensor ver lnea, por lo que ven = 0
if (ven > 0){
si_linea();
}
else{
no_linea();
}
//se vuelcan en los motores las velocidades obtenidas
motor(motorB, motorA);
//LEDs delanteros
/*
if (motorA == motorB){
}
else if (motorA > motorB){
}
else{
}*/
if (bif == 'I'){
}
else if (bif == 'D'){
}
else{
}
//para obtener resultados
resultados();
//delay obligado por la transmisin de datos y del PID
delay(dt);
}
/*
********************************************************
*
Funcin para el clculo de la posicin
*
********************************************************
---------------------Clculo de la posicin
---------------------Para calcular la posicin del siguelineas se va a emplear la siguiente frmula
irM[0] * irP[0] + irM[1] * irP[1] + irM[2] * irP[2] + irM[3] * irP[3] + irM[4] * irP[4]
+ irM[5] * irP[5]
-------------------------------------------------------------------------------------------------------irM[0] + irM[1] + irM[2] + irM[3] + irM[4] + irM[5]
De esta forma si la lnea se encuentra sobre el sensor 2 se obtiene 20, si est entre el
4 y el 5 se obtiene 45, etc...
Pgina 207 de 231
J. L. Prez Motos
*/
void calculo_posicion(){
posicion = 0;
cont = 0;
{
posicion = posicion + irM[i] * irP[i];
cont = cont + irM[i];
}
posicion = posicion / cont;
}
/*
********************************************************
*
*
Funcin para calibrar los sensores
********************************************************
*/
void calibracion(){
motor(50, -50);
tiempo = millis();
while (millis() - tiempo < 2000){
qtrrc.read(irS);
minmax(irS);
}
motor(0, 0);
//terminada la calibracin se coloca el siguelneas sobre la lnea
motor(-25, 25);
while (posicion > seg || posicion < seg)
{
qtrrc.read(irS);
{
irM[i] = map(irS[i], irMin[i], irMax[i], 0, 9);
}
{
filtro(irM[i], 0, 9);
}
calculo_posicion();
//LEDs
if (brillo == 1){
brillo = 0;
}
else{
brillo = 1;
}
}
motor(0, 0);
}
/*
********************************************************
* Funcin para asegurarnos que no se pasan los valores *
********************************************************
*/
void filtro (int input, int inputmin, int inputmax){
if (input < inputmin){
input = inputmin;
}
if (input > inputmax){
input = inputmax;
}
}
/*
********************************************************
Pgina 208 de 231
J. L. Prez Motos
*
Funcin para calcular los mximos y
*
*
mnimos de cada sensor
*
********************************************************
*/
void minmax(unsigned int val[NUM_SENSORS]){
if (val[i] > irMax[i]){
irMax[i] = val[i];
}
if (val[i] < irMin[i]){
irMin[i] = val[i];
}
}
}
/*
********************************************************
*
*
********************************************************
*/
if (out1 >= 0){
}
else{
}
if (out2 >= 0){
}
else{
}
}
/*
********************************************************
*
Funcin por si el robot se ha salido del trazado
*
********************************************************
*/
void no_linea(){
switch(out){
case 'I':
//caso en el que la ltima vez que se vi lnea
esta estaba a la izquierda
error = -seg;
//se fuerza a girar a la izquierda
motorA = vMax;
motorB = -vMax;
break;
case 'D':
esta estaba a la derecha
error = seg;
//se fuerza a girar a la derecha
motorA = -vMax;
motorB = vMax;
break;
case 'C':
esta estaba en el centro
error = 0;
//se fuerza a ir marcha atrs
motorA = -vMax;
motorB = -vMax;
break;
default:
error = 0;
break;
}
}
/*
********************************************************
*
PID
*
********************************************************
----------------------
Pgina 209 de 231
J. L. Prez Motos
Control PID
---------------------Los signos con los que afectan el control PD a cada motor son distintos ya que para vari
ar la posicin del siguelineas
lo que se pretende es qe este gire
*/
void pid(){
integ = integ + error * dt / 1000;
deriv = (error - errora) * 1000 / dt;
//el 1000 es el factor para pasar de ms a
segundos
motorA = vel + error * kp + integ * ki + deriv * kd;
motorB = vel - error * kp - integ * ki - deriv * kd;
errora = error;
la parte derivativativa
}
//se almacena el error para poder aplicar
/*
********************************************************
*
Funcin para mostrar los resultados por pantalla
*
********************************************************
*/
void resultados(){
/*for (i = 0; i < NUM_SENSORS; i++){
Serial.print(' ');
}*/
//Serial.print(posicion);
//Serial.print(' ');
//Serial.println(seg);
Serial.print(error);
Serial.print(' ');
Serial.print(0);
Serial.print(' ');
Serial.print(constrain(motorA,-vMax,vMax));
Serial.print(' ');
Serial.println(constrain(motorB,-vMax,vMax));
//Serial.println(bif);
/*Serial.write(byte(constrain(abs(motorA),0,vMax)-128));
if (motorA >= 0){
}
else{
}
Serial.write(byte(constrain(abs(motorB),0,vMax)-128));
if (motorB >= 0){
}
else{
}
Serial.write(byte(posicion));
switch (bif){
case 'I':
break;
case 'C':
break;
case 'D':
break;
}*/
/*Serial.write(byte(seg));
Serial.write(byte(irM[i]));
}*/
}
/*
********************************************************
*
Funcin para cuando el robot siga el trazado
*
********************************************************
Pgina 210 de 231
J. L. Prez Motos
*/
void si_linea(){
//Marca de bifurcaciones
//if ((((irM[0] && irM[2]) > 0) && (irM[1] == 0)) || (((irM[5] && irM[3]) > 0) &&
(irM[4] == 0)) || ((irM[0] && irM[2] && irM[3] && irM[5] > 0) && ((irM[1] == 0) &&
(irM[4] == 0))))
if ((((irM[0] > irM[1]) && (irM[2] > irM[1])) || ((irM[5] > irM[4]) && (irM[3] >
irM[4]))) && (vena < 3))
//if ((((irM[0] && irM[2]) > 0) && (irM[1] == 0)) || (((irM[5] && irM[3]) > 0) &&
(irM[4] == 0)))
{
si_marca();
}
else if ((((irM[0] > irM[1]) && (irM[2] > irM[1])) || ((irM[5] > irM[4]) && (irM[3] >
irM[4])))){ //evitar que lade cuando ve una marca de bifurcacin
irM[0] = 0;
irM[1] = 0;
irM[4] = 0;
irM[5] = 0;
calculo_posicion();
}
else{
calculo_posicion();
}
//Actualizar las marcas de bifurcacin
if ((vena < 4) && (ven < 3)){
bif = bifa;
}
//Bifurcaciones
if ((ven > 3) && (bif == 'I') && (vena > 3)){
seg = 0;
//obligamos a que gire a la izquierda
vel = vell;
//se frena el coche
}
else if ((ven > 3) && (bif == 'D') && (vena > 3)){
seg = 50;
//obligamos a que gire a la derecha
vel = vell;
//se frena el coches
}
//seguir recto
else{
seg = 25;
//valor por defecto
vel = velr;
//velocidad normal
}
//Clculo del error
error = seg - posicion;
//PID
pid();
/*
Se va guardando la ltima posicin en la que se vio lnea. Si se vio a la izquierda de
la parte central querr decir que el
error es negativo y si por el contrario se vio a la derecha querr decir que el error
es positivo.
*/
if (error < 0){
out = 'I';
}
else if (error > 0){
out = 'D';
}
else{
out = 'C';
}
vena = ven;
}
/*
********************************************************
*
*
Funcin para detectar marcas de bifurcacin
********************************************************
irS[0]
###
###
|||||
|||||
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
|||||||||||||
|||||||||||||
irS[4]
###
###
irS[5]
###
###
//Marca a la izquierda
Pgina 211 de 231
|||||||||||||
|||||||||||||
J. L. Prez Motos
|||||
|||||
//Marca a la derecha
*/
void si_marca(){
if ((irM[0] > irM[1]) && (irM[2] > irM[1])){
bifa = 'I';
posicion = seg;
}
else if ((irM[5] > irM[4]) && (irM[3] > irM[4])){
bifa = 'D';
posicion = seg;
}
else{
bifa = 'C';
posicion = seg;
}
}
ANEXO
A.11:
OBTENCIN
DE
LOS
PARMETROS
DEL
CONTROLADOR PID
clear;
clc;
%borrar previos
%crear objeto serie
%abrir puerto
fopen(s);
% parmetros de medidas
tmax = 15; % tiempo de captura en s
rate = 50; % resultado experimental
% preparar la figura
f = figure('Name','Captura');
a = axes('XLim',[0 tmax],'YLim',[-1.2 1.2]);
l1 = line(nan,nan,'Color','r','LineWidth',2);
l2 = line(nan,nan,'Color','b','LineWidth',1);
l3 = line(nan,nan,'Color','y','LineWidth',2);
l4 = line(nan,nan,'Color','g','LineWidth',2);
xlabel('Tiempo (s)')
ylabel('Error')
title('Captura del error en tiempo real con Arduino')
grid on
hold on
% inicializar
i = 1;
t = 0;
% ejecutar bucle cronometrado
tic
while t<tmax
t = toc;
% leer del puerto serie
puerto = fscanf(s,'%f %f %f %f')';
v1(i)=puerto(1)/25;
Pgina 212 de 231
J. L. Prez Motos
v2(i)=puerto(2)/25;
v3(i)=puerto(3);
v4(i)=puerto(4);
% dibujar en la figura
x = linspace(0,i/rate,i);
drawnow
% seguir
i = i+1;
end
%% Cerrar el puerto
fclose(s);
delete(s);
clear s;
ANEXO A.12: CONTROL REMOTO DEL ROBOT. ARDUINO

/*
***********************************************************
*
Control robot desde Android
*
***********************************************************
enableA
enableB
in1A
in2A
in1B
in2B
DIG08
DIG07
DIG05
DIG03
DIG06
DIG09
LEDi
LEDd
DIG10
DIG16
**
**
LEDi
irS[0]
###
###
**
**
LEDd
irS[1]
###
###
irS[2]
###
###
irS[3]
###
###
____ OUTB1
|
MB ===|
|
____ OUTB2
irS[4]
###
###
irS[5]
###
###
OUTA1 ___
|
|=== MA
|
OUTA2 ___
*/
int
int
int
int
int
int
int
int
enableA = 8;
enableB = 7;
in1A = 5;
in2A = 3;
in1B = 6;
in2B = 9;
LEDi = 10;
LEDd = 16;
//pin
//pin
//pin
//pin
//pin
//pin
//pin
//pin
del enable del puente A

del enable del puente B
del LED izquierdo
del LED derecho
A
A
B
B
//Configuracin para el movimiento de los motores

int vMax = 255;
//constante para limitar la velocidad de los motores

//se limita para que como mucho vayan al 90%
int i;
Pgina 213 de 231

int
int
int
int
giro = 0;
vel = 0;
girom = 0;
velm = 0;
J. L. Prez Motos
//variable donde se guardar el giro

//variable donde se guardar la velocidad
//giro que se lleva al motor
//velocidad que se lleva al motor
/*
===============
=
SETUP
=
===============
*/
void setup(){
//pinMode
motor(0,0);
//espera de un segundo para poder posicionar el siguelineas en el suelo
delay(1000);
}
/*
===============
=
LOOP
=
===============
*/
void loop(){
delay(20);
//motor(0,0);
//Mientras el puerto serie del modulo bluetooth esta disponible
while (Serial.available()>0){
//Guardamos en la variable dato el valor leido por el modulo bluetooth
giro = Serial.read() - 10; //el -10 es cosa de java. Fallaba el paso de numeros
negativos
vel = Serial.read() - 10;
//filtros
filtro(vel, -10, 10);
filtro(giro, -10, 10);
//mapeados
if (vel >= 0){ //hay que cambiar el sentido a vel
velm = map(vel, 0, 10, 0, -255);
}
else{
velm = map(vel, -10, 0, 255, 0);
}
if (giro >= 0){
girom = map(giro, 0, 10, 0, 50);
}
else{
girom = map(giro, -10, 0, -50, 0);
}
//motor
Pgina 214 de 231
J. L. Prez Motos
motor(velm - girom, velm + girom);

}
enviar();
}
void enviar(){
Serial.write(byte(constrain(abs(velm-girom),0,vMax)-128));
if (velm-girom >=0){
}
else{
}
Serial.write(byte(constrain(abs(velm+girom),0,vMax)-128));
if (velm+girom >=0){
}
else{
}
}
void filtro
{
if (input
{
input =
}
if (input
{
input =
}
}
(int input, int inputmin, int inputmax)

< inputmin)
inputmin;
> inputmax)
inputmax;
void motor(int out1, int out2)

//funcin para mover los motores segn el pwm que se
desee
{
if (out1 >= 0)
{
}
else
{
}
if (out2 >= 0)
{
}
else
{
}
}
ANEXO A.13: CONTROL REMOTO DEL ROBOT. ANDROID

package processing.test.mandar_datos;
import
import
import
import
import
import
processing.core.*;
android.bluetooth.BluetoothAdapter;
android.bluetooth.BluetoothDevice;
android.bluetooth.BluetoothSocket;
android.content.BroadcastReceiver;
android.content.Context;
Pgina 215 de 231

import
import
import
import
import
import
import
android.content.Intent;
java.util.ArrayList;
java.util.UUID;
java.io.IOException;
java.io.InputStream;
java.io.OutputStream;
java.lang.reflect.Method;
import
import
import
import
import
import
android.hardware.Sensor;
android.hardware.SensorEvent;
android.hardware.SensorManager;
android.hardware.SensorEventListener;
android.os.Bundle;
android.view.WindowManager;
J. L. Prez Motos
public class mandar_datos extends PApplet {

//variables de las barras
BarraInfo pwmA;
BarraInfo pwmB;
//fuentes
String[] fontList;
PFont androidFont;
//variables de configuracin del acelerometro
SensorManager mSensorManager;
MySensorEventListener accSensorEventListener;
Sensor acc_sensor;
float[] acc_values;
//matriz donde se guardarn los resultados
//variables de la comunicacin bluetooth
private static final int REQUEST_ENABLE_BT = 3;
ArrayList<BluetoothDevice> dispositivos; //matriz con los dispositivos encontrados por el
telfono
BluetoothAdapter bttelefono;
//representa el bluetooth del telfono
BluetoothDevice dispositivo;
//representa el bluetooth de los
dispositivos ajenos al telfono
BluetoothSocket socket;
//establece la conexin entre
telfono y robot
InputStream ins;
//variable para recibir datos
del robot (byte)
OutputStream ons;
//variable para enviar
datos al robot (byte)
//variables del men
int estado;
String error;
//variables para el clculo de valor
byte[] valor={0,0};
//valor que se enviar
por bluetooth
{menu,giro,velocidad}
byte giro = 0;
//variable del giro. El
punto medio ser 4
byte vel = 0;
//variable de la
velocidad. El punto medio ser 5
float ant[] ={0,0};
//variable del valor del
acelermetro anterior. Se calcular la media de las dos ultiams mediciones {vel,giro}
byte[] ardu = {0,0,0,0};
//valor recibido por el robot
int i;
//variables del fondo
float l;
//variables del circulito
float ay;
float ax;
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
//un BroadcastReceiver sirve
BroadcastReceiver receptor = new BroadcastReceiver(){
para recibir eventos
Pgina 216 de 231
J. L. Prez Motos
public void onReceive(Context context, Intent intent){

String accion = intent.getAction();
//recibe el
evento que se enva a la aplicacin
if (BluetoothDevice.ACTION_FOUND.equals(accion)){
//la accin es que ha encontrado
un dispositivo bluetooth
BluetoothDevice dispositivo =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
println(dispositivo.getName() + " " + dispositivo.getAddress());
}
//el telfono
else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(accion)){
est buscando disopositivos
estado = 0;
}
else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(accion)){
//el telfono ha
terminado de buscar
estado = 1;
}
}
};
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void setup() {
size(displayWidth, displayHeight, JAVA2D);
//se obtienen las medidas de la
pantalla y se define que solo habrn
//objetos en 2D
frameRate(25);
//refresco de pantalla
//para que la pantalla est girada
orientation(LANDSCAPE);
//si queremos que la posicin de la pantalla sea vertical:
//orientation(PORTRAIT);
//fuentes
fontList = PFont.list();
androidFont = createFont(fontList[0], 32, true);
textFont(androidFont);
stroke(255);
textAlign(CENTER);
//distancia vertical mxima
l = (float) (0.98 * height);
//barras
pwmA = new BarraInfo();
pwmA.inicio = 0;
pwmA.fin = 255;
pwmA.x = (int) (0.9 * width);
pwmA.y = (int) (0.1 * height);
pwmA.anchura = width/60;
pwmA.altura = (int) (0.8 * height);
pwmA.pasoLinea = height/60;
pwmA.pasoNumero = height/12;
pwmA.recorteX = width/20;
pwmA.recorteY = width/60;
pwmA.digitos = 3;
pwmA.decimales = -1;
pwmA.etiqueta = "Motor derecho";
pwmB = new BarraInfo();
pwmB.inicio = 0;
pwmB.fin = 255;
pwmB.x = (int) (0.1 * width);
pwmB.y = (int) (0.1 * height);
pwmB.anchura = width/60;
pwmB.altura = (int) (0.8 * height);
pwmB.pasoLinea = height/60;
pwmB.pasoNumero = height/12;
pwmB.recorteX = width/20;
Pgina 217 de 231
J. L. Prez Motos
pwmB.recorteY = width/60;
pwmB.digitos = 3;
pwmB.decimales = -1;
pwmB.etiqueta = "Motor izquierdo";
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void draw() {
//para
ir pasando de un estado a otro
switch(estado){
case 0:
listaDispositivos("BUSCANDO DISPOSITIVOS", color(255, 0, 0));
break;
case 1:
listaDispositivos("DISPOSITIVOS DISPONIBLES", color(51, 181, 229));
break;
case 2:
conectaDispositivo();
break;
case 3:
//dibujar el fondo
background(0);
strokeWeight(1);
fill(31,91,76);
stroke(92,214,166);
ellipse(width/2,height/2,(float)(0.98*height),(float) (0.98*height));
noFill();
for (i = 1; i*50 < l/2; i++){
ellipse(width/2,height/2,100*i,100*i);
}
muestraDatos();
//mostrar los resultados por pantalla
break;
case 4:
muestraError();
break;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onCreate(Bundle bundle) {
//funcin para evitar
que se apague la pantalla
super.onCreate(bundle);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onStart(){
//funcin que se ejecuta al iniciarse la aplicacin
super.onStart();
//incluirlo siempre al princpio de onStart
bttelefono = BluetoothAdapter.getDefaultAdapter();
//detectar como est el bluetooth
if (bttelefono != null){
//si el
telfono no dispone de bluetooth devolver null
if (!bttelefono.isEnabLED()){
//si el
bluetooth no est activado, se activa. Permisos
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
//de
bluetooth
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
else{
empieza();
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onStop(){
//funcin para finalizar la aplicacin
if(socket != null){
//si
todava no se ha cortado la comunicacin se intenta
Pgina 218 de 231
J. L. Prez Motos
try{
//cerrar el medio de comunicacin
socket.close();
}
catch(IOException ex){
println(ex);
}
}
super.onStop();
//incluirlo siempre al final del onStop
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onActivityResult (int requestCode, int resultCode, Intent data){
//se obtiene el
resultado de una operacin
if(resultCode == RESULT_OK){
//con resultCode se obtiene si la operacin
empieza();
//ha sido exitosa o no
}
else{
estado = 4;
error = "No se ha activado el bluetooth";
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void mouseReleased(){
//funcin que se llama cada vez que se toca la
pantalla
switch(estado){
case 0:
break;
case 1:
compruebaEleccion();
break;
case 3:
onResume();
break;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void empieza(){
//aade los diferentes dispositivos a la matriz
de dispositivos disponibles
}
estado = 1;
//pasar a la pantalla de
elegir dispositivos -> listaDispositivos
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void listaDispositivos(String texto, int c){
//funcin para mostrar en pantalla los
dispositivos
background(0);
fill(c);
textSize(height/15);
text(texto,width/2, 30);
if(dispositivos != null){
for(int indice = 0; indice < dispositivos.size(); indice++){
BluetoothDevice dispositivo = (BluetoothDevice) dispositivos.get(indice);
fill(0,255,255);
int posicion = height/6 * (1 + indice);
if(dispositivo.getName() != null){
text(dispositivo.getName(),width/2, posicion); //nombre del dispositivo
}
fill(92, 214, 166);
Pgina 219 de 231
J. L. Prez Motos
text(dispositivo.getAddress(),width/2, posicion + height/16);

//direccin mac del
dispositivo
fill(255);
line(width/4, posicion + height/12, width*3/4, posicion + height/12);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void compruebaEleccion(){
int elegido = (mouseY - 50) / 55;
if(elegido < dispositivos.size()){
dispositivo = (BluetoothDevice) dispositivos.get(elegido);
println(dispositivo.getName());
estado = 2;
//ir a conectaDispositivo
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void conectaDispositivo(){
//sirve para conectar el telfono con el dipositivo.
Cuidado con el UUID. Los nmeros
try{
//ah puestos son para el
bluetooth, pero se han tenido que cambiar los primeros (puerto serie)
int.class });
socket.connect();
ins = socket.getInputStream(); //por aqu se recibirn datos del robot en el mvil
ons = socket.getOutputStream(); //por aqu se enviarn datos del mvil al robot
estado = 3;
//ir a muestraDatos
}
catch(Exception ex){
estado = 4;
error = ex.toString();
println(error);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void muestraDatos(){
//funcin donde se realizarn las principales
operaciones y se mostrarn por
//pantalla los resultados
//mandar datos del acelerometro
ax = (ant[1] + acc_values[1]) / 2;
ay = (ant[0] + acc_values[0]) / 2;
giro = (byte) (ax + 10);
//el +10 es para evitar que sea negativo
ant[1] = acc_values[1];
//se almacena el valor del acelermetro para
calcular la media
vel = (byte) (ay + 10);
ant[0] = acc_values[0];
calcular la media
//se almacena el valor del acelermetro para
valor[1]=vel;
valor[0]=giro;
//dibujar el circulo
strokeWeight(2);
stroke(2,52,77);
fill(0,255/* - 180 / 15 * sqrt(ax*ax+ay*ay)*/,255/* - 180 / 15 * sqrt(ax*ax+ay*ay)*/,10 +
sqrt(ax*ax+ay*ay)*245/15);
ellipse(constrain(map(ax, -10, 10, width/2-l/2+width/40, width/2+l/2-width/40), width/2l/2+width/20, width/2+l/2-width/20),
constrain(map(ay, -10, 10, height/2-l/2+width/40, height/2+l/2-width/40),
height/2-l/2+width/20, height/2+l/2-width/20),
width/20, width/20);
//enviar datos al robot desde el telfono*/
try{
ons.write(valor,0,valor.length); //(variable,bites vacos,longitud)
Pgina 220 de 231

ons.flush();
desean
}
estado = 4;
println(error);
}
//recibir datos del robot en el telfono
try{
}
}
estado = 4;
println(error);
}
pwmA.valor
pwmA.signo
pwmB.valor
pwmB.signo
=
=
=
=
J. L. Prez Motos
//evitar que se enven datos que no se
//(variable,desde donde,longitud)
ardu[0] + 128;
ardu[1];
ardu[2] + 128;
ardu[3];
//pwmA.dibuja();
//pwmB.dibuja();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onResume() {
//funcin que sirve para volver a retomar una actividad,
en este caso el acelermetro
super.onResume();
//incluir siempre al principio del
onResume
//se define el SensorManager (te permite acceder al sensor)
mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
//se define un SensorEventListener (recibe la informacin del sensor cuando este vara. Lega
desde el SensorManager)
accSensorEventListener = new MySensorEventListener();
//se coge el sensor tipo acelermetro
acc_sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
//se guarda el SensorEventListener junto con su sensor y su Sensor Manager. Ajustar el delay
segn las necesidades
mSensorManager.registerListener(accSensorEventListener, acc_sensor,
SensorManager.SENSOR_DELAY_GAME);
} //tipos de delay en orden ascendente: SENSOR_DELAY_FASTEST; SENSOR_DELAY_GAME;
SENSOR_DELAY_NORMAL; SENSOR_DELAY_UI
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onPause() {
//desvincular el SensorEventListener antes de salir
mSensorManager.unregisterListener(accSensorEventListener);
super.onPause();
//incluir siempre al final del onPause
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void muestraError() {
//funcin para mostrar errores. Se
mostrar el error en el centro de la pantalla
//con fondo rojo
background(255, 0, 0);
fill(255, 255, 0);
textAlign(CENTER);
translate(width / 2, height / 2);
textSize(16);
text(error, 0, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
//class del sensor
class MySensorEventListener implements SensorEventListener {
public void onSensorChanged(SensorEvent event) {
Pgina 221 de 231
J. L. Prez Motos
int eventType = event.sensor.getType();

if(eventType == Sensor.TYPE_ACCELEROMETER) {
acc_values = event.values;
}
}
public void onAccuracyChanged(Sensor sensor, int accuracy) {
//el sdk dice que hay que incluirlo, pero solo si vara la precisin
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
class BarraInfo {
float inicio; // primer valor del rango
float fin; // ltimo valor del rango
int x; // posicin x del conjunto
int y; // posicin y del conjunto
int anchura; // anchura de las muescas y de la barra
int altura; // altura del conjunto
int pasoLinea; // cada cuantos pxeles se dibuja una muesca
int pasoNumero; // cada cuantos pxeles se dibuja un valor de referencia del rango
int recorteX; // ajuste de la posicin X del texto de los valores de referencia
int recorteY; // ajuste de la posicin Y del texto de los valores de referencia
int digitos; // Nmero de digitos que aparecern en el texto de los valores de referencia
int decimales; // Nmero de decimales que aparecern en el texto de los valores de referencia
byte signo;
String etiqueta;
int valor; // Valor real
BarraInfo() {
valor = 0;
}
void dibuja() {
int indice;
int longitud;
textAlign(LEFT, CENTER);
stroke(92,214,166);
fill(92,214,166);
text(nfs(map(y, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y + recorteY
- pasoLinea);
text(nfs(map(y + altura, y, y + altura, fin, inicio), digitos, decimales), x - recorteX, y +
altura + recorteY - pasoLinea);
for(indice = y; indice <= y + altura; indice++) {
if(indice % pasoLinea == 0) {
line(x, indice, x + anchura, indice);
}
if(indice % pasoNumero == 0) {
text(nfs(map(indice, y, y + altura, fin, inicio), digitos, decimales), x - recorteX,
indice + recorteY - pasoLinea);
}
}
if (signo == 1){
stroke(31,91,76);
fill(92,214,166);
}
else if (signo == 2){
stroke(91,31,31);
fill(255,155,155);
}
longitud = (int) (map(valor, inicio, fin, 0, altura));
rect(x + anchura * 2, y + altura - longitud, anchura, longitud);
textAlign(CENTER,CENTER);
fill(92,214,166);
text(etiqueta, x + anchura / 2, (float) (0.5 * y));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public int sketchWidth() { return displayWidth; }
public int sketchHeight() { return displayHeight; }
public String sketchRenderer() { return JAVA2D; }
Pgina 222 de 231
J. L. Prez Motos
ANEXO A.14: TELEMETRA

package processing.test.mandar_datos;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
processing.core.*;
android.bluetooth.BluetoothAdapter;
android.bluetooth.BluetoothDevice;
android.bluetooth.BluetoothSocket;
android.content.BroadcastReceiver;
android.content.Context;
android.content.Intent;
java.util.ArrayList;
java.util.UUID;
java.io.IOException;
java.io.InputStream;
java.io.OutputStream;
java.lang.reflect.Method;
android.os.Bundle;
android.view.WindowManager;
public class mandar_datos extends PApplet {

//fuentes
String[] fontList;
PFont androidFont;
//variables de la comunicacin bluetooth
private static final int REQUEST_ENABLE_BT = 3;
ArrayList<BluetoothDevice> dispositivos; //matriz con los dispositivos encontrados por el
telfono
BluetoothAdapter bttelefono;
//representa el bluetooth del telfono
BluetoothDevice dispositivo;
//representa el bluetooth de los
dispositivos ajenos al telfono
BluetoothSocket socket;
//establece la conexin entre
telfono y robot
InputStream ins;
//variable para recibir datos
del robot (byte)
OutputStream ons;
//variable para enviar
datos al robot (byte)
//variables del men
int estado;
String error;
//variables para el clculo de valor
byte[] ardu = {0,0,0,0,0};
int[] pwmA;
int[] pwmB;
int[] posicion;
int i;
//valor recibido por el robot

//pwm del motor A
//pwm del motor B
//posicion del robot
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
//un BroadcastReceiver sirve
BroadcastReceiver receptor = new BroadcastReceiver(){
para recibir eventos
public void onReceive(Context context, Intent intent){
String accion = intent.getAction();
//recibe el
evento que se enva a la aplicacin
if (BluetoothDevice.ACTION_FOUND.equals(accion)){
//la accin es que ha encontrado
un dispositivo bluetooth
BluetoothDevice dispositivo =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
println(dispositivo.getName() + " " + dispositivo.getAddress());
}
Pgina 223 de 231
J. L. Prez Motos
else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(accion)){
est buscando disopositivos
estado = 0;
}
else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(accion)){
terminado de buscar
estado = 1;
}
//el telfono
//el telfono ha
}
};
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void setup() {
size(displayWidth, displayHeight, JAVA2D);
//se obtienen las medidas de la
pantalla y se define que solo habrn
//objetos en 2D
frameRate(25);
//refresco de pantalla
//para que la pantalla est girada
orientation(LANDSCAPE);
//si queremos que la posicin de la pantalla sea vertical:
//orientation(PORTRAIT);
//fuentes
fontList = PFont.list();
androidFont = createFont(fontList[0], 32, true);
stroke(255);
//definicin del tamao de la matriz a rellenar
pwmA = new int[width];
pwmB = new int[width];
posicion = new int[width];
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void draw() {
//para
ir pasando de un estado a otro
switch(estado){
case 0:
listaDispositivos("BUSCANDO DISPOSITIVOS", color(255, 0, 0));
break;
case 1:
listaDispositivos("DISPOSITIVOS DISPONIBLES", color(51, 181, 229));
break;
case 2:
conectaDispositivo();
break;
case 3:
//dibujar el fondo
background(0);
strokeWeight(1);
fill(31,91,76);
stroke(92,214,166);
rectMode(CORNERS);
rect(0,(float) (0.01*height),width,(float) (0.33*height));
textAlign(CENTER, CENTER);
fill(253,254,31);
stroke(253,254,31);
text("Motor izquierdo",width/2,(float) (height*0.03));
text("Motor derecho",width/2,(float) (height*0.36));
text("Lnea",width/2,(float) (height*0.69));
textAlign(LEFT, CENTER);
text("255",(float) (0.01*width),(float) (0.03*height));
Pgina 224 de 231
J. L. Prez Motos
text("-255",(float) (0.01*width),(float) (0.31*height));

text("-255",(float) (0.01*width),(float) (0.64*height));
line(0,(float) (0.17*height),width,(float) (0.17*height));
fill(92,214,166);
stroke(92,214,166);
muestraDatos();
//mostrar los resultados por pantalla
break;
case 4:
muestraError();
break;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onStart(){
//funcin que se ejecuta al iniciarse la aplicacin
super.onStart();
//incluirlo siempre al princpio de onStart
bttelefono = BluetoothAdapter.getDefaultAdapter();
//detectar como est el bluetooth
if (bttelefono != null){
//si el
telfono no dispone de bluetooth devolver null
//si el
if (!bttelefono.isEnabLED()){
bluetooth no est activado, se activa. Permisos
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
//de
bluetooth
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
else{
empieza();
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onCreate(Bundle bundle) {
//funcin para evitar
que se apague la pantalla
super.onCreate(bundle);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onStop(){
//funcin para finalizar la aplicacin
if(socket != null){
//si
todava no se ha cortado la comunicacin se intenta
try{
//cerrar el medio de comunicacin
socket.close();
}
catch(IOException ex){
println(ex);
}
}
super.onStop();
//incluirlo siempre al final del onStop
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void onActivityResult (int requestCode, int resultCode, Intent data){
//se obtiene el
resultado de una operacin
Pgina 225 de 231
J. L. Prez Motos
if(resultCode == RESULT_OK){
//con resultCode se obtiene si la operacin
empieza();
//ha sido exitosa o no
}
else{
estado = 4;
error = "No se ha activado el bluetooth";
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void mouseReleased(){
//funcin que se llama cada vez que se toca la
pantalla
switch(estado){
case 0:
break;
case 1:
compruebaEleccion();
break;
case 3:
onResume();
break;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void empieza(){
//aade los diferentes dispositivos a la matriz
de dispositivos disponibles
}
estado = 1;
//pasar a la pantalla de
elegir dispositivos -> listaDispositivos
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void listaDispositivos(String texto, int c){
//funcin para mostrar en pantalla los
dispositivos
background(0);
textAlign(CENTER,CENTER);
fill(c);
text(texto,width/2, 30);
if(dispositivos != null){
for(int indice = 0; indice < dispositivos.size(); indice++){
BluetoothDevice dispositivo = (BluetoothDevice) dispositivos.get(indice);
fill(0,255,255);
int posicion = height/6 * (1 + indice);
if(dispositivo.getName() != null){
text(dispositivo.getName(),width/2, posicion); //nombre del dispositivo
}
fill(92, 214, 166);
text(dispositivo.getAddress(),width/2, posicion + height/16);
//direccin mac
del dispositivo
fill(255);
line(width/4, posicion + height/12, width*3/4, posicion + height/12);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void compruebaEleccion(){
int elegido = (mouseY - 50) / 55;
if(elegido < dispositivos.size()){
dispositivo = (BluetoothDevice) dispositivos.get(elegido);
println(dispositivo.getName());
estado = 2;
//ir a conectaDispositivo
Pgina 226 de 231
J. L. Prez Motos
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void conectaDispositivo(){
//sirve para conectar el telfono con el dipositivo.
Cuidado con el UUID. Los nmeros
try{
//ah puestos son para el
bluetooth, pero se han tenido que cambiar los primeros (puerto serie)
int.class });
socket.connect();
ins = socket.getInputStream(); //por aqu se recibirn datos del robot en el mvil
ons = socket.getOutputStream(); //por aqu se enviarn datos del mvil al robot
estado = 3;
//ir a muestraDatos
}
estado = 4;
println(error);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void muestraDatos(){
//funcin donde se realizarn las principales
operaciones y se mostrarn por
//pantalla los resultados
try{
telfono
}
}
estado = 4;
println(error);
}
//recibir datos del robot en el
for (i=1;i<width;i++){
pwmA[i-1]=pwmA[i];
pwmB[i-1]=pwmB[i];
posicion[i-1]=posicion[i];
}
//Aadir valores
if (ardu[1]==1){
pwmA[i-1]=ardu[0]+128;
}
pwmA[i-1]=-1*(ardu[0]+128);
}
if (ardu[3]==1){
pwmB[i-1]=ardu[2]+128;
}
pwmB[i-1]=-1*(ardu[2]+128);
}
posicion[i-1]=ardu[4];
for (i=1;i<width;i++){
point(i,map(pwmA[i],-255,255,(float)(0.33*height),(float)(0.01*height)));
line(i,map(pwmA[i],-255,255,(float)(0.33*height),(float)(0.01*height)),i,map(pwmA[i1],-255,255,(float)(0.33*height),(float)(0.01*height)));
point(i,map(pwmB[i],-255,255,(float)(0.66*height),(float)(0.34*height)));
line(i,map(pwmB[i],-255,255,(float)(0.66*height),(float)(0.34*height)),i,map(pwmB[i1],-255,255,(float)(0.66*height),(float)(0.34*height)));
point(i,map(posicion[i],0,50,(float)(0.99*height),(float)(0.67*height)));
Pgina 227 de 231
J. L. Prez Motos
line(i,map(posicion[i],0,50,(float)(0.99*height),(float)(0.67*height)),i,map(posicion[i1],0,50,(float)(0.99*height),(float)(0.67*height)));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public void muestraError()
//funcin para mostrar errores. Se
mostrar el error en el centro de la pantalla
{
//con fondo rojo
background(255, 0, 0);
fill(255, 255, 0);
textAlign(CENTER);
translate(width / 2, height / 2);
textSize(16);
text(error, 0, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
public int sketchWidth() { return displayWidth; }
public int sketchHeight() { return displayHeight; }
public String sketchRenderer() { return JAVA2D; }
}
Pgina 228 de 231
J. L. Prez Motos
ANEXO B: PLANOS
ANEXO B.1: DISEO DEL PCB

ANEXO B.2: ESQUEMA ELCTRICO DEL ROBOT
Pgina 229 de 231
76
58
de Navarra
Nafarroako
Unibertsitate Publikoa
E.T.S.I.I.T.
INGENIERO
INDUSTRIAL
PROYECTO:
ROBOT RASTREADOR CON INTERFAZ

BLUETOOTH/ANDROID
PLANO:
DEPARTAMENTO:
DEPARTAMENTO DE
INGENIERIA ELECTRICA
Y ELECTRONICA
REALIZADO:
PEREZ MOTOS, JOSE LUIS

FIRMA:
FECHA:
18/2/2013
ESCALA:
2:1
de Navarra
Nafarroako
Unibertsitate Publikoa
E.T.S.I.I.T.
INGENIERO
INDUSTRIAL
PROYECTO:
ROBOT RASTREADOR CON INTERFAZ

BLUETOOTH/ANDROID
PLANO:
DEPARTAMENTO:
DEPARTAMENTO DE
INGENIERIA ELECTRICA
Y ELECTRONICA
REALIZADO:
PEREZ MOTOS, JOSE LUIS

FIRMA:
FECHA:
18/2/2013
ESCALA:

Guia Seguidor de Linea

Cargado por

Copyright:

Formatos disponibles

Guia Seguidor de Linea

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia Seguidor de Linea

Cargado por

Copyright:

Formatos disponibles

ESCUELA TCNICA SUPERIOR DE INGENIEROS

Ttulo del proyecto:

DISEO Y CONSTRUCCIN DE UN ROBOT SIGUE

Jos Luis Prez Motos

Introduccin y objetivos ......................................................................... 19

Robot sigue lneas................................................................................... 21

Reglamento robots rastreadores ..................................................................... 24

Requisitos del robot ................................................................................ 24

Pruebas de rastreador .............................................................................. 26

Robot seguidor de lneas de la upna ....................................................... 27

Robots rastreadores para usos domsticos e industriales............................... 34

Robot transporta medicamentos ............................................................. 36

Eleccin de componentes ....................................................................... 38

Partes de una placa arduino .................................................................... 41

Lenguaje de programacin ..................................................................... 43

Modelos de Arduino ............................................................................... 46

Eleccin del microcontrolador ............................................................... 49

Configuracin de ruedas ......................................................................... 51

Modelos de ruedas .................................................................................. 54

Motores paso a paso ............................................................................... 57

Motores de corriente continua ................................................................ 59

Clculo de la velocidad .......................................................................... 60

Actuador electrnico ...................................................................................... 62

Pruebas L6205N ..................................................................................... 72

Sensores infrarrojos ....................................................................................... 76

Pruebas QTR-8RC .................................................................................. 80

Estudio de los componentes ................................................................... 88

Eleccin: pilas frente a bateras LiPo ..................................................... 89

Aspectos generales ......................................................................................... 93

Arduino Pro Mini ........................................................................................... 96

Programador y bluetooth ............................................................................... 98

L6205N y motores ......................................................................................... 99

Bola loca, QTR-8RC y pila.......................................................................... 101

Resultado final ............................................................................................. 102

Construccin del robot ......................................................................... 111

Pruebas de los componentes del robot.................................................. 117

Sensores infrarrojos ..................................................................................... 118

Motores ........................................................................................................ 119

Bluetooth ...................................................................................................... 121

Conexin robot - ordenador.................................................................. 122

Conexin robot mvil android........................................................... 126

Sigue lneas ........................................................................................... 129

Declaracin de variables .............................................................................. 130

Asignacin de pines .............................................................................. 130

Variables de los sensores infrarrojos .................................................... 130

Parmetros del PID ............................................................................... 130

Variables para el clculo de la posicin ............................................... 131

Variables para el movimiento de los motores ...................................... 131

Otras variables ...................................................................................... 131

Configuracin del robot ............................................................................... 132

Calibracin de los sensores infrarrojos ........................................................ 132

Seguimiento de la lnea ................................................................................ 134

PID ............................................................................................................... 137

Qu es un controlador PID? ................................................................ 138

Segundo mtodo de ziegler-nichols...................................................... 144

Obtencin de los parmetros PID del robot ......................................... 145

Comparativa de parmetros .................................................................. 150

Salida del trazado ......................................................................................... 155

Control remoto del robot ...................................................................... 156

Aplicacin Android...................................................................................... 157