Embed Size (px)
Citation preview
Proyecto de Grado
Definición de una Arquitectura para la Creación de
Aplicaciones Web integrando Robots Lego EV3
Presentado por:
Eduardo Arturo Cabello Agüero
Asesor:
Prof. Mario Fernando De la Rosa Rosero, PhD
Universidad de los Andes
Departamento de Ingeniería de Sistemas y Computación
Mayo 2018
Tabla de contenido
0. Resumen……………………………………………………………………………. 1
1. Introducción………………………………………………………………………... 2
2. Descripción General………………………………………………………………...4
a. Objetivo General…………………………………………………………… 4
b. Objetivos Específicos……………………………………………………….4
c. Antecedentes……………………………………………………………….. 4
d. Identificación del Problema y su Importancia……………………………....9
3. Diseño y especificaciones………………………………………………………….. 10
a. Definición del problema…………………………………………………….10
b. Especificaciones……………………………………………………………. 10
c. Restricciones……………………………………………………………….. 11
4. Desarrollo del diseño………………………………………………………………. 12
a. Componente Cliente Web………………………………………………….. 13
b. Componente Servidor Intermedio………………………………………….. 13
c. Componente Robot Lego EV3……………………………………………... 15
d. Construcción del Robot……………………………………………………..15
e. Pruebas……………………………………………………………………... 15
f. Alternativas de Diseño……………………………………………………... 16
5. Implementación……………………………………………………………………..17
a. Etapa 1: Instalación de LeJOS en el robot…………………………………. 17
b. Etapa 2: Desarrollo Mediador básico………………………………………. 19
c. Etapa 3: Desarrollo y pruebas conexión Cliente Web-Servidor Intermedio..20
d. Etapa 4: Integración Cliente Web-Servidor Intermedio-Robot……………. 24
6. Análisis de resultados…………………………………………………………..…...26
7. Conclusiones y trabajos futuros……………………………………………………. 30
8. Bibliografía………………………………………………………………………… 32
9. Apéndice A………………………………………………………………………… 33
Tabla de Figuras
Figura 1: Arquitectura LARA………………………………………………………... 5
Figura 2: Interfaz Gráfica del Sistema………………………………………………... 7
Figura 3: Diagrama Funcional Nivel 0 Telerobot-Lab……………………………….. 8
Figura 4: Diagrama de Contexto LABBOT…………………………………………...9
Figura 5: Diagrama casos de uso……………………………………………………... 11
Figura 6: Diagrama de componentes…………………………………………………. 12
Figura 7: Diagrama de despliegue……………………………………………………. 13
Figura 8: Modelo BOBB3E…………………………………………………………... 15
Figura 9: Configuración Eclipse……………………………………………………… 18
Figura 10: Creación de objeto robot…………………………………………………… 19
Figura 11: Comando sencillo de sonido……………………………………………….. 19
Figura 12: Comando sencillo de movimiento…………………………………………..20
Figura 13: Aplicación Demo Navegador………………………………………………. 21
Figura 14: Lógica de envío de Instrucciones del Formulario………………………….. 21
Figura 15: Lógica de métodos de envío de instrucciones………………………………22
Figura 16: Método para manejar las peticiones HTTP………………………………… 23
Figura 17: Clase principal del mediador para recibir las peticiones……………………24
Figura 18: Método para ejecución de una instrucción simple…………………………. 24
Figura 19: Diagrama de clases Mediador……………………………………………… 25
Figura 20: Respuesta Ejemplo Conexión Robot………………………………………..26
Figura 21: Respuesta ejemplo con comando “close”…………………………………...27
Figura 22: Respuesta ejemplo comando complejo “forward”-tiempo …………………28
Figura 23: Parte visual previa a la consulta de información…………………………....28
Figura 24: Ejecución de la consulta sin obstáculo presente…………………………….29
Figura 25: Ejecución de la consulta con obstáculo presente……………………………29
1
0. Resumen
Este proyecto consiste en la definición de una arquitectura base para la creación de
aplicaciones Web para el manejo, control o programación de robots Lego Mindstorms EV3.
Actualmente, son muy pocos los proyectos que trabajan con los robots Lego Mindstorms
EV3, especialmente en el ámbito Web, por lo que se propone una arquitectura Web la cual
servirá como base y guía para proyectos futuros. Por lo tanto, se investiga e integra
tecnologías que satisfagan la arquitectura propuesta. Como parte de la arquitectura se
construye un robot usando un Kit Lego Mindstorms EV3 para la ejecución de comandos
enviados desde el cliente Web. La funcionalidad básica del robot se implementa utilizando la
API LeJOS. Se cuenta con una componente intermedia que se encarga de recibir las
peticiones del cliente Web y de enviarlas al robot para que sean ejecutadas. Por último, se
implementa una aplicación demo basada en la arquitectura propuesta que permite realizar
pruebas de conexión, ejecución de comandos básicos y complejos.
2
1. Introducción
Actualmente los proyectos relacionados con los Robots Lego Mindstorms EV3, están
dirigidos principalmente a un público de niños menores de edad con el objetivo de que se
interesen más en la robótica y en la programación en general. Por el contrario, otros
proyectos se enfocan en un aspecto más pedagógico. Esto con el fin de no sólo incentivar el
estudio por la robótica y la programación, sino como una herramienta más eficiente y versátil
al enseñar estos tipos de temas.
Los proyectos que existen en la actualidad utilizan de cierta forma herramientas web ya
construidas para lograr sus objetivos propuestos. En sus especificaciones, definen las
arquitecturas que se utilizaron para el desarrollo del proyecto, las cuales tienen similitudes
con las arquitecturas propuestas por otros proyectos que trabajan tanto con los robots como
con alguna especie de herramienta web. Por lo anterior, se desea definir una arquitectura web
base para que se facilite la creación y creatividad de nuevos proyectos que involucren
tecnologías web y robots Lego Mindstorms EV3.
Como propuestas de valor, este proyecto presenta varias características como lo son la
integración Web-Java-Robot a través de herramientas como lo son Angular, Eclipse, API
LeJOS y el robot Lego Mindstorms EV3. Otra característica importante es la definición de la
arquitectura general para dicha integración, la cual permite creación de aplicaciones con
temáticas diversas.
El documento presentará la siguiente estructura: En el capítulo 2, se presentará una
descripción general del proyecto, incluyendo objetivos, los trabajos más relevantes
encontrados alrededor de esta temática e identificación del problema que se trata en el
proyecto. En el capítulo 3, se presentará el diseño, especificaciones y restricciones que se
presentan en el proyecto. Luego, en el capítulo 4, se realiza un desarrollo del diseño
planteado en el capítulo anterior, donde se especifican los roles de cada componente de la
arquitectura, se muestra la construcción del robot con el que se trabajará y se definen unas
pruebas a realizar, además, se propone una alternativa al diseño propuesto. Continuando, en
el capítulo 5, se mostrará la implementación del demo por etapas. En el capítulo 6, se harán
análisis de los resultados que se obtuvieron de las pruebas definidas en el capítulo 4. Por
3
último, en el capítulo 7 se presentarán conclusiones del trabajo realizado y mención de
trabajos futuros a realizar.
4
2. Descripción General
a. Objetivo General
Definir una arquitectura Web base que permita la conexión con robots Lego
Mindstorms EV3 e implementar un demo que muestre la funcionalidad de la misma.
b. Objetivos Específicos
Revisar e investigar trabajos relacionados con manejo o programación
remota de robots Lego Mindstorms EV3.
Definir diagramas que muestren (visualmente) la arquitectura propuesta.
Diseñar, implementar y probar un cliente Web que envíe peticiones a un
servidor intermedio.
Diseñar, implementar y probar un servidor intermedio que reciba
peticiones de un cliente Web, las transforme y las envíe a él/los robots
Lego Mindstorms EV3 ubicados en el laboratorio.
Construir un modelo de robot Lego Mindstorms EV3 para que ejecute las
instrucciones recibidas por parte del servidor intermedio.
Diseñar, implementar y probar el componente de programación en el robot
Lego Mindstorms EV3.
Realizar pruebas de integración entre los componentes de la arquitectura.
c. Antecedentes
Web Environment for Programming and Control of a Mobile Robot in a
Remote Laboratory (2017): Este trabajo consiste en describir un ambiente de
control y programación de un robot móvil y sus aplicaciones pedagógicas. El
sistema se compone de un laboratorio remoto de robótica, una herramienta
online de programación y un ambiente virtual de aprendizaje, lo que permite
experimentar con un robot móvil remotamente usando una interfaz gráfica
sencilla mediante navegador web sin necesidad de instalar software adicional
en el computador del usuario. En el trabajo se aplicó una arquitectura CPE
5
(Control and Programming Environment) la cual consiste principalmente de
un cliente que a través de internet se conecta con un servidor el cual contiene
instalados los APIs y controladores necesarios para comunicarse con la tarjeta
ubicada en el robot y la cámara IP. Este sistema CPE es parte de un proyecto
llamado LARA, el cual se enfoca en desarrollar una arquitectura pedagógica
que integra recursos tecnológicos y métodos de enseñanza para mejorar el
proceso de aprendizaje en robótica, programación computacional, algoritmos,
sistemas inteligentes, entre otros. El robot utilizado en el proyecto se llama
L1R2, es un seguidor en línea y vehículo de rescate. Se realizaron varios tipos
de pruebas, principalmente para encontrar el rendimiento y su proceso de
aprendizaje que presentaban los alumnos en un ambiente CPE y uno
académico normal. Para esto, aplicaron cuestionarios previos al experimento y
otro después del mismo, con lo que se encontró que el aprendizaje fue mayor
en un ambiente CPE que en un ambiente académico normal. [1]
Figura 1. Arquitectura de LARA [1]
Implementation of Gesture based Applications and Communication with Lego
Mindstorm EV3 (2017): Este proyecto desarrolla un sistema que puede ser
usado en convenciones de ciencia para enseñar a niños acerca de robots. El
sistema incorpora un sensor de Microsoft Kinect, usado para detectar los
movimientos de baile de un niño y controlar un robot Lego EV3 para que se
6
mueva acorde a los movimientos detectados, haciendo del robot un
compañero de baile para el niño. Se le agrega un algoritmo para detectar
obstáculos en caso de que estos mismos se encuentren cerca del robot y así los
pueda evitar. Adicionalmente, el niño puede escoger una canción y se debería
poder definir como el robot responderá a los movimientos de baile. Como se
mencionó anteriormente, el sistema consta de un Kinect y una aplicación
escrita en C# con un framework para la GUI (Graphical User Interface). El
Kinect se encargará de detectar los movimientos del niño y enviárselos a la
aplicación para que ésta los pueda procesar y enviar al robot Lego. La
comunicación con el robot Lego se hace desde una PC mediante Bluetooth, la
PC envía los comandos en el puerto del robot. Comport5 es usado para aceptar
los comandos mientras que los motores y los sensores deben estar conectados
al EV3 Brick. Como conclusión, se presentó la conexión de Kinect con los
robots Lego EV3. El robot mueve sus motores basado en los gestos de los
niños y aceptara los comandos de el puerto serial de la PC. El sistema
implementado incluye una opción para subir diferentes canciones desde un
directorio particular, del cual el niño puede bailar y cambiar canciones al
cambiar de gesto. Además, también se implementó la detección de obstáculos
que aparecen en frente del robot. El sistema resulta bastante atractivo para los
niños y puede ser usado para enseñarles más sobre robótica. [2]
7
Figura 2. Interfaz Gráfica de Usuario del Sistema [2]
TELEROBOT-LAB (2011): Este Proyecto buscar ampliar la cobertura del
laboratorio de robótica móvil de la Universidad de los Andes a través de
internet, debido a varios factores como la disponibilidad del mismo, de los
estudiantes y de los encargados del laboratorio. Con esto, los estudiantes
tendrán la posibilidad de ingresar al laboratorio de forma remota a cualquier
hora del día y manipular los robots que se encuentren disponibles en el
momento. El objetivo principal del proyecto es ser un punto de partida para un
laboratorio remoto de robótica móvil en la Universidad de los Andes. Los
robots presentan unas cámaras IP inalámbricas, 2 de estos robots son
AmigoBots y un robot Pioneer P3-DX. La programación de los robots se
realizó con un conjunto de librerías del fabricante de Mobile Robots y un
simulador 2D para la ejecución de los programas con robots del fabricante. El
diseño del diagrama funcional muestra una plataforma web que se conectará a
un servidor ubicado en el laboratorio a través de internet. Este servidor se
encargará de comunicarse con los robots y las cámaras y será el intermedio de
comunicación entre la plataforma web y los robots. Se definieron varias
pruebas preliminares para probar el estado de los robots, las cámaras, la
conexión etc. Se realizaron encuestas para validar los resultados del proyecto,
8
en donde se encontró que 50% de los usuarios que probaron el simulador lo
encontraron fácil de utilizar y la mayoría pudo tele-operar el robot con la
información suministrada por la aplicación, entre otros aspectos que se
evaluaron. A manera de conclusión, se logró desarrollar una plataforma web
que tele-opera los robots exitosamente de forma remota, con unos ligeros
ajustes que se deben realizar como mejoramiento de la interfaz gráfica y otros.
[3]
Figura 3. Diagrama Funcional Nivel 0 Telerobot-Lab [3]
LABBOT (2016): Este proyecto es una extensión de un proyecto existente
llamado ROBLOCK. Principalmente se amplía la forma de aprendizaje del
usuario donde éste mismo podrá hacer uso de las técnicas de programación
proporcionadas por la aplicación web para resolver nuevos problemas
emergentes en un ambiente físico real. El usuario se puede conectar a un
escenario físico en un laboratorio remoto desde la aplicación, en el cual
estará ubicado un robot LEGO Mindstorm, el cual ejecutará comandos que
son solución a un problema resuelto por un robot móvil en un ambiente de
simulación. Se usaron 2 modelos diferentes del robot LEGO Mindstorm para
realizar pruebas. Los componentes importantes que cabe resaltar de este
proyecto son la herramienta web perteneciente a ROBLOCK, el servidor que
se encarga de recibir y transformar la información proveniente de ROBLOCK
9
y enviársela a los robots y el robot en sí. Se realizaron diferentes tipos de
prueba, desde unas muy sencillas como lo es giros de diferentes grados del
robot hasta pruebas realizadas con marcas diferentes que el robot debe
detectar. También se crearon diferentes escenarios que el robot debe
recorrer realizando ciertas tareas especificadas en cada uno. Se realizaron
pruebas de un escenario de los propuestos en el proyecto y se realizó
correctamente a pesar de algunos inconvenientes presentados tanto en el
propio escenario como en el robot. [4]
Figura 4. Diagrama de Contexto LABBOT [4]
d. Identificación del problema y su importancia
Actualmente no existe una arquitectura base para la creación de aplicaciones Web
que integren robots Lego Mindstorms EV3, por lo que el objetivo de este proyecto
es definirla para que futuros trabajos tengan una base con la cuál trabajar y así
facilitar y acelerar el desarrollo.
10
3. Diseño y Especificaciones
a. Definición del problema
Se quiere definir una arquitectura de aplicaciones Web que integre los robots Lego
EV3, los cuales puedan recibir instrucciones desde una aplicación Web que esté
desplegada y se esté ejecutando en un computador de un usuario.
b. Especificaciones
Requerimientos no funcionales:
-Las conexiones entre cliente, servidor intermedio y robot no deben tardar más
de 2 segundos.
-La arquitectura definida debe ser escalable.
-La arquitectura debe ser funcional desde diferentes navegadores web.
-Las transformaciones de información realizadas por el servidor intermedio no
deben ser demoradas.
Requerimientos funcionales
-El usuario debe poder establecer conexión con un robot ubicado en el
laboratorio.
-El usuario debe poder abrir la aplicación Web desde internet.
-El usuario debe poder enviar una instrucción al robot desde la aplicación
Web.
-El robot debe poder conectarse y retroalimentar al usuario de su estado de
conexión.
-El robot debe poder ejecutar las instrucciones recibidas.
11
Figura 5. Diagrama Casos de Uso.
c. Restricciones
-La arquitectura funcionará con un primer robot.
-El espacio físico requerido en el laboratorio para realizar las pruebas con el robot.
-El robot funciona con 6 baterías doble A.
-La capacidad del robot al soportar una cantidad máxima de sensores al tiempo.
-Se utiliza un adaptador bluetooth para la conexión del servidor con el robot.
-El despliegue de la aplicación Web y su conexión con el servidor a través de internet.
-El tiempo de ejecución de comandos por parte del robot.
-El robot necesita instalación de API para su correcto funcionamiento con el sistema.
12
4. Desarrollo del Diseño
Inicialmente, se hizo un análisis de las herramientas a usar para el desarrollo del proyecto
propuesto. Se escogió el uso de Eclipse para el desarrollo del Backend debido a la disponibilidad
de un plugin de LeJOS (para facilitar la conexión con el robot) en el Eclipse Marketplace
(https://marketplace.eclipse.org/content/lejos-ev3-plug), en su versión de Eclipse Oxygen
(https://www.eclipse.org/downloads/). Luego, se realizaron las instalaciones necesarias tanto en
el robot como en el computador de conexión con el robot. Para esto, se buscó en la wiki de
LeJOS EV3 los pasos necesarios (https://sourceforge.net/p/lejos/wiki/Home/).
A continuación, se muestra el diagrama de despliegue y de componentes de la arquitectura
propuesta.
Figura 6. Diagrama de componentes
En este diagrama se presentan los componentes que debe tener la arquitectura. El cliente Web se
encarga de enviar instrucciones al Servidor intermedio a través del protocolo HTTP. El servidor
intermedio obtiene la petición, la descompone y le pasa la instrucción al robot Lego. Este obtiene
la instrucción y la ejecuta, una vez terminada la instrucción, el servidor intermedio le responde al
cliente Web que la ejecución de la acción fue exitosa.
13
Figura 7. Diagrama de Despliegue
En este diagrama de despliegue se puede observar los diferentes niveles de despliegue que se
encuentran en la aplicación. Tanto el Cliente Web, como el Mediador, se encuentran
desplegados/ejecutándose en el servidor intermedio. Un usuario accede al cliente Web desde un
navegador Web en un computador externo a través de internet. El Mediador (aplicación Java) se
comunica con el cliente Web a través de un socket TPC/IP y con el robot a través de Bluetooth.
a. Componente Cliente Web
El Cliente Web se encargará de enviar los comandos que el usuario desea ejecutar, además de
pedir información base del robot o información de alguno de los sensores que tenga el robot.
Esto a través de protocolo HTTP, donde enviara peticiones de tipo GET y POST hacia el puerto
definido en el Servidor Intermedio.
b. Componente Servidor Intermedio
Este componente se encargará tanto de desplegar el cliente Web, como mantener en ejecución el
programa (Mediador) que recibe las peticiones del cliente Web y envía las instrucciones al robot.
Las peticiones HTTP enviadas desde el cliente se recibirán y resolverán usando la clase
14
HttpServer de la API de Java SE. Luego de obtener la instrucción, se analiza cuál instrucción es
y se procede a llamar el método correspondiente para que el robot la ejecute.
En las siguientes tablas, se pueden apreciar cuales son las instrucciones definidas que puede
ejecutar el robot en el demo con su descripción:
Simple Instructions
Command Description
begin Starts the connection with the robot (Must start from here to test demo).
done Closes the connection to the robot.
close Closes the connection to the server, server stops.
forward Moves forward for a certain time.
backward Moves backwards for a certain time.
right Rotates the robot to the right.
left Rotates the robot to the left.
Complex Instructions
Command Description
Parameter Number that the robot will execute a certain instruction.
Type Type of the parameter. If time, the parameter will be in seconds.
done Closes the connection to the robot.
close Closes the connection to the server, server stops.
forward Moves forward for a certain time. (If parameter type is time, it will move
for the indicated time).
backward Moves backwards for a certain time. (If parameter type is time, it will
move for the indicated time)
right Rotates the robot to the right. (If parameter type is time, it will move for
the indicated time, if it’s angle, the robot will rotate the indicated angle)
left Rotates the robot to the left. (If parameter type is time, it will move for the
indicated time, if it’s angle, the robot will rotate the indicated angle)
15
c. Componente Robot Lego EV3
El robot se conecta con el Mediador a través de Bluetooth para recibir y ejecutar las
instrucciones dadas por el usuario en el cliente Web.
d. Construcción del robot
Se realizó la construcción de un modelo de robot para realizar pruebas bases de conexión y
recepción de comandos de movimientos sencillos. El modelo escogido es llamado BOBB3E
(https://www.lego.com/es-es/mindstorms/build-a-robot/bobb3e). Este modelo puede realizar
movimientos de rotación de manera sencilla y además tiene la posibilidad de usar varios motores
y el sensor infrarrojo que trae el kit de Lego.
Figura 8. Modelo BOBB3E
e. Pruebas
Pruebas de Conexión entre Mediador/Robot:
Realizar pruebas de conexión entre el Mediador y el Robot usando la API de LeJOS para detallar
su funcionamiento y qué métodos disponibles presenta la misma. Para esto se crea un proyecto
16
en Java que integra la API y se conecte con el robot mediante Bluetooth, el cual deberá ejecutar
un comando básico para corroborar la conexión exitosa.
Pruebas de Conexión entre Mediador/Cliente Web:
Realizar pruebas de conexión entre el Mediador y el Cliente Web. Para esto se implementa en
Java un servidor que reciba peticiones HTTP y responda al Cliente Web de la conexión exitosa.
Pruebas de Conexión entre Cliente Web/Mediador/Robot:
Realizar pruebas de conexión entre los 3 componentes presentes en la arquitectura para lograr
demostrar que la misma funcione y pueda ser replicada para aplicaciones futuras que integren
estos tipos de tecnologías.
Pruebas de comandos de movimientos:
Realizar pruebas sencillas y complejas de varios comandos de movimiento. Entre ellos, mover el
robot hacia adelante/atrás, girarlo hacia la derecha/izquierda como comandos sencillos. Como
comandos complejos se realizan movimientos similares a los anteriores, con la diferencia de que
se le agrega un parámetro de tiempo/ángulo dado por el usuario en el cliente Web, el cual el
robot debe ejecutar.
Pruebas de recepción de información dada por el robot:
Realizar pruebas en las que se le pregunta al robot desde el cliente Web información básica sobre
su estado y sobre algún sensor que posea, por ejemplo, el nivel de la batería, el nombre del robot,
si se detecta un objeto a que distancia se encuentra, etc.
f. Alternativas de diseño
Como alternativa de diseño se propone que el despliegue del cliente Web sea en una plataforma
cloud, con el objetivo de que se pueda acceder al cliente Web desde cualquier computador y se
pueda manejar el robot de una manera remota.
Además, se puede incluir el uso de múltiples robots en la arquitectura para que múltiples
usuarios puedan controlarlos de forma remota.
17
5. Implementación
En este capítulo se mostrará el desarrollo e implementación del demo que expone los
componentes de la arquitectura definida en los capítulos anteriores. La conexión entre cada uno
de los componentes, la recepción de peticiones de parte del cliente Web, la ejecución de
comandos enviados del Mediador al robot, la traducción de las peticiones a comandos, el diseño
del Cliente Web y la integración de la API LeJOS.
a. Etapa 1: Instalación de LeJOS en el robot
Como primera etapa de implementación, se buscó la manera de instalar la API LeJOS en el robot.
Para esto, primero se debe instalar LeJOS en el computador (para el proyecto se instaló la
versión 0.9.1 beta, la cual solo es compatible con JDK 1.7,
https://sourceforge.net/projects/ev3.lejos.p/files/), el cual permite usar una herramienta para la
instalación del mismo programa en el robot. El siguiente paso, es descargar a través de la página
de Oracle el JDK versión 1.7 para EV3
(http://www.oracle.com/technetwork/java/embedded/downloads/javase/javaseemeddedev3-
1982511.html). Luego, se debe insertar una tarjeta SD de 2GB o mayor (para el proyecto se
utilizó una microSD de 2GB) en el computador y ejecutar el programa de creación de tarjeta que
trae LeJOS (llamado ev3sdcard.bat). Seleccionar la tarjeta en donde se creará el instalador, la
imagen de LeJOS (seleccionada automáticamente en algunos casos) y el JDK descargado
(archivo de tipo .tar.gz), para crear el instalador.
Una vez creado el instalador de LeJOS, extraer la tarjeta e insertarla en el ladrillo del robot.
Encenderlo y esperar a que acabe la instalación. Una vez acabe de instalar, el robot muestra el
menú de LeJOS en su pantalla. Las configuraciones que están por defecto en el robot con el
programa son suficientes para realizar las pruebas.
Como siguiente paso, se agrega por Bluetooth el robot EV3 desde el computador (El PIN por
defecto es 1234) y luego en el Panel de Control, se selecciona Dispositivos e Impresoras y se
conecta el EV3 como Punto de Acceso. A continuación, para probar la conexión y el correcto
funcionamiento del robot, se crea un proyecto Java en eclipse, el cuál utilizará los métodos de la
API LeJOS para los comandos del robot. Antes de realizar código, se debe ir a la ventana de
preferencias en eclipse, dar en la opción de LeJOS EV3 y colocar “Conectarse a dispositivo” y
18
colocar la IP del robot (por defecto es 10.0.1.1). Con estos pasos, ya se pueden enviar comandos
al robot para que éste los pueda ejecutar.
Figura 9. Configuración Eclipse
19
b. Etapa 2: Desarrollo Mediador básico y pruebas de comunicación
Servidor Intermedio-Robot.
Para la siguiente etapa, se comienza el desarrollo del Mediador en el servidor intermedio para
realizar pruebas de conexión y comandos básicos del robot.
Primero, se debe crear el buscador de “ladrillos” y crear un robot EV3 a partir de obtener el
ladrillo por defecto (busca el ladrillo con la IP colocada en la configuración anterior) y también
se crean los motores según el puerto al que estén conectados (Además, se le asigna por defecto
que son de tamaño L).
Figura 10. Creación de Objeto Robot
Luego, se crean métodos para probar tanto la conexión, como la ejecución de un comando
sencillo.
Figura 11. Comando sencillo de sonido
20
Figura 12. Comando Sencillo de movimiento
Si las configuraciones son correctas, el robot debe de realizar un sonido y luego moverse hacia
adelante por un cierto tiempo (dado por el método Delay en milisegundos colocado ante de
detener los motores, en este caso la constante DELAY es 6000). Un pequeño detalle en el
comando de movimiento es que los motores usan el comando contrario, esto es debido al modelo
del robot construido, ya que cuando los motores giran hacia atrás, la forma en la que las ruedas
están colocadas hará que giren hacia el lado contrario al de los motores, por lo que, para
movimiento hacia adelante, se debe ejecutar el movimiento contrario en los motores.
c. Etapa 3: Desarrollo y Pruebas de conexión Cliente Web-Servidor
intermedio
Para el desarrollo del Cliente Web, se eligió Angular 5 como herramienta de creación de
aplicaciones Web. Esto debido a que, además de tener buenos tutoriales para aplicaciones
básicas, es fácil de manejar y permite realizar fácilmente conexiones con otras aplicaciones que
actúan como backend.
Primero, se utiliza Angular para crear la parte visual de la aplicación y lógica que se encargará de
enviar peticiones al Mediador. Angular ofrece funciones para enviar peticiones HTTP a una
dirección o end-point definido, con las cuales se comunicará con el Mediador. Siguiendo los
tutoriales básicos de Angular 5 para lo anteriormente dicho, se obtienen los siguientes resultados:
21
La imagen anterior muestra la interfaz gráfica del Cliente Web. La siguiente imagen muestra la
lógica detrás del formulario para enviar instrucciones simples y compuestas:
Figura 14. Lógica de envío de Instrucciones del Formulario
Figura 13. Aplicación Demo Navegador
22
En la siguiente imagen se puede apreciar los métodos llamados en la imagen anterior y cómo
funcionan (estos finalmente son los que envían las peticiones HTTP al servidor intermedio).
Usando la IP del computador (la cual se llama POST_MEDIATOR_URL en el código de
Angular de la imagen anterior) donde se encuentra ejecutando el Mediador y el puerto asignado
en el mismo (llamada “port” en el código java del Mediador), se crean unos objetos con la
instrucción y parámetros dados por el usuario y se añaden a las peticiones:
Figura 15. Lógica de métodos de envío de instrucciones
Por parte del Mediador en el Servidor Intermedio, se creó la clase “RequestHandler” que se
encargará del manejo de las peticiones.
23
Figura 16. Método para manejar las peticiones HTTP
Al inicio se tenía problemas para poder recibir las peticiones POST y GET debido a que Chrome
(navegador que se usa para la aplicación Web) tenía control de acceso (el tipo de petición llegaba
como OPTIONS en vez de POST) que no permitía al Mediador recibir correctamente las
peticiones por lo que, como se puede apreciar en la imagen anterior, se mira el tipo de método
para la petición y si concuerda con OPTIONS, se le añaden a los headers de la petición los
métodos permitidos en la conexión, para finalmente poder recibir la petición POST normal. Una
vez se recibe la petición POST, se extraen la instrucción y los parámetros asociados a la misma y
luego se le envía la instrucción al robot (actualizando cual tipo de instrucción es la actual).
24
Figura 17. Clase Principal del mediador para recibir las peticiones
La imagen anterior representa la clase principal “Main” donde se ejecuta el servidor que recibe
las peticiones usando un servidor nativo de Java SE llamado HttpServer. El servidor se crea con
un socket con puerto definido (en este caso 1234) y se crea un contexto con la clase que maneja
peticiones GET y POST. Una vez se recibe una petición, en la clase de manejador de peticiones
se actualiza la variable global “actualInstruction” para que se pueda utilizar luego en la
ejecución de comandos del robot.
d. Etapa 4: Integración Cliente Web-Servidor Intermedio-Robot
La integración entre los componentes de la arquitectura empieza con la definición de unos
métodos en la clase principal del servidor para enviarle al robot los comandos que debe seguir,
como por ejemplo el siguiente método:
Figura 18. Método para ejecución de una instrucción simple
25
Luego, como se puede observar en la clase que maneja las peticiones HTTP en la etapa anterior,
se hace un llamado al método para ejecutar la instrucción en el robot. Finalmente, las clases del
Mediador quedan organizadas de la siguiente forma:
Figura 19. Diagrama de Clases Mediador
Donde Main es la clase principal donde se ejecuta el servidor HTTP y las instrucciones del robot,
RequestHandler es la clase que se encarga de extraer las instrucciones recibidas del cliente Web
y EV3 es la clase en donde se crea la conexión Bluetooth con el robot y los comandos que
ejecutará utilizando la API LeJOS.
Todo esto forma el demo que muestra en funcionamiento la arquitectura definida en este trabajo.
26
6. Análisis de Resultados
Con respecto a las pruebas de conexión entre cada uno de los componentes de la arquitectura, las
pruebas fueron realizadas con éxito. La prueba de conexión entre el cliente Web, el Mediador y
el robot consiste en: Primero, enviar el comando “begin” desde el cliente Web a través de una
instrucción simple mientras el servidor intermedio está en ejecución. Una vez la petición llegue
al servidor intermedio, este debe crear la conexión Bluetooth con el robot que se encuentra
esperando (creado en el programa el objeto EV3). Después de que se crea la conexión con el
robot, el servidor intermedio le responde al cliente Web la petición y este imprime en la consola
del navegador la petición POST completada.
Figura 20. Respuesta Ejemplo Conexión Robot
27
Figura 21. Respuesta ejemplo con comando “close”
Para las pruebas de comandos de movimientos, la mayoría de las pruebas fueron exitosas. Los
movimientos simples son ejecutados fácilmente por el robot en el tiempo indicado.
Instrucción Simple Resultado
Begin Exitoso
Done Exitoso
Close Exitoso
Forward Exitoso
Backward Exitoso
Right Exitoso
Left Exitoso
Los movimientos complejos con parámetros de tiempo fueron realizados exitosamente. A
diferencia de los anteriores, los comandos complejos con parámetros de ángulos no respondieron
de la manera deseada debido a que las rotaciones se aplican a los motores (por ejemplo, rotan
90°), pero el robot termina rotando poco. Por esta razón, se agregó una multiplicación en el
ángulo recibido para que la rotación fuera lo más cercana posible a la indicada por el usuario.
28
Figura 22. Respuesta ejemplo comando complejo “forward” con parámetro de tipo tiempo
Instrucción
Compleja
Parámetro Tipo Resultado
Done 0 - Exitoso
Close 0 - Exitoso
Forward 10 Tiempo (segundos) Exitoso
Backward 10 Tiempo (segundos) Exitoso
Right 90 Angulo (grados) Exitoso
Left 90 Angulo (grados) Exitoso
Con respecto a las pruebas de retroalimentación del robot se pudieron completar correctamente.
El cliente Web recibe la información dada por el robot y la muestra correctamente como se
puede observar en las siguientes imágenes.
Figura 23. Parte visual previa a la consulta de información
29
Figura 24. Ejecución de la consulta sin obstáculo presente
Figura 25. Consulta con obstáculo presente
30
7. Conclusiones y Trabajo futuro
Por medio de este trabajo, se mostró la definición y construcción de una arquitectura base para el
desarrollo de aplicaciones Web que permiten la conexión con robots Lego Mindstorms EV3.
Inicialmente, se comenzó por analizar los antecedentes que existen en el momento, y de éstos se
concluyó que diseñar una arquitectura de estilo Cliente-Servidor era la más indicada para la
creación de este tipo de aplicaciones. Se construyó un modelo de robot que pueda realizar
diferentes tipos de movimientos de tal forma que no presentara alguna restricción. Luego, se
estudia la forma en la que funciona el robot Lego Mindstorms EV3 junto con la API LeJOS
instalada en Él. Se hacen las configuraciones para que la API pueda funcionar en el robot,
instalándola en una tarjeta SD e insertándola en el mismo. Una vez entendido el funcionamiento
del robot, el cómo se conecta con un computador a través de Bluetooth y la API LeJOS, se
procede a crear un proyecto Java para analizar los comandos disponibles dados por LeJOS para
controlar el robot. Una vez esto se ha llevado a cabo, se procede a estudiar cómo crear una
aplicación Web con Angular 5 y cómo conectarla con una aplicación Java ubicada en un
computador diferente. Esto gracias al protocolo HTTP se puede lograr, para que un usuario
pueda enviar instrucciones desde un navegador Web y controlar al robot de manera remota.
Las pruebas realizadas para verificar el correcto funcionamiento del demo realizado para este
trabajo fueron, en su mayoría, exitosas. Los comandos básicos de movimiento se ejecutaron de
manera ideal; los comandos complejos, por el otro lado, fueron exitosos en su mayoría. Los
comandos complejos con parámetros de tiempo de ejecución fueron completados correctamente,
pero los que eran de tipo ángulo como parámetro, no funcionaban de la manera esperada, por lo
que se necesitó de una pequeña modificación en el código. Además, no se completaron las
pruebas de retroalimentación de información de parte del robot hacia el cliente Web debido a que
no se terminó el proceso de envío de información.
A partir de los resultados obtenidos anteriormente, se pueden realizar más pruebas con el robot
para demostrar lo que se puede lograr con una aplicación Web basada en la arquitectura definida.
Pruebas de los diferentes sensores que posee el robot (por separado), son un ejemplo de otras
pruebas que se pueden realizar. A partir de lo definido en este proyecto, se puede proponer más
proyectos como lo son la realización de navegación en un laberinto con obstáculos que el robot
31
debe resolver, ejecución de una lista de comandos dados por un usuario (estilo ambiente de
aprendizaje para programar), proyecto con múltiples robots que puedan interactuar entre sí,
realización de una aplicación móvil que pueda controlar el robot integrando la API LeJOS. Estos
son algunos ejemplos que pueden llegar a ser en un futuro nuevos proyectos.
32
8. Bibliografía
[1] M. S. d. S. Lopes, I. P. Gomes, R. M. P. Trindade, A. F. da Silva and A. C. d. C. Lima, "Web
Environment for Programming and Control of a Mobile Robot in a Remote Laboratory," in IEEE
Transactions on Learning Technologies, vol. 10, no. 4, pp. 526-531, Oct.-Dec. 1 2017.
doi: 10.1109/TLT.2016.2627565
URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7740908&isnumber=8207712
[2] D. Maraj and A. Maraj, "Implementation of gesture based applications and communication
with Lego Mindstorm EV3," 2017 6th Mediterranean Conference on Embedded Computing
(MECO), Bar, 2017, pp. 1-4.
doi: 10.1109/MECO.2017.7977236
URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7977236&isnumber=7977112
[3] Acero, D. C. & Sanchez, K. D. (2011). TELEROBOT-LAB Laboratorio remoto de robótica
móvil. Documento de Proyecto de Grado – Universidad de los Andes, Colombia, 2011.
[4] Maté, F. (2016). LABBOT: Laboratorio de programación con robots móviles. Documento de
Proyecto de Grado – Universidad de los Andes, Colombia, 2016.
33
9. Apéndice A
Instrucciones por seguir para ejecutar el demo:
1. Conectar por Bluetooth el robot: se debe encender el robot EV3 y esperar a que aparezca
el menú principal de LeJOS (tarjeta SD debe estar insertada).
2. Emparejar el robot con el computador que ejecutará el Mediador (para esto, ir a opciones
de Bluetooth-> agregar nuevo dispositivo-> buscar el robot).
3. Conectar el robot como red LAN (panel de control->dispositivos e impresoras-> otros
dispositivos-> click derecho en robot EV3-> conectar como red).
4. Definir la IP del computador que ejecuta el Mediador en el componente
mediator.service.ts del cliente Web.
5. Ejecutar la aplicación cliente Web (para esto, abrir la consola de Windows -> ir hasta la
carpeta del proyecto del cliente web-> ejecutar el comando ng serve --open)
6. Una vez ejecutado el cliente Web, lo primero que se debe hacer es mandar el comando
“begin” a través de una instrucción simple para empezar la comunicación con el
Mediador y el robot Lego.
7. Se puede probar cualquier comando disponible una vez se establezca correctamente la
conexión.
8. Para terminar la conexión con el robot, pero mantener la conexión con el servidor, se
debe ejecutar el comando “done”. Este cerrará la conexión con el robot, pero no con el
servidor, si se desea conectarse nuevamente al robot, ejecutar el comando “begin” de
nuevo.
9. Para cerrar la conexión con el servidor y acabar la ejecución del programa Mediador, se
debe ejecutar el comando “close”.
