trabajo fin de grado sistema de navegaciÓn autÓnoma de...

Escu

ela

Polit

écn

ica S

up

eri

or

de J

aé

n

UNIVERSIDAD DE JAÉN

Escuela Politécnica Superior de Jaén

Trabajo Fin de Grado

Trabajo Fin de Grado SISTEMA DE

NAVEGACIÓN

AUTÓNOMA DE ROBOT

HEXÁPODO

Alumno: José Antonio Guirado Cárdenas

Tutora: Prof. Dña. Silvia María Satorres Martínez

Dpto: Ingeniería Electrónica y Automática

Universidad de Jaén

Escuela Politécnica Superior de Jaén

Departamento de Ingeniería Electrónica y Automática.

Doña Silvia María Satorres Martínez, tutora del Proyecto Fin de Carrera titulado:

Navegación Autónoma de Robot Hexápodo, que presenta José Antonio Guirado

Cárdenas, autoriza su presentación para defensa y evaluación en la Escuela

Politécnica Superior de Jaén.

Jaén, Octubre de 2018

El alumno: La tutora:

JOSE A. GUIRADO CÁRDENAS SILVIA M. SATORRES MARTÍNEZ

I

RESUMEN

El presente trabajo de fin de grado se centra en elaborar un sistema de

navegación autónoma para un robot hexápodo, con el fin de interacturar y desplazarse

por entornos parcialmente estructurados.

Para llevarlo a cabo se elaborará, mediante el software Python, dos modos de

navegación autónoma, los cuales trabajan en tiempo real. Además, la comunicación

entre el sistema de navegación y el robot hexápodo se hará a traves del puerto serie.

De esta forma se pretende crear una plataforma sólida para futuros proyectos

de la escuela en el ámbito de la robótica.

ABSTRACT

This project focused on intengrating an autonomous navegation system for a

hexapod robot, in order to move and interact in a partially structured available

enviroment.

To carry out, will be done with Python two modes of autonomous navigation,

both in real time. Besides, the comunication between navegation system and hexapod

robot, wil be done through serial port.

This way, it want to create a solid platform for futures projects of the university

of Jaén in the robotic of area.

III

Índice

1. Introducción. ................................................................................................................... 1

1.1. Justificación ............................................................................................................ 1

1.2. Objetivo. .................................................................................................................. 2

1.3. Metodología. ........................................................................................................... 3

1.4. Estructura de la memoria. ....................................................................................... 4

2. Estado del Arte. .............................................................................................................. 5

2.1. Navegación en robots móviles. ............................................................................... 5

2.2. Navegación Reactiva. ............................................................................................. 6

2.2.1. Antecedentes Históricos de la Navegación Reactiva. ....................................... 6

2.3. Navegación autónoma basada en visión. ...............................................................10

3. Hardware y Software empleados. ..................................................................................12

3.1. Hardware. ..............................................................................................................12

3.1.1. Raspberry Pi. ..................................................................................................12

3.1.2. Raspberry Pi Camera V2. ...............................................................................16

3.1.3. Tarjeta MicroSD. .............................................................................................17

3.2. Software. ................................................................................................................18

3.2.1. Raspbian. ........................................................................................................18

3.2.2. Python. ............................................................................................................19

3.2.3. OpenCV. .........................................................................................................19

4. Adquisición y procesado de la imagen. .........................................................................21

4.1. Adquisición de imagen. ..........................................................................................21

4.1.1. Sistema de iluminación. ..................................................................................21

4.1.2. Cámara. ..........................................................................................................22

4.2. Procesamiento de la imagen. .................................................................................23

4.2.1. Nivel de brillo de la imagen. ............................................................................23

4.2.2. Segmentación de la imagen. ...............................................................................25

5. Implementación de la aplicación. ...................................................................................27

5.1. Seguimiento de pelota de tenis. .............................................................................27

5.2. Seguimiento de línea. .............................................................................................30

6. Resultados ....................................................................................................................33

6.1. Resultados obtenidos con el programa “Seguimiento de Pelota”............................34

6.2. Resultados obtenidos con el programa “Seguimiento de Línea”. ............................41

IV

7. Presupuesto. .................................................................................................................45

7.1. Coste de recursos humanos. ..................................................................................45

7.2. Coste de recursos materiales. ................................................................................45

8. Conclusiones. ................................................................................................................48

8.1. Posibles mejoras. ...................................................................................................49

9. Anexos. .........................................................................................................................50

9.1. Instalación de Raspbian. ........................................................................................50

9.2. Configuración inicial. ..............................................................................................53

9.3. Instalación de la Cámara de Raspberry Pi (PiCam)................................................55

9.4. Instalación de la librería OpenCV. ..........................................................................57

Bibliografía ...........................................................................................................................61

V

Índice de figuras.

Figura 2.1: Imagen de las “tortugas” robóticas Elsie y Elmer. ................................................ 7

Figura 2.2: Imagen de robot EV3. .......................................................................................... 8

Figura 2.3: Imagen de robot Roomba y ejemplo de trayectoria. ............................................. 9

Figura 3.1: Imagen Global Rpi más los puertos GPIO de la misma. .....................................15

Figura 3.2: Módulo Raspberry Pi Camera V2. ......................................................................16

Figura 3.3: Tarjeta MicroSD de 32GB. ..................................................................................17

Figura 4.1: Esquema sistema de adquisición. ......................................................................22

Figura 4.2: Imagen Real. ......................................................................................................24

Figura 4.3: Imagen Modificada. ............................................................................................24

Figura 4.4: Detección de contornos de la pelota de tenis. ....................................................25

Figura 5.1: Flujograma del programa Seguimiento de Pelota de Tenis. ................................27

Figura 5.2: Distribución del cuadrante de la imagen. ............................................................29

Figura 5.3: Flujograma del programa Seguidor de Línea. .....................................................30

Figura 5.4: Captura PiCam Seguimiento de Línea (línea recta). ...........................................31

Figura 5.5: Esquema donde se muestra el sentido de giro del robot. ...................................32

Figura 6.1: Interfaz principal de la aplicación. .......................................................................33

Figura 6.2.: Imagen del ángulo de la cámara respecto de la posición de origen (30°). .........34

Figura 6.3: Captura PiCam modo HSV. ................................................................................35

Figura 6.4: Captura PiCam con la detección de pelota en el sector izquierdo. .....................36

Figura 6.5: Captura PiCam con la detección de pelota en el sector izquierdo y con mano. ..37

Figura 6.6: Captura PiCam donde se detecta obstáculo. ......................................................38

Figura 6.7: Captura PiCam donde no se detecta pelota. ......................................................39

Figura 6.8: Captura PiCam donde no se detecta pelota por estar muy próxima. ..................40

Figura 6.9: Imagen del circuito de prueba.............................................................................41

Figura 6.10: Imagen del ángulo de la cámara respecto de la posición de origen (90°). ........41

Figura 6.11: Capturas PiCam Seguimiento de Línea (línea recta). .......................................42

Figura 6.12: Captura PiCam Seguimiento de Línea (giro a izquierdas) ................................43

Figura 6.13: Captura PiCam Seguimiento de Línea (sin detección de camino). ...................43

Figura 6.14: Captura PiCam Seguimiento de Línea (detección obstáculo). ..........................44

Figura 9.1: Opciones de instalación de Raspbian. ................................................................50

Figura 9.2: Captura de SD Card Formatter. ..........................................................................51

Figura 9.3: Menú de Instalación. ..........................................................................................51

Figura 9.4: Imagen de inicio de Raspberry. ..........................................................................52

Figura 9.5: Escritorio de Raspberry. .....................................................................................53

VI

Figura 9.6: Configuración de Raspberry. ..............................................................................54

Figura 9.7: Conector SCI. .....................................................................................................55

Figura 9.8: Comandos para actualizar el software de Raspbian actual. ................................56

Figura 9.9: Comando para instalar librería de la PiCam en python. ......................................56

Figura 9.10: Código de ejemplo. ...........................................................................................56

Figura 9.11: Imagen obenida del ejemplo. ............................................................................57

VII

Índice de Tablas.

Tabla 3.1: Tabla comparativa para poder apreciar en una imagen las diferencias reseñables

de los modelos de Raspberry Pi. ..........................................................................................13

Tabla 3.2: Comparación de las dos RPi modelo 3. ...............................................................14

Tabla 3.3 Características del módulo de cámara V2 para RPi. .............................................17

Tabla 7.1: Coste total de los recursos humanos del proyecto. ..............................................45

Tabla 7.2: Coste unitario de algunos recursos materiales. ...................................................46

Tabla 7.3: Coste total de los recursos materiales del proyecto. ............................................46

Tabla 7.4: Coste total del proyecto. ......................................................................................47

José Antonio Guirado Cárdenas Navegación Autónoma de Robot Hexápodo

1 Escuela Politécnica Superior de Jaén

1. Introducción.

El siguiente proyecto corresponde a la asignatura Trabajo de Fin de Grado

(TFG) de cuarto curso de Ingeniería Electrónica Industrial de la Universidad de Jaén.

Este proyecto consiste en elaborar un sistema de navegación autónoma para un robot

hexápodo.

El presente TFG sirve de complemento al TFG “Control de Robot Hexápodo”

del alumno Miguel Gómez Díaz, que se centra en el montaje y control a bajo nivel de

un robot hexápodo. Con este se pretende dotar al robot de funcionalidades tales como

