MEMORIA

FIN FP

TÍTULO DEL TRABAJO DE FP: CUENTAKILOMETROS TITULACIÓN: Desarrollo de Aplicaciones Multiplataforma AUTOR: Daniel Guillén Toledano FECHA: 05 de Diciembre de 2013

ÍNDICE

INTRODUCCIÓN ....................................................................... 6

CAPÍTULO 1. ARQUITECTURA ANDROID Y PLATAFORMA

UTILIZADA ............................................................................... 7

1.1 Arquitectura Android ................................................................... 7

1.1.1 Kernel Linux .......................................................................... 7

1.1.2 Runtime de Android .............................................................. 8

1.1.3 Librerías nativas .................................................................... 8

1.1.4 Entorno de aplicación ........................................................... 9

1.1.5 Aplicaciones .......................................................................... 9

1.2 Plataforma utilizada ................................................................... 10

1.2.1 Hardware utilizado .............................................................. 10

1.2.2 Software utilizado ............................................................... 11

CAPITULO 2. SENSOR Y LOCALIZACIÓN ................................. 13

2.1 Acelerómetro ............................................................................. 13

2.2 Localización mediante coordenadas (GPS) ................................. 14

2.2.1 Triangulación ...................................................................... 14

2.2.2 Distancia ............................................................................. 14

2.2.3 Timing perfecto .................................................................. 16

2.2.4 Posicionamiento de los satélites ...................................... 16

2.2.5 Errores ................................................................................ 16

CAPITULO 3. HEURÍSTICAS DE NIELSEN................................. 18

3.1 Utilizar el lenguaje de los usuarios ............................................. 18

3.2 Minimizar la carga de la memoria del usuario ............................ 18

3.3 Diálogos estéticos y diseño minimalista ..................................... 19

CAPITULO 4. INTEGRACIÓN DEL SISTEMA Y CONTROL

MEDIANTE EL ORDENADOR .................................................... 20

4.1 Aspectos generales y funciones básicas .................................. 20

4.1.1 Información actividades ...................................................... 20

4.1.2 Manejo mediante el ordenador .......................................... 22

4.2 Diagramas explicativos del Software .......................................... 24

4.2.1 GPS ..................................................................................... 25

4.2.2 Acelerómetro ...................................................................... 28

CAPITULO 5. CONCLUSIONES ............................................... 30

CAPITULO 6. BIBLIOGRAFÍA ................................................. 31

ÍNDICE FIGURAS

Fig. 1.1 Arquitectura Android .......................................................7

Fig. 1.2 Android Device ............................................................... 10

Fig. 1.3 Móvil G510 ..................................................................... 11

Fig. 2.1 Ecuación Acelerómetro .................................................. 13

Fig. 2.2 Ejes Acelerómetro .......................................................... 13

Fig. 2.1 Código Pseudo Aleatorio ................................................ 15

Fig. 2.2 Ecuación Distancia .......................................................... 15

Fig. 2.3 Satélite Atmósfera .......................................................... 17

Fig. 4.1 Esquema Inicio ............................................................... 20

Fig. 4.2 Esquema GPS .................................................................. 21

Fig. 4.3 Esquema Acelerómetro .................................................. 21

Fig. 4.4 Coordenadas simples ..................................................... 22

Fig. 4.6 DDMS ............................................................................. 22

Fig. 4.7 Emulador Seleccionado .................................................. 23

Fig. 4.8 Fichero GPX .................................................................... 23

Fig. 4.9 Diagrama Inicio ............................................................... 24

Fig.4.10 Diagrama General ......................................................... 25

Fig. 4.11 Opciones GPS ............................................................... 26

Fig. 4.12 Diagrama GPS ............................................................... 27

Fig. 4.13 Diagrama Acelerómetro ............................................... 28

Fig. 4.14 Ecuación Distancia ........................................................ 29

6 Introducción

INTRODUCCIÓN

Este proyecto tiene como objetivo crear una aplicación que registra una

distancia recorrida a través del sensor interno Acelerómetro y localización

externa GPS. El entorno de software usado para desarrollar la aplicación

es Eclipse.

En el primer capítulo veremos la arquitectura de los proyectos

desarrollados en Android y veremos la plataforma utilizada para

desarrollar el proyecto.

En el segundo capítulo, se presentan las características generales del

sensor Acelerómetro y desarrollaremos un poco el esquema de la

