Aplicación Domótica mediante Arduino y Programación …deeea.urv.cat/public/PROPOSTES/pub/pdf/2195pub.pdf · 4 2. Arduino Arduino es una placa de bajo coste con microcontrolador

Aplicación Domótica mediante Arduino y Programación Android

TITULACIÓN: Enginyeria Automàtica i Electrònica Industrial

AUTOR: Luis Rolin Almagro

DIRECTOR: Albert Oller Pujol

FECHA: Junio / 2014.

2

Índice

1. Descripción de proyecto ......................................................................................3

2. Arduino ...............................................................................................................4

2.1. Historia .........................................................................................................4

2.2. Hardware ......................................................................................................6

2.3. Arduino Software .........................................................................................9

2.3.1. Arduino Software ....................................................................................9

2.3.2. Concurrency ...........................................................................................9

2.3.3. DK-Basic ................................................................................................9

2.3.4. NanoVM .................................................................................................9

3.3.5 Amforth ...................................................................................................9

3. Android ............................................................................................................. 11

3.1. Historia ....................................................................................................... 11

3.2. Entorno de programación .......................................................................... 14

3.2.1. Eclipse. Java para Android ................................................................... 14

3.2.2. Basic4Android ...................................................................................... 14

3.2.3. Mono para Android .............................................................................. 14

3.2.4. App Inventor ......................................................................................... 15

3.2.5. LiveCode ............................................................................................... 15

4. La Aplicación. DomoAndruino ......................................................................... 18

4.1. La Capa Hardware ..................................................................................... 18

4.2. La Capa Software Arduino ........................................................................ 26

4.3. La Capa Software Android ........................................................................ 28

4.3.1. Librerías Utilizadas ............................................................................... 28

4.3.2. Interfaz Gráfica .................................................................................... 29

4.3.3. Núcleo de la aplicación ......................................................................... 34

4.4. Presupuesto................................................................................................. 36

5. Conclusiones ...................................................................................................... 37

Anexo A. Bibliografía ........................................................................................... 38

Anexo B. Datasheets.............................................................................................. 39

Anexo C. Esquemático .......................................................................................... 40

Anexo D. Código Arduino .................................................................................... 42

Anexo E. Código Android ..................................................................................... 46

3

1. Descripción de proyecto

Las tecnologías de la información y de la comunicación (TIC) son una parte omnipresente y dominante de la vida moderna. El mundo conectado o también conocido como el “internet de las cosas” hace que cada vez tengamos más elementos tecnológicos a nuestro alrededor, y al mismo tiempo conectados a internet, incluso dentro de nuestro propio hogar: ordenadores, teléfonos móviles, televisores y cada vez más, lavadoras, frigoríficos, incluso cepillos de dientes. A la vez, tenemos el creciente interés en el diseño de prototipos hardware basados en la filosofía Do It Yourself (DIY) abanderada por la plataforma de Arduino, que permiten que ingenieros y aficionados a la electrónica puedan llevar a cabo sus proyectos reduciendo el capital a invertir. Además, el desarrollo de aplicaciones para móviles que nos permiten interactuar con dichos elementos, a coste cero gracias a Android y su plataforma de software libre (el cual representa el 72% de los móviles inteligentes vendidos en el mundo), nos llevan a la gestación de este proyecto, que consiste en crear una solución asequible para la monitorización de diversas características de interés a tener en cuenta en un hogar y el control básico de algunas funcionalidades. Para llevar este proyecto a término se ha optado por las dos soluciones mencionadas anteriormente, de hardware y software libre, Arduino y Android respectivamente.

En nuestro caso concreto trataremos de monitorizar las siguientes variables comunes en cualquier hogar:

• temperatura

• humedad

• ruido

• humo

• un sistema de alarma con detector de presencia

• control de luces y persianas

• control del aire acondicionado y calefacción

Además mediante el uso de una cámara IP podemos realizar un control visual del recinto, y gracias a las características de motorización de la cámara y de visión nocturna podremos controlar grandes espacios incluso de noche.

Con todas estas características, el objetivo es crear un sistema sencillo, intuitivo y de bajo coste, que a la vez sea robusto y configurable.

Primeramente, comentaremos las principales características de las dos plataformas que hemos utilizado, tanto hardware como software, así como las diferentes opciones en el mercado para trabajar con ellas. Más tarde, una vez introducidas las dos plataformas, pasaremos a comentar la aplicación que hemos creado: DomoAndruino, resultado final de este proyecto.

4

2. Arduino

Arduino es una placa de bajo coste con microcontrolador que permite incluso a un novato llevar a cabo sus proyectos. Arduino puede ser conectado a todo tipo de sensores, luces, motores y otros dispositivos y utilizar un software, fácil de aprender, para programar la aplicación que correrá en el hardware.

2.1. Historia

Lanzado en el 2005 como una modesta herramienta creada por Massimo Banzi, un profesor del Instituto de Diseño Interactivo de Ivrea (IDII) y algunos de sus estudiantes, Arduino ha generado una revolución en la electrónica a nivel internacional del “DIY”. Se puede comprar una placa de Arduino por unos 30€ o construirse una propia desde cero. Todos los esquemas del hardware y código fuente están disponibles de forma gratuita bajo licencias públicas. Como resultado, Arduino se ha convertido en el movimiento del hardware open-source más influyente de su tiempo.

Arduino surgió de otro tremendo desafío: cómo enseñar a los estudiantes a crear electrónica, de forma rápida. Era el año 2002 y Banzi, un arquitecto de software, fue traído por el IDII como profesor asociado para promover nuevas formas de hacer diseño interactivo- un campo emergente conocido a veces como informática física. Pero con un presupuesto reducido y tiempo limitado, sus opciones para la técnica eran escasas.

Al igual que muchos de sus colegas, Banzi confió en el BASIC Stamp, un microcontrolador creado por la compañía californiana Parallax el cual fue usado por los ingenieros durante casi una década. Codificado con el lenguaje de programación BASIC, el Stamp era como una pequeña placa, que contenía lo esencial: fuente de alimentación, un microcontrolador, memoria y puertos de entradas y salidas para el hardware agregado. Pero Banzi descubrió que el BASIC Stamp tenía dos problemas, no tenía suficiente potencia de computación para alguno de los proyectos que sus estudiantes tenían en mente, y además era un poco caro -una placa más las partes básicas podría costar alrededor de los 100€. Además él necesitaba algo que pudiera funcionar en ordenadores Macintosh, los cuales eran comunes entre los diseñadores del IDII. Por lo que se plateó crear una placa que se adaptase a sus propias necesidades.

Banzi y sus colaboradores eran grandes partidarios del software de código abierto, puesto que el propósito era crear una plataforma rápida y de fácil acceso. Otro factor que contribuyó a tomar esta decisión fue que después de cinco años de funcionamiento, el IDII se estaba quedando sin fondos y se temía que podría cerrar sus puertas. El modelo de código abierto se ha utilizado durante mucho tiempo para impulsar la innovación para el campo del software, pero no ha sucedido así con el hardware. Para hacerlo funcionar, tuvieron que encontrar una solución apropiada de licencias que pudiese aplicarse a su proyecto. Después de algunas investigaciones, se dieron cuenta de que si simplemente miraban a su proyecto de manera diferente, se podría utilizar una licencia de Creative Commons, el grupo sin fines de lucro cuyos acuerdos se utilizan normalmente para las obras culturales, como la música y la literatura.

Fig. 1. Logo de Arduino

5

La primera placa de prototipo, realizado en 2005, fue un diseño simple, y no fue llamado Arduino aunque Massimo Banzi acuñó el nombre ese mismo año.

Fig. 2. Prototipo del primer Arduino

Para fabricar la placa, el grupo tenía un precio específico, asequible a los estudiantes, como meta: $30. También querían que fuese peculiar, por lo que abandonaron el tradicional color verde de los PCBs y lo sustituyeron por el azul.

De todas maneras, el éxito de Arduino le debe mucho a la existencia previa de los proyectos Processing y Wiring. Dichos proyectos dieron a Arduino una de sus fortalezas esenciales: un entorno de programación fácil de usar. Antes de Arduino, programar un microcontrolador conllevaba una difícil curva de aprendizaje. Con Arduino, incluso aquellos que no tienen experiencia en electrónica pueden crear sus propios proyectos sin excesiva dificultad.

6

2.2. Hardware

Actualmente Arduino dispone de una gran variedad de placas divididas en dos tipos: los componentes conocidos como boards, que en esencia son una placa con un microprocesador y distintos pines de entrada/salida; y los conocidos como shields, que son accesorios para los integrantes del primer grupo.

Por un lado, en el grupo de Boards, encontramos diversas opciones según las necesidades del proyecto tanto en tamaño del dispositivo como en cantidad de entradas salidas o memoria. En la siguiente tabla se encuentra una comparativa de los principales productos existentes a día de hoy en el mercado.

Tabla 1. Comparativa de los principales modelos Arduino

En nuestro caso, el dispositivo con el cual hemos llevado a cabo el proyecto se trata del Arduino Mega 2560, por lo que disponemos de un total de 16 Entradas analógicas, 54 entradas/salidas digitales y 15 salidas PWM.

Fig 3. Imagen del Arduino Mega 2560

Name Processor

Operating

Voltage/Input

Voltage

CPU

Speed

Analog

In/Out

Digital

IO/PWM

EEPROM

[KB] SRAM [KB] Flash [KB] USB UART

Uno ATmega328 5 V/7-12 V 16 Mhz 6/0 14/6 1 2 32 Regular 1

Due AT91SAM3X8E 3.3 V/7-12 V 84 Mhz 12/2 54/12 - 96 512 2 Micro 4

Leonardo ATmega32u4 5 V/7-12 V 16 Mhz 12/0 20/7 1 2.5 32 Micro 1

Mega 2560 ATmega2560 5 V/7-12 V 16 Mhz 16/0 54/15 4 8 256 Regular 4

7

El Arduino Mega 2560 es una placa electrónica basada en el microprocesador Atmega2560 La placa Arduino Mega 2560 es una actualización de la Arduino Mega, producto al que sustituye. El Arduino Mega 2560 difiere de todas las placas mencionadas anteriormente ya que no utiliza el chip controlador de USB a serial FTDI. En su lugar, usa el ATmega16U2 programado como convertidor USB a serie.

El chip ATmega2560 en el Mega Arduino viene precargado con un bootloader que le permite cargar un código nuevo sin el uso de un programador de hardware externo. Se comunica utilizando el protocolo original STK500.

Cada uno de los 54 pines digitales en el Mega se puede utilizar como una entrada o salida, usando las funciones pinMode(), digitalWrite(), y digitalRead(). Operan a 5 voltios. Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia de pull-up (desconectado por defecto) de 20-50kOhms. Además, algunos pines tienen funciones especializadas:

• Comunicación serie: Bus 0, pin 0 y 1, Bus 1, pin 19 y 18, Bus 2, pin 17 y 16, Bus 3, pin 15 y 14. Se utiliza para recibir y transmitir datos TTL.

• Interrupciones externas: pin 2, (interrupción 0), pin 3 (interrupción 1), pin 18 (interrupción 5), pin 19 (interrupción 4), pin 20 (interrupción 3) y pin 21 (interrupción 2). Estos pines pueden ser configurados para activar una interrupción en un valor bajo, un flanco ascendente o descendente, o un cambio de valor.

• PWM: pines del 2 al 13 y 44 al 46 para salidas PWM de 8 bits a usar con la función analogWrite().

• SPI: pin 50 (MISO), pin 51 (MOSI), pin 52 (SCK) y pin 53 (SS). Estos pines soportan comunicación SPI.

• LED: Hay un LED integrado conectado al pin digital 13 Cuando el pin tiene valor alto, el LED está encendido, cuando es bajo, está apagado.

• TWI: pin 20 (SDA) y pin 21 (SCL). Soporte comunicación TWI utilizando la librería Sire.

El Mega2560 tiene 16 entradas analógicas, cada una de las cuales proporcionan 10 bits de resolución (es decir, 1.024 valores diferentes). Por defecto se miden desde masa a 5 voltios, aunque es posible cambiar este último gracias al pin AREF y la función analogReference().

Por último ofrece un botón de reset que permite reiniciar el software del microprocesador en caso de avería o malfuncionamiento.

8

A su vez, haremos uso de un shield: el Ethernet Shield que permite a una placa Arduino conectarse a Internet. Está basada en el chip Wiznet W5100 Ethernet. Es capaz de efectuar comunicaciones TCP y UDP y admite hasta cuatro conexiones de socket simultáneas. El Shield de Ethernet tiene una conexión estándar RJ -45, con un transformador de línea integrado. Arduino se comunica con el chip W5100 mediante el bus SPI (a través de la cabecera ICSP).

El shield contiene un número de LEDs informativos:

• PWR: indica que la junta y el shield están alimentados. • LINK: indica la presencia de un enlace de red y parpadea cuando el shield

transmite o recibe datos. • FULLD: indica que la conexión de red es full dúplex. • 100 M: indica la presencia de una conexión de red de 100 Mb / s (en contraposición

a 10 Mb / s). • RX: parpadea cuando el shield recibe datos. • TX: parpadea cuando el shield envía datos. • COLL: parpadea cuando se detectan colisiones de red.

Fig. 4. Ethernet shield

9

2.3. Arduino Software

Para programar el microcontrolador de una placa Arduino, actualmente existen diversas opciones, aunque hay una que destaca por encima de todas, y es la proporcionada por el propio fabricante de las placas. Aun así enumeraremos las opciones detallando sus principales características. Todas estas plataformas que se comentan a continuación son completamente gratuitas pues este es un requisito para poder trabajar con placas Arduino que implementan licencias de hardware y software libre.

2.3.1. Arduino Software Esta es la opción del fabricante, es multiplataforma, es decir, funciona en Windows, Mac OS X y Linux. El entorno está escrito en Java y basado en Processing, Wiring y otros programas también de código abierto e implementa todas las instrucciones necesarias para interactuar con la familia de microprocesadores Atmel AVR de 8-Bits, que son los utilizados por las placas Arduino.