la navegación en entornos parcialmente estructurado con y sin la presencia de

obstáculos en los mismos.

1.1. Justificación

Actualmente son varias las actividades realizadas por la Escuela Politécnica

Superior de Jaén para que se conozcan de primera mano todos los proyectos

desarrollados o que se encuentran en etapa de desarrollo por lo que se organizan

jornadas de puertas abiertas y talleres bajo el nombre de “Conoce la Ingeniería” para

que, de esta forma, las personas ajenas a la escuela la conozcan de una forma más

cercana.

Debido a esto surge el desarrollo de los dos trabajos de fin de grado que

anteriormente se ha indicado que están estrechamente relacionados, como son

“Control de Robot Hexápodo” y “Navegación Autónoma de Robot Hexápodo”. Ambos

son creados con la finalidad de ser mostrados en estas jornadas de puertas abiertas

y talleres, ya que se le dotará al robot de distintas funcionalidades que pondrán de

manifiesto algunas de las competencias que han sido adquiridas por los autores de

los trabajos de fin de grado a lo largo de la titulación que hayan realizado.



1.2. Objetivo.

Como se ha indicado anteriormente, este proyecto solo va a tratar el bloque de

navegación autónoma del robot haciendo uso de visión por computador. Para ello se

va a implementar una herramienta low-cost que nos proporcione varios modos de

movimiento automático por medio de la implementación de distintos algoritmos como

se verá más adelante.

Por lo tanto, el objetivo de este proyecto es, que a partir de la herramienta

elaborada por visión por computador permita al robot una cierta autonomía de

movimientos ante escenarios parcialmente estructurados para él.

El alcance del proyecto según lo expuesto en el párrafo anterior va a constar

de dos modos de navegación, los cuales van a tener algunas restricciones:

• Seguimiento de la pelota de tenis: Este algoritmo va a proceder a que el robot

sea capaz de seguir el movimiento de una pelota de tenis siempre que se

encuentre en el rango de operación como se verá en el capítulo de

conclusiones. También este algoritmo será capaz de detectar y esquivar

obstáculos de color rojo y azul. Para que estos sean considerados como

obstáculos deben de ocultar total o parcialmente a la pelota de tenis. En el caso

de que sea parcialmente, el área del obstáculo debe de ser similar o mayor que

la de la pelota de tenis a detectar.

• Seguidor de línea: Este script está preparado para el seguimiento de líneas de

color negro sobre un fondo blanco, cualquier objeto que corte el camino a seguir

por la el robot es tomado como un obstáculo, independientemente del tamaño

o color que tenga. Uno de los inconvenientes es que el objeto a detectar no

puede sobrepasar una altura superior a la distancia entre el suelo y la cámara.



1.3. Metodología.

Para realizar esta herramienta se ha desarrollado, durante 11 semanas (30

Julio 2018 – 8 Octubre 2018), una interfaz a través de Python (Python 3.5) la cual

muestra dos opciones para poder indicarle al robot el modo de funcionamiento.

Para la realización de la GUI en Python y, sobre todo, a la hora de elaborar

cada uno de los scripts se han realizado los siguientes puntos:

• Adquisición de la imagen: Ha sido necesario hacer una pequeña inicialización

de los parámetros de nuestra cámara cada vez que esta es iniciada en cada

uno de los diferentes modos de operación. Además, en algunos de ellos

también será necesario controlar un servomotor para cambiar la orientación del

sistema de visión.

• Segmentación de la imagen: Una vez adquirida la imagen, es necesario tratarla

para su posterior evaluación, ya sea pasando la imagen a formato binario,

detectar colores en formato HSV o realizar operaciones de erosión y dilatación.

• Métodos de extracción de características: Se ha analizado la imagen de

entrada y se ha buscado las cualidades necesarias para desarrollar el

algoritmo, por ejemplo, detectar un color o una forma en concreta para que el

sistema sea capaz de seguir un camino u objeto, o para evitar los obstáculos

que puedan aparecer en la escena.

• Métodos de clasificación de características: Los algoritmos deben ser capaces

de detectar los contornos conocidos, los cuales resultaran aptos para el

seguimiento por parte del sistema de visión. En el caso de que se encuentre

alguna irregularidad, el sistema, debe de ser capaz de distinguir entre un

obstáculo o simple ruido en la adquisición de la imagen.



1.4. Estructura de la memoria.

La estructura del presente proyecto va a estar formada por nueve capítulos, los

cuales se detallan a continuación:

• En el capítulo 1 se realiza una introducción del TFG donde se expone la

justificación de por qué se realiza, también se indican los objetivos a alcanzar

con este TFG; además, se indica la metodología empleada para alcanzar esos

objetivos indicados en el apartado anterior y, finalmente, se da una descripción

de cómo va a ser la estructura de la memoria de este TFG.

• En el capítulo 2 se describe el estado del arte, en cuanto al tema abordado con

este proyecto, donde se expondrá como otros autores han abordado la

problemática de los sistemas navegación autónoma a partir de la visión

artificial.

• En el capítulo 3 se describen los componentes hardware y software necesarios

para llevar a cabo este trabajo de fin de grado.

• En el capítulo 4 se hace referencia a los elementos necesarios en un sistema

de adquisición de la imagen, así como a los métodos de procesamiento de la

imagen que se han empleado en la realización de este TFG.

• En el capítulo 5 se describe la interfaz gráfica, así como los diferentes modos

de operación que tiene la misma.

• En el capítulo 6 se muestran los resultados obtenidos de los diferentes scripts

que componen la interfaz.

• En el capítulo 7 se realiza un estudio económico del proyecto, englobando todo

lo necesario para poder llevarlo a cabo.

• En el capítulo 8 se muestran las conclusiones obtenidas de la ejecución de este

proyecto, así como, líneas de mejora que se pueden aplicar para actualizar el

robot en un futuro si, esto, fuera necesario.

• En el capítulo 9 se incluyen los anexos utilizados en el TFG, donde se recoge

un breve manual de como instalar Raspbian, la instalación de las librerías para

la cámara de las Raspberry Pi; así como, la librería OpenCV ,que tiene un peso

importante (en cuanto a software se refiere), en este trabajo fin de grado.



2. Estado del Arte.

A lo largo de esta sección se quiere dar una visión más específica de los temas

tratados en el desarrollo de este trabajo de fin de grado, así como, una indicación de

la solución adoptada. En primer lugar, se pretende dar una explicación breve sobre la

navegación en robots móviles y algunos ejemplos; además, de las diferentes opciones

existentes de navegación autónoma basada en visión.

2.1. Navegación en robots móviles.

La navegación autónoma puede definirse “como la capacidad de un vehículo

(robot) para desplazarse de una manera automática desde una posición inicial a otra

final”. Desde la perspectiva humana, se cree que la navegación autónoma de los

robots se fundamenta en la realización de un mapa que debe de seguir el robot desde

un punto inicial a otro final. Sin embargo, es posible que los robots realicen dicha tarea

sin la necesidad de poseer de antemano un mapa descriptivo del entorno o elaborarlo

a medida que el dispositivo se va desplazando, ya que existe la alternativa de la

navegación reactiva y cómo el robot es capaz de reaccionar directamente con él

entorno para llevar a cabo el movimiento del mismo.

A continuación, se va a proceder a explicar que se entiende por navegación

reactiva y algunos de sus casos de uso.



2.2. Navegación Reactiva.

Como se ha explicado con anterioridad la navegación reactiva consta

básicamente de dos etapas: una primera etapa de recopilación de información por

parte de los sensores y otra etapa de actuación, la cual siempre va a depender de la

información que haya sido recogida en la anterior etapa.

Un robot puede llevar a cabo una tarea compleja utilizando esta metodología y

sin necesidad de tener un mapa y sin tener en cuenta donde se encuentra, solo sería

necesario superponer varias tareas de sentir-actuar (módulos) para poder llevar a

cabo dicha tarea.

Su funcionalidad establece un flujo lineal de información entre los sensores y

los actuadores, lo cual da lugar a una serie de ventajas como son:

• Reducción del tiempo de respuesta de cada módulo, lo que repercute en un

tiempo de respuesta más rápido de todo el sistema completo.

• Mayor robustez a los errores y mayor facilidad de diseño de los módulos

debido a que estos son independientes entre sí, lo que dota al sistema de una

mayor estabilidad.

Hay una gran cantidad de robots que incorporan este tipo de sistema de

navegación ya que, es el sistema ideal para sistemas que quieran gozar de una cierta

flexibilidad a la hora de navegar ante entornos cambiantes y desconocidos, pues

ofrece una elevada velocidad de respuesta con una capacidad computacional baja.

(La carga computacional va a depender de la complejidad de la tarea a desarrollar).

2.2.1. Antecedentes Históricos de la Navegación Reactiva.

En este apartado se van a dar a conocer algunos ejemplos de los robots que

han influido en el desarrollo de este tipo de sistemas de navegación.



Las tortugas “Elsie y Elmer” de William Grey Walter.

De este modo fueron apodados los robots creados por William Grey Walter

(1910-1977), un neurofisiológico americano, y este fue uno de los resultados entre

varios robots que construyó para poder estudiar el comportamiento existente entre las

interconexiones neuronales.

Figura 2.1: Imagen de las “tortugas” robóticas Elsie y Elmer.