localización mediante GPS.

En el tercer capítulo se encuentran definidas las heurísticas de Nielsen que

se pueden encontrar en el proyecto desarrollado.

En el cuarto capítulo daremos una breve explicación de cómo manejar la

aplicación desde el entorno de desarrollo ‘Eclipse’ y de cómo funcionan las

distintas partes de la aplicación.

Cuentakilometros 7

CAPÍTULO 1. ARQUITECTURA ANDROID Y PLATAFORMA UTILIZADA

1.1 Arquitectura Android

Fig. 1.1 Arquitectura Android

1.1.1 Kernel Linux

Android utiliza el núcleo de Linux 2.6 como una capa de abstracción para

el hardware disponible en los dispositivos móviles, por lo tanto, es la única

que es dependiente del hardware.

Esta capa proporciona servicios como la seguridad, el manejo de la

memoria, el multiproceso, la pila de protocolos y el soporte de drivers

para dispositivos. Esta capa contiene los drivers necesarios para que

cualquier componente hardware pueda ser utilizado mediante las

llamadas correspondientes.

8 Arquitectura Android y plataforma utilizada

1.1.2 Runtime de Android

Está basado en el concepto de máquina virtual utilizado en Java. Dado las

limitaciones de los dispositivos donde ha de correr Android (poca

memoria y procesador limitado) no fue posible utilizar una máquina

virtual Java estándar. Google tomó la decisión de crear una nueva, la

máquina virtual Dalvik, que respondiera mejor a estas limitaciones.

El entorno de ejecución lo constituyen las Core Libraries, que son librerías

con multitud de clases Java y la máquina virtual Dalvik.

1.1.3 Librerías nativas

Incluye un conjunto de librerías en C/C++ usadas en varios componentes

de Android. Están compiladas en código nativo del procesador. Muchas de

las librerías utilizan proyectos de código abierto. Algunas de estas librerías

son: System C library: una derivación de la librería BSD de C estándar

(libc), adaptada para dispositivos embebidos basados en Linux. Media Framework: librería basada en PacketVideo's OpenCORE;

soporta codecs de reproducción y grabación de multitud de

formatos de audio vídeo e imágenes MPEG4, H.264, MP3, AAC,

AMR, JPG y PNG. Surface Manager: maneja el acceso al subsistema de

representación gráfica en 2D y 3D. WebKit: soporta un moderno navegador web utilizado en el

navegador Android y en la vista webview. Se trata de la misma

librería que utiliza Google Chrome y Safari de Apple. SGL: motor de gráficos 2D. Librerías 3D: implementación basada en OpenGL ES 1.0 API. Las

librerías utilizan el acelerador hardware 3D si está disponible, o el

software altamente optimizado de proyección 3D. FreeType: fuentes en bitmap y renderizado vectorial. SQLite: potente y ligero motor de bases de datos relacionales

disponible para todas las aplicaciones.

Cuentakilometros 9

SSL: proporciona servicios de encriptación Secure Socket Layer.

1.1.4 Entorno de aplicación

Representa fundamentalmente el conjunto de herramientas de desarrollo

de cualquier aplicación. Toda aplicación que se desarrolle para Android

utiliza el mismo conjunto de API y el mismo ‘framework’, representado

por este nivel.

Los servicios más importantes que incluye son:

Views: extenso conjunto de vistas, (parte visual de los componentes).

Resource Manager: proporciona acceso a recursos que no son en código.

Activity Manager: maneja el ciclo de vida de las aplicaciones y proporciona un sistema de navegación entre ellas.

Notification Manager: permite a las aplicaciones mostrar alertas personalizadas en la barra de estado.

Content Providers: mecanismo sencillo para acceder a datos de otras aplicaciones (como los contactos).

1.1.5 Aplicaciones

Este nivel está formado por el conjunto de aplicaciones instaladas en una

máquina Android. Todas las aplicaciones han de correr en la máquina

virtual Dalvik para garantizar la seguridad del sistema. Estas aplicaciones

utilizan los servicios, las API y librerías de los niveles anteriores.

10 Arquitectura Android y plataforma utilizada

1.2 Plataforma utilizada

Para llevar a cabo este proyecto he escogido como plataforma hardware

‘Android Virtual Device Manager’ incluido en el entorno de desarrollo de