2.3.2. Concurrency Concurrency es una plataforma de trabajo para placas Arduino que se basa en el lenguaje de programación concurrente conocido como Occam-π, basado a su vez en Occam, creado en 1983 y utilizado para la programación de microprocesadores de tipo Transputer, que ha sido adaptado para la programación de microprocesadores actuales entre los que se incluye los montados en placas Arduino.

2.3.3. DK-Basic Por su parte, DK-BASIC es un intérprete de BASIC, escrito en C, inspirado en GW-BASIC, con aplicación en plataformas de microcontroladores AVR de 8-Bits. El proyecto esta aun en fase alfa pero una gran cantidad de instrucciones ya han sido incluidas en el proyecto.

2.3.4. NanoVM La plataforma NanoVM es una máquina virtual Java para las CPU Atmel AVR ATmega8 usando el estándar JDK de Sun Systems. La NAnoVM y sus herramientas se distribuyen bajo licencias GPL.

3.3.5 Amforth AmForth es un intérprete de comandos para la familia de micros AVR8 Atmega de Atmel. AmForth corre por completo en el controlador. No necesita hardware adicional más allá de una fuente de alimentación. El lenguaje de comandos es Forth. AmForth se publica bajo la GNU Public License v2 (GPL).

10

Obviamente, tras comentar la situación actual para desarrollar aplicaciones para placas Arduino, nos hemos decantado por la opción del fabricante.

El entorno de Arduino incluye el concepto de sketchbook: que es el lugar estándar para el almacenamiento de sus programas (o sketch). A estos sketches se les pueden añadir librerías, las librerías proporcionan funcionalidad extra para la utilización en sketches, por ejemplo para trabajar con hardware o manipular datos. Normalmente el código de un sketch se divide en tres secciones:

• la zona de declaración: en esta zona se colocaran las declaraciones de variables del programa y la inclusión de librerías externas para el control de hardware (mediante #include)

• la zona de setup: en esta zona es donde se configura el hardware del módulo Arduino. Es decir, por ejemplo, como actuará cada pin usado en nuestro programa, como input o como output, u otro hardware asociado (p.e. un motor paso a paso)

• la zona de loop: es el set de instrucciones que se ejecutan cíclicamente en el microprocesador. Aquí es donde se incluirán las acciones que queremos que se realicen en nuestro programa.

Las principales instrucciones para controlar el Input/Output del microprocesador son las siguientes:

• digitalRead(): Lee el valor del pin digital especificado, ya sea valor HIGH o LOW.

• digitalWrite(): Escribe un valor alto o bajo en un pin digital. Si el pin se ha configurado como una salida mediante la función pinMode(), su voltaje se establece en el valor correspondiente: 5V para HIGH, 0V (masa) para LOW.

• analogRead(): Lee el valor del pin analógico especificado mediante el convertidor analógico-digital de 10 bits. Esto significa que va a asignar voltajes de entrada entre 0 y 5 voltios en valores enteros entre 0 y 1023 Esto produce una resolución entre las lecturas de: 5 voltios / 1024 unidades o, 0.0049 voltios (4.9 mV) por unidad. Se tarda unos 100 microsegundos para leer una entrada analógica, por lo que la velocidad máxima de lectura es de aproximadamente 10.000 veces por segundo.

• analogWrite(): Escribe un valor analógico (señal PWM) en un pin. Se puede utilizar para encender un LED en diferentes brillos o conducir un motor a diversas velocidades. La frecuencia de la señal PWM en la mayoría de los pines es de aproximadamente 490 Hz.

Por último, el software de programación de Arduino incluye una herramienta muy útil conocida como Serial Monitor que muestra los datos enviados desde la placa Arduino a través del bus serie, mediante la instrucción Serial.println().

3. Android

Android es actualmente el sistema operativo para dispositivos móviles (teléfonos inteligentes y tabletas) más extendido en todo el mundo, con un porcentaje del mercado mundial del 78%, en España este dato es asistema operativo está basado en una arquitectura Linux y está escrito sobre Java. Su principal punto fuerte es ser un sistema abierto, de código libre, lo que permite que exista una gran comunidad de desarrolladoreen todo momento. También, el hecho de ser de código libre supone que para los fabricantes de hardware las licencias para poder utilizarlo son gratuitas, lo cual abarata costes.

3.1. Historia

En 2003, la empresa Android Inc. fue creada por Andy Rubin junto con un grupo de ingenieros. En principio, la empresa estaba focalizada a crear un sistema operativo para cámaras digitales, pero pronto vieron que era un mercado demasiado pequeño. Entonces, en 2005 Android Inc. fue adquirida por Google Inc., aunque Andy Rubin mantuvo el puesto de CEO y se comenzóteléfonos inteligentes.

Gmail, Contactos y Calendario, Google Search, Google Talk y YouTube. reproductor de archivos multimedia que por entoncúltimo cabe destacar que Android 1.0 ofreció desde sus inicios el soporte para WiFi y Bluetooth, y el popular sistema de notificaciones que aparecen en la barra de estado

Medio año mas tarde, en febrero de 2009, apareció la solo se trató de una actualizaciónPor otro lado en abril de 2009, tan solo unos meses versión, la 1.5 conocida como Cupcake. Esta

Fig. 5. HTC Dream

11

Android es actualmente el sistema operativo para dispositivos móviles (teléfonos inteligentes y tabletas) más extendido en todo el mundo, con un porcentaje del mercado mundial del 78%, en España este dato es aún más avasallador, siendo del 92%. Este sistema operativo está basado en una arquitectura Linux y está escrito sobre Java. Su principal punto fuerte es ser un sistema abierto, de código libre, lo que permite que exista una gran comunidad de desarrolladores capaces y dispuestos a mejorar el sistema operativo en todo momento. También, el hecho de ser de código libre supone que para los fabricantes de hardware las licencias para poder utilizarlo son gratuitas, lo cual abarata costes.

empresa Android Inc. fue creada por Andy Rubin junto con un grupo de principio, la empresa estaba focalizada a crear un sistema operativo para

digitales, pero pronto vieron que era un mercado demasiado pequeño. Entonces, roid Inc. fue adquirida por Google Inc., aunque Andy Rubin mantuvo el

comenzó el desarrollo de un sistema operativo, esta vez centrado en

En 2007, Android fue anunciado oficialmente pero no fue hasta Septiembre2008 que no se presentó un llevase en su interior dicho sistema operativo, en su versión conocida como Apple Pie (aquícomienza la relación de las versiones de Android con diversos postres, ordenados por orden alfabético). Este teléfonoHTC Dream, un teléfono con un teclado físico desplegable. Esta versiónprimera versión del Android Market, un Navegador Web, soporte para mensajes de texto SMS y MMS, y una aplicacióntomar fotos aunque bastante Además se incluyeron algunas aplicaciones para dar soporte a los

servicios de Google más populares comoGoogle Maps con Latitude y Street View,

Gmail, Contactos y Calendario, Google Search, Google Talk y YouTube. Tampoco faltómultimedia que por entonces no era capaz de reproducir ví

cabe destacar que Android 1.0 ofreció desde sus inicios el soporte para WiFi y Bluetooth, y el popular sistema de notificaciones que aparecen en la barra de estado

en febrero de 2009, apareció la versión 1.1 (banana bread) aunque actualización menor y a un número de dispositivos muy limitado.

Por otro lado en abril de 2009, tan solo unos meses más tarde, se presentó una nueva conocida como Cupcake. Esta versión ya incluía los widgets y la

HTC Dream

Android es actualmente el sistema operativo para dispositivos móviles (teléfonos inteligentes y tabletas) más extendido en todo el mundo, con un porcentaje del mercado

ún más avasallador, siendo del 92%. Este sistema operativo está basado en una arquitectura Linux y está escrito sobre Java. Su principal punto fuerte es ser un sistema abierto, de código libre, lo que permite que exista

s capaces y dispuestos a mejorar el sistema operativo en todo momento. También, el hecho de ser de código libre supone que para los fabricantes de hardware las licencias para poder utilizarlo son gratuitas, lo cual abarata costes.

empresa Android Inc. fue creada por Andy Rubin junto con un grupo de principio, la empresa estaba focalizada a crear un sistema operativo para

digitales, pero pronto vieron que era un mercado demasiado pequeño. Entonces, roid Inc. fue adquirida por Google Inc., aunque Andy Rubin mantuvo el

el desarrollo de un sistema operativo, esta vez centrado en

En 2007, Android fue anunciado oficialmente pero no fue hasta Septiembre

un teléfono que llevase en su interior dicho sistema

1.0 también aquí es donde

comienza la relación de las versiones de Android con diversos postres, ordenados

teléfono era el con un teclado

versión incluía la primera versión del Android Market, un Navegador Web, soporte para mensajes de

aplicación para tomar fotos aunque bastante básica.

se incluyeron algunas caciones para dar soporte a los

os de Google más populares como Google Maps con Latitude y Street View,

Tampoco faltó el es no era capaz de reproducir vídeo. Por

cabe destacar que Android 1.0 ofreció desde sus inicios el soporte para WiFi y Bluetooth, y el popular sistema de notificaciones que aparecen en la barra de estado.

nana bread) aunque muy limitado.

tarde, se presentó una nueva los widgets y la creación

12

de carpetas en su pantalla de inicio. Aun tenía muchos defectos por pulir pero mostraba el camino que seguiría el sistema operativo de aquí en adelante. Más tarde, en septiembre del mismo año, llegó Donut, la versión 1.6. Esta versión fue en realidad una pequeña actualización, pero vino empaquetada con un cuadro de búsqueda mejorado, cámara y aplicación de galería, y una renovada Android Market. Android Eclair (2.0) sorprendió con su integración social permitiendo sincronizar los contactos de Facebook, y más tarde, Twitter, que le permitió a sus usuarios tener todos sus contactos de todas las redes sociales en un solo lugar. Eclair también trajo el menú de contacto rápido, permitiendo que al tocar la foto de un contacto se deslizara un menú mostrando todas las formas de comunicación con el mismo. En cuanto a la interfaz de usuarios, también se realizaron mejoras que recayeron básicamente en las animaciones en las transiciones y su fluidez general. Por otro lado, el teclado virtual de Android fue mejorado también con el soporte multitouch, y el diccionario de sugerencias ampliado, que incluía los nombres de nuestros contactos. Finalmente, una de las mayores novedades de Android 2.0 fue Google Maps que recibió el servicio de navegación GPS gratuito, trayendo solo con el lanzamiento una reducción del precio de las acciones de Garmin del 16%, y de Tom Tom del 21%.

Android 2.1 representa la segunda etapa en la evolución de Eclair con su introducción en el Nexus One. Éste fue también el primer teléfono que extendiera las capacidades de voz existente encontrados en versiones anteriores de Android, dando al usuario la opción de transcribir la voz en texto, así Android comenzaba a dar soporte a la búsqueda a través del reconocimiento de voz. Lanzada en mayo de 2010, Android 2.2 Froyo fue una de las actualizaciones que consagró al sistema operativo como la competencia de iOS 4 de Apple, dotando a los terminales Android con un notable incremento de la velocidad de todo el sistema, tanto en sus aplicaciones como en la navegación de Internet. A su vez, Android 2.2 incluye la posibilidad de hacer tethering, es decir, compartir la conexión 3G a través del wifi del teléfono con otros dispositivos, con la posibilidad de convertir tu móvil en un hotspot. En diciembre de 2010 Google presentó de forma oficial Android 2.3 Gingerbread, una actualización que se materializaría con el lanzamiento del Nexus S. Gingerbread incorporó una gran cantidad de novedades, a nivel estético con una renovada interfaz de usuario con incrementos de velocidad y simpleza, y se preparó para la llegada de los smartphones de doble núcleo al cambiar al sistema de archivos EXT4y de pantallas más grandes con el soporte para resoluciones WXGA y mayores. Del lado del usuario, una de las características más notables fue el nuevo teclado virtual que simplificó la entrada de texto y permitió una edición más rápida gracias a la nueva disposición de las teclas y la función para corregir palabras ya ingresadas con sugerencias del diccionario o la opción de cambiarlas mediante voz. El 22 de febrero de 2011 Google comenzó a desdoblar el sistema operativo con la actualización de Android 3.0 Honeycomb y su correspondiente SDK, algo que tendría poca vida debido al alto costo que supone mantener dos plataformas separadas. Basado en el kernel 2.6.36.50 de linux, Honeycomb llegó por primera vez a las tablets con el Motorola Xoom. Sus principales características fueron una renovada interfaz de usuario

con una nueva barra de sistema en la parte inferior de la pantalla que permitía el acceso rápido a notificaciones, estados y botones dpermitía el acceso a opciones contextuales, navegación, widgets y otros tipos de contenido desde la parte superior. Además se agregó una nueva interfaz de contactos divida en docaló en la interfaz de correo para simplificar la visualización y organización de mensajes, permitiendo a su vez seleccionar uno o más mensajes.

Por otro lado la actualización de Honeycomb trajo un tecladogran tamaño y se simplificó la función multitarea con una opción que permitió acceder a las aplicaciones recientes que se mostraban en una lista con imágenes para reconocerlas fácilmente.

Por multiencriptar todos los datos del usuario, y mejoras en el uso de HTTPS gracias a la incorporación de SNI.

La llegada de Android 4.0 Ice Cream Sandwichoctubre de 2011 significó un importante paso en la evoluciónAndroid que no solo vio renovada casi por completo su interfaz de usuario con el nuevo diseño Holo, sino que volvió a integrar el sistema operativo en sus versiones para Tablets y Smartphones.

La nuevaperfeccionamiento de las ideas de Android 3.0. construyó su propia fuente denominada Roboto y en lugar de botones de hardware, el sistema operativo ofreció sus propios botones virtuales de Atrás, Inicio, y los botones de aplicaciones