Las tortugas estaban formadas, cada una de ellas, por tres ruedas, dos

receptores: uno sensible a la luz y otro al contacto; y un par de motores: uno para

avanzar y otro para girar. Eran apodadas como tortugas debido a la forma de su chasis

de plástico con forma de caparazón. Estas eran capaces de moverse hacia una fuente

de luz, no intensa, si se encontraba con un nivel de batería óptimo. También tenían

capacidad para evitar obstáculos gracias a su sensor de contacto, siempre y cuando,

se encontraran en zonas donde la intensidad de luz no fuera muy baja, ya que, de lo

contrario, el robot no accedería. En el caso de que se encontrara con un nivel bajo de

batería, las tortugas estaban diseñada para buscar niveles de intensidad de luz

intensa que, casualmente, estaban ligados a la “madriguera” del robot.



Los Vehículos Braitenberg, Valentino Braitenberg (1926).

Valentino Braitenberg es un neurocientífico y cibernético austriaco-italiano que,

en su libro “Vehículos: Experimentos en psicología sintética” (1986), describió el

concepto de lo que actualmente se conoce como vehículos Braitenberg. Estos, se

caracterizan por tener una combinación de sensores y actuadores en conexión directa,

de manera, que son capaces de lograr objetivos.

Un claro ejemplo de este tipo de vehículos sería el descrito anteriormente, es

decir, las tortugas “Elsie y Elmer”, aunque estas tienen la particularidad de que se

crearon antes de que surgiera este término.

Un ejemplo actualizado de este tipo sería el famoso robot EV3 de la compañía

de Lego (Figura 2.2). Este posee un gran abanico de sensores que, junto con su

software, permite un gran número de rutinas y tareas que se pueden ejecutar de

manera autónoma.

Figura 2.2: Imagen de robot EV3.



Roomba.

El Roomba es un robot aspirador fabricado y comercializado por la empresa

iRobot. Es un ejemplo actual y que ha tenido un gran éxito a nivel internacional, reflejo

de ello es el hecho de que se han vendido más de 5 millones de aspiradoras teniendo

en cuenta las distintas versiones, del mismo, que han ido surgiendo.

Figura 2.3: Imagen de robot Roomba y ejemplo de trayectoria.

Este dispositivo está formado por una serie de sensores de contacto e

infrarrojos y dos ruedas independientes, las cuales, le permiten efectuar giros de 360º.

Para su funcionamiento no sigue ningún mapa de las habitaciones donde opera, ya

que resultaría imposible almacenar tanta cantidad de información en un robot de su

tamaño. Su patrón de movimiento estándar (ya que dependiendo de la versión del

dispositivo o los distintos modos de operación esto puede variar), se ejecuta en forma

de espiral y a medida que va detectando, por ejemplo, diferencias de nivel debido a la

existencia de una escalera, o una pared u obstáculos los cuales han sido detectados

a su sensor de contacto, la trayectoria se irá modificando.

Además, se puede programar rutinas para en el caso de que detecte pared, el

robot las vaya siguiendo hasta que haya pasado por todas las paredes que componen

la habitación.



2.3. Navegación autónoma basada en visión.

El algoritmo de navegación debe elaborar los comandos de movimiento del

robot para que este se pueda desplazar por el entorno donde se encuentra. Para poder

llevar a cabo dicho algoritmo de navegación autónoma, se suele dividir los problemas

que presenta en tres cuestiones:

• Localización: ¿Dónde estoy?

• Planificación de las tareas: ¿Hacia dónde quiero ir?

• Planificación del movimiento: ¿Cómo puedo llegar ahí?

El problema de la localización consiste en que el robot debe tener la capacidad

de saber, en todo momento, donde se encuentra respecto a un sistema que tome

como referencia.

La planificación de las tareas, por su parte, se encarga del procedimiento a

seguir para que se realicen unas determinadas acciones y, de esta forma, llegar a

cumplir el objetivo marcado en un principio. Dicho objetivo puede ser la posición final

a la que se quiere que llegue el robot. Así mismo, la planificación del movimiento se

refiere a la generación automática de acciones para poder llevar a cabo las tareas

planificadas anteriormente, por ejemplo, las acciones para esquivar los obstáculos que

se encuentre el dispositivo antes de llegar a su posición final.

Antes de entrar en la navegación de robots basada en visión es importante que

se entienda visión artificial o visión por computador como “la disciplina que estudia

cómo reconstruir, interpretar y entender una escena en tres dimensiones a partir de

imágenes en dos dimensiones siendo el objetivo último, de esto, crear un modelo que

exceda las limitaciones de la visión humana usando un software y hardware

determinados”. Resulta de gran importancia en este trabajo de fin de grado, ya que el

único sensor empleado para adquirir información del entorno va a ser de este tipo.

En la navegación de robots basada en visión podemos distinguir dos ramas de

aplicación diferentes, como son: la navegación basada en exteriores y la navegación

basada en interiores. Como se ha indicado anteriormente, el presente TFG está

enfocado a un sistema de navegación basado en interiores.



Dentro de los sistemas de navegación de interiores se puede tener tres posibles

casos:

- Aproximaciones basadas en mapas: este tipo de navegación, consiste en

proporcionar al robot un modelo o mapa topológico del entorno, a partir del cual,

el sistema es capaz de construir un mapa.

- Navegación basada en la construcción de mapas: En este tipo de navegación,

los robots exploran su entorno por medio de los sensores que estos tengan y,

a través de ello, son capaces de construir una representación interna del

mismo.

- Navegación sin mapas: En este caso, la navegación de este tipo de sistemas

se consigue sin ninguna descripción del entorno. Los movimientos del robot

son producidos por la extracción de la información de los elementos que se

encuentran en el entorno.

En el caso de este TFG, el sistema de navegación reactivo va a estar

compuesto por un sensor de visión, el cual va a ser el encargado de enviar toda la

información necesaria de cómo debe interactuar el robot con el entorno, todo esto,

de acuerdo a la programación descrita a lo largo de este documento.

Indicar también que, por problemática ajena a este trabajo final de grado, la

plataforma para realizar los ensayos será un vehículo de Braitenberg, en concreto

el EV3 como se ha visto anteriormente. Además, al tratarse de una navegación de

interiores, se va a usar una navegación sin mapas, ya que las aplicaciones que se

llevan a cabo en este TFG, interactúan con los elementos del entorno como puede

ser: evitar obstáculos, seguir la línea negra y seguir la pelota de tenis.



3. Hardware y Software empleados.

3.1. Hardware.

En este capítulo se pretende explicar la arquitectura hardware empleada para

poder abordar el desarrollo de este proyecto y los componentes que integra. Para ello,

haremos una breve introducción histórica de la RPi y, seguidamente, pasaremos con

sus especificaciones y las de los componentes que integran la arquitectura hardware.

3.1.1. Raspberry Pi.

Se trata de un ordenador de placa reducida (SBC) de bajo coste desarrollado

en el Reino Unido por la organización Raspberry Pi. Este dispositivo fue creado con

la idea de motivar tanto a los jóvenes de las escuelas a que aprendiesen informática

como a las personas adultas que se encontraran trabajando o estudiando con temas

relacionados.

La idea inicial era crear una placa con la finalidad anterior y que a dicha placa

se le pudieran conectar los distintos periféricos que conectamos, hoy en día, a nuestro

ordenador como son el ratón, el teclado y el monitor.

La elección de esta tarjeta no ha sido tomada aleatoriamente, ya que para

poder abordar este proyecto, se necesitaba que cumpliera una serie de características

mínimas como son las siguientes:

• Un dispositivo de bajo coste y de pequeñas dimensiones, el cual se pudiese

acoplar al robot hexápodo.

• Con una buena capacidad de procesamiento, pues tiene que manejar

imágenes en directo y no puede tener un delay muy elevado entre el evento y

la acción que produzca ese evento.

• Además, tiene que tener una cierta compatibilidad con la tarjeta de Arduino,

qué es el “cerebro” del robot hexápodo, y, con el cual nos debemos comunicar

para poder llevar a cabo las acciones del robot.

• También hay que tener en cuenta que, a esta tarjeta, había que añadirle una

serie de sensores, los cuales, habría que observar si estos podían satisfacer

las necesidades de este trabajo de fin de grado, así como si iban a suponer un

incremento alto del coste final del dispositivo final.



Característica Raspberry Pi 1 Raspberry Pi 2 Raspberry Pi 3

Chip Broadcom

BCM2835

Broadcom

BCM2836

Broadcom SCO

BCM2837

Procesador ARM 1176JZF-S a

700 MHz

ARM Cortex A7,

900 MHz quad-

core

ARM Cortex A43,

quad-core a 1.2

GHz

Procesador gráfico Video Core IV 520

MHZ OPENGLES

2.0

Video Core IV 250

MHZ OPENGLES

2.0

Video Core IV 400

MHZ OPENGLES

2.0

Memoria RAM 256 MB LPDDR

SDRAM 400 MHZ

1 GB LPDDR2

SDRAM 450 MHZ

Vídeo HDMI 1.4

1920x1200

HDMI 1.4 1900x1200

Entradas y Salidas

de vídeo

Conector MIPI CSI,

Conector RCA,

Conector HDMI

Entradas y Salidas

de audio

HDMI

Minijack

Puertos USB

Uno (En el modelo

B dos; en el

modelo B+, cuatro)

Cuatro

Almacenamiento