Eclipse y un móvil Huawei G510 y como software he elegido el entorno de

desarrollo de Eclipse.

1.2.1 Hardware utilizado

Como hardware he usado el ‘Android Virtual Device Manager’ incluido en

el entorno de desarrollo ‘Eclipse’, instalando el SDK en un ordenador

portátil ‘Lenovo’.

Fig. 1.2 Android Device

Cuentakilometros 11

También hago uso de un móvil Huawei G510, con una versión Android

4.1.1

Fig. 1.3 Móvil G510

1.2.2 Software utilizado

Para el software existen varias alternativas a la que he elegido (‘Eclipse’)

para el desarrollo del mismo, en lenguajes distintos a Java

Basic4Android: es una plataforma de programación para

aplicaciones Android cuyo lenguaje base de programación es Visual

Basic. No es el mismo lenguaje de Microsoft, pero su sintaxis es la

misma.

Mono para Android: Otro de los lenguajes que Microsoft desarrollo

para hacer aplicaciones fue C# y .NET

LiveCode: es una plataforma en la que puedes programar tanto

para Android, iOS, Windows, Linux, iPhone, iPad, Web y para

Servidores con una sola plataforma de trabajo.

12 Arquitectura Android y plataforma utilizada

Eclipse: conjunto de herramientas de programación de código

abierto multiplataforma para desarrollar lo que el proyecto llama

"Aplicaciones de Cliente Enriquecido", opuesto a las aplicaciones

"Cliente-liviano" basadas en navegadores. Esta plataforma,

típicamente ha sido usada para desarrollar entornos de desarrollo

integrados (del inglés IDE), como el IDE de Java llamado Java

Development Toolkit (JDT) y el compilador (ECJ) que se entrega

como parte de Eclipse.

Cuentakilometros 13

CAPITULO 2. SENSOR Y LOCALIZACIÓN

2.1 Acelerómetro

Un acelerómetro es un sensor que mide la aceleración relativa, tomando como referencia la de caída libre (es decir, en la Tierra la referencia será g = 9,81 m/s^2). Por lo tanto, la medida que nos dará un acelerómetro será:

Fig. 2.1 Ecuación Acelerómetro

Esto quiere decir que, si el móvil se encuentra en reposo sobre la mesa, la medida del acelerómetro será A= 9,81 m/s^2. Sin embargo, si sufre una caída libre, obtendremos como medida A=0.

Fig. 2.2 Ejes Acelerómetro

14 Sensor y localización

En los dispositivos Android, el sistema de coordenadas es relativo a la pantalla:

Eje x: Es horizontal y apunta a la derecha. Eje y: Es vertical y apunta hacia arriba. Eje z: Es la normal saliente a la pantalla del dispositivo.

Las librerías de Android nos proporcionan varias clases e interfaces que nos permiten trabajar con sus sensores (entre ellos el acelerómetro) y que nosotros usaremos.

2.2 Localización mediante coordenadas (GPS)

GPS son las siglas de ‘Global Positioning System’, es decir ‘Sistema de

Posicionamiento Global’ y consiste en una red de 24 satélites que emiten

una serie de señales simultáneamente las cuales una vez interpretadas por

un receptor nos dan nuestra posición en tres dimensiones en cualquier

punto del globo terráqueo, nuestra velocidad y nuestra orientación.

A continuación detallo el funcionamiento de un GPS.

2.2.1 Triangulación

La idea general detrás del GPS es utilizar los satélites en el espacio como puntos de referencia para ubicaciones aquí en la tierra.

Esto se logra mediante una muy exacta medición de nuestra distancia hacia tres satélites, lo que nos permite "triangular" nuestra posición en cualquier parte de la tierra.

2.2.2 Distancia

Para calcular la distancia medimos el tiempo que tarda una señal emitida por el satélite en llegar hasta nuestro receptor de GPS, la cual es una señal de radio, que viaja a la velocidad de la luz, 300.000 km por segundo.

Cuentakilometros 15

Nos queda el problema de medir el tiempo de viaje de la señal, para lo cual asumimos que nuestro receptor GPS y el satélite, están generando el mismo Código Pseudo Aleatorio en exactamente el mismo momento.

Este Código Pseudo Aleatorio es una parte fundamental del GPS. Físicamente solo se trata de una secuencia o código digital muy complicado. O sea una señal que contiene una sucesión muy complicada de pulsos "on" y "off"