recientes en la pantalla también para los smartphones. Y así es como llegamos a los tiempos modernos donde Jelly Bean última actualización importante del sistema operativo de Google que dicho sea de paso, fue presentada el 27 de junio de 2primer tablet de Google. El objetivo primordial de Android Jelly Bean fue mejorar la estabilidad, funcionalidad y rendimiimplementó el núcleo de LinuxButter que permitió aumentar hasta 60 FPS luna experiencia realmente fluida.

Sin embargo esto no fue todo lo que la barra de notificaciones, una de las características que distinguió a Android desdinicios. Ahora ofrece una mayor integraciónésta, como realizar llamadas o acceder a diferentes opciones y mostrar información proveniente de las aplicaciones que lanzan la notificación.

Fig. 6. Interfaz ICS

13

con una nueva barra de sistema en la parte inferior de la pantalla que permitía el acceso rápido a notificaciones, estados y botones de navegación suavizados y el Action Bar que permitía el acceso a opciones contextuales, navegación, widgets y otros tipos de contenido

una nueva interfaz de contactos divida en dos paneles, algo que también en la interfaz de correo para simplificar la visualización y organización de mensajes,

permitiendo a su vez seleccionar uno o más mensajes.

Por otro lado la actualización de Honeycomb trajo un teclado rediseñado para pantallas de icó la función multitarea con una opción que permitió acceder a

las aplicaciones recientes que se mostraban en una lista con imágenes para reconocerlas

Por último cabe mencionar el soporte para microprocesadores multi-núcleo, la aceleración de hardware, la posibilidad de encriptar todos los datos del usuario, y mejoras en el uso de HTTPS gracias a la incorporación de SNI.

La llegada de Android 4.0 Ice Cream Sandwich (ICS)octubre de 2011 significó un importante paso en la evoluciónAndroid que no solo vio renovada casi por completo su interfaz de usuario con el nuevo diseño Holo, sino que volvió a integrar el sistema operativo en sus versiones para Tablets y Smartphones.

La nueva interfaz de usuario se mostró como la evoluciónperfeccionamiento de las ideas de Android 3.0. Ademásconstruyó su propia fuente denominada Roboto y en lugar de botones de hardware, el sistema operativo ofreció sus propios botones virtuales de Atrás, Inicio, y los botones de aplicaciones

ntes en la pantalla también para los smartphones.

así es como llegamos a los tiempos modernos donde Jelly Bean aún resuena como la última actualización importante del sistema operativo de Google que dicho sea de paso, fue presentada el 27 de junio de 2012 y llegó al mercado el 13 de julio con el primer tablet de Google. El objetivo primordial de Android Jelly Bean fue mejorar la estabilidad, funcionalidad y rendimiento de la interfaz de usuario, para lo cual se

Linux 3.0.31 y una serie de mejoras en lo que se llamó que permitió aumentar hasta 60 FPS las transiciones en la interfaz de usuario, dando

una experiencia realmente fluida.

Sin embargo esto no fue todo lo que trajo Jelly Bean, ya que Google mejoró notablemente la barra de notificaciones, una de las características que distinguió a Android desd

hora ofrece una mayor integración, ya que permite realizar más acciones desde sta, como realizar llamadas o acceder a diferentes opciones y mostrar información

proveniente de las aplicaciones que lanzan la notificación.

con una nueva barra de sistema en la parte inferior de la pantalla que permitía el acceso e navegación suavizados y el Action Bar que

permitía el acceso a opciones contextuales, navegación, widgets y otros tipos de contenido

s paneles, algo que también en la interfaz de correo para simplificar la visualización y organización de mensajes,

para pantallas de icó la función multitarea con una opción que permitió acceder a

las aplicaciones recientes que se mostraban en una lista con imágenes para reconocerlas

cabe mencionar el soporte para microprocesadores de hardware, la posibilidad de

encriptar todos los datos del usuario, y mejoras en el uso de

(ICS) el 19 de octubre de 2011 significó un importante paso en la evolución de Android que no solo vio renovada casi por completo su interfaz de usuario con el nuevo diseño Holo, sino que volvió a integrar el sistema operativo en sus versiones para Tablets y

interfaz de usuario se mostró como la evolución y Además Google

construyó su propia fuente denominada Roboto y en lugar de botones de hardware, el sistema operativo ofreció sus propios botones virtuales de Atrás, Inicio, y los botones de aplicaciones

resuena como la última actualización importante del sistema operativo de Google que dicho sea de paso, fue

012 y llegó al mercado el 13 de julio con el Nexus 7, el primer tablet de Google. El objetivo primordial de Android Jelly Bean fue mejorar la

ento de la interfaz de usuario, para lo cual se 3.0.31 y una serie de mejoras en lo que se llamó Project

as transiciones en la interfaz de usuario, dando

Jelly Bean, ya que Google mejoró notablemente la barra de notificaciones, una de las características que distinguió a Android desde sus

más acciones desde sta, como realizar llamadas o acceder a diferentes opciones y mostrar información

14

3.2. Entorno de programación

En el mercado, actualmente, existe un gran abanico de opciones para desarrollar aplicaciones en Android. Existen todo tipo de soluciones, para profesionales de la programación, para neófitos e incluso para completos desconocedores de su existencia. A continuación enumeraremos las principales opciones en lenguajes de programación para Android y sus principales características.

3.2.1. Eclipse. Java para Android Eclipse es la plataforma oficial de desarrollo de aplicaciones para Android y también el lenguaje en el cual está programado el sistema operativo Android. Es por ello que es la plataforma mas extendida en todo el mundo. Se basa en el leguaje de programación Java usando los SDK (Software Development Kit) oficiales de Google para Android. Es por tanto un lenguaje orientado a objetos con un desarrollo grafico basado en arquitecturas XML. Esta opción es totalmente gratuita y tiene además, debido a que Android está también programado en este lenguaje, acceso a las actualizaciones del sistema operativo y las API de Google de manera casi automática. Además Google, en la página oficial de Android, da sus guías de programación siempre bajo el uso de Java para Android.

3.2.2. Basic4Android Basic4Android es una plataforma de programación para aplicaciones Android cuyo lenguaje base de programación es Visual Basic, lenguaje que está orientado a la programación de una manera más gráfica y no tan abstracta. No es el mismo lenguaje de Microsoft, pero su sintaxis es la misma, lo cual tiene sus mismas ventajas como algunos de sus inconvenientes. Esta plataforma no es gratuita, encontramos desde la versión mínima de pago que es de 49 dólares hasta la versión máxima de 249 dólares. 3.2.3. Mono para Android Otro de los lenguajes que Microsoft desarrolló para hacer aplicaciones fue C# y .NET, los cuales son muy usados en diferentes ambientes, por lo que no podría faltar que estos lenguajes tan comunes y opuestos a Java llegaran a Android. Según Xamarin (la empresa creadora de Mono), se trabaja con un lenguaje nativo para Android ya que no tiene un intérprete como lo tendría Basic4Android, y su aprendizaje es relativamente sencillo. Por otro lado está el tema del precio, ya que la versión más económica de Mono es de 399 dólares.

15

3.2.4. App Inventor Esta plataforma de desarrollo fue impulsada por Google hace un tiempo con el fin de que más personas se unieran a la familia de Android, en este caso personas no relacionadas directamente con el entorno de la programación, sino todo lo contrario. Es un lenguaje totalmente gráfico y dedicado a personas sin ningún conocimiento de programación de ningún tipo; esta herramienta usa el navegador como centro principal de trabajo, y almacena todo esto en servidores que están disponibles cada vez que se entre a internet. Este entorno es totalmente gratuito y no tiene límite de tiempo.

3.2.5. LiveCode El lenguaje de programación que usa LiveCode se llama “Programación Orientada a Eventos”, y se basa en arrastrar elementos a un área de trabajo y programar los eventos que estén vinculados a este elemento. Este programa también es de pago dependiendo de qué alcance se quiera tener en el desarrollo, es decir, de las plataformas móviles a las cuales queramos tener acceso.

La opción que hemos elegido es finalmente Eclipse, pues es la opción mas generalizada, es la única soportada oficialmente por Google y además es complemente gratuita. En este punto, partiremos a explicar los fundamentos básicos de esta plataforma en base a poder profundizar más adelante en los conceptos utilizados durante la programación de la aplicación creada en Android.

Las aplicaciones de Android, como hemos comentado anteriormente, están escritas en el lenguaje de programación Java. Las herramientas del SDK de Android compilan dicho código escrito en Java (junto con todos los datos y archivos de recursos) en un Android package, un paquete de Android, que es un archivo con extensión apk. Un archivo APK contiene todo el código de una aplicación para Android y es el archivo que los dispositivos con Android utilizan para instalar la aplicación.

Una vez instalado en un dispositivo, cada aplicación Android vive en su propio entorno limitado de seguridad:

• El sistema operativo Android es un sistema Linux para múltiples usuarios en el que cada aplicación es un usuario diferente.

• Por defecto, el sistema asigna a cada aplicación un ID de usuario único de Linux (el ID es utilizado sólo por el sistema y no se conoce por la aplicación). El sistema establece permisos para todos los archivos en una aplicación para que sólo el ID de usuario asignado a esa aplicación pueda acceder a ellos.

• Cada proceso tiene su propia máquina virtual (VM), por lo que el código de una aplicación se ejecuta en forma aislada de otras aplicaciones.

• Por defecto, cada aplicación se ejecuta en su propio proceso de Linux. Android comienza el proceso cuando alguno de los componentes de la aplicación necesita ser ejecutado, y cierra el proceso cuando ya no es necesario o cuando el sistema debe recuperar memoria para otras aplicaciones.

De esta manera, el sistema Android implementa el principio de privilegios mínimos. Es decir, cada aplicación, por defecto, sólo tiene acceso a los componentes que necesita para

16

hacer su trabajo y nada más. Esto crea un ambiente muy seguro en el que una aplicación no puede tener acceso a partes del sistema para el cual no se le ha dado permiso. Los App Components son los componentes esenciales de una aplicación Android. Cada componente es un punto diferente a través del cual el sistema puede entrar a la aplicación pero no todos los componentes son puntos de entrada para el usuario e incluso algunos dependen unos de otros. Hay cuatro tipos diferentes de componentes de aplicaciones. Cada tipo tiene un propósito distinto y tiene un ciclo de vida diferente que define cómo se crea el componente y se destruye. Éstos son los cuatro tipos de componentes de aplicaciones:

1. Activity (o Actividad) Una actividad representa una única pantalla con una interfaz de usuario. Por ejemplo, una aplicación de correo electrónico puede tener una actividad que muestra una lista de los nuevos mensajes de correo electrónico, otra actividad para redactar un correo electrónico, y otra de las actividades para la lectura de mensajes de correo electrónico. Aunque las actividades trabajan juntas para formar una experiencia de usuario coherente en la aplicación de correo electrónico, cada una es independiente de las demás. Como tal, una aplicación diferente puede iniciar cualquiera de estas actividades (si la aplicación de correo electrónico lo permite). Por ejemplo, una aplicación de cámara puede iniciar la actividad en la aplicación de correo electrónico que compone correo nuevo, con el fin de que el usuario pueda compartir una imagen.

2. Service (o Servicio) Un servicio es un componente que se ejecuta en segundo plano para realizar operaciones de larga ejecución o para realizar un trabajo para procesos remotos. Un servicio no proporciona una interfaz de usuario. Por ejemplo, un servicio puede reproducir música en segundo plano mientras el usuario está en una aplicación diferente, o puede obtener los datos sobre la red sin bloquear la interacción del usuario con una actividad. Otro componente, como una actividad, puede iniciar el servicio y dejar que se ejecute o se unen a ella con el fin de interactuar con él.

3. Content Provider (o Proveedores de Contenido) Un proveedor de contenido gestiona un conjunto compartido de datos de aplicaciones. Puede almacenar los datos en el sistema de archivos, una base de datos SQLite, en la web, o cualquier otro lugar de almacenamiento permanente que la aplicación pueda tener acceso. A través del proveedor de contenido, otras aplicaciones pueden consultar o incluso modificar los datos (si el proveedor de contenido lo permite). Por ejemplo, el sistema Android ofrece un proveedor de contenidos que gestiona la información de contacto del usuario . Como tal, cualquier aplicación con los permisos adecuados puede consultar parte del proveedor de contenidos (como ContactsContract.Data) para leer y escribir información sobre una persona en particular.

4. Broadcast Receiver (o Receptores de Radiodifusión) Un receptor de radiodifusión es un componente que responde a transmitir anuncios de todo el sistema. Muchas emisiones se originan en el sistema - por ejemplo, una emisión de anunciar que la pantalla se ha apagado, la batería está baja, o una imagen fue capturada. Las aplicaciones también pueden iniciar las emisiones, por ejemplo, dejar que otras apps sean informadas de que se han descargado algunos

datos al dispositivo y estáde radiodifusión no muestran una interfaz de usuario, es posible crear una notificación de la barra de estado para alertar al usuario cuando se produce un evento de difusión.

Por último, antes de que el sistema Android sistema debe saber que existe el componente, y esto se consigue mediante la lectura del archivo AndroidManifest.xml de la aplicación. La aplicación componentes en este archivo, que debe estar en la raíz del directorio del proyecto de aplicaciones. El manifiesto hace una serie de cosas, además de declarar los componentes de la aplicación, tales como:

• Identificar los permisos deInternet o acceso de lectura a los contactos del usuario.

• Declarar el Nivel API (la aplicación, a partir del cual las API de los usos de aplicaci

• Declarar características de hardware y software utilizados o requeridos por la aplicación, tales como una cámara, los servicios Bluetooth o una pantalla multitouch.

• Librerías API a las que la API del marco de Android), como la biblioteca de Google Maps.