Integrado

SD (En el modelo

A+, microSD)

microSD

Conexión red Ninguna 10/100 Ethernal

vía hub USB

WiFi 802.1 ln

Bluetooth No Bluetooth 4.1

Dimensiones 8.5 x 3.5 centímetros

Peso (gr) 45 (El modelo A+,

23)

45

Precio 29,95€ 34,95€ 35€

Tabla 3.1: Tabla comparativa para poder apreciar en una imagen las diferencias reseñables

de los modelos de Raspberry Pi.



Después de estas especificaciones mínimas descritas, se decidió que el

dispositivo debía ser de la familia de Raspberry Pi. Así, tras comparar las

especificaciones entre las distintas placas, se llegó a la opción de la Raspberry Pi 3.

Como se puede apreciar en la tabla anterior, una de las características que más

resaltan son la capacidad de procesamiento de los distintos elementos, lo cual resulta

un elemento diferencial muy a tener en cuenta, ya que, las dimensiones de los

elementos no varían poco entre los distintos modelos; al igual que, los distintos

sensores a colocar, aunque sí hay que resaltar que la familia de la Raspberry Pi 3 si

ofrece cobertura WiFi y Bluetooth.

Estas especificaciones provocaron que me decantara por la familia de

Raspberry Pi 3, ahora bien, dentro de esta familia existen dos modelos.

Características Raspberry Pi 3 B Raspberry Pi 3 B+

Procesador Broadcom BCM2837B0, Cortex-A53 (ARMv8) 64-bit SoC 1.2GHz

Broadcom BCM2837, Cortex-A53 (ARMv8) 64-bit SoC 1.4GHz

RAM 1GB RAM 1GB RAM

Conectividad

WiFi 802.11 b/g/n (2.4GHz) Bluetooth 4.1

Puerto Ethernet de hasta 100Mbps

WiFi 802.11 b/g/n/ac de doble banda 2.4GHz y 5GHz

Bluetooth 4.2 Puerto Ethernet de hasta

300Mbps

Puertos

HDMI completo 4 USB 2.0 Micro SD

CSI camera DSI display

HDMI completo 4 USB 2.0 Micro SD

CSI camera DSI display

Tabla 3.2: Comparación de las dos RPi modelo 3.

Como se puede observar en la tabla anterior (Tabla 3.2), las mejoras entre

ambos modelos están en el aumento de la frecuencia de la CPU, que pasa de 1.2

GHZ a 1.4 GHz, y en el apartado de la conectividad, ya que pasa a tener doble banda

WiFi y; además, se mejora el Bluetooth que pasa de 4.1 a 4.2 cuyo cambio es, sobre

todo, a mejorar los protocolos de seguridad del BLE (Bluetooth Low Energy). Son este

conjunto de cualidades por las que se ha elegido usar este dispositivo, sobre el cual

ha girado la realización de este trabajo.



Figura 3.1: Imagen Global Rpi más los puertos GPIO de la misma.

A consecuencia de lo anterior, se indican las características técnicas de esta placa

(Figura 3.1):

• Procesador Broadcom BCM2837, Cortex-A53 (ARMv8) 64-bit SoC 1.4GHz

• WiFi 802.11 b/g/n/ac de doble banda 2.4GHz y 5GHz

• Bluetooth 4.2 que incorpora el Bluetooth Low Energy (BLE)

• Puerto Ethernet de hasta 300Mbps

• 40 pines GPIO

• Puerto Full HDMI

• Conector combo compuesto de audio y video a 3.5 mm

• Interfaz de la cámara (SCI)

• Interfaz de pantalla (SDI)

• Ranuras para tarjetas microSD (push-pull en lugar de push-push)

• Dimensiones de la placa de 8.5 por 5.6 cm.



3.1.2. Raspberry Pi Camera V2.

Se trata de una cámara de alta definición que se puede usar tanto para vídeo

como para capturar imágenes. Dispone de funciones de control automático como, por

ejemplo, la detección de iluminación. Entre muchas de las ventajas hay que señalar

que se conecta a la placa a través del puerto SCI, lo cual supone una ventaja si en un

futuro necesitamos mejorar el presente proyecto y vamos a necesitar usar puertos

USB.

Figura 3.2: Módulo Raspberry Pi Camera V2.

Existen dos tipos de este periférico conocidos con el Daylitgh (Figura 3.2) y

Noir. El modelo Noir es usado para aplicaciones en oscuridad o con el uso de fuentes

infrarrojas de iluminación; Mientras que el modelo Dayligth es usado para escenas de

luz natural, lo cual es lo que se necesita para llevar a cabo este TFG.

Además de su pequeño tamaño posee 8 megapíxeles, gracias al sensor Sony

IMX219 que lleva incorporado. También indicar, que es capaz de tomar imágenes fijas

así como vídeos en alta definición.



Seguidamente se muestra una tabla (Tabla 3.3) con las especificaciones de

este módulo:

Característica Módulo Cámara V2

Tamaño 25 x 20 x 9 mm

Peso 3g

Resolución 8 megapíxeles

Modo de Video 1080p30 720p60 y 640x480p60/90

Sensor Sony IMX219

Resolución del Sensor 3280 x 2464 pixeles

Área de imagen del sensor 3.68 x 2.76 mm (4.6 mm diagonal)

Tamaño del pixel 1.12μm x 1.12μm

Tamaño Óptica 1/4"

Longitud Focal 3.04 mm

Campo de Visión Horizontal 62.2 grados

Campo de Visión Vertical 48.8 grados

Ratio Focal (F-Stop) 2.0

Tabla 3.3 Características del módulo de cámara V2 para RPi.

3.1.3. Tarjeta MicroSD.

La Raspberry Pi no dispone, por sí sola, de espacio de almacenamiento sólido

donde incorporar el sistema operativo. De hecho, es necesario disponer de, al menos,

2GB de capacidad para almacenar todos los archivos relacionados con el sistema

operativo de la placa.

Figura 3.3: Tarjeta MicroSD de 32GB.



Es bastante importante la elección de este componente ya que, de él, va a

depender parte de que mi Raspberry Pi tenga un mayor rendimiento, en general; y,

sobre todo, un buen rendimiento en cuanto a la lectura y escritura de datos. Es por

eso que recomiendan el uso de la tarjeta microSD Samsung EVO Plus 32GB, además

de lo todo lo anterior, disponemos de espacio suficiente para el sistema operativo y

para el resto de librerías que hemos necesitado.

3.2. Software.

3.2.1. Raspbian.

Es el sistema operativo gratuito basado en Debian (distribución de GNU/Linux)

que está optimizado para poder usarlo en la Raspberry Pi. Raspbian proporciona más

que un sistema operativo común, ya que incluye más de 35.000 paquetes, software

precompilado para una instalación fácil en nuestra Raspberry Pi. Además, se

encuentra en una fase de desarrollo activa de manera que cada cierto tiempo (meses),

se dispone de una nueva versión disponible ya que se centran en ir mejorando la

estabilidad y el rendimiento del mismo. Existen dos versiones para poder instalarlas

en las tarjetas como son:

• Raspbian Pixel: Se trata de una versión completa con entorno gráfico, es decir,

la versión que conocemos todos con menús, ventanas, iconos, etc.

• Raspbian Lite: Esta versión por contra, no dispone de entorno gráfico y por

tanto debemos operar desde la consola (o terminal).

Como no se había trabajado antes con el sistema operativo de Raspbian, se ha

optado por la versión Pixel en este proyecto, ya que resulta más intuitiva para la hora

de programar. Asimismo, al tener que trabajar con cámara es la opción más sencilla,

ya que me permite comprobarlo al instante.



3.2.2. Python.

Es un lenguaje de programación multiplataforma y que está orientado a objetos,

preparado para realizar cualquier tipo de programa desde aplicaciones Windows hasta

servidores de red. Permite varios tipos de programación como, por ejemplo:

programación orientada a objetos o programación imperativa, de forma que no fuerza

al programador a adoptar un nuevo estilo particular de programación.

Se ha seleccionado como lenguaje de programación para este proyecto por

tener un gran potencial en el presente y en el futuro al tener esa diversidad ya que,

puede ser usado en varias plataformas. También, porque posee un gran número de

librerías que se pueden usar para trabajar con él y, las cuales, ofrecen un abanico

muy amplio de opciones para poder llevar a cabo los objetivos marcados para este

proyecto.

3.2.3. OpenCV.

OpenCV no es más que las siglas en ingles de “Biblioteca de Visión por

Computador de Código Abierto” y es una librería de código abierto para el tratamiento

de imágenes que incluye varios cientos de algoritmos de visión por computador en

tiempo real. Como se encuentra bajo licencia BSD permite su uso tanto para fines

comerciales como académicos.

Del mismo modo que ocurre con Python, es multiplataforma al tener versiones

para Windows, GNU/Linux, Mac OSX, iOS y Android. Está escrita en lenguaje C/C++

de manera optimizada y orientada a la eficiencia computacional con un enfoque

especial en aplicaciones de tiempo real.



Posee una estructura modular, estando agrupadas la mayoría de las funciones

de la biblioteca, en los siguientes módulos:

• Core: Módulo donde se definen las estructuras de datos básicas del resto de

módulos.

• Imgproc: Módulo de procesamiento de imágenes donde nos podemos

encontrar transformaciones geométricas de las imágenes, conversión del