Fig. 2.1 Código Pseudo Aleatorio

Comparando el retardo existente entre la llegada del Código Pseudo

Aleatorio proveniente del satélite y la generación del código de nuestro

receptor de GPS, podemos determinar cuánto tiempo le llevó a dicha

señal llegar hasta nosotros.

Multiplicamos dicho tiempo de viaje por la velocidad de la luz y

obtenemos la distancia al satélite:

Fig. 2.2 Ecuación Distancia

16 Sensor y localización

2.2.3 Timing perfecto

La medición del tiempo de viaje de una señal de radio es clave para el GPS, los relojes que empleamos deben ser exactos, dado que si miden con un desvío de una milésima de segundo, a la velocidad de la luz, ello se traduce en un error de 300 kilómetros.

Por el lado de los satélites, el timing es casi perfecto porque llevan a bordo relojes atómicos de increíble precisión.

Para obtener un timing perfecto efectuamos una medición satelital adicional.

Los relojes de los receptores GPS no necesitan ser tan exactos porque la

medición de un rango a un satélite adicional permite corregir los errores

de medición.

2.2.4 Posicionamiento de los satélites

Un satélite a gran altura se mantiene estable, por ello están flotando a unos 20.000 km de altura en el espacio.

Esta altura es en realidad un gran beneficio para este caso, orbitará de manera regular y predecible mediante ecuaciones matemáticas sencillas.

2.2.5 Errores

Una señal de GPS pasa a través de partículas cargadas en su paso por la ionosfera y luego al pasar a través de vapor de agua en la troposfera pierde algo de velocidad, creando el mismo efecto que un error de precisión en los relojes.

Cuentakilometros 17

Fig. 2.3 Satélite Atmósfera

Hay varias maneras de minimizar este tipo de error. Por un lado, podríamos predecir cuál sería el error de un día promedio. A esto se lo llama modelación y nos puede ayudar, pero las condiciones atmosféricas raramente se ajustan exactamente al promedio previsto.

Otra manera de manejar los errores inducidos por la atmósfera es comparar la velocidad relativa de dos señales diferentes. Esta medición de doble frecuencia es muy sofisticada y solo es posible en receptores GPS muy avanzados.

18 Integración del sistema y control mediante el ordenador

CAPITULO 3. HEURÍSTICAS DE NIELSEN

En este apartado señalaré las heurísticas de Nielsen que se dan en el

proyecto, explicando que heurística es y como la he implementado.

3.1 Utilizar el lenguaje de los usuarios

El sistema debe utilizar el lenguaje de los usuarios, con palabras o frases

que le sean conocidas, en lugar de los términos que se utilizan en el

sistema, para que al usuario no se le dificulte utilizar el sistema.

Las frases usadas en la aplicación son las imprescindibles, usando un

lenguaje formal pero sencillo, sin hacer uso de palabras técnicas.

3.2 Minimizar la carga de la memoria del usuario

El sistema debe minimizar la información que el usuario debe recordar

mostrándola a través de objetos, acciones u opciones. El usuario no tiene

por qué recordar la información que recibió anteriormente. Las

instrucciones para el uso del sistema deberían ser visibles o estar al

alcance del usuario cuando se requieran.

El usuario siempre sabe el método de acceso elegido, ya que se muestra

en la ‘cabecera’ de la pantalla, justo encima de la variable que almacena

los kilómetros recorridos.

El color de fondo elegido se usa en todas las pantallas, por lo que siempre

sabe cuál es el color que se está usando.

Cuentakilometros 19

3.3 Diálogos estéticos y diseño minimalista

La interfaz no debe contener información que no sea relevante o se utilice

raramente, pues cada unidad adicional de información en un diálogo

compite con las unidades relevantes de la información y disminuye su

visibilidad relativa.

La aplicación apenas hace usos de los diálogos y los pocos que hay son

explicativos.

20 Integración del sistema y control mediante el ordenador

CAPITULO 4. INTEGRACIÓN DEL SISTEMA Y

CONTROL MEDIANTE EL ORDENADOR

4.1 Aspectos generales y funciones básicas

La idea principal es la de crear una aplicación capaz de medir una distancia

recorrida, pudiendo parar la aplicación y reiniciar los valores, si fuese

preciso, además de que esto se pudiese hacer de dos formas, mediante