Por otro lado, está la Interfaz de usuario o componente de una aplicación se define usando una jerarquía de objetos ViewGroup, como se muestra en laque organiza las Views. Este que sea (pero la simplicidad es mejor para el rendimiento).

Fig. 7. Ilustració

17

al dispositivo y están disponibles para que los utilicen. Aunque los receptores de radiodifusión no muestran una interfaz de usuario, es posible crear una notificación de la barra de estado para alertar al usuario cuando se produce un

, antes de que el sistema Android pueda iniciar un componente de aplicación, el sistema debe saber que existe el componente, y esto se consigue mediante la lectura del archivo AndroidManifest.xml de la aplicación. La aplicación debe declarar todos sus componentes en este archivo, que debe estar en la raíz del directorio del proyecto de aplicaciones. El manifiesto hace una serie de cosas, además de declarar los componentes

Identificar los permisos de usuario que la aplicación requiere, como el acceso a Internet o acceso de lectura a los contactos del usuario. Declarar el Nivel API (Application Programming Interface) mínima requerida por la aplicación, a partir del cual las API de los usos de aplicaciones. Declarar características de hardware y software utilizados o requeridos por la aplicación, tales como una cámara, los servicios Bluetooth o una pantalla

Librerías API a las que la aplicación debe estar vinculada (con excepción de las I del marco de Android), como la biblioteca de Google Maps.

Por otro lado, está la Interfaz de usuario o Layout. La interfaz de usuario para cada componente de una aplicación se define usando una jerarquía de objetos

, como se muestra en la figura 7. Cada ViewGroup es un contenedor invisible . Este diagrama puede ser tan simple o complejo como

que sea (pero la simplicidad es mejor para el rendimiento).

ón de una jerarquía View, la cual define a su vez un layout

. Aunque los receptores de radiodifusión no muestran una interfaz de usuario, es posible crear una notificación de la barra de estado para alertar al usuario cuando se produce un

iniciar un componente de aplicación, el sistema debe saber que existe el componente, y esto se consigue mediante la lectura del

debe declarar todos sus componentes en este archivo, que debe estar en la raíz del directorio del proyecto de aplicaciones. El manifiesto hace una serie de cosas, además de declarar los componentes

usuario que la aplicación requiere, como el acceso a

mínima requerida por

Declarar características de hardware y software utilizados o requeridos por la aplicación, tales como una cámara, los servicios Bluetooth o una pantalla