espacio de color, histogramas, etc.

• Video: Módulo para el análisis de video que incluye algoritmos de seguimiento

de objetos, para la estimación del movimiento y extracción del fondo.

• Calib3d: Algoritmos básicos de geometrías de múltiple vista, como calibración

de cámaras o reconstrucción 3D entre otros.

• Features2d: Detectores de características, descriptores y comparadores.

• Objdetect: Algoritmos de detección de objetos o instancias de clases

predefinidas (por ejemplo: caras, nariz, ojos, personas, coches…)

• Highgui: Todo lo relacionado con la interfaz gráfica de OpenCV y el conjunto de

funciones que permiten importar imágenes y vídeo.

• Gpu: Algoritmos de diferentes módulos de OpenCV con aceleración de GPU.



4. Adquisición y procesado de la imagen.

Como se indicó en el primer capítulo, en este apartado se explica, de una

manera más detallada, aquellos métodos empleados en la adquisición y procesado

de la imagen que se han utilizado en las funcionalidades que componen los modos de

navegación autónoma.

4.1. Adquisición de imagen.

A continuación, se van a indicar los elementos a tener en cuenta en un sistema

de adquisición de la imagen.

4.1.1. Sistema de iluminación.

La principal misión de este elemento es resaltar aquellas características de un

objeto, para facilitarle al sistema de visión la detección de las mismas. Este elemento

es muy importante tenerlo en cuenta pues va a influir en la elección de elementos

posteriores como, pueden ser, el tipo de cámara o los accesorios necesarios acoplar

a mi sistema de adquisición.

Para su elección hay que tener en cuenta diferentes aspectos, como son:

• Propiedades del objeto a detectar: Como pueden ser la forma y el color del

mismo. En los casos de estudio, los objetos a detectar tienen un color y forma

característicos (la pelota de tenis forma de circulo y color propio y la línea a

seguir de color negro y por lo general forma de rectángulo.)

• Tipos de fuentes luminosas: En el caso de que necesite de fuente luminosa

independiente de la del entorno. En el caso de este TFG, al estar orientado a

navegación en interiores, no es necesario el aporte de una fuente luminosa

extra aparte de la que exista en la escena de actuación.

• Técnicas de iluminación: Solo en el caso de que se usen fuentes luminosas

externas a las del entorno. Como se ha indicado en el apartado anterior, en

este trabajo final de grado no se utiliza.



4.1.2. Cámara.

La elección de la cámara no se debe tomar de manera aleatoria, ya que es una

parte fundamental del sistema de adquisición. Es por ello, que para su elección, como

se ha explicado en el capítulo anterior, va a depender de si es posible o no cubrir las

necesidades que se necesitan para, en este caso, llevar a cabo los objetivos

expuestos en este TFG, así de las condiciones de operación, tamaño, precio, campo

de visión, resolución y necesidad de sistema de iluminación.

Es por ello que para este TFG se ha usado el módulo de Raspberry Pi Camera

V2 ya que es de pequeño tamaño, robusta, no tiene necesidad de iluminación externa

para los casos de estudio y tiene una alta eficiencia por un precio asequible. Tiene un

tipo de enfoque fijo, aunque por medio de software, se puede ampliar una zona de la

imagen.

También resaltar que el sensor de la cámara tiene una resolución de

2592x1944 pixeles (aproximadamente unos 5 megapíxeles de área), pero sólo los

1920x720 pixeles en el centro del sensor se utilizan para el modo video. Esto puede

suponer un problema, pero la librería de la cámara permite modificar por medio de

código la resolución a usar.

A modo de conclusión de este apartado, indicar que la librería OpenCV es la

librería que se ha empleado para la adquisición de imagen en este proyecto, ya que

esta tiene un enfoque orientado a objetos. En términos generales, la adquisición de

imágenes a través de OpenCV sigue el siguiente esquema:

Figura 4.1: Esquema sistema de adquisición.



A continuación, se da una breve explicación de cada bloque:

• Instalar dispositivo de adquisición: El primer paso es instalar el dispositivo de

adquisición, que en nuestro caso se trata de la PiCam. Dicha instalación está

recogida en el capítulo de anexos.

• Instalar paquetes correspondientes: Nos referimos a los paquetes necesarios,

que se deben de instalar a través de la consola de Raspbian, para que el

dispositivo sea compatible con Python y la librería OpenCV. En el capítulo de

anexos se indica cómo se realiza la instalación.

• Configuración de las propiedades del objeto: Una vez se hallan hecho los dos

puntos anteriores, se podrá verificarán las propiedades de la cámara para

poder hacer un ejemplo y probar que el dispositivo se encuentra bien conectado

y hay una configuración adecuada.

• Adquirir imagen: En este bloque se define si queremos obtener una captura de

una imagen o de un clip de video, donde guardarla, con que nombre, etc.

4.2. Procesamiento de la imagen.

Por procesamiento de la imagen se entiende al “conjunto de técnicas aplicadas

a las imágenes con el fin de mejorar la calidad de las mismas o facilitar la obtención

de información por parte de un sistema de adquisición.”

Es por ello que, a continuación, se recogen las técnicas empleadas junto con

su argumentación de por qué se ha realizado dicha selección.

4.2.1. Nivel de brillo de la imagen.

Para el caso del script del “Sigue Línea”, se ha procedido a realizar un ajuste

del nivel de brillo de la imagen ya que, como se verá con más detalle en el capítulo de

Resultados, en un primer momento se tenía brillos en la imagen, los cuales dificultaban

que el robot fuera capaz de detectar la línea a seguir, lo que hacía que, como se

intuye, el sistema reciba una serie de errores que no se podían pasar por alto.



Figura 4.2: Imagen Real.

Para poder reducir los brillos de la imagen, se ha procedido a hacer un ajuste

de la imagen de entrada de mi dispositivo de visión, lo cual lo que se realiza es una

comprobación de que el nivel de los pixeles que excedan de un valor medio en formato

RGB de (120,120,120), los pasamos automáticamente a este valor. Lo que permite

eliminar los brillos que dificultaban la detección del camino a seguir, como se puede

observar en la siguiente imagen:

Figura 4.3: Imagen Modificada.



4.2.2. Segmentación de la imagen.

En el ámbito de la visión artificial nos referimos al campo de la segmentación

de la imagen como “aquel que nos permite separar o destacar zonas de ella con

características específicas de color o de forma como puede ser: objetos, figuras,

caras, etc.”

En los casos en los que se centra el presente TFG se han usado los siguientes

métodos:

• Umbralización.

• Detección de bordes.

El proceso de umbralización permite establecer un valor de umbral de

intensidad de pixeles para que, de esta forma, sea más fácil detectar, por ejemplo,

algunos colores característicos a detectar como pueden ser el de la pelota de tenis o

el del camino que debe de seguir el robot. Este método es importante, ya que permite

descartar de una manera simple y rápida aquella región que no nos interese, lo cual

resulta clave para un sistema de navegación autónoma en tiempo real.

Figura 4.4: Detección de contornos de la pelota de tenis.



El proceso de detección de bordes se encuentra estrechamente relacionado

con el proceso anterior pues, para poder llevar a cabo este tipo de algoritmos y tener

una mayor precisión, es recomendable usar imágenes binarias y, a ser posible, que el

contorno a detectar sea el de un objeto blanco sobre un fondo negro (Figura 4.4).

Además, va a ser en gran medida el causante de detectar los obstáculos en mi escena

para que, de esta manera, el robot no colisione con objetos de unas determinadas

características como se podrá observar en capítulos posteriores.



5. Implementación de la aplicación.

En este capítulo se muestra y explica cómo funciona cada una de los diferentes

modos de operación que se han elaborado para poder llevar a cabo el objetivo de este

proyecto, que, no es otro que la navegación autónoma de un robot hexápodo.

5.1. Seguimiento de pelota de tenis.

El siguiente programa muestra, como su propio nombre indica, como se realiza

el seguimiento de una pelota de tenis. Se trata de uno de los sistemas de navegación

autónoma que se ha elaborado.

Figura 5.1: Flujograma del programa Seguimiento de Pelota de Tenis.



En primer lugar, una vez se inicia el programa, se realiza una etapa de

inicialización de la cámara, en la cual se configuran algunos de los parámetros de

nuestra cámara como son la resolución de la cámara o el número de fotogramas por

segundo que va a tener. Al mismo tiempo se realiza, también, una etapa de chequeo

del servomotor ya que, de este modo, se puede verificar si el dispositivo se encuentra

en la posición de origen una vez se inicia el programa o; en caso de no ser así, me

permite dirigirlo a dicha posición. Seguidamente se desplaza el servomotor con una

inclinación específica para este modo de operación, ya que la cámara al encontrarse

montada sobre un soporte, y este, a su vez, se encuentra ensamblado al chasis del

robot, se encuentra a una altura en la cual se pierde información de la escena si el

servomotor se encuentra fijo en su posición de reposo.

A continuación, se pasa la imagen de entrada que obtenemos por el periférico

de visión a formato HSV, ya que esta forma es mucho más práctica para detectar

colores que en el formato RGB. Después, creamos dos máscaras, una tendrá un rango

de colores (de colores verdes y amarillos como los de las pelotas de tenis) para poder

detectar esos colores en el video en este caso (en formato HSV). La otra por su parte

estará formada por una máscara que sea capaz de detectar un rango de colores que

