Evaluación de Middlewares Sensibles al Contexto
76
Universidad ORT Uruguay Facultad de Ingeniería Evaluación de Middlewares Sensibles al Contexto Entregado como requisito para la obtención del título de Licenciatura en Ingeniería de Software. Mateus Würth - 147799 Tutor: Santiago Matalonga 2015
Transcript of Evaluación de Middlewares Sensibles al Contexto
Universidad ORT Uruguay
Facultad de Ingeniería
Evaluación de Middlewares Sensibles al
Contexto
Entregado como requisito para la obtención del título
de Licenciatura en Ingeniería de Software.
Mateus Würth - 147799
Tutor: Santiago Matalonga
2015
2
Declaración de autoría
Yo, Mateus Würth, declaro que el trabajo que se presenta en esta obra es de mi propia mano. Puedo
asegurar que:
La obra fue producida en su totalidad mientras realizaba el proyecto de Licenciatura de
Ingeniería de Software;
Cuando he consultado el trabajo publicado por otros, lo he atribuido con claridad;
Cuando he citado obras de otros, he indicado las fuentes. Con excepción de estas citas, la
obra es enteramente mía;
En la obra, he acusado recibo de las ayudas recibidas;
Cuando la obra se basa en trabajo realizado conjuntamente con otros, he explicado
claramente qué fue contribuido por otros, y qué fue contribuido por mí;
Ninguna parte de este trabajo ha sido publicada previamente a su entrega, excepto donde
se han realizado las aclaraciones correspondientes.
XMateus Wurth
Autor
Fecha: 03/02/2015
3
Agradecimientos
Me gustaría comenzar por las personas que hicieron posible la presentación de este trabajo. Desde
principios del año 2014 retome la actividad estudiantil, concurriendo a la facultad con el objetivo de
finalizar lo que en el año 2008 comencé. Las razones son variadas por las cuales en su momento
tuve que abandonar la carrera. Frente a la oportunidad de retomar en el año 2014 concurrí a la
universidad para informarme del estado en el que me encontraba académicamente y además volver
a dictar clases como docente. En ese momento tuve un apoyo muy grande de Patricia Corbo la cual
me impulso y ayudo a concretar todo lo que necesite. Además de motivarme a seguir en la búsqueda
e investigación de tecnologías como Arduino y Raspberry Pi (las cuales eran de gran interés para mí
y fueron utilizadas en este proyecto). Por todo esto con especial énfasis quería agradecerle todo el
tiempo que me dedico.
En segundo lugar quería agradecerles a Martin Solari y Nora Szasz, las personas que lograron
coordinar este proyecto para que fuera de interés de la facultad y mío.
Además quiero agradecerles también a aquellas personas que durante el proceso de la elaboración
del trabajo colaboraron con el desarrollo del mismo.
En primer lugar, agradezco a Santiago Matalonga como tutor, quien me apoyo en el transcurso del
proyecto y me brindo su experiencia y conocimiento para finalizar este trabajo.
En segundo lugar al grupo del Freedomotic, los cuales me ayudaron a solucionar problemas del
framework, luego de informarlos de funcionalidades que no realizaban lo esperado.
Finalmente a toda mi familia, con especial énfasis a mi esposa e hija las cuales me acompañaron en
todo el proceso.
Muchas gracias a todos.
4
Abstract
Los objetivos principales de este trabajo son identificar y clasificar los principales middlewares
sensibles al contexto, con la intención de profundizar en su análisis. Para cumplir dichos objetivos,
se han utilizado como marco teórico, tesis de carreras y publicaciones internacionales que, no solo
contemplan el desarrollo tecnológico, sino también el impacto en los vínculos sociales y culturales.
Una de las principales motivaciones que promueve la realización de esta investigación, es la
creciente demanda de usuarios con la necesidad de recolectar información de su entorno.
La sensibilidad al contexto busca comprender la situación de un usuario con su entorno y permite
tomar decisiones autónomas o no, para proporcionarle una experiencia de alta calidad al mismo.
Incorporando dicha sensibilidad a aplicaciones y servicios computacionales, se logra identificar y
reaccionar al estado de las variables del contexto del mismo.
Las principales tecnologías de software que se utilizaron fueron Android, Arduino y Java,
construyendo además un prototipo de hardware que permite realizar las pruebas sobre todos los
middlewares evaluados.
Con el prototipo de hardware desarrollado se logra definir un marco común de estudio para todos
los middlewares, obteniendo como consecuencia reportes con los resultados obtenidos de la prueba
de dichos componentes. En particular el caso de estudio que se analiza brinda la funcionalidad de
encender o apagar cualquier dispositivo electrónico (en el caso del proyecto una fuente de luz),
tomando como contexto la proximidad del usuario.
Profundizando aún más en el concepto de middleware sensibles al contexto, se presentan formas de
recolección de datos desde el ambiente y desde otros orígenes.
Luego de realizar el análisis y evaluación de estos middlewares se lograron observar avances en el
campo de los middlewares sensibles al contexto, aunque considero que aún no se encuentra lo
suficientemente maduro para poder integrarlos en aplicaciones comerciales. Esto es debido a que
para intentar lograr dicha integración se realizaron cambios sobre el software que originalmente se
obtuvo, obteniendo en algunos casos resultados positivos y en otros negativos.
5
Palabras clave:
Context Aware
Middleware
Arduino
Middlewares sensibles al contexto
6
Índice:
1. Análisis de Middlewares Sensibles al Contexto ......................................................... 9
1.1 Introducción a los Middlewares Sensibles al Contexto:.......................................... 9
1.2 Objetivos principales ............................................................................................. 10
1.3 Metodología de trabajo:......................................................................................... 10
1.4 Organización de este documento:.......................................................................... 11
2. Resumen de Investigación en Aplicaciones Sensibles al Contexto ........................... 13
2.1 Aplicaciones sensibles al contexto ........................................................................ 13
2.2 Arquitectura de aplicaciones y middlewares sensibles al contexto ....................... 14
2.3 Servidor de Contexto (Context Server): ................................................................ 14
3. Arduino........................................................................................................................ 16
3.1 Evaluación RSCM ................................................................................................. 33
3.1 Introducción:.......................................................................................................... 16
3.2 Obtención Información de su entorno: .................................................................. 16
3.3 Comando Importantes del Leguaje:....................................................................... 16
3.4 Secciones De Programación en Arduino .............................................................. 17
4. Descripción de los Middlewares Encontrados ............................................................ 18
4.1 Proceso de Identificación de Búsqueda. ................................................................ 18
4.1 RSCM .................................................................................................................... 18
4.1.1 Principales componentes de RSCM .................................................................. 18
4.1.2 Arquitectura ........................................................................................................ 19
4.2 FreeDomotic .......................................................................................................... 20
4.2.1 Principales componentes .................................................................................... 20
4.2.2 Características adicionales.................................................................................. 20
4.2.3 Arquitectura ........................................................................................................ 21
4.2.4 Proceso de funcionamiento................................................................................. 22
4.3 Msense....................................................................................................................... 23
4.3.1 Nodos de sensores de bajo nivel actuales:.......................................................... 23
4.3.2 Nodos de sensores de alto nivel.......................................................................... 24
4.3.3 Arquitectura ........................................................................................................ 24
4.4 LOCCAM .................................................................................................................. 25
4.4.1 Principales Componentes: .................................................................................. 25
5. Evaluación: .................................................................................................................. 27
5.1 Criterios de selección para la evaluación ............................................................. 27
5.1.1 Criterios que clasificaron en la categoría 1 ........................................................ 28
5.1.2 Criterios que clasificaron en la categoría 2 y 3 .................................................. 28
5.1.3 Criterios que clasificaron en la categoría 4 ........................................................ 28
5.2 Descripción de los criterios: .................................................................................. 28
7
5.3 Puntajes asignados a los criterios: ......................................................................... 29
5.4 Evaluación de los Middlewares sensibles al contexto seleccionado ..................... 31
5.4.1 Evaluación RSCM .............................................................................................. 31
5.4.2 Evaluación FreeDomotic .................................................................................... 32
5.4.3 Evaluación mSense............................................................................................. 32
5.4.4 Evaluación Loccam ............................................................................................ 33
5.5 Comparación de puntajes ...................................................................................... 34
6. Fase Experimental: ...................................................................................................... 35
6.1. Plan de Trabajo ..................................................................................................... 35
6.1.1 Definición del caso de estudio............................................................................ 35
6.1.2 Objetivos: .......................................................................................................... 35
6.2 Circuito Integrado de 2 Reles + Transistores + Leds ........................................... 36
6.3 Descripción del diagrama del circuito electrónico: ............................................... 37
6.4 Principales componentes del circuito: ................................................................... 37
6.4.1 Forma de Interconectar los anteriores componentes: ......................................... 37
6.5 Descripción de los componentes utilizados........................................................... 38
7. Implementación de los casos de estudio: .................................................................... 40
7.1 Java + Arduino ...................................................................................................... 40
7.1.1 Descripción:........................................................................................................ 40
7.1.2 Programando el micro controlador: .................................................................... 41
7.1.3 Resultados : ........................................................................................................ 43
7.1.4 Prueba del caso de estudio con la aplicación Java ............................................. 44
7.2 RSCM +Arduino ................................................................................................... 45
7.2.1 Descripción ......................................................................................................... 45
7.2.1 Medidas de mitigación de errores: ..................................................................... 48
7.2.1.2 Creación del contexto ...................................................................................... 45
7.2.2 Configuración + Programación .......................................................................... 45
7.2.2.1 Proceso de instalación ..................................................................................... 45
7.2.2.3 Programando el contexto ................................................................................. 46
7.2.2.4 Programando el sensor .................................................................................... 46
7.2.3 Resultados........................................................................................................... 48
7.3 FreeDomotic + Arduino ........................................................................................ 50
7.3.1 Descripción:........................................................................................................ 50
7.3.2 Configuración + Programación: ......................................................................... 51
7.3.2. Resultados: ........................................................................................................ 53
7.3.2.1 Configuración de Freedomotic ........................................................................ 51
7.3.2.3 Programando Arduino ..................................................................................... 52
7.4 mSense +Arduino .................................................................................................. 54
7.5 LOCCAM +Arduino ............................................................................................. 54
7.5.1 Descripción ......................................................................................................... 54
7.5.2 Configuración ..................................................................................................... 54
8
8. Conclusiones ............................................................................................................... 56
9. Bibliografía: ................................................................................................................ 58
10. Anexos....................................................................................................................... 60
10.1 Instalación de Maven :......................................................................................... 60
10.10 Controlar flujo de corriente eléctrica:................................................................ 75
10.2 Guía de Instalación de FreeDomotic: .................................................................. 63
10.3 Configuración de FreeDomotic Con Arduino .................................................... 65
10.4 Circuito detallado del hardware para el caso de estudio ..................................... 69
10.5 Wheather Undergound......................................................................................... 70
10.6 Localización de Celulares: .................................................................................. 72
10.7 Medir Temperatura con Arduino ......................................................................... 72
10.8 Censar Movimiento con Arduino: ....................................................................... 73
10.9 Medición de Distancia con Arduino:................................................................... 74
9
1. Evaluación de Middlewares Sensibles al Contexto
A continuación se presentan características generales del trabajo.
1.1 Introducción a los Middlewares Sensibles al Contexto
En respuesta a la sensibilidad al contexto se busca entender la situación de un usuario y así poder
proporcionarle una experiencia de alta calidad. Con el fin de obtener mejores resultados se busca
identificar y establecer cuáles son las variables que forman parte de dicho entorno.
Las aplicaciones sensibles al contexto consiguen dichos objetivos mediante el uso de servicios que
remotamente brindan información del entorno de ejecución de otros sistemas, así como también de
sensores que la brindan localmente. Dependiendo de las metas que posea cada usuario con dicha
aplicación, cada acción genera una reacción. Para que el usuario detecte dicha reacción, el sistema
pasa por tres etapas. La primera es la recolección de datos, esta implica la utilización de sensores
(Locales o no). La segunda es el procesamiento de la información, donde se interpretan los datos de
la etapa anterior y se notifica a los actores miembros de la tercera etapa, los cuales hacen visible
todo el proceso (reacción).
Uno de los problemas que surge cuando se incorporan estas aplicaciones a dispositivos móviles, es
el procesamiento limitado que muchos poseen en la actualidad, ya que sin la aparición de otro
componente intermedio todo el procesamiento se realiza en dicho dispositivo. Con el objetivo de
aliviar este problema y brindarle escalabilidad a todo el proceso, surgen los middlewares sensibles
al contexto. Dichos middlewares continúan utilizando como un componente principal los
recolectores, pero incorporan a la solución razonadores (en la etapa de procesamiento) que
determinen la forma de actuar luego de recopilada la información. Estos razonadores le brindan a la
solución una estructura genérica para extender el sistema y su comportamiento. Para que posean un
buen funcionamiento se añade cierto grado de inteligencia artificial, que ayude a tomar la mejor
decisión dependiendo del todo el entorno.
El presente trabajo se centra en la evaluación de middlewares sensibles al contexto entendiendo
como middleware; “Un software de conectividad que ofrece un conjunto de servicios que hacen
posible el funcionamiento de aplicaciones distribuidas sobre plataformas heterogéneas. Funciona
como una capa de abstracción de software distribuida, que se sitúa entre las capas de aplicaciones y
las capas inferiores (sistema operativo y red)”.
Gracias a los avances de tecnologías y dispositivos móviles, se espera poder disminuir la sobrecarga
de procesamiento que estos empiezan a tener, brindando al usuario las mismas funcionalidades que
podría tener desde su dispositivo preferido. Este objetivo se puede alcanzar procesando la
información y gestionando todo su procesamiento desde otro componente con mayor capacidad,
otorgando al usuario una interfaz para interactuar con dicho middleware.
Para poder evaluar estos middlewares se determinó la utilización de hardware libre. En esta ocasión
se utilizará Arduino como un medio de recolección de información, interactuando con sensores de
10
distancia y movimiento, además de contar con actores como relés que permitirán encender las luces
con un comportamiento pre programado.
1.2 Objetivos principales
A continuación se detallaran los dos objetivos primordiales del proyecto:
Identificar y evaluar frameworks o middleware existentes para sistemas sensibles al
contexto.
Determinar alcance y su futura permanencia a través del tiempo.
Brindar formas de extender la recolección de información.
Crear una aplicación Java que administre el mismo caso de estudio que el de los
middlewares.
1.3 Metodología de trabajo
La metodología utilizada para completar los objetivos de este trabajo, consistió en los siguientes
pasos:
Lectura de Literatura:
Se realizó una lectura de la literatura para entender el funcionamiento de las aplicaciones
sensibles al contexto y sus principales componentes. El resumen se encuentra en el
capítulo 2.
Identificación de Middleware sensibles al contexto a evaluar:
Para realizar la búsqueda se recurrió a documentos técnicos, los cuales mencionan, en
algunos casos, trabajos de posgrado que exponen dichos middlewares. También se
indagó en foros y portales de internet.
Elaboración de criterios de evaluación:
Se determinaron los criterios más importantes para la evaluación de los middlewares,
que contemplan las principales necesidades de la sensibilidad al contexto.
Elaboración del caso de estudio:
En esta etapa se determinó que información del contexto sería importante para realizar
pruebas sobre cada middleware. Además se identificó el hardware necesario para llevar a
cabo dicho caso, con su posterior implementación.
11
Realización de la evaluación:
Se intentó establecer la comunicación entre el hardware y cada middleware, con el
objetivo de realizar la prueba sobre el caso de estudio antes definido. Asimismo se
generaron reportes sobre los puntajes obtenidos en cada sección.
1.4 Organización de este documento
El documento presenta los siguientes capítulos:
Capítulo 2:
En este capítulo se introduce a los middlewares sensibles al contexto, donde se detallan
sus componentes principales y el desarrollo de metodologías para generar aplicaciones
sensibles al contexto.
Capítulo 3:
Es este capítulo se introduce a Arduino, se describen sus principales características,
comandos relevantes del entorno de programación y su estructura.
Capítulo 4:
Este capítulo describe los middlewares que se identificaron y se evaluaron, con el
objetivo de conocer sus arquitecturas y principales características.
Capítulo 5:
Este capítulo describe los criterios que se utilizaron para evaluar los middlewares
seleccionados, además se otorga el puntaje respectivo por cada sección.
Capítulo 6:
En este capítulo se describen los middlewares sensibles al contexto que se tomaron como
objeto de estudio.
Capítulo 7:
Este capítulo se describe la implantación e incorporación de circuitos importantes del
objeto de estudio. Así mismo se da una descripción de la aplicación desarrollada.
Capítulo 8:
Este capítulo desarrolla las conclusiones del trabajo.
Capítulo 9:
Bibliografía
12
Capítulo 10:
Este capítulo posee los anexos del trabajo.
13
2. Resumen de investigación en aplicaciones sensibles al contexto
A continuación se presenta un resumen de las aplicaciones sensibles al contexto.
2.1 Aplicaciones sensibles al contexto
Para comprender que son las aplicaciones sensibles al contexto, en primer lugar se debe definir qué
se concibe por contexto en el marco de estas aplicaciones. Se entiende por contexto al entorno que
rodea a una entidad, siendo esta una persona, lugar u objeto relevante para realizar su estudio.
Para profundizar aún más Dey define: “Un sistema es sensible al contexto si se utiliza para
proporcionar información y / o servicios relevantes para el usuario, donde la relevancia depende de
la tarea del usuario” [1].
Si bien el contexto de cada persona puede ser diferente debido a las necesidades que estos posean,
se pueden clasificar en los siguientes grupos:
Identidad: usuarios, necesidades.
Espacial: ubicación, orientación, velocidad.
Temporal: fecha, hora del día, la estación.
Medio Ambiente: medición de la temperatura, luz y el ruido.
Sociales: personas cercanas, actividades, calendario.
Recursos: disponibilidad, energía.
Computación: CPU, sistema operativo, memoria, interfaces.
Psicología: preferencias, emociones.
A un mayor nivel de abstracción estos grupos todos se podrían clasificar en dos grandes áreas, el
contexto interno y el externo. El interno es el que es capturado de la interacción con el usuario. El
externo que es medido por sensores ajenos al individuo.
14
2.2 Arquitectura de aplicaciones y middlewares sensibles al contexto
A continuación se detalla cómo se pueden clasificar los sistemas sensibles al contexto.
2.2.1 Procesamiento directo de datos
La Imagen 2-1 muestra la estructura general de este tipo de framework.
Se recolectan los datos de los sensores y
luego, el tratamiento de los datos lo
realiza la misma aplicación. Esto genera
una sobrecarga sobre el dispositivo
donde se ejecuta la aplicación. Además
quita escalabilidad a la misma ya que no
posee un comportamiento dinámico [2].
Imagen 2-1
2.2.2 Middleware
La Imagen 2-2 muestra la estructura general de este tipo de framework.
La aplicación delega
responsabilidades al middleware
ocultando detalles de bajo nivel, que
le brindan extensibilidad y
escalabilidad a la solución, ya que no
se debe modificar la aplicación [2].
Imagen 2-2
2.2.3 Servidor de contexto (Context Server):
La Imagen 2-3 muestra las estructura
general de este tipo de framework.
Los sensores y la aplicación se comunican
directamente con el servidor para recolectar
o enviar información. Esta arquitectura
permite múltiples accesos remotos [2].
Imagen 2-3
Servidor/BD
Sensores Aplicación
15
Profundizando en la arquitectura de los middlewares en la Imagen 2-4 a continuación se puede
observar el proceso por el cual se recolecta información y es procesada y transferida a todas las
aplicaciones.
Imagen 2-4 Arquitectura General de los Middlewares Sensibles al contexto [2]
16
3. Arduino
3.1 Introducción
Arduino es una plataforma de hardware libre, basada
en una placa con un micro controlador que permite la
creación de diferentes proyectos de electrónica. Esta
placa posee un leguaje propietario de programación
que permite administrar todo su potencial [3].
Este micro controlador puede tomar información del
entorno a través de sus entradas analógicas y digitales,
lo cual le permite controlar luces, motores y otros
actuadores. E importante destacar que los proyectos
desarrollados con Arduino pueden ejecutarse sin necesidad de conectar a un computador. [4]
Conjugando el concepto de middleware sensible al contexto, con Arduino se logra poseer
información tanto global como local, permitiéndole tomar las mejores decisiones.
3.2 Obtención de información de su entorno
A través de conjunto de pines analógico y digitales, Arduino recolecta toda la información
necesaria, conectando periféricos y programando el comportamiento necesario en el micro
controlador
Cada pin de esta plaqueta puede ser configurado en modo OUTPUT o INPUT.
Si se determina que será de tipo OUTPUT ese pin actuará para encender dispositivos electrónicos,
motores, etc. Básicamente la plaqueta emite voltaje a través de su pin para activar algún dispositivo.
Si se determina que será de tipo INPUT ese pin podrá leer contantemente los voltajes que llegan a
él. De este modo interpretando los valores almacenados, se determina el valor del periférico.
Aclaración: Sin importar que tipo de pin sea hay que agregar la electrónica que haga falta para
poder actuar o recolectar información.
3.3 Comandos importantes del lenguaje
PinMode: Se utiliza para establecer si el pin será del tipo OUTPUT o INPUT. Por ejemplo
PinMode (5,INPUT), establece que el pin 5 de Arduino será del tipo INPUT.
DigitalWrite: Activa un pin que se encuentre configurado del modo OUTPUT.
Imagen 3-1
17
DigitalRead: Lee un valor digital del pin que se le indique y retorna el valor leído del
periférico.
AnalogRead: Lee un valor analógico del pin que se le indique y retorna el valor leído del
periférico.
3.4 Secciones de programación
Sección 1: Se definen las variables y constantes que se utilizaran en el programa.
Sección 2: se determina que pines serán utilizados como INPUT y cuales como OUTPUT,
además de inicializar las variables que se consideren relevantes.
Sección 3: Para concluir Arduino funciona en un eterno loop, ejecutando el código
colocado en esta sección infinitamente. Así es que constantemente puede obtener
información constante de los sensores, así como activarlos o desactivarlos.
Esta sección es la cual controla el comportamiento de Arduino. Se caracteriza con la firma:
void loop(){}.
18
4. Descripción de los middlewares encontrados
Los middlewares evaluados aquí parten de una búsqueda ad-hoc de la literatura realizada.
El punto de partida fue la identificación previa de RSCM por parte de un trabajo de investigación
del Grupo. A partir de la identificación de RSCM como un middleware, que cumplía con las
características mencionadas, se procedió a la búsqueda e identificación de otras soluciones.
Dentro de los middlewares identificados se destacan RSCM, Freedomotic, mSense y LOCCAM. A
continuación se describirán, para su posterior evaluación.
4.1 RSCM
RSCM es un middleware sensible al contexto que permite el desarrollo de aplicaciones sensibles al
contexto para Android. Esto lo logra mediante la incorporación de plugins.
Estos plugins se clasifican en sensores y razonadores de contexto. Los primeros se utilizan para
producir datos directamente desde sensores subyacentes. Los segundos típicamente requieren la
entrada de datos, lo cual significa que actúan tanto como consumidores y productores de contexto.
[5]
4.1.1 Principales componentes de RSCM
1. RSCM library
Es una librería que contiene el código necesario para para poder desarrollar aplicaciones con
RSCM. Cuando se desea implementar un nuevo plugin de este middleware es obligatorio
utilizarla ya que posee la estructura abstracta de los sensores y razonadores. Su
incorporación logra que todos los componentes del sistema puedan interactuar libremente.
Parta que forme parte del sistema debe agregarse como una librería externa al proyecto
(rscm-library.jar).
2. RSCM runtime
Consiste en un servicio que se ejecuta en segundo plano con el objetivo de facilitar y mediar
las comunicaciones entre los productores (sensores) y los consumidores de contexto
(razonadores).
19
3. Context viewer
Provee de un entorno grafico en el cual se puede visualizar todos los plugins que están
conectado al runtime.
4. Plugins
RSCM provee de un conjunto limitado de plugins dentro de los cuales se identifican:
medición de batería, indicador de conexión a la corriente, localización del dispositivo móvil.
Toda la información que solicitan los plugins de este middleware se encuentran locales en el
dispositivo móvil, por lo cual aún más grande es el desafío de incorporar otras tecnologías.
[5]
4.1.2 Arquitectura
En la Imagen 4-1 a continuación se puede observar la estructura arquitectónica de RSCM. Los
principales componentes que se incorporan son los sensores, ADCs encargado de proveer
información del contexto al middleware y aplicaciones sensibles al contexto que consumen
información del middleware.
Imagen 4-1 Arquitectura de RSCM
20
4.2 Freedomotic
Freedomotic es un framework libre, flexible basado en Internet of Things (IoT) usado para crear y
controlar espacios inteligentes. Su objetivo es la automatización de diferentes ambientes como
puede ser la casa u otro. Este software soporta las populares tecnologías de automatización de
edificios (por ejemplo KNX, Modbus RTU, X10), así como proyectos personalizados de
automatización. [6]
Freedomotic se encuentra actualmente en versión beta de trabajo, pero el proyecto muestra una
actividad importante, por lo que se prevé que continuará evolucionando.
4.2.1 Principales componentes
Aplicación Freedomotic:
Este es el componente principal. Se comporta como el administrador de la interacción de
todos los plugins, brindando una interfaz gráfica a través de la cual se interactúa con la casa.
A cada componente de la casa se le puede pre programar o configurar el comportamiento
deseado luego de que el usuario genere una interacción con él. El ambiente puede ser
modificado agregándole nuevos objeto que le briden al usuario mayor confort.
Plugins:
Este framework permite la utilización de no tan solo plugins que generen la sensibilidad al
contexto, sino también mayor escalabilidad en el acceso a los datos y gestión del mismo.
Esto se logra a través de plugins que son encargados de la comunicación. [7]
4.2.2 Características adicionales
Le brinda gran escalabilidad a la solución utilizando otro middleware orientado a gestionar
el intercambio de mensajes e información entre los componentes (JSON y XML, mensajes
de texto).
Multiplataforma. Freedomotic está escrito en Java por lo que se puede ejecutar en Windows,
Linux, Mac, Solaris.
Basado en eventos programables
21
Modular y extensible. Freedomotic es modular y puede enriquecer sus funciones mediante
plugins. Proporcionan APIs que se distribuyen junto con el software para crear fácilmente
nuevos add-ons.
Independientes del hardware. Freedomotic permite independizarse de la infraestructura de
hardware (sensores y actuadores) con los eventos, factores desencadenantes y los comandos.
Posee un foro con repuesta rápida de problemas.
Posee errores de programación al ser una versión beta. [6]
4.2.3 Arquitectura
En la imagen 4-2 a continuación se puede observar la interacción entre los actores de Freedomotic.
Imagen 4-2 Arquitectura de Freedomotic [8]
22
4.2.4 Proceso de funcionamiento
A continuación en la Imagen 4-3 se puede observar una línea de proceso de automatización con
Freedomotic.
Capas:
1- En la sección de automatización se puede reconocer eventos de usuarios, horarios y datos
del entorno que pueden hacer variar el contexto del middleware.
2- Los objetos virtuales representan a cada elemento que queremos automatizar pudiendo
cambiar su comportamiento tras reconocer la presencia de un evento. Se le incorpora el
comportamiento programando reglas que responden a estímulos de la casa.
3- Por último en este caso el plugin establece la comunicación con el hardware, con el fin de
tomar acciones de acuerdo al evento antes liberado.
Imagen 4-3 Automatización [8]
23
4.3 mSense
mSense es un middleware sensible al contexto para los teléfonos móviles de gama alta basado en
Qt. Qt es una biblioteca multiplataforma ampliamente usada para desarrollar aplicaciones con o
sin interfaz gráfica de usuario [9]. Dentro del middleware se distinguen “nodos de bajo nivel” que
encapsulan una API para acceder a la perfección los sensores de hardware, servicios de sensores o
web simulados, que se utilizan de forma implícita como orígenes de datos externos en el contexto
del middleware. Otro tipo de nodo son los sensores de alto nivel (los llamados canales o
agregadores) combinan información de otros nodos para adquirir y extraer información de los
sensores. Por ejemplo, un GPS, un acelerómetro y una brújula podrían combinarse para
proporcionar un nodo más preciso como un sensor de posicionamiento inercial. Por el momento, la
salida se suministra a través de una interfaz nativa. [10]
4.3.1 Nodos de sensores de bajo nivel actuales:
Acelerómetro: proporciona la aceleración 3D del dispositivo a una velocidad configurable.
Sensor de alarma: brinda información, así como las notificaciones de alarmas activas
actuales.
Sensor Calendario: establece datos actuales del calendario (reuniones, etc.).
Orientación dispositivo: proporciona orientación del dispositivo actual y la actitud
(rotación) de la información.
Localización GPS: GPS brinda información basada en la ubicación del dispositivo.
Norte Magnético: determina rumbo actual del dispositivo con respecto al norte magnético.
Magnetómetro: proporciona información de densidad de flujo geomagnético 3D.
Perfil de sensor: proporciona información sobre el perfil del dispositivo actual.
Sensor Tiempo: proporciona información del tiempo real a través de un servicio web para
un área configurable. [11]
24
4.3.2 Nodos de sensores de alto nivel
Disponibilidad del Usuario: le brinda al usuario información actual de su estado (si el
usuario está disponible o no). Esto se realiza mediante una combinación de los datos de la
agenda y de perfil del dispositivo.
Estado de Movimiento: le proporciona información al usuario de su movimiento. Esto se
hace por una combinación de la ubicación GPS y del sensor de acelerómetro.
Posición / Dirección: establece la posición actual del usuario en función de la ubicación
actual del GPS. [11]
4.3.3 Arquitectura
En la imagen 4-4 a continuación se puede observar la estructura arquitectónica de mSense separado
en capas, dentro de las cuales se distinguen la capa de datos, la de sensores y otros proveedores de
información.
Imagen 4-4 Arquitectura de mSense
25
4.4 LOCCAM
El LOCCAM es un middleware de apoyo para los sistemas móviles y sensibles al contexto que
utilizan el sistema operativo Android. [12] [13]
Actúa como gestor del contexto para brindarle apoyo a las aplicaciones sensibles al contexto en los
dispositivos móviles. Para ello, utilizan los sensores físicos, lógicos y virtuales presentes en el
móvil real, que son una fuente para la obtención de ésta información contextual.
4.4.1 Principales Componentes
Estructuralmente, se distinguen principalmente dos partes:
1- SYSSU.
Éste permite la interoperabilidad del sistema, actuando como intermediario entre:
aplicaciones que envían y reciben información de interés con el middleware, como la
información contextual capturada por CAM (más específicamente, por los CACs).
Los CACs son Componentes de Adquisición de Contexto los cuales reportan a los gerentes
de adquisición de contexto (CAM).
2- CAM (Contexto Adquisición Administrador).
CAM se puede dividir en su propia arquitectura interna: en primer lugar el componente
“Adaptation Reasoner” es responsable de mantener una lista de la relación de los intereses
de todas las aplicaciones y comprueba si se produjo algún cambio en esta relación de
intereses. Luego los datos son transferidos al Administrador de CAC. [14]
El Administrador de CAC es responsable de la gestión del ciclo de vida de las CAC, iniciar
o finalizar su ejecución. Él es también responsable de la gestión de la lista de las CAC
disponibles.
La Imagen 4-1 a continuación muestra la arquitectura y la relación entre la SYSSU y CAM, aparte
de la arquitectura interna CAM específico
26
.
Imagen 4-5 [14]
27
5. Evaluación
Con el fin de evaluar las capacidades de estos middlewares, se elaboró una lista de los criterios que
se consideran de mayor relevancia para el caso de estudio planteado. Estos criterios son orientados a
la escalabilidad, conectividad con el hardware, facilidad de uso y control del contexto.
A cada middleware se le otorgará un puntaje del 1 al 100 con el objetivo de profundizar en aquellos
que apliquen con mayor naturalidad al proyecto.
A continuación se detallan los criterios y puntaje para evaluar cada middleware.
5.1 Criterios seleccionados para la evaluación
Para poder evaluar con mayor claridad cada middleware sensible al contexto, la tabla 5-1, determina
una serie de criterios a los cuales se le asignaron puntajes dependiendo de cuatro criterios que se
detallan a continuación.
1- El criterio restringe la integración del framework con el caso de estudio y aporta al
concepto de middleware sensible al contexto. (15 puntos)
2- El criterio no restringe la integración del framework con el caso de estudio y aporta al
criterio de middleware sensible al contexto. (10 puntos)
3- El criterio involucra información necesaria para realizar una investigación avanzada.
(10 puntos)
4- El criterio no restringe la integración del framework con el caso de estudio, solo dificulta en
mayor o menor medida su realización. Es ajeno al concepto de middleware sensible al
contexto. (5 puntos)
Además de clasificarlos en estas categorías pueden sufrir pequeñas variaciones de hasta tres puntos
consecuencia de la importancia que cada criterio posee para el evaluador.
Por ejemplo, si consideramos a Freedomotic se determinó que es totalmente abierto a la extensión
por lo cual en la tabla se le asignaran los 16 puntos que le corresponden a la categoría “Es abierto a
la extensión” (Ver tabla 5-1).
28
5.1.1 Criterios que clasificaron en la categoría 1 (Puntaje base 15 puntos):
1- Es abierto a la extensión (Puntaje sumado: 1 punto).
2- Permite la interconexión con hardware (Puntaje sumado: 3 puntos).
.
5.1.2 Criterios que clasificaron en la categoría 2 y 3 (Puntaje base 10 puntos):
1- Es orientado a la domótica.
2- Continúa su utilización y desarrollo.
3- Su código es público.
4- Posee versiones finales consolidadas (Puntaje restado: 2 puntos).
5- Posee manejo del contexto (Puntaje restado: 2 puntos).
.
5.1.3 Criterios que clasificaron en la categoría 4 (Puntaje base 5 puntos):
1- Permite la interconexión con otro software.
2- Es multiplataforma.
3- Dificultad de utilización.
4- Dificultad de Instalación.
Nota: En los criterios que se realizaron subdivisiones, los puntajes fueron adjudicados sin un juicio
previo. Los mismos se adjudicaron de acuerdo a la importancia para el evaluador.
5.2 Descripción de los criterios
A continuación en la tabla 5-1 se detalla la definición de aquellos criterios que pueden resultar
ambiguos. En la descripción se detallará los puntos fundamentales utilizados que conforman cada
criterio.
29
Criterios
Descripción
Es abierto a la extensión.
Permite la incorporación de nuevos módulos sin realizar modificaciones en los ya existentes.
El código fuente es abierto a su modificación. Su arquitectura es escalable.
Permite la interconexión
con hardware (Arduino,
Raspberry pi, etc.)
Posee plugins desarrollados para la utilización de
computadoras minimalistas que recolecten
información del ambiente.
Permite la interconexión
con otro software.
Posee algún mecanismo de intercambio de
información con otro software.
Es orientado a la
domótica.
Posee objetos pre configurados que simulan ser
elementos reales de la casa. Un ejemplo de esto, son
la representación de lámparas, puertas, sensores, etc.
Es multiplataforma.
(Puede ser utilizado desde
múltiples dispositivos y sistemas operativos)
Puede ejecutarse en múltiples plataformas, considerando entre estas Windows, Linux, Android
,etc.
Posee manejo del
contexto.
Tiene mecanismos para almacenar el estado de cada objeto de la casa. Y
reconocer sus posibles cambios.
Tabla 5-1
5.3 Puntajes asignados a los criterios
La tabla 5-2 siguiente detalla los posibles puntajes para cada criterio.
Criterios
Evaluación Pts.
Es abierto a la extensión
1- No
2- Solo permite modificación del código por parte del propietario.
3- Solo permite agregar módulos
nuevos. 4- Permite realizar ambos ítems
anteriores, pero posee inconsistencias propietarias.
5- Es totalmente abierto a la extensión.
0
2
4
7
16
30
Permite la interconexión
con hardware (Arduino,
Raspberry pi, etc.)
1- Posee plugins desarrollados. 2- Tiene posibilidad de comunicarse
con hardware. 3- No
18 9
0
Permite la interconexión
con otro software.
1- Si 2- No
5 0
Es Orientado a la
Domótica.
(Trae componentes ya desarrollados para
interactuar con la casa)
1- Si 2- No
10 0
Continúa su utilización y
desarrollo.
(Se realizó alguna
actualización en los últimos 6 meses)
1- Si
2- No
10
0
Su código es publico
1- Si 2- No
10 0
Es multiplataforma.
1- Si 2- No
5 0
Dificultad de utilización.
1- Baja
2- Media 3- Alta
5
3 0
Dificultad de Instalación. 1- Necesita la instalación de otros programas para su utilización. No
tiene archivos de configuración. 2- Necesita la instalación de otros
programas para su utilización.
3- No necesita de programas para su funcionamiento.
1
4
5
Posee versiones finales
consolidadas.
1- Si
2- No
8
0
Posee manejo del
contexto.
1- Si
2- No
8
0
Tabla 5-2
31
5.4 Evaluación de los Middlewares sensibles al contexto seleccionado
En esta sección se presenta la evaluación de cada uno de los middlewares seleccionados.
5.4.1 Evaluación RSCM
La tabla 5-3 siguiente se detalla los puntajes obtenidos por la evaluación a RSCM.
Criterios
Puntos
Es abierto a la extensión. 7
Permite la interconexión con hardware. 9
Permite la interconexión con otro software. 5
Es orientado a la domótica. 0
Continúa su utilización y desarrollo. 0
Su código es público. 10
Es multiplataforma. 0
Dificultad de utilización. 3
Dificultad de instalación. 5
Posee versiones finales consolidadas. 8
Posee manejo del contexto.
8
Tabla 5-3
Total de Puntos: 55
32
5.4.2 Evaluación Freedomotic
La tabla 5-4 siguiente detallan los puntajes obtenidos por la evaluación.
Criterios
Puntos
Es abierto a la extensión. 16
Permite la interconexión con hardware. 18
Permite la interconexión con otro software. 5
Es orientado a la domótica. 10
Continúa su utilización y desarrollo. 10
Su código es público. 10
Es multiplataforma. 5
Dificultad de utilización. 5
Dificultad de instalación. 1
Posee versiones finales consolidadas. 8
Posee manejo del contexto.
0
Tabla 5-4
Total de Puntos: 88
5.4.3 Evaluación mSense
La tabla 5-5 siguiente detallan los puntajes obtenidos por la evaluación a mSense. Si bien se
reconoce que mSense es uno de los middlewares que posee más plugins desarrollados junto con
Freedomotic, la calificación negativa de mucho de los puntos radica en la falta del código fuente
para realizar las pruebas pertinentes. En el caso de no realizar la prueba de cada sección la
calificación es 0.
Criterios
Puntos
Es abierto a la extensión. 4
Permite la interconexión con hardware. 9
Permite la interconexión con otro software. 0
33
Es orientado a la domótica. 0
Continúa su utilización y desarrollo. 10
Su código es público. 0
Es multiplataforma. 5
Dificultad de utilización. 0
Dificultad de instalación. 0
Posee versiones finales consolidadas. 8
Posee manejo del contexto.
8
Tabla 5-5
Total de Puntos: 49
5.4.4 Evaluación LOCCAM
La tabla 5-6 siguiente detallan los puntajes obtenidos por la evaluación a LOCCAM.
Criterios Puntos
Es abierto a la extensión. 7
Permite la interconexión con hardware. 9
Permite la interconexión con otro software. 5
Es orientado a la domótica. 0
Continúa su utilización y desarrollo. 10
Su código es público. 5
Es multiplataforma. 0
Dificultad de utilización. 5
Dificultad de instalación. 1
Posee versiones finales consolidadas. 8
Posee manejo del contexto.
8
Tabla 5-6
Total de Puntos: 58
34
5.5 Resumen de los puntajes obtenidos
A continuación en la tabla 5-6 se exponen todo los puntajes de los middlewares evaluados.
Criterios
RS
CM
Fre
edom
oti
c
mS
ense
LO
CC
AM
Es abierto a la extensión. 7 16 4 7
Permite la interconexión con hardware. 9 18 9 9
Permite la interconexión con otro
software.
5 5 0 5
Es orientado a la domótica. 0 10 0 0
Continúa su utilización y desarrollo. 0 10 10 10
Su código es público. 10 10 0 5
Es multiplataforma. 0 5 5 0
Dificultad de utilización. 3 5 0 5
Dificultad de instalación. 5 1 0 1
Posee versiones finales consolidadas. 8 8 8 8
Posee manejo del contexto.
8 0 8 8
Tabla 5-7
Observaciones:
De las tablas antes descriptas se puede observar que el framework más avanzado para la integración
con Arduino es Freedomotic, además de ser el que brinda mayor flexibilidad para realizar cambios.
Gracias a la reciente adquisición de mSense por parte del grupo Windows Phone, se produjo un
punto de inflexión en el estudio de dicho middleware, éste liberó una versión demo (ya en una
etapa muy avanzada de esta investigación), que no pudo ser evaluada. Los puntajes asignados
fueron en base a la lectura de características del middleware en su versión anterior.
Del resto de los middlewares se identificó una tendencia muy marcada en la incorporación de
sensores y razonadores. Esto les brinda gran escalabilidad, teniendo la posibilidad de extenderlos
pero con gran dificultad. Esta tarea no podría ser realizada por un usuario estándar.
35
6. Fase Experimental
Esta sección describe la evaluación de los middlewares y tecnologías seleccionadas para un caso de
laboratorio definido como representativo.
6.1. Plan de Trabajo
A continuación se detallará el caso de estudio elegido para implantar en los middlewares.
6.1.1 Definición del caso de estudio
Encender una luz como un caso representativo, utilizando middlewares o frameworks sensibles al
contexto. Relacionándolos con Arduino como un medio de recolección de información, tomando
decisiones en base al contexto creado.
6.1.2 Objetivos
- Establecer la comunicación serial de Arduino con cada middleware estudiado.
- Controlar el estado de corriente eléctrica.
- Recolectar información del contexto y encender una luz si la distancia a la cual se
encuentra de una de las paredes es menor a 50 cm. (el encendido de la luz es simbólico
ya que se podría realizar cualquier otra acción).
- Recolectar información del contexto y encender una luz si se produce un movimiento en
un plano de 180°.
6.1.3 Requerimientos de Hardware
- Micro controlador Arduino.
- Cable de cobre de 1mm - Conectores
- 4 Relés
- 1 Resistencia (330 ohm) - 4 Resistencias (1k ohm)
- 6 Leds
- Lámpara de luz
- Porta lámpara
- Computadora
- N Sensor PIR - N Sensor HC-SR04
- Cable USB Arduino
- 4 Transistores - Diodos
- Protoboard
36
6.2 Circuito Integrado de 2 Relés + Transistores + Leds
En la Imagen 6-1 que se muestra a continuación, se observa el circuito encargado a nivel físico de
encender o apagar cualquier dispositivo. Este circuito es utilizado en cada uno de los casos de
estudio. Su componente principal es el relé, el cual actúa como interruptor. Esto lo logra ya que
dentro del mismo posee una bobina, que en el momento de activar su pin de datos, genera un
campo electromagnético que atrae al interruptor y permite el pasaje de corriente eléctrica.
Imagen 6-1 [15]
37
6.3 Descripción del diagrama del circuito electrónico
Aquí se describe el circuito principal que interactuará con los middlewares sensibles al contexto.
Este está compuesto por tres grandes componentes, actores, Arduino y los recolectores.
Para poder visualizar un diagrama del circuito interconectando todo los componentes del mismo,
recurrir al anexo 10.4.
El circuito comprende en su totalidad todo el hardware necesario para el caso de estudio planteado,
comunicando la plaqueta Arduino con una computadora, se establece así la comunicación mediante
el puerto serial y éste es controlado por software o en este caso por un middleware sensible al
contexto. Este circuito es el encargado de recolectar información de forma autónoma y enviársela
través del mismo puerto al software que lo gestione, para que luego el middleware o el usuario final
tome la mejor decisión.
6.4 Principales componentes del circuito:
1- Arduino: Es el cerebro y administrador de sensores y actores. Para profundizar leer el
capítulo 3.
2- Sensor de distancia: Este sensor utiliza dos pines digitales de Arduino, uno es configurado
como INPUT y otro como OUTPUT . Encargados de emitir y recibir una onda ultrasónica,
con la cual se mide el tiempo de llegada y se convierte a distancia. Además posee un pin
conectado a 5v y otro a tierra.
3- Placa de relés: Esta posee al menos 3 pines, uno conectado a 5 v otro conectado a tierra y
uno más de control. El último mencionado es el que se conecta a Arduino con el fin
activarlo o desactivarlo. Cabe destacar que además posee bornes para conectar el conducto
que se desea interrumpir.
6.4.1 Forma de Interconectar los anteriores componentes:
Todos los componentes posee pines de control, estos al conectarlos a Arduino se pueden gestionar.
Mediante su lenguaje de programación se itera constantemente preguntando sobre el estado de cada
componente, utilizando comandos de lectura analógica y digital para obtener los resultados.
38
6.5 Descripción de los componentes utilizados
Sensor Ultrasonico
Imagen 6-2
Utilizado para medir distancias,
emitiendo y recibiendo una onda con el
fin de determinar el tiempo y distancia a
otro elemento.
Reles
Conjunto de 4 relés los cuales se activan
o desactivan con Arduino. Su fin es
permitir/denegar el pasaje de corriente
eléctrica, logrando a través una bobina
que genera un campo magnético el cual
atrae o repele al interruptor.
Imagen 6-3
Sensor PIR
Sensor de movimiento, éste detecta
mediante cambios mínimos de
temperatura en el ambiente el
movimiento de cualquier objeto en el
entorno.
Imagen 6-4
39
Arduino
La descripción y características generales
de esta plaqueta ya fueron descriptas en la
sección 3 del documento.
Imagen 6-5
Con el objetivo de profundizar en la interconexión de los componentes antes descriptos, acceder al
Anexo 10.4, donde se puede visualizar un circuito completo del caso de estudio.
40
7. Implementación de los casos de estudio
A continuación se detallaran las implementaciones del caso de estudio con cada uno de los
middlewares evaluados.
Cabe destacar que además de realizar las tareas antes mencionadas, se desarrolló una aplicación
Java, la cual realiza el caso de estudio completo. Esto se realizó con dos objetivos:
1- Generar una versión final probada con anterioridad a la de los middlewares.
2- Medir el tiempo de construcción sin un middleware intermedio.
7.1 Java + Arduino
En esta sección se detallara le ejecución de la aplicación que desarrolle con los objetivos antes
mencionados.
7.1.1 Descripción
Creación de la Aplicación Java:
El principal cometido de esta aplicación es probar el mismo caso de estudio que el de los
middleware .Esto brinda la oportunidad de medir la dificultad de realizar la misma tarea con o sin
un middleware. Como se puede visualizar en la imagen 7-1 esta aplicación posee una lista de
eventos (log viewer) dedicada a recolectar información de contexto, con la utilización de sensores.
Una vez que el software detecta que la distancia al sensor es inferior a los 50 cm se enciende la luz.
Además permite encenderla o apagarla en cualquier momento presionando el correspondiente
botón, enviando un mensaje el cual es decodificado e interpretado por el micro controlador.
Imagen 7-1 ( Log Viever + Light Control)
41
7.1.2 Programando el micro controlador
Este es el codigo que programa el comportamiento de la plaqueta Arduino con el objetivo de
cumplir con el plan de estudio.
Sección de Configuración:
void setup(){
Serial.begin(9600);
pinMode(trigPin1, OUTPUT);
pinMode(echoPin1, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(sensor,INPUT);
pinMode(rele,OUTPUT);
Serial.flush();
}
Se determina que pines
serán del tipo OUTPUT y
cuáles serán del tipo
INPUT.
void loop(){
enviarDatos();
recibirDatos();
}
void recibirDatos(){
if(Serial.available()>0)
{
input=Serial.read();
if(input=='3'){
digitalWrite(ledPin,HIGH);
digitalWrite(rele,LOW);
}
if(input=='4'){
digitalWrite(ledPin,LOW);
digitalWrite(rele,HIGH);
}
}
}
}}
El método void loop() ejecuta
constantemente las funciones enviar
Datos y recibir Datos. Enviar Datos
envía información de los sensores al
programa o middleware. Mientras que
recibir Datos, recibe mensaje desde el
programa o middleware.
Enciende la luz
Apaga la luz
42
long distanciaFun(int trigPin,int echoPin){
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duracion = pulseIn(echoPin, HIGH);
dist = duracion/58.2;
return dist;
}
void enviarDatos(){
estado=digitalRead(sensor);
distancia1=distanciaFun(trigPin1,echoPin1);
if (estado==HIGH || (distancia1<10 && distancia1>0))
{
digitalWrite(ledPin,HIGH);
digitalWrite(rele,LOW);
Serial.print("1");
delay(500);
}
else {
digitalWrite(ledPin,LOW);
digitalWrite(rele,HIGH);
Serial.print("2");
delay(500);
}
}
Obtiene el valor que mide el
sensor para determinar si hay
movimiento.
Mide la distancia
con un sensor
ultrasónico.
Enciende la luz y envía un mensaje
a su controlador (Programa Java o
middleware).
43
7.1.3 Resultados
1- Creación de Software Java
2- Generación de Código Arduino
3- Realizar comunicación entre los dos componentes
4- Pruebas
5- Encender La luz desde la aplicación Java
6- Apagar la luz desde la aplicación Java
7- Encender La luz por una proximidad inferior a 50 cm
Leyenda:
- Se realizó con éxito.
- No se obtuvo el resultado esperado.
44
7.1.4 Prueba del caso de estudio con la aplicación Java
Antes de detectar movimiento con el sensor:
En la imagen que se observa a continuación puede visualizarse como la luz está
apagada. Esta foto fue tomada antes de producir un evento. Por evento se entiende
encender la luz desde la pc o generar movimiento a una distancia menor a 50 cm del
sensor. También puede observarse la representación física del circuito antes
detallado.
Imagen 7-2
Después de detectar movimiento con el sensor:
Luego de producir el evento se observa como en la Imagen 7-3 la luz se enciende. Esta misma tecnología puede aplicarse para encender cualquier
dispositivo electrónico.
Imagen 7-3
45
7.2 RSCM +Arduino
A continuación se estudiará la incorporación de Arduino a y Freedomotic con el fin de tomar información del contexto.
7.2.1 Descripción
Como se mencionó antes RSCM se basa en tres componentes principales a los cuales sus autores
hacen alusión. Estos son el contexto, razonadores y recolectores.
7.2.2 Configuración + Programación
Para comenzar con el proceso de implantar el caso de estudio a RSCM, se deben generar al menos
el contexto y un recolector de contexto (Sensor). A continuación se detallará la creación de los
mismos.
7.2.2.1 Proceso de instalación
Copiar y ejecutar “rscm-runtime_0.2.1.apk” en el dispositivo Android.
Copiar y ejecutar “rscm-viewer_0.2.1.apk” en el dispositivo Android.
Con el objetivo de poseer un plugin pre configurado de RSCM, copiar y ejecutar “plugin-sensor-battery_0.2.1.apk” en el dispositivo Android. [16]
7.2.1.2 Creación del contexto
1- Crear una Activity de Java y modificarla para que extienda de
org.aspectsense.rscm.context.client.ContextListenerActivity.java.
2- Implementar los métodos abstractos getRequestedScopes() y onContextValueChanged(). [17]
46
7.2.2.3 Programando el contexto
A continuación se puede observar el código de la creación del contexto. Este está programado de
acuerdo con la normas establecidas por los autores, fue instalado luego de los pasos de la sección 7.2.2.1. [17]
7.2.2.4 Programando el sensor
Este Sensor también fue programado de acuerdo a las normas de los autores. El código se puede
observar en el siguiente cuadro de texto. Este sensor es una aplicación nueva, donde su clase
principal extiende de SensorService (“org.aspectsense.rscm.context.plugin.SensorService”).
Este es el componente que define la estructura general de los sensores. [18]
public class MyContextAwareActivity extends ContextListenerActivity { @Override public String[] getRequestedScopes() { return new String[] { "distance.value" }; } private TextView messageTextView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); messageTextView =(TextView) findViewById(R.id.log_info); appendMessage("Activity created"); }
private void appendMessage(final String message) { final String currentMessage = messageTextView.getText().toString(); messageTextView.setText(currentMessage + "\n" + message); } @Override public void onContextValueChanged(ContextValue contextValue) { try{
appendMessage(new Date() + ": La distancia es: " + contextValue.getValueAsInteger() + "%"); if(contextValue.getValueAsInteger()<50){
encenderLuz();
}
}catch (JSONException jsone){ Toast.makeText(this, "Error while displaying context event: " + contextValue, Toast.LENGTH_SHORT).show();
}}}
47
public class SensorProy extends SensorService { public static final String TAG = "org.aspectsense.rscm.sensor.distance.DistanceSensor"; public static final String SCOPE_DISTANCE = "distance.value"; public static final String ACTION_DISTANCIA_CHANGED = "distance.changed"; public static final IntentFilter filter = new IntentFilter(ACTION_DISTANCIA_CHANGED); @Override public IBinder onBind(Intent intent){ Log.d(TAG, "DistanceSensor: registerReceiver"); registerReceiver(distanceReceiver, filter); return super.onBind(intent); } @Override public boolean onUnbind(Intent intent){ Log.d(TAG, "DistanceSensor: unregisterReceiver"); unregisterReceiver(distanceReceiver); return super.onUnbind(intent); } final BroadcastReceiver distanceReceiver = new BroadcastReceiver(){ int oldDistance=-1; @Override public void onReceive(Context context, Intent intent){ int distance = returnDistance(); if(distance <= 50){
final ContextValue lastContextValueDistanceValue = ContextValue.createContextValue(SCOPE_DISTANCE, distance);
notifyListener(lastContextValueDistanceValue); oldDistance = distance; } }
48
7.2.3 Resultados
1- Instalación de RSCM
2- Instalación de Sensores de RSCM
3- Pruebas del Contexto
4- Creación del Contexto para el caso de estudio
5- Creación del Sensor de distancia
6- Unificación y prueba de los puntos 4 y 5
7- Encender La luz por una proximidad inferior a 50 cm
Leyenda:
- La operación se realizó con éxito.
- No se obtuvo el resultado esperado.
La prueba no resulto exitosa, pero se tomaron varias
medidas para intentar mitigar los errores.
7.2.1 Medidas de mitigación de errores:
Los resultados obtenidos por los prototipos desarrollados no concluyeron como se esperó, a pesar
de que los mismos fueron implementados de acuerdo a las normas del autor del middleware. Para
intentar solucionar estos errores se tomaron tres acciones, en primer lugar contactarse con el autor
para solucionar los problemas, en segundo lugar probar todos los plugins desarrollados por el autor
para verificar su funcionamiento y en tercer lugar intentar realizar el mismo caso de prueba sin el
middleware (encender desde el celular un dispositivo).
49
Medida Resultado
Contactarse con el autor.
No se lograron solucionar los problemas.
Probar todos los plugins desarrollados por el
autor.
Funcionaron correctamente, se descartan problemas del middleware.
Realizar el mismo caso de prueba sin el
middleware.
Se realizó el caso de prueba y funciono
correctamente, se descartaron problemas de conexión.
Nota: Si bien se realizaron pruebas para intentar eliminar los errores, no se lograron solucionar los
problemas.
Observaciones:
Los proyectos creados para los sensores y el contexto se localizan en el repositorio y en el
cd.
50
7.3 Freedomotic + Arduino
A continuación se estudiará la incorporación de Arduino a y Freedomotic con el fin de tomar información del contexto.
7.3.1 Descripción:
En los anexos 10.1 y 10.2 se observa al detalle la instalación de Maven y Freedomotic. En este
caso la instalación involucra la opción de poder recompilar el software luego de realizar
modificaciones del código. La instalación de Maven es necesaria para poder recompilar el código.
[19]
La estructura de Freedomotic soporta la incorporación de plugins, los cuales personalizan el
comportamiento del framework. Este puede ser programado y configurado para gestionar la casa en
base a dichos componentes.
Para el caso de estudio antes determinado, es conveniente la instalación del plugin llamado
“Arduino USB”. Este plugin, permite la comunicación con el hardware desde la interfaz principal
de Freedomotic. Además de realizar la instalación de dicho plugin, se debe configurar los canales a
través de los cuales se comunicarán (Ver Anexo 10.3).
Uno de los mayores inconvenientes fue que los plugins para utilizar Arduino no se encontraban
estables, para conseguir establecer las conexiones se interactúa con los desarrolladores de
Freedomotic quienes presentaron un nuevo realese en donde finalmente se logró realizar por
completo el caso de estudio aquí descripto. Aunque como se muestra en la sección 7.3.2, el actuador
para encender la lámpara automáticamente, aún contiene defectos que a la fecha de entrega de este
documento no han sido resueltos.
A continuación en la Imagen 7-4 se puede observar la pantalla principal de Freedomotic a través de
la cual se puede gestionar los elementos de la casa.
Imagen 7-4
51
7.3.2 Configuración + Programación
En este apartado se detallaran las configuraciones que se realizaron y las porciones de código
fuentes con el objetivo de llevar a cabo el caso de estudio.
7.3.2.1 Configuración de Freedomotic
A continuación se especificaran los pasos necesarios para poder realizar la comunicación entre
Arduino y Freedomotic. En el anexo 10.3 se puede observar detenidamente como realizar dichas
configuraciones.
7.3.2.2 Pasos
1- Instalar Arduino comunication desde el conjunto de plugins (Market Place).
Este plugin inicia los protocolos de comunicación entre Arduino y Freedomotic. Otorgando
la posibilidad de enviarse mensajes entre ambos con el fin de decodificarlos e interpretarlos.
A través de ellos se toman las decisiones.
2- Configurar el puerto por el cual se realizará la comunicación.
Al conectar Arduino a una terminal, este se conecta a un puerto serial del mismo. Se debe
obtener esta información consultando al administrador de dispositivos del sistema operativo
que se utilice. Una vez obtenido el puerto al cual se ha conectado Arduino, en la sección de
configuración del plugin se le debe indicar dicho dato.
3- Configurar el evento de encendido de una luz desde el frontend de Freedomotic.
Una vez configurado todo lo anterior, haciendo doble clic sobre el plugin se puede observar
cómo se realiza lo conexión. Si dicha conexión se realizó correctamente, el icono del
mismo se verá en colores, de lo contrario en grises.
Esta es la parte más importante del proceso ya que es donde se programa el comportamiento
del framework en relación al plugin. Para obtener información detallada de dicha
configuración se debe acceder al anexo 10.3.
En esta sección se determina el protocolo de comunicación que se utilizará y el pin al cual se
conectara el dispositivo a nivel físico en la plaqueta Arduino. En la imagen 7-5 a
continuación se puede observar la configuración del puerto.
52
Imagen 7-5
7.3.2.3 Programando Arduino
Este código es necesario ejecutarlo antes de ejecutar Freedomotic, con el objetivo de tener
pre-configurada la plaqueta.
void setup(){ Serial.begin(9600); pinMode(13, OUTPUT); } void loop (){ if (Serial.available()) { char ser = Serial.read(); switch (ser) { case 'a': pinON(13); Serial.print("on"); break; case 'b': pinOFF(13); Serial.print("off"); break; } } } void pinON(int pin){ digitalWrite(pin, HIGH); } void pinOFF(int pin){ digitalWrite(pin, LOW); }
Consulta si hay datos
disponibles y
dependiendo del
mensaje que retorne
enciende o apaga la luz.
53
7.3.2. Resultados
A continuación de presentan los resultados de Freedomotic
1- Instalar Freedomotic (Ver guía).
2- Instalar Arduino comunication desde el conjunto de plugins (Market Place).
3- Configurar el puerto en el cual se realizará la comunicación con Arduino.
4- Una vez instalado el plugin, abrirlo con netbeans o cualquier
otro compilador.
5- Realizar las modificaciones necesarias al archivo “sketch.ino” el cual contiene todo el comportamiento programado del
micro controlador.
6- Configurar el evento de encendido de una luz desde el frontend de Freedomotic.
7- Realizar prueba de encendido y apagado.
8- Tomar información de sensores para encender la luz
(El último punto no se pudo concretar debido a que el plugin seguía en desarrollo y planificaban su incorporación con posterioridad)
- La operación se realizó con éxito.
- No se obtuvo el resultado esperado.
54
7.4 mSense +Arduino
Desde el inicio de la búsqueda de middlewares sensibles al contexto, este middleware sufrió
cambios. En un inicio no se identificó código aparente, ni una aplicación para poder realizar las
mismas pruebas que en los otros middleware. Esto género no poder obtener resultados concretos de
este middleware. Luego de varias lecturas se observó que este middleware ofrece muchas
oportunidades las cuales no pudieron ser verificadas. Posteriormente, a mediados de enero se
identificó una notificación del grupo de Nokia (con fecha 24/10/2014) [11], que dicho middleware
propiedad de ellos pasaría a formar parte del grupo de Windows Phone, liberando una versión del
mismo, la cual no pudo ser probada.
7.5 LOCCAM +Arduino A continuación se mostraran los resultados obtenidos de la implantación del caso de estudio.
7.5.1 Descripción
Este middleware posee una bibliografía que detalla paso a paso la instalación del mismo. Siguiendo
exactamente los pasos recomendados, se logró realizar la instalación del middleware, pero sin
acceso a la apertura de la instalación. El cuál era el siguiente paso para su configuración.
Luego de varias pruebas y consecutivas instalaciones en SmartPhones y tablets no se logró realizar
dicha instalación, sin la posibilidad de realizar las pruebas del caso de estudio.
7.5.2 Configuración
A continuación se detallaran los procedimientos realizados, con o sin éxito.
1- Instalación de LOCCAM.apk;
Para realizar la instalación, en primer lugar hay que descargar la aplicación LOCCAM.apk,
transferirla al dispositivo móvil y ejecutarla en el mismo. Este paso se pudo realizar sin
ningún inconveniente.
2- Iniciar Servicio;
Para Iniciar el servicio hay que iniciar la aplicación, paso que nunca se concretó, ya que no
brindo la opción de abrir la aplicación. A continuación se pueden visualizar en la imagen 7-6
55
el proceso que no se pudo completar:
Imagen 7-6 [14]
56
8. Conclusiones
Este trabajo presentó un estudio y evaluación sobre los middleware sensibles al contexto. Estos se
nutren de información del entorno, cada vez con orígenes más variados. Así es que enfrentan la
dificultad o necesidad de poder adaptarse naturalmente a los cambios. A través de la creación de
dichos middlewares se logra unificar, canalizar y procesar la información, además de brindar apoyo
a dispositivos móviles disminuyendo su sobrecarga.
Dicho trabajo fue dividido en cinco partes. Estas son investigación (identificación de los
middlewares), elaboración de criterios, evaluación de los middlewares y prueba del caso de
estudio.
Como resultado de la investigación, se identificaron cuatro middlewares (RSCM, mSense,
Freedomotic, LOCCAM). Destacando a RSCM y a LOCCAM como sistemas resultado de
proyectos de grado y/o posgrado. Mientras que Freedomotic y mSense son aplicaciones comerciales
en crecimiento.
Para evaluar a estos middlewares se desarrollaron criterios basados en el objetivo del trabajo y en la
investigación realizada. Como resultado de la evaluación se pudo observar, que el middleware con
mayor desarrollo es Freedomotic, obteniendo los resultados más altos según los criterios
elaborados. Con el fin de profundizar en su análisis se diseñó un caso de estudio genérico, el cual se
intentó aplicar a cada uno de ellos. El caso de estudio consistió en encender y apagar una bombita
de luz, basado en la identificación de la posición del usuario.
Se codificaron dos pruebas de concepto exitosas (Java+Arduino y Freedomotic+Arduino), sin
conseguir el caso de éxito completo en ninguno de los otros middlewares evaluados.
Si bien se lograron observar avances en el campo de los middlewares sensibles al contexto, desde el
punto de vista de la ingeniería de software el único middleware que se puede integrar con
aplicaciones comerciales es Freedomotic, siendo que los RSCM, mSense, y LOCCAM carecen de
aspectos técnicos para poder lograrlo.
Luego de trabajar con Arduino y los middlewares sensibles al contexto e intentar integrar ambas
tecnologías, se observó que el costo de intentar realizar dicho vínculo, es inclusive mayor que la
creación de un software específico para la administración de este tipo de dispositivos; sin perder de
vista la escalabilidad que brindan los middlewares.
Como resultado de esta investigación y el conocimiento adquirido, considero que a corto plazo
todas las grandes empresas y fabricantes de dispositivos móviles incorporarán este tipo de
soluciones con los sensores que los celulares ya poseen y otros dispositivos. Un ejemplo muy claro
es la tendencia de las pulseras electrónicas las cuales brindan la posibilidad de recolectar cada vez
más información.
57
Como lecciones aprendidas de este trabajo destaco la dificultad que encierra la utilización de
tecnologías emergentes, considerando la diferencia entre trabajar con aquellas que poseen grandes
bases de usuario y accesos bibliográficos, en contraste con las estudiadas en este caso, por ejemplo
en el caso de Freedomotic, la comunidad es menor a 50 personas y para RSCM, se tuvo que
contactar directamente al programador.
58
9. Referencias bibliográficas:
[1] D. Dransch, Activity and Context — “A Conceptual Framework for Mobile Geoservices”,
Springer Berlin Heidelberg, 2005.
[2] J. Ma, «Ubiquitous Computing,» [Online]. Available:
http://cis.k.hosei.ac.jp/~jianhua/course/ubi/Lecture09.pdf.
[3] Wikipedia, «Wikipedia Arduino,» [Online]. Available:
http://es.wikipedia.org/wiki/Arduino.
[4] Arduino, «Sitio Oficial Arduino,» [Online]. Available: http://www.arduino.cc/.
[5] Y. Stephen S., K. Fariaz, W. Yu y W. Bin, “Reconfigurable context-sensitive middleware
for pervasive”, M.S. thesis, Dept. Computer. Eng., Arizona, 2002.
[6] isimo, «Domonetio,» 02 2014. [Online]. Available:
http://www.domonetio.com/content/freedomotic-es-el-software-abierto-de-
automatizaci%C3%B3n-del-hogar.
[7] Freedomotic, «Freedomotic,» [Online]. Available: http://www.freedomotic.com/.
[8] Enrrico, «Repositorio Freedomotic,» [Online]. Available:
https://github.com/freedomotic/freedomotic/wiki/Freedomotic-components- interaction.
[9] Wikipedia, «Wikipedia,» [Online]. Available:
http://es.wikipedia.org/wiki/Qt_%28biblioteca%29.
[10] A. Jakl, D. Gusenbauer, D. Rothbauer y B. Ehringer, “Managing context on a sensor
enabled mobile device – the mSense approach,” presented at the International Conference
on Wireless and Mobile Computing, Networking and Communications, Austria, 2009.
[11] N. -. W. Phone, «Nokia Developers,» 08 2014. [Online]. Available:
http://developer.nokia.com/community/wiki/Qt_Mobility_Usage_Scenario:_The_mSense_
middleware.
[12] A. Fonteles, B. Neto, R. Gadelha, W. Viana, R. Andrade y M. Maia, «LOCCAM - loosely
coupled context acquisition middleware,» ACM New York, São Paulo, Brazil, 2013.
[13] M. E. F. Maia, «ACM Digital Library,» 2013. [Online]. Available:
http://dl.acm.org/citation.cfm?id=2480465.
[14] Loccam, «Loccam,» [Online]. Available: http://loccam.great.ufc.br/informacoes-
gerais/arquitetura.html.
59
[15] Argeduino, «Argeduino,» [Online]. Available:
http://www.argeduino.com.ar/download/releshield2canales.jpeg.
[16] N. Paspallis, «Google Code,» 9 2009. [Online]. Available: https://code.google.com/p/rscm/.
[17] N. Paspallis, «Google Code,» Septiembre 2009. [Online]. Available:
https://code.google.com/p/rscm/wiki/Creating_a_context_aware_app.
[18] N. Paspallis, «Google Code,» Septiembre 2009. [Online]. Available:
https://code.google.com/p/rscm/wiki/Creating_a_context_sensor_plugin.
[19] Freedomotic, «Get Started,» [Online]. Available:
https://github.com/freedomotic/freedomotic/wiki#developers-quick-start.
[20] Maven. [Online]. Available: http://maven.apache.org/download.cgi.
[21] Dallas, «MilesBurton,» [Online]. Available:
http://milesburton.com/Dallas_Temperature_Control_Library.
60
10. Anexos
A continuación se detallaran todos los anexos que ayudaron a la comprensión del documento y a la
elaboración del mismo.
10.1 Instalación de Maven
La instalación de Maven es necesaria para ejecutar y modificar código fuente de los plugins de
Freedomotic.
Paso 1:
Acceder a: http://maven.apache.org/download.cgi
Descargar: apache-maven-3.2.3-bin.zip
Paso 2:
Descomprimir el archivo descargado en C:\Program Files\Apache Software Foundation\apache-
maven-3.2.3
Paso 3:
(Configuración Oficial de Maven [20] )
1. Unzip the distribution archive, i.e. apache-maven-3.2.3-bin.zip to the directory you wish to install Maven 3.2.3. These instructions assume you chose C:\Program Files\Apache
Software Foundation. The subdirectory apache-maven-3.2.3 will be created from the archive.
2. Add the M2_HOME environment variable by opening up the system properties (WinKey + Pause), selecting the "Advanced" tab, and the "Environment Variables" button, then adding
61
the M2_HOME variable in the user variables with the value C:\Program Files\Apache Software Foundation\apache-maven-3.2.3. Be sure to omit any quotation marks around the path even if it contains spaces. Note: For Maven 2.0.9, also be sure that
the M2_HOME doesn't have a '\' as last character. 3. In the same dialog, add the M2 environment variable in the user variables with the
value %M2_HOME%\bin. 4. Optional: In the same dialog, add the MAVEN_OPTS environment variable in the user
variables to specify JVM properties, e.g. the value -Xms256m -Xmx512m. This
environment variable can be used to supply extra options to Maven. 5. In the same dialog, update/create the Path environment variable in the user variables and
prepend the value %M2% to add Maven available in the command line. 6. In the same dialog, make sure that JAVA_HOME exists in your user variables or in the
system variables and it is set to the location of your JDK, e.g. C:\Program
Files\Java\jdk1.7.0_51 and that %JAVA_HOME%\bin is in your Path environment variable. 7. Open a new command prompt (Winkey + R then type cmd) and run mvn --version to verify
that it is correctly installed.
.
Configuración de las siguientes variables de entorno:
Para comenzar debemos configurar las variables de entorno las cuales son requeridas. Para realizar dichas configuraciones se deben seguir los pasos de las siguientes imágenes:
Imagen 10-1 Pantalla de Windows
Imagen 10-2 Variable de Entorno
62
Imagen 10-3 Variable de Entorno
Imagen 10-4 Variable de Usuario
Imagen 10-5 Variables de Usuario
Una vez configuradas todas las variable de entorno de usuario. Ejecutar en modo de consola: mvn --version
63
10.2 Guía de instalación de Freedomotic
1- Acceder al sitio https://github.com y crear una
cuenta para poder acceder al repositorio de
Freedomotic.
2- Una vez creado el usuario acceder a su cuenta y realizar la búsqueda del repositorio
(Freedomotic). En la Imagen 10-7 a continuación se muestra la prueba realizada.
3- Acceder al repositorio público llamado freedomotic/freedomotic como se muestra en la
Imagen 10-8.
4- Accediendo al repositorio se podrán observar entre otros los siguientes archivos, como se
puede observar en la imagen 10-9.
Imagen 10-6 Login GitHub
Imagen 10-7 Usuario Logueado
Imagen 10-8 Repositorio
64
5- Una vez verificado el repositorio, se puede observar en la esquina superior derecha de la
aplicación web la opción FORK, la cual nos permite unirnos al repositorio para poder
consumirlo. En este paso se debe seleccionar dicha opción.
6- Una vez unidos al repositorio debemos clonarlo a un directorio físico en una Pc.
Esto se puede lograr en modo consola con el siguiente comando:
git clone https://github.com/YOUR-GITHUB-USERNAME/freedomotic.git
O también se puede realizar utilizando la aplicación web presionando el botón “Clone in Desktop,”
ubicado a la derecha del centro de la página, representado por la siguiente imagen.
Localmente se ha creado una carpeta llamada Freedomotic con todo el contenido del repositorio.
Imagen 10-9 Archivos del repositorio
65
Acceder a la carpeta física del repositorio:
Ejecutar en modo de consola: mvn clean install
Este proceso tomará algunos minutos.
Ejecutar en modo de consola:
cp -r data-example/ framework/freedomotic-core/data
Una vez finalizado, para ejecutar la aplicación
Ejecutar en modo de consola:
java -jar framework/freedomotic-core/target/freedomotic-core/freedomotic.jar
10.3 Configuración de Freedomotic con Arduino
1- Instalar Arduino comunication desde el conjunto de plugins (Market Place).
Esta guía debe ser utilizada para incorporar la comunicación de Arduino con Freedomotic.
Una vez en el MarketPlace se selecciona la opción
Internet Of Things.
Imagen 10-10
66
Se selecciona Arduino Serial comunication.
Imagen 10-11
Se Activa la comunicación
con Arduino realizando doble click sobre el nuevo
plugin instalado.
Imagen 10-12
2- Configurar el puerto por el cual se realizará la comunicación.
Para configurar el puerto de comunicación de Arduino con Freedomotic, se debe seleccionar
del menú principal la opción Plugins y luego Configure. Después de seleccionar las
opciones antes mencionadas aparecerá una pantalla con información de la comunicación, en
el valor de la sección que dice “Serial.Port” se debe poner el puerto correcto de
comunicación.
67
Imagen 10-13
3- Configurar el evento de encendido de una luz desde el frontend de Freedomotic.
En esta sección se determina el protocolo de comunicación que se utilizará y el pin al cual se conectara el dispositivo a nivel físico en la plaqueta Arduino.
Se desactiva la opcion “Is a virtual object…..” , se seta el protocolo y la dirección.
Imagen 10-14 Configuración
68
Seleccionando la etiqueta DataSource, configurar el item powered. Escogiendo la
opción que comienza por Arduino Usb.
Imagen 10-15
Para el encendido de la luz se selecciona la opcion Yun On Arduino Led y viceversa
para el apagado de la misma.
Imagen 10-16
69
10.4 Circuito detallado del hardware para el caso de estudio
A continuación en la Imagen 10-17 se puede visualizar el circuito utilizado para el caso de estudio
seleccionado.
Imagen 10-17
70
10.5 Wheather Undergound:
Wheather Underground es un Servicio web que permite obtener el estado del tiempo, junto con
otras características de él, que pueden ser de interés para desarrollar una aplicación que sea sensible al contexto. A continuación se presentan los pasos realizados para obtener datos de este servicio.
Procedimiento:
1- Creación de un usuario 2- Generar clave de acceso a los datos
3- Crear una aplicación Java que consuma XML. 4- Prueba.
Clave:
http://api.wunderground.com/api/24350adefbeb2b9d/conditions/q/UY/Montevideo.xml
Resultado:
<response>
<version>0.1</version>
<termsofService>
http://www.wunderground.com/weather/api/d/terms.html
</termsofService>
<features>
<feature>conditions</feature>
</features>
<current_observation>
<image>
<url>http://icons.wxug.com/graphics/wu2/logo_130x80.png</url>
<title>Weather Underground</title>
<link>http://www.wunderground.com</link>
</image>
<display_location>
<full>Montevideo, Uruguay</full>
<city>Montevideo</city>
<state/>
<state_name>Uruguay</state_name>
<country>UY</country>
<country_iso3166>UY</country_iso3166>
<zip>00000</zip>
<magic>1</magic>
<wmo>86580</wmo>
<latitude>-34.83000183</lat itude>
<longitude>-56.00000000</ longitude>
<elevation>32.00000000</elevation>
</display_location>
<observation_location>
<full>Montevideo,</full>
<city>Montevideo</city>
<state/>
<country>UY</country>
<country_iso3166>UY</country_iso3166>
<latitude>-34.83333206</lat itude>
<longitude>-56.01166534</ longitude>
<elevation>105 ft</elevation>
71
</observation_location>
<estimated></estimated>
<station_id>SUMU</station_id>
<observation_time>Last Updated on October 10, 9:00 AM UYST</observation_time>
<observation_time_rfc822>Fri, 10 Oct 2014 09:00:00 -0200</observation_time_rfc822>
<observation_epoch>1412938800</observation_epoch>
<local_time_rfc822>Fri, 10 Oct 2014 09:28:29 -0200</local_time_rfc822>
<local_epoch>1412940509</local_epoch>
<local_tz_short>UYST</local_tz_short>
<local_tz_long>America/Montevideo</local_tz_long>
<local_tz_offset>-0200</local_tz_offset>
<weather>Mostly Cloudy</weather>
<temperature_string>55 F (13 C)</temperature_string>
<temp_f>55</temp_f>
<temp_c>13</temp_c>
<relative_humidity>67%</relative_humidity>
<wind_string>From the SSW at 16 MPH</wind_string>
<wind_dir>SSW</wind_dir>
<wind_degrees>210</wind_degrees>
<wind_mph>16</wind_mph>
<wind_gust_mph>0</wind_gust_mph>
<wind_kph>26</wind_kph>
<wind_gust_kph>0</wind_gust_kph>
<pressure_mb>1014</pressure_mb>
<pressure_in>29.95</pressure_in>
<pressure_trend>+</pressure_trend>
<dewpoint_string>45 F (7 C)</dewpoint_string>
<dewpoint_f>45</dewpoint_f>
<dewpoint_c>7</dewpoint_c>
<heat_index_string>NA</heat_index_string>
<heat_index_f>NA</heat_index_f>
<heat_index_c>NA</heat_index_c>
<windchill_string>NA</windchill_string>
<windchill_f>NA</windchill_ f>
<windchill_c>NA</windchill_c>
<feelslike_string>55 F (13 C)</feelslike_string>
<feelslike_f>55</feelslike_f>
<feelslike_c>13</feelslike_c>
<visibility_mi>6.2</v isibility_mi>
<visibility_km>10.0</visibility_km>
<solarradiation/>
<UV>1</UV>
<precip_1hr_string>-9999.00 in (-9999.00 mm)</precip_1hr_string>
<precip_1hr_in>-9999.00</precip_1hr_in>
<precip_1hr_metric>-9999.00</precip_1hr_metric>
<precip_today_string>0.00 in (0.0 mm)</precip_today_string>
<precip_today_in>0.00</precip_today_in>
<precip_today_metric>0.0</precip_today_metric>
<icon>mostlycloudy</icon>
<icon_url>http://icons.wxug.com/i/c/k/mostlycloudy.gif</icon_url>
<forecast_url>
http://www.wunderground.com/global/stations/86580.html
</forecast_url>
<history_url>
</history_url>
<ob_url>
http://www.wunderground.com/cgi-bin/findweather/getForecast?query=-34.83333206,-56.01166534
</ob_url>
</current_observation>
</response>
72
10.6 Localización de celulares:
Con el avance de las tecnologías, la localización y ubicación de los usuarios es cada vez más
necesaria. Esto se puede lograr a través de una herramienta de google llamada devicemanager, la
cual teniendo una cuenta de google asociada al dispositivo permite identificar la posición del mismo
remotamente. Este sistema permite incluirlo en otros programas que utilicen dicha información.
Por ejemplo podría ser un middleware sensible al contexto.
10.7 Medición de temperatura con Arduino
A continuación se muestra el código necesario para poder medir la temperatura con Arduino. La
conexión del sensor utiliza un pin digital de la placa. [20]
Para recolectar la temperatura se utiliza el sensor Dallas 18B20.
#include <Wire.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
void setup(void){
Serial.begin(9600);
sensors.begin();
}
void loop(void){
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
sensors.requestTemperatures();
Serial.print("Temperature-------------->: ");
Serial.println(sensors.getTempCByIndex(0)); // Why "byIndex"?
// You can have more than one IC on the same bus.
// 0 refers to the first IC on the wire
delay(2000);
}
73
10.8 Censar movimiento con Arduino:
Para poder censar el movimiento se conecta un sensor a Arduino, el cual al producirse un
movimiento en su entorno envía una señal de 5 v a la plaqueta. La cual mediante la programación
de la plaqueta se traduce en otra acción.
A continuación se detallara el código necesario para controlar este tipo de sensor. En el caso de que
se produzca movimiento enciende una luz.
int input=-1;
int sensor=7;
int estado;
void setup(){
pinMode(rele,OUTPUT);
pinMode(sensor,INPUT);
digitalWrite(rele, LOW);
Serial.begin(9600);
}
void loop(){
estado=digitalRead(sensor);
if(estado==HIGH){
digitalWrite(rele,HIGH);
delay(1000);
}
else
{
digitalWrite(rele,LOW);
}}
74
10.9 Medición de distancia con Arduino:
A continuación se muestra el código necesario para poder medir la distancia con Arduino. La
conexión del sensor utiliza un pin analógico de la placa.
Para medir la distancia se utiliza el periférico HC-SR04
#include <NewPing.h>
#include <Ping.h>
const int echoPin1=24;
const int trigPin1=7;
const int ledPin=8;
long dist;
long duracion;
long distancia1;
void setup(){
Serial.begin(9600);
pinMode(trigPin1, OUTPUT);
pinMode(echoPin1, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop(){
delay(1000);
distancia1=distanciaFun(trigPin1,echoPin1); // Este método se puede
visualizar en la sección 7
Serial.print("La distancia es: ");
Serial.print(distancia1);
}
75
10.10 Controlar flujo de corriente eléctrica:
El código que se presenta a continuación enciende un relé y por consecuencia cualquier dispositivo
electrónico conectado a él, luego lo apaga consecutivamente. El código comenta lo que realiza cada
línea.
Para controlar el flujo de corriente eléctrica se utilizan relés.
int rele=6;
void setup(){
pinMode(rele,OUTPUT);
}
void loop(){
digitalWrite(rele,HIGH);
//se activa el relé y permite el pasaje de corriente eléctrica
delay(1000); //Se genera una espera por 1 segundo
digitalWrite(rele,LOW);
// se desactiva el relé y permite el pasaje de corriente eléctrica
delay(1000); // Se genera una espera por 1 segundo
}
76
![INFORME 1 PAPELES SENSIBLES (1)[1]](https://static.fdocuments.es/doc/165x107/557202844979599169a3aad7/informe-1-papeles-sensibles-11.jpg)
![CAPS SENSIBLES [Modo de compatibilidad]](https://static.fdocuments.es/doc/165x107/6194887ba6d12a7a8b7a545b/caps-sensibles-modo-de-compatibilidad.jpg)