aplicación debe estar vinculada (con excepción de las

. La interfaz de usuario para cada componente de una aplicación se define usando una jerarquía de objetos View y

es un contenedor invisible puede ser tan simple o complejo como se necesite

18

4. La Aplicación. DomoAndruino Como hemos explicado previamente, se pretende crear una plataforma de monitorización y control de ciertos servicios básicos que se pueden encontrar en un hogar estándar, para poder convertirlo en un hogar conectado.

Este proyecto consta de tres partes bien diferenciadas: • Capa Hardware, donde se conectarán todos los sensores y actuadores de nuestro

proyecto. • Capa Software en Arduino, que hace las tareas de controlador de la capa hardware

y a la vez de servidor TCP para hacer de enlace con la última capa. • Capa Software en Android, que realiza la tarea de interfaz gráfica con el usuario

final. A continuación detallaremos cada una de las capas.

4.1. La Capa Hardware

Para la monitorización del estado de la casa se han escogido las siguientes variables: • Temperatura • Humedad • Nivel de Ruido • Nivel de CO • Presencia • Estado de Luces • Estado de Persianas • Estado de la Sirena • Estado de la Calefacción • Estado del Aire Acondicionado

A su vez para el control tenemos: • Control de Luces (On/Off) • Control de Persianas (Arriba/Abajo) • Control de la Sirena (On/Off) • Control de la Calefacción (On/Off) • Control del Aire Acondicionado (On/Off)

Y por último, se ha conectado una Cámara IP Zaapa, modelo ZA-CIPRW para poder visualizar una estancia e incluso controlar el movimiento de dicha cámara para así poder abarcar más espacios.

Fig. 8. Cámara IP

19

Además de todo esto es necesario un router donde conectar tanto la cámara IP como nuestro módulo Arduino, puesto que hemos de hacerlos accesibles al resto de la red para poder enlazarlos con nuestro móvil.

Fig. 9. Router Livebox 2.1 uitlizado

Para empezar, a continuación se muestra una representación de la circuitería:

Fig. 10. Representación grafica del circuito

20

Y el diagrama esquemático del circuito (se puede ver en más detalle en el Anexo C):

Fig. 11. Esquemático del circuito El primer detalle a comentar es la inclusión de un regulador de tensión para forzar una tensión de 8V a la entrada proveniente de la fuente de continua a 12V para alimentar el módulo de Arduino y el módulo de Ethernet. El regulador usado es el UA7808C de Texas Instruments.

Fig. 12. Encapsulado TO220 del regulador de tensión

21

Seguidamente, pasaremos a explicar la circuitería de la medida de la temperatura. Para ello se ha utilizado un divisor de tensión en el cual hemos usado un sensor de temperatura PTC modelo B59339-A1201-P20. Para el cálculo de la temperatura se ha tenido en cuenta su punto de trabajo según la siguiente gráfica:

Fig. 13. Gráfica de la resistencia vs la temperatura

Por tanto, dentro del margen habitual de temperaturas posibles en un hogar, se considera un rango de 0 a 60ºC, podemos considerar el comportamiento del valor de resistencia como lineal, y así obtenemos el valor de resistencia según temperatura con la siguiente fórmula:

=−550

29∙ + 247414

Ecuación 1. Resistencia de la PTC vs. temperatura

Obviamente, el valor constante de esta recta dependerá de muchos factores, principalmente de la tension de entrada al divisor de tension y del propio divisor de tension, es por ello que se ha incluido un proceso de calibración en la aplicacion, concretamente en la parte de software de Andriod, para poder ajustar el valor dinámicamente.

22

Siguiendo el repaso de la circuitería, la medida de humedad se realiza utilizando el sensor comercial MMT1001 que tiene una relación de tensión de salida frente a la humedad relativa del ambiente según la siguiente gráfica:

Fig. 14. Gráfica de la tensión vs la humedad relativa

También hemos de comentar el uso del sensor comercial para detección de gas metano en el aire MQ-5. Este componente necesita de una circuitería muy concreta para funcionar correctamente. Esta circuitería se divide en dos, la alimentación del heater y la circuitería de la tensión de salida que requiere de una resistencia de carga de un valor entre 10kΩ y 47kΩ. En este caso hemos usado el valor recomendado de 20kΩ. La relación del valor leído respecto a la presencia de gas metano en el ambiente se realiza según información obtenida en su datasheet y reflejada en la siguiente gráfica:

Fig. 15. Gràfica de la resistencia vs la composición del aire

23

El siguiente circuito es el del sensor de ruido, este sensor es concretamente un micrófono al cual se le añade una circuitería de conversión de sonido a un valor digital de 0 o 1 gracias al valor del potenciómetro que se utiliza para escoger la sensibilidad de la señal de ruido.

Fig. 16. Esquemático del circuito de sonido

Para la detección de presencia se ha optado por el sensor comercial E2EG-X1R5B1 de Omron que detecta presencia de un objeto metálico, el cual tan solo necesita una alimentación a 12V y un divisor de tensión a la salida para dar un rango admisible para la entrada del módulo de Arduino.

Fig. 17. Sensor de proximidad de Omron

24

En cuanto a la activación de luces se ha realizado mediante un relé tipo reel para así aislar al módulo de Arduino de la señal de corriente alterna. El relé escogido tiene como principal característica que sólo necesita 5V en la bobina para cerrar sus contactos, lo cual lo hace ideal para uso con una placa Arduino. De todas maneras, en nuestro caso práctico tan solo encendemos un LED para simular la bombilla.

Fig. 18. Relé Meder utilizado

Por otro lado, tanto para la activación de la calefacción como del aire acondicionado, puesto que se trata tan solo de pilotar cuadros de control de los aparatos, el consumo de corriente y los valores de tensión se adecuan a los limites especificados, podemos controlarlos directamente a través de los pines de salida del módulo Arduino.

En cambio, para el control del movimiento de las persianas se utiliza un motor paso a paso de 5VDC con un controlador ULN2003 que lógicamente acarrea un consumo de corriente muy superior a la capacidad del módulo Arduino.

Fig. 19. Esquemático del motor paso a paso

Por lo que se utiliza un regulador de tensión, el UA7805C de Texas Instruments (mismas características que el UA7808C mencionado anteriormente) a 5V para fijar la tensión, conectado a la fuente de alimentación principal de 12V y se usan las salidas PWM de Arduino, pines 8 a 11 para controlar las 4 fases del motor.

25

Por último, está el control de la sirena, para simular una sirena se utiliza un buzzer PKM13EPYH4002-B0 de muRata que es capaz de generar hasta 70dB. Para esto es necesario enviarle una señal cuadrada, con una relación de frecuencia-sonido como la de la siguiente gráfica:

Fig. 20. Relación frecuencia vs dB

Por tanto, y usando la frecuencia nativa de un pin de salida PWM de Arduino (490Hz) nos encontramos con un sonido aproximado de 65dB a 10cm. Además es necesario añadir una resistencia de carga de 20kΩ para cumplir con las especificaciones del fabricante.

26

4.2. La Capa Software Arduino En la capa de software del módulo de Arduino, tenemos el sketch que nos permite controlar todo el hardware comentado anteriormente. Este sketch se divide en dos secciones: la parte de configuración del hardware y la parte de ejecución. En la parte de configuración hemos de observar la definición de las variables internas del programa, así como de los parámetros para la creación del servidor TCP para establecer la comunicación con el dispositivo móvil. A su vez, también está la definición de la variable y parámetros de configuración del controlador del motor paso a paso. Así pues lo primero es configurar el servidor TCP para que tenga una dirección MAC fija, este valor es aleatorio, puesto que el shield de Ethernet no dispone de una dirección MAC propia y hay que asignársela. El único requisito es que no coincida con ninguna dirección MAC de nuestra red local para no provocar ningún conflicto con el resto de dispositivos. Tras esto, es hora de configurar el motor paso a paso, para ello, seleccionamos el número de pasos por revolución y las revoluciones por minuto. Esto nos permitirá controlar la velocidad y precisión de nuestro motor. El resto es tan solo declaración de variables y configuración de pines. Todo esto es el código introducido dentro de la función setup del código de Arduino: void setup()

Serial.begin(9600); // arranquem el debugger

Ethernet.begin(mac, serverIP); // arrancar el servidor

server.begin();

Serial.println("Server started");//log

...

Por otro lado tenemos la parte de ejecución, que también se divide en dos partes, la obtención de datos por parte de los sensores y actuación sobre las salidas de nuestro módulo (si los flags así nos lo indican) y la sección para la comunicación entre el módulo Arduino y el teléfono Android. Este código está incluido en la función Loop del sketch. Esta función, como su propio nombre indica se ejecuta en bucle infinito mientras el módulo se encuentra alimentado. void loop()

EthernetClient client = server.available(); // escoltar el port

if (client)

while (client.connected())

// lectura de totes les inputs

if (client.available())

char c = client.read();

clientMsg+=c;//guardar el caracter dins del missatge

//si el caracter es un carro de linia el missatge ha acabat

if (c == '\n')

Serial.println("Missatge rebut:"+clientMsg); debugger

delay(1); // espera per rebre dades

client.stop(); // tancar la conexio:

27

La idea es capturar periódicamente el estado de los sensores conectados a la vez que consultamos si se ha producido una petición de conexión por parte de un cliente y si éste ha enviado algún comando, y en caso afirmativo, ejecutarlo. Todo el proceso de comunicación con clientes es monitorizado y enviado por el puerto USB a un PC para poder ser evaluado en tiempo real.

Fig. 21. Serial Monitor

28

4.3. La Capa Software Android La capa de software que corre bajo Android se encarga de comunicar con el servidor que hemos creado con el módulo Arduino para poder mostrar los valores leídos por este último, así como para poder controlar el hardware correspondiente. Además nos permite conectarnos a la cámara IP y crear gráficas de los principales valores analógicos obtenidos. 4.3.1. Librerías Utilizadas Como hemos comentado previamente, Android funciona a base de APIs, también llamadas packages, que son básicamente librerías pre-compiladas. En nuestro proyecto hemos utilizado varias APIs nativas de Android, de las cuales las siguientes son las más importantes:

• android.content.Intent: un Intent es una operación a ejecutar. Se puede utilizar para lanzar una Activity con el método startActivity, arrancar un Service en background con los métodos startService o BindService, aunque su principal función es ejecutar Activities.

• android.os.AsyncTask: un AsyncTask habilita la ejecución de operaciones en background y comunica los resultados en el entorno gráfico sin necesidad de trabajar con threads. Idealmente se debería usar para operaciones de corta duración. Consta de tres tipos diferentes (Params, Progress y Result) y 4 métodos principales conocidos como onPreExecute, doInBackground, onProgressUpdate y onPostExecute.

• android.os.IBinder: IBinder es la clase base para crear objetos remotos y comunicarse con ellos para hacer transferencia de datos desde otros procesos de la aplicación.

• android.support.v4.app.Fragment: un Fragment es una parte de una interfaz gráfica que puede integrarse dentro de una Activity que permite tener varios layouts en un mismo activity dando usualmente el aspecto de varias pestañas de trabajo en una única ventana. La interacción con Fragments se realiza mediante un FragmentManager

• android.util.Log: API que permite crear log de eventos dentro de la aplicación para así poder controlar excepciones y verificar el correcto funcionamiento de la aplicación.

• android.widget.Toast: un Toast es una vista que contiene un pequeño mensaje para el usuario que se visualizará temporalmente en la parte inferior de la pantalla sobre la activity actual.

• android.app.NotificationManager: Clase que permite crear notificaciones de aplicación para el usuario, para avisar de que un evento concreto de la aplicación ha ocurrido o ha sido lanzado.

Además hemos usado algunas nativas de Java directamente, las más importantes:

• java.io.File: referencia para el tratamiento de ficheros dentro del sistema de archivos de Android.

• java.util.TimerTask: librería que permite crear eventos periódicos e incluso unitarios mediante un objeto timer.

29

• java.net.URL: la clase de URL representa un Localizador Uniforme de Recursos (URL en sus siglas en inglés), un puntero a un "recurso" en la World Wide Web. Un recurso puede ser algo tan simple como un archivo o un directorio, o puede ser una referencia a un objeto más complicado, como una consulta a una base de datos o de un motor de búsqueda.

• java.net.Socket: Esta clase implementa sockets de cliente (también llamados simplemente "sockets"). Un socket es un punto final para la comunicación entre dos máquinas.

Finalmente, se ha utilizado el package open source AChartEngine para poder crear las gráficas de la aplicación ya que desde sus inicios Android retiró el soporte a Swing y AWT, paquetes de librearías de interfaz grafica de Java para crear gráficos.

4.3.2. Interfaz Gráfica

En cuanto al apartado gráfico de la aplicación, y según el flujo de ésta, nos encontraremos primero con una pantalla de Login para asegurar que solo un usuario autorizado accede a las funcionalidades de la aplicación.

Fig. 22 Login Screen

Una vez hemos accedido al menú principal de la aplicación nos encontramos con tres pestañas diferentes que nos permiten acceder a diferente información:

• Pestaña de status de variables

• Pestaña de control de variables

• Pestaña de control de la cámara IP

30

En la pestaña de status de variables podremos observar periódicamente el valor en tiempo real de cada una de las variables monitorizadas por la aplicación (mencionadas en capítulos anteriores): Temperatura, Humedad, Nivel de Ruido, Nivel de Metano, Presencia, Estado de Luces, Estado de Persianas, Estado de la Sirena, Estado de la Calefacción, Estado del Aire Acondicionado y el estado de la Alarma. A tener en cuenta que el estado de la alarma tan solo refleja el valor de la variable de Alarma, y no tiene ningún hardware asociado directamente. Esta es la vista que podemos obtener en este menú:

Fig. 23 Status Screen

A su vez, también podremos acceder a las gráficas de los últimos valores almacenados por las variables analógicas capturadas (Temperatura, Humedad, Ruido y Nivel de gas Metano) desde el menú secundario que se encuentra en todas las pestañas en la esquina superior derecha de la pantalla. La información se va recolectando periódicamente, preguntándole al servidor, cada 2 segundos, por el estado de todas las variables del proceso mediante la conexión TCP creada mediante sockets entre la aplicación Android, que en este caso hace las veces de cliente, mientras el módulo Arduino se comporta como servidor. También está accesible, dentro del menú secundario, la opción de calibrar la medida de temperatura, pues el hardware puede tener un offset diferente en cada caso. Esta opción se encontraría disponible para un supuesto usuario avanzado o un usuario técnico del sistema.

31

Fig. 24 Menú de acceso a Gráficas Fig.25. Gráfica de ejemplo Fig.26. Menú de calibración

Por otro lado, en la pestaña de control de variables, podremos modificar el estado de diversas variables, también mencionadas anteriormente, como son el control de Luces, el control de Persianas, el control de la Sirena, el control de la Calefacción y el control del Aire Acondicionado, por último, además está el control de la Alarma.

Fig. 27. Menú de Control

32

El último menú de nuestra aplicación es el encargado de interactuar con la cámara Ip conectada a nuestra red LAN. Mediante este menú podremos conectar la cámara, desconectarla, moverla arriba y abajo, de izquierda a derecha, y por último, salvar las imágenes ofrecidas en nuestro dispositivo móvil, para su posterior visualización, con tan sólo pulsar un botón.

Fig. 28. Menú de la cámara Fig. 29. Imagen de ejemplo capturada

33

Por último cabe destacar que incluso al salir de la aplicación, el programa queda residente en memoria para poder monitorizar el estado de las variables y así poder lanzar notificaciones en el caso de encontrarnos con una señal de alarma. En esta aplicación, en el caso que nos encontremos con que, teniendo la alarma activada, el sensor de presencia detecta, valga la redundancia, una presencia, enviaría a nuestro sistema operativo una notificación que nos avisaría del hecho que está ocurriendo en este momento.

Al hacer clic sobre dicha notificación, se abriría de nuevo la aplicación para que podamos observar el estado del resto de variables e incluso conectar la cámara si así lo deseásemos.

Fig. 30. Notificación presente por alarma

34

4.3.3. Núcleo de la aplicación

El núcleo de nuestra aplicación es el que se encarga de interactuar con el hardware del sistema a través de la comunicación con el módulo Arduino mediante una conexión cliente-servidor, nuestro dispositivo Android y nuestro módulo Arduino respectivamente. Para ello, en la clase principal de nuestra aplicación Android creamos una tarea periódica que se ejecuta cada 2 segundos (según variable mInterval) que llama a la función showServiceData, que se encarga de actualizar las valorables de estado de nuestra aplicación.

public void showServiceData(View view) throws InterruptedException

String stemp="";

String[] splits;

int i=0;

double value=0;

Log.d("Tab",String.valueOf(tabsel));

if( s != null && tabsel<1)

String message = s.getMessage();

if (message!=null)

Log.d("Message",message);

consecutiveerrorframes=0;

...

Esta función recoge los valores leídos y almacenados en nuestro servicio en background que a su vez ejecuta una tarea asíncrona periódica cada 200 ms (mediante la variable UPDATE_INTERVAL) donde se crea un cliente TCP, se conecta al servidor, se envía la trama al servidor escogida para cada momento, según queramos conocer el estado de las variables o controlar alguno de los parámetros hardware de nuestro módulo Arduino, y se recepciona la respuesta del servidor:

private void pollForUpdates()

timer.scheduleAtFixedRate(new TimerTask()

@Override

public void run()

try

...

Client c = new Client(message);

list=c.getResultado();

...

if(c.getResultado()!=null)

...

, 0, UPDATE_INTERVAL);

35

Por último, tenemos el cliente TCP, que es el encargado a más bajo nivel de conectarse al servidor y gestionar los envíos y recepciones de datos que se producen durante las sesiones de cliente-servidor:

//private static final String serverIP="lrolin.no-ip.biz";

private static final String serverIP="192.168.1.106";

private static final int serverPort=8881;

private String resultado;

public Client(String message) throws IOException

...

Socket clientSocket = new Socket(serverIP, serverPort);

DataOutputStream outToServer = new

DataOutputStream(clientSocket.getOutputStream());

BufferedReader inFromServer = new BufferedReader(new

InputStreamReader(clientSocket.getInputStream()));//

msgToServer = message;

...

msgFromServer = inFromServer.readLine();

setResultado(msgFromServer);

clientSocket.close();

Como se puede comprobar, la comunicacion entre cliente-servidor se cierra después de cada trama para controlar la duración de servidores y permitir conexiones de más de un cliente al servidor, ya que el servidor acepta sólo 4 clientes conectados simultáneamente.

36

4.4. Presupuesto

Los principales componentes del proyecto en cuanto a coste son los detallados a continuación:

Descripción Cantidad Precio

Unitario Subtotal

Placa Arduino Mega 1 41,00 € 41,00 €

Placa Ethernet Shield 1 31,00 € 31,00 €

Sensor Presencia 1 46,70 € 46,70 €

Sensor Humedad 1 7,35 € 7,35 €

Sensor Temperatura 1 1,10 € 1,10 €

Sensor de Sonido 1 5,51 € 5,51 €

Sensor de Metano 1 2,75 € 2,75 €

Regulador de tensión 3 2,50 € 7,50 €

Cámara IP 1 39,00 € 39,00 €

Cableado 1 3,42 € 3,42 €

Set Resistencias 1 6,90 € 6,90 €

Motor paso a paso 1 6,43 € 6,43 €

Total 198,66 € Tabla 2. Presupuesto aproximado del proyecto

Obviamente, el teléfono móvil ha sido excluido de este presupuesto, por dos motivos:

1. Actualmente, en España, el uso de teléfonos móviles inteligentes está altamente extendido. El último estudio del Observatorio Nacional de las Telecomunicaciones y de la Sociedad de la Información (ONTSI) para el 2012 habla sobre que el porcentaje de teléfonos móviles por habitante es del 53.7%.

2. El rango de precios de un teléfono móvil inteligente oscila entre los 60€ y los 750€ dependiendo de sus características de hardware, como el procesador, tamaño y calidad de la pantalla, memoria RAM, por lo que poner un precio sería dar un valor al azar.

Como se puede comprobar el coste de crear esta aplicación es muy limitado, gracias principalmente al uso de tecnologías de hardware y software de licencias gratuitas.

Por otro lado, para establecer el que sería un hipotético coste de las horas de diseño y programación, se estima que el coste por hora es de 22€/h (coste de mercado) y se han establecido un total de 256 horas de horas de trabajo, por lo que se calcula un coste de diseño de 5632 €. Lo que repercutiría en un coste final de 5830.66 € por todo el proyecto.

37

5. Conclusiones

En este proyecto se ha realizado una aplicación que permite la interacción de un teléfono móvil con un sistema microcontrolado remoto. El sistema remoto emula una aplicación domótica implementada mediante la tecnología Arduino que permite el acceso a sensores y actuadores diversos. La aplicación en el teléfono móvil se ha programado mediante Android, la cual permite establecer una conexión remota via TCP permitendo al usuario visualizar datos domóticos en forma tanto numérica como gráfica. El resultado final ha sido que la aplicación es elegante y sencilla, a la vez que intuitiva para el usuario. Globalmente, esta solución, cumple a la perfección con las necesidades de un usuario medio y todo ello por un módico. Así mismo, la gran cantidad de información para ambas plataformas (Android y Arduino) acelera el proceso de aprendizaje y facilita la solución de problemas, lo que potencia que aumente el número de aplicaciones para estas plataformas de manera exponencial. Es por ello que podemos concluir que, tal y como se indicaba al principio, tanto las plataformas Arduino como Android son realmente útiles para realizar proyectos de DIY en todo tipo de ámbitos, asegurando robustez sin tener que preocuparse por el coste final del proyecto.

38

Anexo A. Bibliografía

International Data Corporation Analyze the Future, [en línea]. Framingham USA: IDC; 2014.[fecha de consulta 11 marzo 2014]. Disponible en http://www.idc.com/getdoc.jsp?containerId=prUS24676414

Arduino, [en línea]. Ivrea, Italia: Arduino; 2014. .[fecha de consulta 11 marzo 2014]. Disponible en http://arduino.cc/en/

Atmel Corporation AVR061: STK500 Communication Protocol, [en línia]. San Jose Ca. USA: Atmel; 2014. .[fecha de consulta 15 marzo 2014]. Disponible en: http://www.atmel.com/Images/doc2525.pdf

Android, [en línia]. San Francisco: Android; 2014. .[fecha de consulta 15 marzo 2014]. Disponible en: http://developer.android.com/index.html

Eclipse, [en línia]. Ottawa: Eclipse; 2014.[fecha de consulta 16 marzo 2014]. Disponible en: http://www.eclipse.org/

Anywhere Software, [en línea]. Moshav Yodfat Israel: Basic4Android; 2014.[fecha de consulta 16 marzo 2014]. Disponible en: http://www.basic4ppc.com

Xamarin. Android, [en línia]. San Francisco: Xamarin; 2014.[fecha de consulta 16 marzo 2014]. Disponible en: http://xamarin.com/android

MIT App Inventor, [en línia]. Massachusetts : Massachusetts Institute of Technology; 2014.[fecha de consulta 15 marzo 2014]. Disponible en:http://explore.appinventor.mit.edu/

RunRev, [en línia]. Edinburgh UK: Runtime Revolution Ltd; 2014.[fecha de consulta 25 marzo 2014]. Disponible en: http://www.runrev.com/home/

Arduino, [en línea]. Ivrea, Italia: Arduino; 2009-13. [fecha de consulta 10 marzo 2014]. Disponible en: http://www.arduino.cl/int/lenguaje.html

ONTSI, [en línia]. Madrid: Observatorio Nacional de Telecomunicacions y de la SI; 2014. [fecha de consulta 10 marzo 2014]. Disponible en: http://www.ontsi.red.es/ontsi/es/estudios-informes/xli-oleada-del-panel-hogares-%E2%80%9Clas-tic-en-los-hogares-espa%C3%B1oles%E2%80%9D-3t2013

Oracle, [en línea]. Redwood City: Oracle Corporation; 2014. [fecha de consulta 10 marzo 2014]. Disponible en: http://docs.oracle.com/javase/6/docs/api/

IEEE Spectrum, [en línia]. New York: Institute of Electrical and Electronics Engineers; 2014. [fecha de consulta 10 marzo 2014]. Disponible en: http://spectrum.ieee.org/geek-life/hands-on/the-making-of-arduino/0

39

Anexo B. Datasheets

Siemens Matsuchita Components, [en linea]. Berlin: Siemens; 2014. [fecha de consulta 03 abril 2014]; 96.Disponible en : http://www.ryston.cz/pdf5/ptc.pdf

Murata Manufacturing Co.,Ltd. Piezoelectric Sound Components [data sheet en internet] 2014 marzo-abril [acceso 05 abril 2014];10. Disponible en: http://www.murata.com/products/catalog/pdf/p37e.pdf

Texas Instruments [datasheet en internet]. Fixed Positive voltaje regulators. Texas Instruments Inc. 2014 marzo-abril [acceso 05 abril 2014];5. Disponible en: http://www.ti.com/lit/ds/symlink/ua7805.pdf

Maxdetect Electronics Co., Ltd. [datasheet en internet]. Voltage-output relative humidity and temp. sensor /module. Model: MMT1001. Maxdetect Electronics Co., Ltd. 2014 marzo-abril [acceso 04 abril 2014]; 1-3. Disponible en: http://www.eleparts.co.kr/data/design/product_file/Hoon/MMT1001.pdf

Motion Solution, LLC.[datasheet en internet]. 24BYJ48, 28BYJ48, 30BYJ46 type stepping motor. Motion Solution, LLC. 2014 marzo-abril [acceso 10 abril 2014]; 1. Disponible en: http://www.motionsolutions.us/motors/Stepper_Motors/Geared_Steppers/24_28_30BYJ.pdf

OMROM.[datasheet en internet]. Cylindral Proximity Sensor E2EG. OMROM. 2014 marzo-abril [acceso 10 abril 2014]; 6. Disponible en: http://www.proenergo.ru/doc_pdf/sensor/proximity/E2EG.pdf

HANWEI ELECTRONICS CO.,LTD. [datasheet en internet]. Technical Data MQ-5 Gas Sensor. 2014 marzo-abril [acceso 10 abril 2014]; 1-2. Disponible en: http://parallax.com/sites/default/files/downloads/605-00009-MQ-5-Datasheet.pdf

MEDER ELECTRONICS CO.,LTD. [datasheet en internet]. Single-In-Line Reed Relay. 2014 marzo-abril [acceso 18 abril 2014]; 198-199. Disponible en: http://www.meder.com/fileadmin/meder/pdf/en/Products/Reed_Relays/Relay_SIL_Series_E.pdf

40

Anexo C. Esquemático

Anexo D. Código Arduino

/*

Servidor TCP

*/

#include <SPI.h>

#include <Ethernet.h>

#include <Stepper.h>

// Configuracio: MAC address, IP i port al qual es connectarà el client

Android

byte mac[] = 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ;

IPAddress serverIP(192,168,1,106);

int serverPort=8881;

// Inicialitzar el servidor

EthernetServer server(serverPort);

// Definicio de pinout de I/O

int presencia = 2;

int temperatura = 2;

int humitat = 0;

int fum = 3;

int soroll = 1;

int llum = 3;

int aire = 4;

int calefaccio = 5;

int buzzer = 6;

int llum_estat =0;

int aire_estat =0;

int calefaccio_estat =0;

int buzzer_estat =0;

int blinds_estat =0;

int blinds_moving=0;

int iblindsteps=0;

int ibuzzersteps=0;

int ibuzzerhighlow=0;

int ibuzzerlow=0;

int flag_presencia=0;

int flag_soroll=1023;

int steppersteps = 200;

Stepper blinds(steppersteps,8,10,9,11);

void setup()

// arranquem el debugger

Serial.begin(9600);

// arrancar el servidor

Ethernet.begin(mac, serverIP);

server.begin();

Serial.println("Server started");//log

// configurem el pinout com a I o O

pinMode(2, INPUT);

pinMode(A2, INPUT);

pinMode(A0, INPUT);

pinMode(A3, INPUT);

pinMode(A1, INPUT);

pinMode(A5, INPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

43

pinMode(6, OUTPUT);

// posem la velocitat a 60rpm

blinds.setSpeed(60);

void loop()

// començar a escoltar el port

EthernetClient client = server.available();

if (client)

String clientMsg ="";

String data="data rebuda";

while (client.connected())

// lectura de totes les inputs

int estat_presencia = digitalRead(presencia);

int estat_temperatura = analogRead(temperatura);

int estat_humitat = analogRead(humitat);

int estat_fum = analogRead(fum);

int estat_soroll = analogRead(A5);

if (flag_presencia==0)

flag_presencia=estat_presencia;

if (flag_soroll>=1005)

flag_soroll=estat_soroll;

// generacio de la trama a enviar

data= "Status: <Presence:" + String(flag_presencia)+ ">";

data+= "<Temperature:" + String(estat_temperatura)+ ">";

data+= "<Humidity:" + String(estat_humitat)+ ">";

data+= "<Smoke:" + String(estat_fum)+ ">";

data+= "<Noise:" + String(estat_soroll)+ ">";

data+= "<Light:" + String(llum_estat)+ ">";

data+= "<AirCon:" + String(aire_estat)+ ">";

data+= "<Heating:" + String(calefaccio_estat)+ ">";

data+= "<Buzzer:" + String(buzzer_estat)+ ">";

data+= "<Blinds:" + String(blinds_estat)+ ">";

if (buzzer_estat==1)

if (ibuzzerhighlow=0)

ibuzzersteps++;

if (ibuzzersteps==255)

ibuzzerhighlow=1;

else

ibuzzersteps--;

if (ibuzzersteps==0)

ibuzzerlow++;

if (ibuzzerlow ==100)

ibuzzerhighlow=0;

ibuzzerlow=0;

analogWrite(6, ibuzzersteps);

else

analogWrite(6, 0);

44

if (blinds_moving==1)

if (blinds_estat==1)

blinds.step(steppersteps);

if (blinds_estat==0)

blinds.step(-steppersteps);

iblindsteps+=1;

if (iblindsteps>=4)

iblindsteps=0;

blinds_moving=0;

if (client.available())

char c = client.read();

clientMsg+=c;//guardar el caracter dins del missatge

//si el caracter es un carro de linia el missatge ha acabat

if (c == '\n')

Serial.println("Missatge rebut:"+clientMsg);//mostrar al

debugger

if (clientMsg=="RetrieveStatus\n") //Pregunta status general

Serial.println("Missatge per enviar: Status RetrieveStatus

Data:"+data);//mostrar al debugger

client.println("Response RetrieveStatus: "+data);//enviar

status

Serial.println("Missatge enviat: Status RetrieveStatus

Data:"+data);//mostrar al debugger

flag_presencia=0;

flag_soroll=1023;

if (clientMsg=="SetBuzzerON\n") //posar buzzer ON

buzzer_estat=1;

client.println("ACK:"+clientMsg);//enviar ACK

Serial.println("Missatge enviat:ACK:"+clientMsg);//mostrar al

debugger

if (clientMsg=="SetBuzzerOFF\n") //posar buzzer OFF

buzzer_estat=0;



debugger

if (clientMsg=="SetAirConON\n") //activar A/C

digitalWrite(aire, HIGH);

aire_estat=1;



debugger

if (clientMsg=="SetAirConOFF\n") //desactivar A/C

digitalWrite(aire, LOW);

aire_estat=0;



debugger

45

if (clientMsg=="SetHeatingON\n") //activar calefaccio

digitalWrite(calefaccio, HIGH);

calefaccio_estat=1;



debugger

if (clientMsg=="SetHeatingOFF\n") //desactivar calefaccio

digitalWrite(calefaccio, LOW);

calefaccio_estat=0;



debugger

if (clientMsg=="SetLightsON\n") // posar llums a on

digitalWrite(llum, HIGH);

llum_estat=1;



debugger

if (clientMsg=="SetLightsOFF\n") // posar llums a on

digitalWrite(llum, LOW);

llum_estat=0;



debugger

if (clientMsg=="SetBlindsUp\n") // pujar persianes (1 volta

stepper)

blinds_estat=1;

blinds_moving=1;



debugger

if (clientMsg=="SetBlindsDown\n") // baixar persianes (1 volta

stepper)

blinds_estat=0;

blinds_moving=1;



debugger

clientMsg="";

// espera per rebre dades

delay(1);

// tancar la conexio:

client.stop();

46

Anexo E. Código Android

Login Activity package com.example.domoandruino;

import android.os.Bundle;

import android.app.Activity;

import android.widget.Button;

import android.widget.CheckBox;

import android.widget.EditText;

import android.widget.Toast;

import android.content.Intent;

import android.view.View;

import android.view.View.OnClickListener;

public class LoginActivity extends Activity

EditText user, password;

Button AccessGranted;

CheckBox chkRememberMe;

@Override

protected void onCreate(Bundle savedInstanceState)

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_login);

this.user= (EditText) findViewById(R.id.txtUser);

this.password= (EditText) findViewById(R.id.txtPassword);

this.AccessGranted= (Button) findViewById(R.id.btnAccess);

this.AccessGranted.setOnClickListener(new OnClickListener()

@Override

public void onClick(View v)

String datouser = user.getText().toString();

String datopass = password.getText().toString();

//datouser="Luis Rolin";

//datopass="pokayoke";

if (datouser.matches("Luis Rolin") &&

datopass.matches("pokayoke"))

Intent intent = new Intent(LoginActivity.this,

MainActivity.class);

startActivity(intent);

else

Toast.makeText(LoginActivity.this, "Incorrect

User/Password", Toast.LENGTH_SHORT).show();

);

47

Login Layout <RelativeLayout

xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:paddingBottom="@dimen/activity_vertical_margin"

android:paddingLeft="@dimen/activity_horizontal_margin"

android:paddingRight="@dimen/activity_horizontal_margin"

android:paddingTop="@dimen/activity_vertical_margin"

tools:context=".MainActivity" >

<EditText android:id="@+id/txtUser"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_alignParentLeft="true"

android:layout_alignParentRight="true"

android:layout_marginTop="72dp"

android:ems="10"

android:imeOptions="actionNext"

android:inputType="textPersonName" >

<requestFocus />

</EditText>

<EditText android:id="@+id/txtPassword"



android:layout_alignLeft="@+id/txtUser"


android:layout_below="@+id/txtUser"


android:ems="10"

android:imeOptions="actionDone"

android:inputType="textPassword">

</EditText>

<Button android:id="@+id/btnAccess"



android:layout_alignLeft="@+id/txtPassword"

android:layout_alignRight="@+id/txtUser"

android:layout_below="@+id/txtPassword"


android:text="@string/signin" />

<TextView android:id="@+id/textView1"



android:layout_alignLeft="@+id/txtUser"

android:layout_alignParentTop="true"


android:text="@string/login"

android:textAppearance="?android:attr/textAppearanceLarge" />

</RelativeLayout>

48

MainWindow Activity package com.example.domoandruino;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Locale;

import android.app.ActionBar;

import android.app.AlertDialog;

import android.app.FragmentTransaction;

import android.content.ComponentName;

import android.content.Context;

import android.content.DialogInterface;


import android.content.ServiceConnection;

import android.graphics.Color;

import android.os.AsyncTask;

import android.os.Bundle;

import android.os.Environment;

import android.os.Handler;

import android.os.IBinder;

import android.support.v4.app.Fragment;

import android.support.v4.app.FragmentActivity;

import android.support.v4.app.FragmentManager;

import android.support.v4.app.FragmentStatePagerAdapter;

import android.support.v4.view.ViewPager;

import android.text.InputFilter;

import android.text.InputType;

import android.util.Log;

import android.view.LayoutInflater;

import android.view.Menu;

import android.view.MenuItem;

import android.view.View;

import android.view.ViewGroup;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.CompoundButton;

import android.widget.CompoundButton.OnCheckedChangeListener;

import android.widget.EditText;

import android.widget.ImageView;

import android.widget.Switch;

import android.widget.TextView;

import android.widget.Toast;

public class MainActivity extends FragmentActivity implements

ActionBar.TabListener

int mInterval = 2000; // interval de 2 segons, es pot canviar

Handler mHandler;

static public MiServicio s;

static int tabsel=0;

int[] currentdots=new int[100];

int[] newdots=new int[100];

int[] currentdotshr=new int[100];

int[] newdotshr=new int[100];

int[] currentdotsgas=new int[100];

int[] newdotsgas=new int[100];

double offsetTemp=153.293;

int currTemp=0;

int consecutiveerrorframes =0;

49

SectionsPagerAdapter mSectionsPagerAdapter;

ViewPager mViewPager;

int index =0;

int indexhr =0;

int indexgas =0;

@Override

protected void onCreate(Bundle savedInstanceState)

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

ReadOffsetTemp();

doBindService();

mHandler = new Handler();

startRepeatingTask();

final ActionBar actionBar = getActionBar();

actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);

mSectionsPagerAdapter = new SectionsPagerAdapter(

getSupportFragmentManager());

mViewPager = (ViewPager) findViewById(R.id.pager);

mViewPager.setAdapter(mSectionsPagerAdapter);

mViewPager

.setOnPageChangeListener(new

ViewPager.SimpleOnPageChangeListener()

@Override

public void onPageSelected(int position)

actionBar.setSelectedNavigationItem(position);

);

for (int i = 0; i < mSectionsPagerAdapter.getCount(); i++)

actionBar.addTab(actionBar.newTab()

.setText(mSectionsPagerAdapter.getPageTitle(i))

.setTabListener(this));

Runnable mStatusChecker = new Runnable()

View view;

@Override

public void run()

try

showServiceData(view);

catch (InterruptedException e)

// TODO Auto-generated catch block

e.printStackTrace();

mHandler.postDelayed(mStatusChecker, mInterval);

;

void startRepeatingTask()

mStatusChecker.run();

50

void stopRepeatingTask()

mHandler.removeCallbacks(mStatusChecker);

private ServiceConnection mConnection = new ServiceConnection()

@Override

public void onServiceConnected(ComponentName name, IBinder

binder)

s = ((MiServicio.MyBinder) binder).getService();

s.message="RetrieveStatus";

Toast.makeText(MainActivity.this, "Connected",

Toast.LENGTH_SHORT).show();

@Override

public void onServiceDisconnected(ComponentName name)

s = null;

;

void doBindService()

Log.d("","Click");

bindService(new Intent(this, MiServicio.class), mConnection,

Context.BIND_AUTO_CREATE);

Log.d("","Click2");

public void showServiceData(View view) throws InterruptedException

String stemp="";

String[] splits;

int i=0;

double value=0;

Log.d("Tab",String.valueOf(tabsel));

if( s != null && tabsel<1)

String message = s.getMessage();

if (message!=null)

Log.d("Message",message);

consecutiveerrorframes=0;

if (message.startsWith("Response RetrieveStatus:

Status: "))

stemp= message.replace("Response RetrieveStatus:

Status: ", "");

Log.d("stemp",stemp);

splits= stemp.split(">");

for(String asset: splits)

i++;

if (asset.startsWith("<Temperature:"))

stemp=

asset.substring(asset.indexOf(":")+1);

value=

(((Double.parseDouble(stemp))*5/1023)*(-58)/0.486)+offsetTemp;

i=(int) Math.round(value);

51

TextView dummyTextView = (TextView)

findViewById(R.id.textViewstatus01);

dummyTextView.setTextColor(Color.BLACK);

dummyTextView.setText(String.valueOf(i)+"ºC");

currTemp=i;

if(index<99)

newdots[index]=i;

Log.d("N_Datos",String.valueOf(index));

else

Log.d("N_Datos","99_1");

for (int count = 0; count < 99;

count++)

currentdots[count]=newdots[count+1];

newdots[count]=currentdots[count];

Log.d("N_Datos","99_2");

newdots[99]=i;

index++;

if (asset.startsWith("<Presence:"))

stemp=


if (stemp.contains("1"))

stemp="YES";

else

stemp="NO";




dummyTextView.setText(stemp);

if (asset.startsWith("<Humidity:"))

stemp=


value=

((Double.parseDouble(stemp))*5/1023)/0.03;





dummyTextView.setText(String.valueOf(i)+"%");

if(indexhr<99)

newdotshr[indexhr]=i;

else

52


count++)

currentdotshr[count]=newdotshr[count+1];

newdotshr[count]=currentdotshr[count];

newdotshr[99]=i;

indexhr++;

if (asset.startsWith("<Smoke:"))

stemp=






i =Integer.parseInt(stemp);

if(indexgas<99)

newdotsgas[index]=i;

else


count++)

currentdotsgas[count]=newdotsgas[count+1];

newdotsgas[count]=currentdotsgas[count];

newdotsgas[99]=i;

indexgas++;

if (asset.startsWith("<Noise:"))

stemp=


value=

((Double.parseDouble(stemp))*5/1023)*10;





dummyTextView.setText(String.valueOf(i)+"dB");

if (asset.startsWith("<Light:"))

stemp=



stemp="YES";

else

stemp="NO";

53





if (asset.startsWith("<AirCon:"))

stemp=



stemp="YES";

else

stemp="NO";





if (asset.startsWith("<Heating:"))

stemp=



stemp="YES";

else

stemp="NO";





if (asset.startsWith("<Buzzer:"))

stemp=



stemp="YES";

else

stemp="NO";





if (asset.startsWith("<Blinds:"))

54

stemp=



stemp="DOWN";

else

stemp="UP";





if (s.alarm==1)

stemp="YES";

else

stemp="NO";





else

Log.d("ErrorFrames",String.valueOf(consecutiveerrorframes));

consecutiveerrorframes+=1;

if (consecutiveerrorframes>=10)



dummyTextView.setTextColor(Color.LTGRAY);

dummyTextView = (TextView)





















55










@SuppressWarnings("deprecation")

public void ReadOffsetTemp()

FileInputStream fis;

final StringBuffer storedString = new StringBuffer();

String strLine = null;

Log.d("Offset","try read");

try

fis = openFileInput("offsettemp.txt");

DataInputStream dataIO = new DataInputStream(fis);

if ((strLine = dataIO.readLine()) != null)

storedString.append(strLine);

dataIO.close();

fis.close();

catch (Exception e)

Log.d("Error Offset",e.getMessage());

if (strLine!=null)

Log.d("Offset","leido " + strLine);

if (strLine.startsWith("Offset:"))

String stemp=

strLine.substring(strLine.indexOf(":")+1);

Log.d("Offset","leido string " + stemp);

offsetTemp= Double.parseDouble(stemp);

Log.d("Offset","leido double " +

String.valueOf(offsetTemp));

@Override

public boolean onCreateOptionsMenu(Menu menu)

getMenuInflater().inflate(R.menu.main, menu);

return true;

@Override

public boolean onOptionsItemSelected(MenuItem item)

switch(item.getItemId())

case R.id.action_settings:

LineGraph line = new LineGraph();

56

line.y= new int[100];

String s ="";

for (int count = 0; count < 100; count++)

line.y[count]= newdots[count];

s+= String.valueOf(newdots[count])+" ";

Log.d("datos",s);

Intent lineIntent = line.getIntent(this);

startActivity(lineIntent);

return true;

case R.id.action_hrgraph:

LineGraphHR linehr = new LineGraphHR();

linehr.y= new int[100];

String shr ="";


linehr.y[count]= newdotshr[count];

shr+= String.valueOf(newdotshr[count])+" ";

Log.d("datos",shr);

Intent lineIntenthr = linehr.getIntent(this);

startActivity(lineIntenthr);

return true;

case R.id.action_gasgraph:

LineGraphGas linegas = new LineGraphGas();

linegas.y= new int[100];

String sgas ="";


linegas.y[count]= newdotsgas[count];

sgas+= String.valueOf(newdotsgas[count])+" ";

Log.d("datos",sgas);

Intent lineIntentgas = linegas.getIntent(this);

startActivity(lineIntentgas);

return true;

case R.id.action_tempcal:

AlertDialog alertDialog = new

AlertDialog.Builder(MainActivity.this).create();

alertDialog.setTitle("Temperature Calibration");

final EditText input = new EditText(this);

alertDialog.setView(input);

input.setText(String.valueOf(currTemp));

input.setInputType(InputType.TYPE_CLASS_NUMBER);

input.setFilters(new InputFilter[]

new InputFilter.LengthFilter(2),

);

alertDialog.setMessage("Please set new Temperature value:

(from 0 to 99)");

alertDialog.setButton(DialogInterface.BUTTON_NEGATIVE,

"CANCEL", new DialogInterface.OnClickListener()

public void onClick(DialogInterface dialog, int which)

Log.d("Offset", "cancelado");

);

57

alertDialog.setButton(DialogInterface.BUTTON_POSITIVE,

"OK", new DialogInterface.OnClickListener()

public void onClick(DialogInterface dialog, int which)

String value = input.getText().toString();

Log.d("Offset", value);

int userTemp= Integer.parseInt(value);

offsetTemp= offsetTemp + (userTemp - currTemp);

Log.d("New Offset", String.valueOf(offsetTemp));

try

File root = new

File(getFilesDir().getPath());

if (!root.exists())

root.mkdirs();

File gpxfile = new File(root,

"offsettemp.txt");

FileWriter writer = new

FileWriter(gpxfile);

writer.write("Offset:"+String.valueOf(offsetTemp));

writer.flush();

writer.close();

Log.d("Offset", "File saved in " +

root.toString());

catch(IOException e)


Log.d("Save Offset error",

e.getMessage());

);

alertDialog.show();

return true;

return false;

@Override

public void onBackPressed()

Toast.makeText(this, "Please...", Toast.LENGTH_SHORT).show();

@Override

public void onTabSelected(ActionBar.Tab tab,

FragmentTransaction fragmentTransaction)

tabsel= tab.getPosition();

mViewPager.setCurrentItem(tab.getPosition());

@Override

public void onTabUnselected(ActionBar.Tab tab,


58

@Override

public void onTabReselected(ActionBar.Tab tab,


public class SectionsPagerAdapter extends FragmentStatePagerAdapter

public SectionsPagerAdapter(FragmentManager fm)

super(fm);

@Override

public Fragment getItem(int position)

Bundle args;

switch (position)

case 0:

Fragment fragment1 = new StatusSectionFragment();

args = new Bundle();

args.putInt(StatusSectionFragment.ARG_SECTION_NUMBER, position +

1);

fragment1.setArguments(args);

return fragment1;

case 1:

Fragment fragment2 = new

ControlSectionFragment();


args.putInt(ControlSectionFragment.ARG_SECTION_NUMBER, position +

1);


return fragment2;

case 2:

Fragment fragment3 = new CameraSectionFragment();


args.putInt(CameraSectionFragment.ARG_SECTION_NUMBER, position +

1);


return fragment3;

return null;

@Override

public int getCount()

return 3;

@Override

public CharSequence getPageTitle(int position)

Locale l = Locale.getDefault();

switch (position)

case 0:

return

getString(R.string.title_section1).toUpperCase(l);

case 1:

return


59

case 2:

return


return null;

public static class StatusSectionFragment extends Fragment

public static final String ARG_SECTION_NUMBER =

"section_number";

public StatusSectionFragment()

@Override

public View onCreateView(LayoutInflater inflater, ViewGroup

container,

Bundle savedInstanceState)

View rootView =

inflater.inflate(R.layout.fragment_main_status,

container, false);

return rootView;

public static class ControlSectionFragment extends Fragment


"section_number";

public ControlSectionFragment()

@Override


container,


View rootView =

inflater.inflate(R.layout.fragment_main_control,

container, false);

Switch sw1 = (Switch)

rootView.findViewById(R.id.switch1);

sw1.setOnCheckedChangeListener(new

OnCheckedChangeListener()

@Override

public void onCheckedChanged(CompoundButton

buttonView,

boolean isChecked)

String message;

if(isChecked)

Log.d("Switch","ON");

message="SetLightsON";

else

Log.d("Switch","OFF");

message="SetLightsOFF";

60

s.message=message;

s.extramessage=1;

try

Thread.sleep(300);




message=s.getMessage();

if (message!=null)

if (message.contains("ACK"))

Log.d("ACK","Received");


);





@Override


buttonView,

boolean isChecked)

String message;

if(isChecked)


message="SetAirConON";

else


message="SetAirConOFF";

s.message=message;

s.extramessage=1;

try

Thread.sleep(300);





if (message!=null)




);





@Override


buttonView,

boolean isChecked)

String message;

61

if(isChecked)


message="SetHeatingON";

else


message="SetHeatingOFF";

s.message=message;

s.extramessage=1;

try

Thread.sleep(300);





if (message!=null)




);





@Override


buttonView,

boolean isChecked)