incluye desde algunos tonos marrones y naranjas. Esta máscara esta creada para los

obstáculos.

Luego se realiza una apertura de la imagen (primero se realiza una erosión y a

continuación una dilatación). Realizamos este proceso para suavizar los colores de

una imagen y eliminar las pequeñas imperfecciones que podamos detectar (mayor

facilidad para detectar los colores y los bordes de un objeto).

Más tarde, la cámara empezará a buscar el área de los objetos, pero

delimitaremos el área a encontrar a un valor y a un color, con la configuración expuesta

en el párrafo anterior. Al mismo tiempo, buscará contornos de esos objetos que tengan

forma de circunferencia y que cumpla con los valores límite de radio a detectar. Si se

cumplen estas condiciones, buscará y mostrará el centroide del objeto de manera que

sea fácil su seguimiento.



Todo esto se realiza en el caso de que el dispositivo de visión no sea capaz de

detectar ningún tipo de obstáculo. Por tanto, para detectar algún objeto como

obstáculo se deben dar unas condiciones las cuales, a su vez, delimitan el uso de la

aplicación. Dichas condiciones son las siguientes:

• La detección de los obstáculos es sensible a los cambios de iluminación, ya

que al contemplar como obstáculos aquellos objetos que sean de la gama del

azul (aunque también del rojo), en determinadas ocasiones cualquier reflejo o

sombra de algún objeto de la escena lo puede tomar como obstáculo.

• En el caso de que, en la misma imagen, coincidan tanto un obstáculo como la

pelota, va a tener preferencia el seguir la pelota por encima de evitar el

obstáculo. Si el obstáculo no es capaz de ocultar la pelota en su totalidad, el

robot entiende que sigue encontrándose presente la pelota y por tanto la

seguiría, aunque se encontrase un obstáculo de menor tamaño delante de la

pelota.

Teniendo en cuenta las condiciones anteriores, se muestra por pantalla

mediante algunos indicadores, la dirección donde se encuentra la pelota pero, para

ello, la pantalla del dispositivo ha sido dividida de la siguiente forma como se puede

apreciar en la posterior figura:

Figura 5.2: Distribución del cuadrante de la imagen.



Como se puede apreciar, está dividida en tres regiones:

• Central: Esta región corresponde al centro de la imagen +/- una tolerancia. Si

el objeto se encuentra en esa región (región c), el robot seguirá hacia delante.

El objetivo que se sigue es que el objeto siempre se encuentre en esta zona.

• Lateral: Si se encuentra dentro de estas regiones (i y d), el objeto no se

encuentra centrado y por lo tanto se le indicará al robot mediante una

simbología (que es visualizado por pantalla) que se desplace hacia un

determinado lado parar que el objeto se quede centrado.

5.2. Seguimiento de línea.

Este script muestra el otro sistema de navegación autónoma para el robot. Este

se basa en el seguimiento de un camino de color negro sobre un fondo blanco. El

siguiente flujograma muestra un resumen de su funcionamiento:

Figura 5.3: Flujograma del programa Seguidor de Línea.



En este programa se ha procedido a realizar una configuración inicial de la

cámara como en el resto de scripts de la aplicación pero, en esta ocasión, además,

se hace una inicialización a un servomotor al que se encuentra acoplada la cámara,

ya que esta dejará su posición inicial para enfocar hacia al suelo que es donde se va

a encontrar el camino a seguir por el robot. Seleccionamos el rango de valores para

los cuales se va a detectar el color negro.

Cuando se active la cámara, el programa se centrará en localizar contornos en

la imagen que se encuentren dentro del rango de valores descritos anteriormente.

Seguidamente realizamos un proceso de apertura, como en el anterior programa (un

proceso de erosión y a continuación otro de dilatación), con el cual obtenemos un

mejor resultado de cara a posible ruido en la imagen o de falsos positivos que

generalmente va a proceder por la iluminación. Después de detectar contornos y

realizar la apertura en la imagen, se dibujan líneas por los contornos detectados para

que se pueda apreciar por pantalla.

Figura 5.4: Captura PiCam Seguimiento de Línea (línea recta).



Una vez se dibujen esas líneas, como se puede apreciar en la figura anterior,

nos encontraremos ante el contorno del camino en verde, un rectángulo de color rojo,

el cual se detectará su centro y se indicará (línea vertical azul). Esta marca es

importante para poder detectar si el robot se encuentra alineado o no con respecto al

camino a seguir. Mediante una de las funciones proporcionadas por la librería de

OpenCV (minAreaRect) va a ser posible obtener el área mínima de rectángulo que

puede albergar la imagen (en este caso el camino a seguir por el robot o franja negra).

Esto proporcionará la información necesaria a la hora de efectuar cualquier giro

del robot ya que el área mínima ira variando. El centro del rectángulo de área mínima

se comparará con el centro de nuestro camino (marca que se ha indicado al principio

de este párrafo) y, de esta forma, podremos obtener el valor del ángulo, así como una

“predicción” del camino con el que se va a enfrentar el robot.

El valor de los ángulos va a determinar el sentido de giro del robot, con lo que,

si el ángulo es de valor positivo, el robot deberá girar hacia la izquierda para alinearse

con el camino que sigue y, en caso contrario, deberá desplazarse hacia la derecha.

Esto lo podemos resumir de una forma más ilustrativa en la siguiente figura:

Figura 5.5: Esquema donde se muestra el sentido de giro del robot.

En caso de que el sistema de visión detecte el camino, el robot irá avanzando

según las indicaciones necesarias; y, en el caso de que, en algún momento, deje de

detectar el camino o encuentre algún obstáculo en el mismo, el robot, se detendrá.



6. Resultados

Este apartado se centra en mostrar y describir cómo se comportan cada una

de las dos funciones que se han desarrollado a lo largo del presente trabajo fin de

grado de manera independiente.

Antes de empezar con los respectivos apartados, indicar que, para este capítulo

de resultados se ha utilizado la plataforma del robot educador de lego EV3, aunque el

sistema de navegación autónoma ha sido elaborado para un robot hexápodo. No

obstante, debido a problemas ajenos al presente TFG, dicho robot no ha podido ser

acabado a tiempo.

En primer lugar, se aprecia el resultado de la interfaz gráfica, a través de la cual

va a permitir acceder a cada uno de los sistemas de navegación planteados, y, cuyos

resultados se observarán a continuación:

Figura 6.1: Interfaz principal de la aplicación.



6.1. Resultados obtenidos con el programa “Seguimiento de Pelota”.

Una vez se inicie este script, antes de que se inicie la cámara, esta se colocará

en la posición de operación que, en este caso, es de 30° como se puede ver en la

siguiente imagen (Figura 6.2):

Figura 6.2.: Imagen del ángulo de la cámara respecto de la posición de origen (30°).

El valor de este ángulo ha sido tomado a partir de las diferentes pruebas

experimentales, en el laboratorio. En un primer momento, surgió la idea de que la

cámara fuera fija para ambos sistemas de navegación que más tarde se descartó. El

principal problema de llevar esta idea a cabo es que, para un sistema de navegación

(este en concreto), se pierde bastante información de la escena pues enfocaría solo

al suelo y, por tanto, la pelota estaría siempre en contacto con el robot, y eso es algo

que este algoritmo pretende evitar.



Y seguidamente buscará detectar el color en modo HSV como podemos

apreciar en la figura 7.2:

Figura 6.3: Captura PiCam modo HSV.

Como se puede apreciar en la imagen (Figura 6.3), resulta de este modo más

sencillo detectar colores ante variaciones o deficiencias de luz en la escena. Esto es

importante ya que, como se ha indicado en anteriores capítulos, al tratarse de un

sistema orientado al interior de la vivienda, tenemos que tener en cuenta que vamos

a tener diferentes tipos de escenas en cuanto a la iluminación se refiere.



A continuación, se van a mostrar una serie de situaciones y ejemplos de

imágenes en cuanto al funcionamiento de este programa.

Figura 6.4: Captura PiCam con la detección de pelota en el sector izquierdo.

En la imagen anterior (Figura 6.4), se puede apreciar el ejemplo en el que el

programa es capaz de detectar la pelota de tenis en la franja designada como central

(i). En esta zona daremos la orden al robot avance hacia delante y, como se puede

observar en la imagen anterior, en la esquina superior izquierda podemos ver un

símbolo (“<-”) que hace referencia de esta orden. También se puede ver como se

detecta el contorno del objeto (en este caso de la pelota, con un color naranja), al

mismo tiempo que se marca el centroide del mismo (en color blanco y con las líneas

horizontal y vertical en color azul).



Además, también se puede ver que en color “rojo”, aparece un numero en el

margen superior izquierdo, el centroide, la pantalla y una línea desde el centro de la

pantalla al centroide de la pelota de tenis. El número muestra el valor del ángulo con

valores positivos si el objeto se encuentra a la derecha y, negativos, si está a la

izquierda. El valor del ángulo va a servir para identificar el sentido de giro del robot.

Además, por trigonometría, sacamos el valor de esa línea roja y, es esta la que me

permite calcular el valor del ángulo necesario para realizar los giros.

En la siguiente imagen (Figura 6.5) se puede ver el caso en el que la pelota se

encuentre en el mismo plano que un posible obstáculo (mano), pero que, como se

puede apreciar, no lo detecta ya que la cámara toma que el área de la pelota en ese