GPS y el uso del Acelerómetro, pudiendo así seleccionar el método que

más conveniente resulte.

4.1.1 Información actividades

La aplicación tiene un uso bastante sencillo e intuitivo, simplemente

debemos seleccionar el método de acceso que queramos usar, darle al

botón ‘Comenzar’ y, si hemos elegido el Acelerómetro, pulsar el botón

‘Empezar’, En caso de que no hayamos seleccionado ningún método de

acceso la aplicación selecciona por defecto el ‘GPS’.

Fig. 4.1 Esquema Inicio

El esquema (Fig. 4.1) representa la actividad ‘Inicio’ y sus diferentes

funciones, dando la opción de empezar la segunda actividad, cambiar las

opciones, o salir de la aplicación.

Cuentakilometros 21

La segunda actividad dependerá del método de acceso y pueden ser dos,

GPS (Fig. 4.2) o Acelerómetro (Fig. 4.3).

Fig. 4.2 Esquema GPS

La actividad del empieza calibrando automáticamente la señal del GPS y

cargando los kilómetros recorridos de la actividad anterior. Se puede parar

la aplicación y al continuar se vuelve a calibrar el GPS. Al volver atrás hacia

la actividad ‘Inicio’ se devuelven los kilómetros recorridos.

Fig. 4.3 Esquema Acelerómetro

La actividad empieza cargando los kilómetros recorridos de la actividad

anterior y los muestra. Debemos comenzar la actividad pulsando el botón

‘Iniciar’, también podremos pararla y continuar más adelante con ella. Al

volver atrás hacia la actividad ‘Inicio’ se devuelven los kilómetros

recorridos.

22 Integración del sistema y control mediante el ordenador

4.1.2 Manejo mediante el ordenador

Desde el entorno de desarrollo eclipse podemos manejar las coordenadas

que recibirá el GPS de modo que podamos hacer simulaciones de

distancias a través del ordenador, ya sea escribiendo estas coordenadas

de una en una (Fig. 4.4) o cargando un fichero con varias coordenadas y

que eclipse las interprete (Fig. 4.5).

Fig. 4.4 Coordenadas simples

Para ello lo primero que debemos hacer es abrir la vista DDMS de eclipse

situada en la pestaña superior derecha (Fig. 4.6).

Fig. 4.6 DDMS

Una vez abierta esta vista seleccionamos el emulador (Fig. 4.7) en el que

estemos probando el proyecto y ya podremos introducir coordenadas o

cargar un fichero de coordenadas .gpx (Fig. 4.8)

Cuentakilometros 23

Fig. 4.7 Emulador Seleccionado

Fig. 4.8 Fichero GPX

24 Integración del sistema y control mediante el ordenador

4.2 Diagramas explicativos del Software

A continuación explicare la funcionalidad del programa e introduciré

varios diagramas explicativos de la misma.

Fig. 4.9 Diagrama Inicio

Al iniciar la aplicación lo primero que hace es leer de los ficheros, si están

creados, el color de fondo y el método de acceso seleccionados en el

momento de salir de la aplicación la vez anterior y aplica estos mismos a la

aplicación.

Estas opciones siempre se pueden cambiar en el menú de opciones.

Una vez pulsado el botón ‘Comenzar’ lanzará una segunda actividad que

dependerá del método seleccionado, dicha actividad será lanzada

mediante un ‘Intent’ que esperará respuesta de la actividad lanzada.

Cuentakilometros 25

Fig.4.10 Diagrama General

En la segunda actividad, ya sea el GPS o el Acelerómetro, al inicio de la

misma se reciben los datos del color de fondo y los kilómetros recorridos y

se colorea el fondo de pantalla y se muestran los kilómetros.

Al reiniciar se ponen las variables en su valor por defecto, permitiendo

volver a empezar la actividad sin tener que reiniciar la aplicación. Aunque

aquí varían ligeramente entre la actividad del GPS y la del Acelerómetro

en esencia realiza la misma función.

Por último la acción de volver atrás, la cual devuelve los kilómetros

recorridos, permitiendo la comunicación entre ambas actividades (GPS y

Acelerómetro) a través de la actividad principal (Inicio).

4.2.1 GPS

En primer lugar inicia la localización mediante GPS, si este no está

activado entonces nos re direcciona a la pantalla de configuración de GPS

(Fig. 4.11).

