Download - Memoria CuentaKilometros
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)