momento es mucho mayor del que puede apreciar la mano, además la mano no se

interpone entre la pelota y la cámara.

Figura 6.5: Captura PiCam con la detección de pelota en el sector izquierdo y con mano.



A continuación, se muestra un ejemplo (Figura 6.6) en el cual se puede

observar como interactúa el sistema al encontrarse ante un obstáculo. Ante este

hecho, el sistema le mandará al robot que se detenga para que este no colisione con

el obstáculo.

Figura 6.6: Captura PiCam donde se detecta obstáculo.



Otro de los casos es el de que, siempre que no se detecte pelota, el sistema

remite por pantalla el mensaje de “NADA” simbolizando que no se detecta ningún

objeto de seguimiento en la imagen.

Figura 6.7: Captura PiCam donde no se detecta pelota.



Por último, en esta última captura (Figura 6.8) se puede apreciar que el

programa está diseñado para que la detección de pelota no sea a cualquier distancia.

Ya que como es el caso de la imagen, si el objeto se encuentra demasiado cerca del

sistema de visión, el sistema no lo detectará ya que en ningún momento se pretende

desplazar la pelota con el robot.

Figura 6.8: Captura PiCam donde no se detecta pelota por estar muy próxima.



6.2. Resultados obtenidos con el programa “Seguimiento de Línea”.

En primer lugar, indicar que el circuito en el cual se han realizado las pruebas

oportunas es uno que se encuentra en el laboratorio de robótica y automática de la

Universidad de Jaén, el cual es empleado en la asignatura de Robótica Industrial, que

pertenece al cuarto curso de Ingeniería Electrónica Industrial.

Figura 6.9: Imagen del circuito de prueba.

Al iniciarse este programa, al igual que en el anterior, se accionará el

servomotor, pero, en esta ocasión, la cámara enfocará hacia el suelo (90°) para, de

esta forma, poder detectar el camino a seguir (Figura 6.10).

Figura 6.10: Imagen del ángulo de la cámara respecto de la posición de origen (90°).



Una vez se cumpla lo anterior nos podemos encontrar con algo parecido a la

imagen de la figura 6.11, en la que podemos observar como el programa detecta el

camino de color negro sobre fondo blanco. Para ello se muestra la pantalla original,

así como la imagen binarizada de la pantalla principal, de modo que se puede observar

como el robot es capaz de distinguir los objetos que ve por pantalla.

Figura 6.11: Capturas PiCam Seguimiento de Línea (línea recta).

En la imagen anterior (Figura 6.11), se pueden apreciar dos números: uno en

rojo y otro de color azul. El de color rojo muestra el ángulo formado entre el rectángulo

y la línea azul que me delimita el centro de mi imagen. El número de color azul me da

el error, que no es más que la diferencia entre el centro de la imagen (línea vertical

amarilla) y el centro del rectángulo (coordenada eje x). En la esquina superior derecha

se aprecia un símbolo, que al igual que en el programa de “Sigue pelota de tenis”, me

da la indicación de la orden que el programa le mandará al robot, en este caso, que

avance.



Figura 6.12: Captura PiCam Seguimiento de Línea (giro a izquierdas)

En la figura (Figura 6.12) se puede apreciar un caso, de cómo el sistema afronta

una curva, ya que el rectángulo delimitador ya le está informando al robot de hacía

que dirección va a ir el camino próximo que se va a encontrar. Como se puede ver, el

ángulo para que el robot se encuentre alineado con la franja negra, es de 54 grados.

La dirección en la que debe girar el robot para estabilizarse me la da el símbolo de

color verde de la imagen.

Figura 6.13: Captura PiCam Seguimiento de Línea (sin detección de camino).

En la figura 6.13 se observa que el sistema no detecta el camino a seguir, ya

que, al igual que en el otro método de navegación explicado anteriormente, aparece

el mismo mensaje por pantalla y, como se puede apreciar en la imagen binarizada, no

aparece nada en blanco ya que no detecta ningún objeto de color negro en la ventana

principal (Seguimiento de Línea).



Un último ejemplo del funcionamiento de este sistema es mostrar el caso en el

que el sistema encuentre más de un contorno en la escena, lo cual se mostrará como

obstáculo, independiente del color de este, ya que el sistema busca en todo momento

un único contorno y de colores que se encuentren dentro del umbral especificado

mediante código.

Figura 6.14: Captura PiCam Seguimiento de Línea (detección obstáculo).



7. Presupuesto.

En este capítulo se va a detallar el presupuesto del presente proyecto. Para

poder apreciar los diferentes costes se ha optado por dividir los costes en: coste de

recursos humanos y coste de recursos materiales.

7.1. Coste de recursos humanos.

A través de un estudio proporcionado por la empresa Page Personnel, se han

obtenido los datos necesarios para calcular el salario del autor de este proyecto. El

presente estudio nos indica que un Ingeniero de Proyectos tiene un salario anual

mínimo de 25.000 € netos, lo que supone un salario de 11,57 € por hora. Asimismo,

hay que tener en cuenta las horas de la tutora de este TFG, suponiendo un coste de

25 € por hora.

En la siguiente tabla se recogen los costes totales de los recursos humanos del

proyecto tomando como unidad de medida las horas:

Recursos Humanos

Descripción € / Ud. Ud. Total

Horas del alumno 312 3.609,84 €

Investigación 11,57 € 58 671,06 €

Desarrollo de algoritmos 11,57 € 54 624,78 €

Experimentación y resultados 11,57 € 24 277,68 €

Redacción memoria 11,57 € 124 1.434,68 €

Elaboración de la presentación defensa 11,57 € 52 601,64 €

Horas del/la tutor/a 6 150,00 €

Reuniones 25,00 € 3 75,00 €

Revisión de la memoria 25,00 € 3 75,00 €

Subtotal 3.759,84 €

Tabla 7.1: Coste total de los recursos humanos del proyecto.

7.2. Coste de recursos materiales.

Para el cálculo de los recursos materiales se ha tenido en cuenta que los días

trabajados se han dedicado una media de 6 horas, durante 52 días, lo que nos da un

total de 312 horas.



Para algunos de los recursos como el ordenador, coste de electricidad usada y

el consumo de internet. Estos quedan recogidos en la siguiente tabla resumen.

Recurso Año Mes Día

Ordenador 125,00 € 10,42 € 0,34 €

Consumo eléctrico 500,00 € 41,67 € 1,37 €

Internet 270,00 € 22,50 € 0,74 €

Tabla 7.2: Coste unitario de algunos recursos materiales.

Y a continuación, se muestra la tabla donde se muestran los costes de los

recursos materiales usando como unidad de medida los días:

Recursos Materiales

Descripción € / Ud. Ud. Total

Días de amortización ordenador 0,34 € 52 17,68 €

Cuota diaria de consumo eléctrico 1,37 € 52 71,24 €

Cuota diaria de internet 0,74 € 52 38,48 €

Raspberry Pi 3B + 40,99 € 1 40,99 €

Raspberry Pi cámara 25,59 € 1 25,59 €

Tarjeta MicroSD 11,00 € 1 11,00 €

Carcasa Raspberry 15,00 € 1 15,00 €

Carcasa cámara 7,61 € 1 7,61 €

Chasis Cámara 17,00 € 1 17,00 €

Gastos generales 50,00 € 1 50,00 €

Subtotal 294,59 €

Tabla 7.3: Coste total de los recursos materiales del proyecto.



En resumen, teniendo en cuenta los costes anteriores, en la siguiente tabla se

recogen los costes totales del TFG junto con el IVA:

Coste total del proyecto

Descripción Subtotal

Recursos Humanos 3.759,84 €

Recursos Materiales 294,59 €

Total, sin IVA 4.354,43 €

IVA (21%) 914,43 €

TOTAL 5.268,86 €

Tabla 7.4: Coste total del proyecto.

Por tanto, el coste final del presente TFG asciende a cinco mil doscientos

sesenta y ocho con ochenta y seis euros (5.268,86 €).



8. Conclusiones.

En el presente Trabajo de fin de Grado se ha desarrollado una aplicación para

la navegación autónoma de un robot hexápodo. El objetivo principal era realizar un

sistema de navegación autónoma al robot en entornos interiores, y, parcialmente

estructurados. La aplicación se ha realizado a través de Python que permite usar

diferentes algoritmos dependiendo del modo que se quiera usar.

Uno de los sistemas de navegación que se ha planteado consiste en el

seguimiento de una pelota de tenis por parte del robot. Para ello, se establece un

rango de colores al cual pertenezca nuestro objeto a detectar y, dicha imagen, se pasa

a HSV para tener mayor facilidad a la hora de detectar el color. Al mismo tiempo, se

busca detectar un contorno con forma de circunferencia. Una vez se cumplan las

condiciones anteriores se podrá detectar la pelota, siempre que se encuentre a una

determinada distancia, se mandará las respectivas ordenes al robot para que este se

mueva siguiendo la pelota.

El otro sistema se trata del seguimiento de línea, que se va a encargar de seguir

la línea negra sobre un fondo blanco. El sistema en un principio ajusta el rango de

valores a detectar. Seguidamente, detecta los contornos de ese color y dibuja las

líneas de ese determinado contorno. Hecho esto y, tras calcular el área mínima del

rectángulo y su posterior comparación, se detecta el ángulo que indica hacia donde

se debe desplazar el robot para alinearse con el camino que está siguiendo.