if(isChecked)


s.alarm=1;

else


s.alarm=0;

);





@Override


buttonView,

boolean isChecked)

String message;

if(isChecked)


message="SetBuzzerON";

else


message="SetBuzzerOFF";

s.message=message;

s.extramessage=1;

62

try

Thread.sleep(300);





if (message!=null)




);





@Override


buttonView,

boolean isChecked)

String message;

if(isChecked)


message="SetBlindsDown";

else


message="SetBlindsUp";

s.message=message;

s.extramessage=1;

try

Thread.sleep(300);





if (message!=null)




);

return rootView;

public static class CameraSectionFragment extends Fragment

implements OnClickListener


"section_number";

private ImageView myFirstImage;

private DownloadImagesTask myTask;

63

String URL1 =

"http://192.168.1.107/snapshot.cgi?user=admin&pwd=";

String URL2 =

"http://192.168.1.107/decoder_control.cgi?user=admin&pwd=&command=";

String URL3 = Environment.getExternalStorageDirectory() +

File.separator + "MisImagenes"+ File.separator + "blank.bmp";

Button b1;

Button b2;

Button bup;

Button bdown;

Button bleft;

Button bright;

Button bstop;

public CameraSectionFragment()

@Override


container,


View rootView =

inflater.inflate(R.layout.fragment_main_camera,

container, false);