26 Integración del sistema y control mediante el ordenador

Fig. 4.11 Opciones GPS

Una vez activado el GPS la aplicación crea un listener (Fig. 4.12) para el

GPS y empieza a recibir sus coordenadas.

Cuentakilometros 27

Fig. 4.12 Diagrama GPS

Si es la primera vez que empieza a hacer la localización mediante GPS

esperara hasta que se calibre, para ello hago uso de dos flags que indican

se actualizan cuando la distancia sea menor a uno. Cuando la distancia es

menor a uno el primer flag se actualiza, y si en la siguiente localización la

distancia vuelve a ser menor a uno se actualiza el segundo flag y se

supone al GPS calibrado. De ser la distancia menor a uno en la segunda

ocasión, el primer flag volvería a su estado inicial para la comprobación.

Para evitar la re calibración del GPS se usa un flag para indicar si la

aplicación esta parada o no, en caso de que esté parada la clase que

recibe la localización no hace nada y por lo tanto no se actualizan las

coordenadas. En caso de que pase mucho tiempo antes de que se vuelva a

poner en marcha la aplicación es posible que se pierda la señal y se tenga

que volver a re calibrar, por lo que puede dar lugar a errores en las

lecturas de la señal.

28 Integración del sistema y control mediante el ordenador

4.2.2 Acelerómetro

A diferencia de la actividad del GPS, el acelerómetro no inicia

automáticamente a pedir datos, sino que debemos pulsar el botón

‘Empezar’ para llamar a la clase que recibe las variaciones del sensor (Fig.

4.13).

Fig. 4.13 Diagrama Acelerómetro

Lo primero que hace la clase ‘OnSensorChanged’ es recoger los valores de

coordenadas del sensor y guardarlos en variables globales inicializadas a

cero, seguidamente comprueba si las variables de los ejes de coordenadas

anteriores están inicializadas o no, de no estarlo se guardan los valores del

nuevo eje de coordenadas en el antiguo eje de coordenadas y se sale de la

función.

Una vez tenemos ambos ejes de coordenadas listos pasamos a comprobar

si el tiempo pasado es mayor a un segundo, de no ser así la clase no haría

nada (tampoco actualizaría el eje de coordenada antiguo).

Cuentakilometros 29

Si el tiempo es mayor a un segundo se calcula la distancia (Fig. 4.14) y se

convierte a kilómetros, si la distancia es mayor al mínimo movimiento (1e-

3f o 0.001) entonces se suman a los kilómetros recorridos.

Fig. 4.14 Ecuación Distancia

Si es menor al mínimo movimiento se guarda en una variable local y

permanece a la espera de una nueva actualización de coordenadas al que

se le sumara su valor.

El acelerómetro esta siempre en movimiento, por lo que habría que hacer

una calibración del sensor del aparato que fuese a usar dicho sensor,

porque de lo contrario se dan errores de lecturas que afectarían en mayor

o menor medida al desarrollo de la aplicación, ya que darían cifras

erróneas al calcular distancias entre dos puntos.

30 Conclusiones

CAPITULO 5. CONCLUSIONES

Se ha cumplido con el objetivo primario de realizar una aplicación para

calcular distancias mediante la localización GPS.

El cálculo basado en la distancia entre dos puntos localizados a través del

acelerómetro puede resultar en una mala lectura de las coordenadas por

parte del mismo si el sensor no ha sido bien calibrado anteriormente, por

lo que no se recomienda el uso del acelerómetro.

Cuentakilometros 31

CAPITULO 6. BIBLIOGRAFÍA

Apuntes recogidos en el transcurso del curso 2012-2013.

http://www.elandroidelibre.com/2010/08/aprendiendo-android-v-

inicializacion-a-la-api-del-gps.html (06/12/2013)

http://javiercancela.com/2008/01/07/leyendo-nuestro-gps-desde-java-

con-la-javame-location-api-jsr-179-parte-i/ (06/12/2013)

http://www.maestrosdelweb.com/editorial/curso-android-sensores-

trabajar-con-acelerometro/ (06/12/2013)

http://developer.android.com/reference/java/sql/Timestamp.html

(06/12/2013)

http://sekthdroid.wordpress.com/2013/03/12/sensores-en-android-

acelerometro/ (06/12/2013)

http://developer.android.com/reference/android/hardware/SensorEvent.

html (06/12/2013)