Cada uno de los sistemas de navegación empleados tiene una inclinación de

la cámara la cual va a ser específica para cada modo de operación, ya que no puede

ser la misma para ambos porque, en ese caso, ambos perderían información de su

respectivo objeto de seguimiento.

También es aconsejable la correcta calibración de movimientos por parte del

robot (no pertenece al alcance de este trabajo de fin de grado), ya que eso va a influir

en la tolerancia a incluir en cada sistema para que estos funcionen de manera precisa.



8.1. Posibles mejoras.

Dentro de las posibles mejoras a implementar, cabría destacar la mejor

interpretación de los obstáculos por parte del sistema de navegación ya que de esta

forma el robot fuese capaz de elaborar una trayectoria para poder “esquivar” el

obstáculo.

Otra posible mejora podría ser añadir algún sensor extra al sistema de

navegación expuesto a lo largo de este TFG como, por ejemplo, un sensor infrarrojo,

de manera que gracias a este se pudiera evitar el choque con obstáculos que se

encontraran a una determinada distancia de nuestro robot o, también, se le podría

incluir un zumbador que nos indicara de manera sonora el modo de operación

seleccionado o el nombre, la dirección que va siguiendo el robot, por poner algunos

ejemplos.

También se podría plantear la realización de una aplicación Android y que esta

fuera capaz de conectarse por Bluetooth a la Raspberry Pi y que, por medio de algún

móvil o Tablet, se les diera las indicaciones necesarias para moverse (a modo de

mano inalámbrico) o, al menos, para elegir el modo de navegación que se quiera usar.



9. Anexos.

En los anexos se va a incluir todo lo que es necesario instalar para poder llevar

a cabo el desarrollo de la aplicación realizada en este trabajo fin de grado.

9.1. Instalación de Raspbian.

Para la instalación de este sistema operativo en la tarjeta SD existen dos vías:

una es usando el archivo de imagen de Raspbian y la otra es usando NOOBS. Las

cuales la podemos encontrar en la siguiente página:

https://www.raspberrypi.org/downloads/

Figura 9.1: Opciones de instalación de Raspbian.

Se opta por la segunda opción (opción NOOBS). La opción de NOOBS es la

más sencilla de instalar, aunque también ocupa un espacio adicional en la tarjeta SD

ya que también incluye otras distribuciones de Linux para Raspberry Pi. Para este

caso no supone un problema ya que disponemos de espacio suficiente.

https://www.raspberrypi.org/downloads/



Para ello, en primer lugar tenemos que formatear la tarjeta SD con formato

FAT32, para lo cual podemos usar el programa SD Card Formatter.

Figura 9.2: Captura de SD Card Formatter.

Seguidamente se introducirá la SD en la Raspberry y la iniciamos. Aparecerá

un menú con los distintos sistemas operativos de los que dispone el paquete que de

la SD (Figura 9.3). Para nuestra finalidad se marca la opción de Raspbian. Y se

selecciona el botón instalar.

Figura 9.3: Menú de Instalación.



A continuación, aparecerá una imagen a modo de espera mientras se completa

la instalación del sistema operativo seleccionado en la tarjeta de memoria. Una vez se

haya completado la instalación se reiniciará el sistema de manera automática, y nos

debe aparecer la siguiente imagen:

Figura 9.4: Imagen de inicio de Raspberry.



9.2. Configuración inicial.

Una vez nos encontremos en el escritorio principal, se selecciona la opción de

la figura 9.5, para poder configurar algunas de las opciones de la misma.

Figura 9.5: Escritorio de Raspberry.

A continuación, aparecerá una ventana como la de la figura 9.6, en la cual hay

que desplazarse hasta el apartado interfaces. En dicho apartado, debe tener las

opciones marcadas en la imagen ya que serán de utilidad por distintos motivos como

se explican a continuación:



Figura 9.6: Configuración de Raspberry.

• Cámara: Esta opción es muy necesaria para el desarrollo de este TFG, ya que

activa la interfaz SCI, que es donde se conecta la PiCam a la Raspberry Pi.

• SSH: La activamos para poder acceder a la Raspberry de forma remota desde

un cliente SSH.

• VNC: Habilitamos el servido VNC, ya que es otra forma de acceder de manera

remota al dispositivo. Para poder llevar a cabo esta opción, el dispositivo debe

de estar conectado a la misma red WiFi que el dispositivo externo (ordenador,

móvil o Tablet). La aplicación usada para poder conectarse mediante VNC se

llama VNC Viewer for Google Chrome, ya que, al ser una aplicación de Google

Chrome es más fácil de instalar.

• Puerto Serie: Esta opción es habilitada, ya que a través del puerto serie se va

a establecer la comunicación con el robot hexápodo, más concretamente con

el módulo de Arduino que lo maneja.

• Remote GPIO: La marcamos ya que se va a usar pines de la placa para poder

controlar el servomotor del sistema de visión.



9.3. Instalación de la Cámara de Raspberry Pi (PiCam).

En este apartado se va a explicar la instalación de la PiCam. Para ello la

conexión se hace mediante un bus de cinta que irá conectado al conector SCI como

se explica a continuación. Se deben levantar la pestaña de color negro para que de

esta forma se pueda introducir el cable. Este debe tener los cables metálicos mirando

hacia afuera del puerto Ethernet.

Figura 9.7: Conector SCI.

Cuando el conector se encuentre como en la imagen anterior, se bajarán la

pestaña a su posición inicial, de manera que el cable quede bloqueado físicamente en

su lugar correspondiente. Después de efectuar lo anterior, pasamos con el software.



Una vez esté encendida las Raspberry, se ejecuta la consola de Raspbian y se

debe introducir los siguientes comandos, los cuales son obligatorios introducir de

manera que les dé tiempo a ejecutarse de manera completa cada uno por separado.

Figura 9.8: Comandos para actualizar el software de Raspbian actual.

Los comandos anteriores se introducen para actualizar el software, en primer

lugar, antes de instalar cualquier otro paquete en el sistema. A continuación, se instala

la librería escribiendo el siguiente comando:

Figura 9.9: Comando para instalar librería de la PiCam en python.

De esta forma, se podrá emplear la PiCam desde Python. Para comprobar la

correcta instalación se va a proceder a realizar un ejemplo de prueba para captar una

imagen. El código sería el siguiente:

Figura 9.10: Código de ejemplo.



Del cual se ha obtenido la siguiente imagen como resultado:

Figura 9.11: Imagen obenida del ejemplo.

9.4. Instalación de la librería OpenCV.

Para su instalación, se han de aplicar una serie de comandos que se deben

seguir de manera ordenada. En primer lugar, se debe de hacer una actualización del

software como el de la figura 9.8. A continuación se reinicia la Raspberry. Después

del reinicio volvemos a abrir el terminal y se hace lo siguiente:

• Instalar los paquetes de desarrollador CMAKE.

• Instalar los paquetes de I/O de imagen.



• Instalar los paquetes de I/O de video.

• Instalar la biblioteca de desarrollo GTK para GUI básicas.

• Instalar paquetes de optimización.

A continuación, se instala Python y la librería numpy con los siguientes comandos:

Descargamos la librería OpenCV junto con sus módulos extras:

Y, una vez descargada la librería junto con sus paquetes, se instala y se compila en

Python con las siguientes opciones:



Ahora se debe cambiar el tamaño del espacio para que, de esta manera, la

Raspberry pueda compilar con los cuatro núcleos sin tener problemas de memoria.

Se abre / etc / dphys-swapfile y luego se edite la variable CONF_SWAPSIZE. Para

ello en el terminal se escribe:

Y en la variable se coloca:

Para guardar los cambios se debe de presionar las teclas Ctrl + O. Y para salir

se presiona Ctrl + X. Escribimos las siguientes líneas para llevar a cabo esos cambios:

Finalmente, se compila todo lo anterior usando los cuatro núcleos de la placa.

(Indicar que este proceso puede durar del orden de hora y media a dos horas).



Y, para finalizar todo este proceso de instalación de la librería OpenCV y

asegurar su correcto funcionamiento: (Este proceso tiene una duración similar al

anterior)

Una vez se complete lo anterior, es recomendable hacer un reinicio del

dispositivo antes de empezar a trabajar con esta librería.



Bibliografía

Clément, P. (2018). Pyhotn y Raspberry Pi: aprenda a desarrollar en su nano-ordenador.

Edición ENI.

Knapp, M. (2017). Python programming for advanced:learn the fundamentals of Python in 7

days.

Corke, P. (2011). Robotics, Vision and Control – Fundamental Algorithms in MATLAB. Berlin,

Heidelberg : Springer Berlin Heidelberg : Imprint : Springer, 2011.

González Jiménez, J. (2000). Vision por computador. Madrid : Paraninfo, cop. 2000

Web Oficial Raspberry: https://www.raspberrypi.org

Web Oficial iRobot: https://www.irobot.es/

Documentación sobre la RaspiCam:

https://www.raspberrypi.org/app/uploads/2013/07/RaspiCam-Documentation.pdf

Documentación general sobre la librería OpenCV: https://docs.opencv.org/

https://www.raspberrypi.org/

https://www.irobot.es/

https://www.raspberrypi.org/app/uploads/2013/07/RaspiCam-Documentation.pdf

https://docs.opencv.org/

trabajo fin de grado sistema de navegaciÓn autÓnoma de...

Documents