b1 = (Button) rootView.findViewById(R.id.button1);

b2 = (Button) rootView.findViewById(R.id.button2);

bup = (Button)

rootView.findViewById(R.id.buttonArriba);

bdown = (Button)

rootView.findViewById(R.id.buttonAbajo);

bright = (Button)

rootView.findViewById(R.id.buttonDerecha);

bleft = (Button) rootView.findViewById(R.id.buttonIzq);

bstop = (Button)

rootView.findViewById(R.id.buttonStop);

b1.setOnClickListener(this);

b2.setOnClickListener(this);

bup.setOnClickListener(this);

bdown.setOnClickListener(this);

bright.setOnClickListener(this);

bleft.setOnClickListener(this);

bstop.setOnClickListener(this);

myFirstImage = (ImageView)

rootView.findViewById(R.id.imageViewCamera);

myFirstImage.setTag(URL3);

myFirstImage.setOnClickListener(this);

Log.d("Hola",URL3);

myTask = (DownloadImagesTask) new

DownloadImagesTask().execute(myFirstImage);

myTask.cancel(true);

myFirstImage.setTag(URL1);

return rootView;

@Override

public void onClick(View v)

switch(v.getId())

case R.id.button1:

Log.d(getTag(), "Hemos tocado el boton Play");

64

myTask = (DownloadImagesTask) new

DownloadImagesTask().execute(myFirstImage);

break;

case R.id.button2:

Log.d(getTag(), "Hemos tocado el boton Stop");

myTask.cancel(true);

break;

case R.id.buttonArriba:

Log.d(getTag(), "Hemos tocado el boton UP");

new

MoverCamaraTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,

URL2+"0");

break;

case R.id.buttonAbajo:

Log.d(getTag(), "Hemos tocado el boton Down");

new


URL2+"2");

break;

case R.id.buttonDerecha:

Log.d(getTag(), "Hemos tocado el boton Right");

new


URL2+"4");

break;

case R.id.buttonIzq:

Log.d(getTag(), "Hemos tocado el boton Left");

new


URL2+"6");

break;

case R.id.buttonStop:

Log.d(getTag(), "Hemos tocado el boton Stop");

new


URL2+"1");

new


URL2+"3");

new


URL2+"5");

new


URL2+"7");

break;

case R.id.imageViewCamera:

Log.d(getTag(), "Hemos tocado Save");

myTask.saveImage=true;

Toast.makeText(getActivity(), "Image Saved",

Toast.LENGTH_SHORT).show();

break;

65

MainWindow Layouts: MainWindow <android.support.v4.view.ViewPager



android:id="@+id/pager"



tools:context=".MainActivity" >

<android.support.v4.view.PagerTitleStrip android:id="@+id/pager_title_strip"



android:layout_gravity="top"

android:background="#33b5e5"

android:paddingBottom="4dp"

android:paddingTop="4dp"

android:textColor="#fff" />

</android.support.v4.view.ViewPager>

MainWindow Layouts: Status Fragment <RelativeLayout









tools:context=".MainActivity$DummySectionFragment" >




android:layout_alignBaseline="@+id/section_label"

android:layout_alignBottom="@+id/section_label"

android:layout_alignLeft="@+id/section_label"

android:text="Temperature"

android:textAppearance="?android:attr/textAppearanceMedium" />




android:layout_alignLeft="@+id/textView1"

android:layout_below="@+id/textView1"


android:text="Humidity"








android:text="Noise Level"



66






android:text="CO Level"








android:text="Presence"








android:text="Lights"








android:text="Air Conditioner"








android:text="Heating"





android:layout_alignRight="@+id/textView6"



android:text="Alarm"








android:text="Horn"

67








android:text="Blinds Status"


<TextView android:id="@+id/textViewstatus01"



android:layout_above="@+id/textView2"


android:text="Value"














android:text=" Value"

























68









android:layout_alignBaseline="@+id/textView10"

android:layout_alignBottom="@+id/textView10"




























</RelativeLayout>

MainWindow Layouts: Control Fragment <RelativeLayout









tools:context=".MainActivity$DummySectionFragment" >

<Switch android:id="@+id/switch1"





69

android:layout_marginLeft="14dp"


android:text="Lights "

android:textOff="@string/sw_off"

android:textOn="@string/sw_on" />





android:layout_below="@+id/switch1"



android:text="Air Conditioner"






android:layout_alignLeft="@+id/switch2"



android:text="Heating "









android:text="Alarm Mode "







android:layout_centerVertical="true"

android:text="Horn "









android:text="Move Blinds "

android:textOff="@string/sw_dw"

android:textOn="@string/sw_up" />

</RelativeLayout>

70

MainWindow Layouts: Camera Fragment <LinearLayout


android:orientation="vertical"


android:layout_height="match_parent">

<ImageView android:id="@+id/imageViewCamera"



android:minHeight="240dp"

android:src="@drawable/ic_launcher" />

<Button android:id="@+id/button1"



android:text="@string/btnplay" />

<Button android:id="@+id/button2"



android:text="@string/btnstop" />

<RelativeLayout android:layout_width="match_parent"

android:layout_height="279dp" >

<Button android:id="@+id/buttonArriba"

android:layout_width="70dp"



android:layout_toRightOf="@+id/buttonIzq"

android:text="@string/btnup" />

<Button android:id="@+id/buttonIzq"



android:layout_alignBaseline="@+id/buttonStop"

android:layout_alignBottom="@+id/buttonStop"

android:layout_marginRight="21dp"

android:layout_toLeftOf="@+id/buttonStop"

android:text="@string/btnleft" />

<Button android:id="@+id/buttonStop"



android:layout_alignLeft="@+id/buttonAbajo"

android:layout_below="@+id/buttonArriba"

android:text="@string/btnstop" />

<Button android:id="@+id/buttonDerecha"



android:layout_alignBaseline="@+id/buttonStop"

android:layout_alignBottom="@+id/buttonStop"


android:layout_toRightOf="@+id/buttonStop"

android:text="@string/btnright" />

<Button android:id="@+id/buttonAbajo"

71



android:layout_below="@+id/buttonStop"

android:layout_centerHorizontal="true"

android:text="@string/btndown" />

</RelativeLayout>

</LinearLayout>

MainWindow Layouts: Menu <menu xmlns:android="http://schemas.android.com/apk/res/android" >

<item android:id="@+id/action_settings"

android:orderInCategory="100"

android:showAsAction="never"

android:title="Temperature Graph"/>

<item android:id="@+id/action_hrgraph"



android:title="Humidity Graph"/>

<item android:id="@+id/action_gasgraph"



android:title="Gas Levels Graph"/>

<item android:id="@+id/action_tempcal"



android:title="Temperature Calibration"/>

</menu>

MiServicio Service package com.example.domoandruino;


import java.util.Timer;

import java.util.TimerTask;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.app.Service;


import android.os.Binder;

import android.os.IBinder;


public class MiServicio extends Service

public String message;

private Timer timer = new Timer();

private static final long UPDATE_INTERVAL = 200;

private final IBinder mBinder = new MyBinder();

private String list;

private int index = 0;

private int count=0;

public int extramessage=0;

public int alarm=0;

72

private void pollForUpdates()

timer.scheduleAtFixedRate(new TimerTask()

@Override

public void run()

try

count++;

if (message==null)

message="RetrieveStatus";

if (count==10 || extramessage==1)

count=0;

extramessage=0;

Client c = new Client(message);

list=c.getResultado();

if(c.getResultado()!=null)

if(c.getResultado().trim().length()>

0)

Log.d("Alarm mode",

String.valueOf(alarm));

if(c.getResultado().contains("Presence:1"))

index ++;

if (alarm==1)

Notification("Hemos

detectado presencia", "Esta es la " + index + " vez");

catch (IOException e)



, 0, UPDATE_INTERVAL);

Log.i(getClass().getSimpleName(), "timer started.");

@SuppressWarnings("deprecation")

private void Notification(String notificationTitle, String

notificationMessage)

NotificationManager notificationManager =

(NotificationManager) getSystemService(NOTIFICATION_SERVICE);

android.app.Notification notification = new

android.app.Notification(R.drawable.ic_launcher, "Home Secure

Notification",

System.currentTimeMillis());

Intent notificationIntent = new Intent(this,

MainActivity.class);

PendingIntent pendingIntent =

PendingIntent.getActivity(this, 0, notificationIntent, 0);

notification.setLatestEventInfo(MiServicio.this,

notificationTitle, notificationMessage, pendingIntent);

notificationManager.notify(10001, notification);

73

@Override

public IBinder onBind(Intent intent)

Log.d("Pepe","Create Bind");

return mBinder;

@Override

public void onCreate()

super.onCreate();

Log.d("Pepe","Start Poll");

pollForUpdates();

@Override

public void onDestroy()

super.onDestroy();

if(timer != null)

timer.cancel();

Log.i(getClass().getSimpleName(), "timer stopped.");

public class MyBinder extends Binder

MiServicio getService()

return MiServicio.this;

public String getMessage()

return list;

Client Class package com.example.domoandruino;

import java.io.BufferedReader;

import java.io.DataOutputStream;


import java.io.InputStreamReader;

import java.net.Socket;

public class Client

//private static final String serverIP="lrolin.no-ip.biz";

private static final String serverIP="192.168.1.106";

private static final int serverPort=8881;

private String resultado;

public Client(String message) throws IOException

String msgToServer;

String msgFromServer;

Socket clientSocket = new Socket(serverIP, serverPort);

DataOutputStream outToServer = new

DataOutputStream(clientSocket.getOutputStream());

74

BufferedReader inFromServer = new BufferedReader(new

InputStreamReader(clientSocket.getInputStream()));//

msgToServer = message;

outToServer.writeBytes(msgToServer+'\n');

msgFromServer = inFromServer.readLine();

setResultado(msgFromServer);

clientSocket.close();

public String getResultado()

return resultado;

public void setResultado(String resultado)

this.resultado = resultado;

MoverCamaraTask Class package com.example.domoandruino;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;



public class MoverCamaraTask extends AsyncTask<String, Void, Void>

@Override

protected Void doInBackground(String... params)

try

Log.d("URL", params[0]);

URL ulrn = new URL(params[0]);

HttpURLConnection con =

(HttpURLConnection)ulrn.openConnection();

Log.d("URL", "COnnection OK");

InputStream is = con.getInputStream();

Log.d("URL", "Get input");

@SuppressWarnings("unused")

Bitmap bmp = BitmapFactory.decodeStream(is);

catch(Exception e)

return null ;

75

MoverCamaraTask Class package com.example.domoandruino;

import java.io.File;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Bitmap.CompressFormat;


import android.os.Environment;


import android.widget.ImageView;

public class DownloadImagesTask extends AsyncTask<ImageView, Bitmap,

Bitmap>

public boolean saveImage;

ImageView imageView = null;

@Override

protected void onCancelled()

// TODO Auto-generated method stub

Log.d("DownloadImageTask","Cancelled");

@Override

protected void onPreExecute()

// TODO Auto-generated method stub

super.onPreExecute();

@Override

protected void onProgressUpdate(Bitmap... values)

imageView.setImageBitmap(values[0]);

@Override

protected Bitmap doInBackground(ImageView... imageViews)

this.imageView = imageViews[0];

while(!isCancelled())

publishProgress( download_Image((String)imageView.getTag()));

return null;

@Override

protected void onPostExecute(Bitmap result)

private Bitmap download_Image(String url)

Bitmap bmp =null;

try

URL ulrn = new URL(url);

HttpURLConnection con =

(HttpURLConnection)ulrn.openConnection();

InputStream is = con.getInputStream();

76

bmp = BitmapFactory.decodeStream(is);

if (null != bmp)

if (saveImage== true)

Log.d("DownloadImageTask","SaveImage");

try

saveImage=false;

File sdCardDirectory = new

File(Environment.getExternalStorageDirectory() + File.separator +

"MisImagenes");

sdCardDirectory.mkdirs();

String imageNameForSDCard = "image_" +

System.currentTimeMillis() + ".png";

File image = new File(sdCardDirectory,

imageNameForSDCard);

FileOutputStream outStream;

outStream = new FileOutputStream(image);

bmp.compress(CompressFormat.PNG, 100,

outStream);

outStream.flush();

outStream.close();

Log.d("Save ImageTask","Saved Image");

catch (Exception e)


return bmp;

catch(Exception e)

return bmp;

77

LineGraph Class package com.example.domoandruino;

import org.achartengine.ChartFactory;

import org.achartengine.chart.PointStyle;

import org.achartengine.model.TimeSeries;

import org.achartengine.model.XYMultipleSeriesDataset;

import org.achartengine.renderer.XYMultipleSeriesRenderer;

import org.achartengine.renderer.XYMultipleSeriesRenderer.Orientation;

import org.achartengine.renderer.XYSeriesRenderer;




import android.graphics.Paint.Align;


public class LineGraph

public int[] y;

public Intent getIntent(Context context)

Log.d("datos","datos recibidos");

int[] x= new int[100];

for( int i = 0; i < x.length; i++)

x[i]=i;

TimeSeries series = new TimeSeries("Temperature in

ºC");


series.add(x[i], y[i]);

XYMultipleSeriesDataset dataset = new

XYMultipleSeriesDataset();

dataset.addSeries(series);

XYMultipleSeriesRenderer mRenderer = new

XYMultipleSeriesRenderer();

XYSeriesRenderer renderer = new XYSeriesRenderer();

mRenderer.addSeriesRenderer(renderer);

renderer.setColor(Color.BLUE);

renderer.setPointStyle(PointStyle.SQUARE);

renderer.setFillPoints(true);

mRenderer.setXLabels(12);

mRenderer.setYLabels(10);

mRenderer.setShowGrid(true);

mRenderer.setXLabelsAlign(Align.RIGHT);

mRenderer.setYLabelsAlign(Align.RIGHT);

mRenderer.setPanLimits(new double[] 0, 100, 0, 60 );

78

mRenderer.setZoomLimits(new double[] 0, 100, 0, 60

);

mRenderer.setRange(new double[] 0, 100, 0, 60 );

//cambiar color del fondo del grafico

mRenderer.setBackgroundColor(Color.LTGRAY);

mRenderer.setApplyBackgroundColor(true);

mRenderer.setAxesColor(Color.MAGENTA);

mRenderer.setAxisTitleTextSize(50);

mRenderer.setBarWidth(50);

mRenderer.setOrientation(Orientation.HORIZONTAL);

mRenderer.setShowLabels(true);

Intent intent =

ChartFactory.getLineChartIntent(context, dataset, mRenderer, "Temperature

Timeline");

return intent;

LineGraphGas Class package com.example.domoandruino;













public class LineGraphGas

public int[] y;





x[i]=i;

TimeSeries series = new TimeSeries("Gas Levels");





79






renderer.setColor(Color.RED);

renderer.setPointStyle(PointStyle.DIAMOND);







mRenderer.setPanLimits(new double[] 0, 100, 0, 1000

);


);










Intent intent =

ChartFactory.getLineChartIntent(context, dataset, mRenderer, "Gas Level

Timeline");

return intent;

LineGraphHR Class package com.example.domoandruino;













public class LineGraphHR

public int[] y;

80





x[i]=i;

TimeSeries series = new TimeSeries("Relative Humidity

in %");










renderer.setColor(Color.GREEN);

renderer.setPointStyle(PointStyle.TRIANGLE);







mRenderer.setPanLimits(new double[] 0, 100, 0, 100

);


);










Intent intent =

ChartFactory.getLineChartIntent(context, dataset, mRenderer, "Relative

Humidity Timeline");

return intent;

81

Android Manifest.xml

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.domoandruino"

android:versionCode="1"

android:versionName="1.0" >

<uses-sdk android:minSdkVersion="14"

android:targetSdkVersion="18" />

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<application android:allowBackup="true"

android:icon="@drawable/ic_launcher"

android:label="@string/app_name"

android:theme="@style/AppTheme" >

<activity android:name="com.example.domoandruino.LoginActivity"

android:label="@string/app_name" >

<intent-filter> <action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER"

/>

</intent-filter>

</activity>

<activity android:name="com.example.domoandruino.MainActivity"

android:label="@string/title_activity_main" >

</activity>

<activity android:name="com.example.domoandruino.MainWindow"

android:label="@string/title_activity_main_window" >

</activity>

<activity android:name="com.example.domoandruino.BackgroundActivity"

android:label="@string/title_activity_background" >

</activity> <activity android:name="org.achartengine.GraphicalActivity"/>

<service android:name="MiServicio"></service>

</application>

</manifest>

Documents

Aplicación Domótica mediante Arduino y Programación …deeea.urv.cat/public/PROPOSTES/pub/pdf/2195pub.pdf · 4 2. Arduino Arduino es una placa de bajo coste con microcontrolador