Diseño e implementación de un prototipo de enchufe inteligente mediante la placa Arduino

Trabajo de Fin de Grado en Ingeniería Informática – Julio 2014 – Diseño e implementación de un prototipo de enchufe inteligente mediante la placa Arduino Alumno: Óscar Antonio González de Chaves Pérez Tutor: Dr. Alexis Quesada Arencibia / Escuela de Ingeniería Informática 1 A mi abuelo Paco. 2 Agradecimientos “A hombros de gigantes” sea tal vez una de las frases más célebres de nuestra historia. Atribuida al gigante Isaac Newton, su origen real se cree en boca de Bernardo de Chartres. Él decía: “Somos enanos encaramados a hombros de gigantes. De esta manera, vemos más y más lejos que ellos, no porque nuestra vista sea más aguda sino porque ellos nos sostienen en el aire y nos elevan con toda su altura gigantesca.”1 Esta frase, sin género de duda, tiene ganado su espacio en los anales de la historia. Nosotros no podemos más que compartir su significado y pensar en todos aquellos gigantes que nos han elevado. Aprovecho esta oportunidad que se me ofrece para agradecer el tiempo, la dedicación y el esfuerzo entregado por cada persona que me ha acompañado a lo largo de mi vida. A quienes estuvieron conmigo en cada etapa, en el colegio, el instituto, la universidad y el trabajo. Gracias de forma especial a mi tutor Alexis Quesada Arencibia, y al Instituto Universitario de Ciencias y Tecnologías Cibernéticas, sin quienes este trabajo no habría sido posible. Gracias por supuesto a mis compañeros y amigos, que con su compañía han iluminado tantos momentos felices. Agradezco el apoyo incondicional recibido siempre por parte de mi familia. Gracias a mi padre por haberme inspirado la honradez, a mi madre por haberme inculcado el carácter y la sensibilidad. Gracias a mi abuelo Paco por haber dejado en mí su huella indeleble, a mi querida abuela María Luisa, a mis tías y hermanas… Por último, acabo recordando a mi persona más especial, mi compañera y amiga, la persona que se acuesta y amanece conmigo cada mañana, que me conoce y aún así me quiere. Gracias, Marta. 1 Juan e Salisbury, siglo XII 3 Resumen Este trabajo detalla las diferentes etapas del desarrollo de construcción del prototipo Clever Socket, abarcando desde su análisis, a su diseño e implementación. Clever Socket es un conjunto hardware y software que facilita el control del encendido y el apagado de los aparatos electrónicos conectados a él a través de redes de comunicación LAN y WAN. Para lograr este propósito, el artefacto se apoya en la placa de desarrollo electrónico Arduino UNO y la placa Arduino WiFi Shield –que posibilita su conexión inalámbrica a la red–. El dispositivo cuenta con cuatro bases de enchufe controladas a través de relés, que permiten la gestión de hasta cuatro dispositivos electrónicos de manera simultánea. En el lado del software se presentan tres componentes: Un servicio web de bajo nivel destinado a la gestión de la placa Arduino. Permite la comunicación con la placa, la lectura y escritura de sus pines. Un servicio web específico del dispositivo Clever Socket. Facilita la comunicación con el prototipo hardware, permitiendo así la gestión de diferentes operaciones que se llevan a cabo sobre los aparatos conectados a sus enchufes. Una aplicación web. Actúa como interfaz entre el usuario y el servicio web de Clever Socket, permitiendo la gestión del dispositivo. El diseño de la aplicación es responsive, lo que posibilita su correcta visualización en todo tipo de dispositivos, tanto móviles como de escritorio. 4 Abstract This essay details the different building development stages of the Clever Socket prototype, covering different subjects, such as its analysis, design and implementation. Clever Socket is a hardware and software system that makes possible the remote on and off control of all its electronic devices connected through, enabling the management via LAN and WAN communication networks. In order to achieve that goal, the device relies on the electronic development Arduino UNO board together with the Arduino WiFi Shield (which allows the network wireless communication). The device has four sockets controlled by a group of relays which enable the management of up to four electronic devices in a simultaneous way. On the software side, the system is divided into three components: A low level web service focus on the Arduino board management. It allows the communication with the board and enables the reading and writing of its pins. A web services oriented to the Clever Socket device. It provides a communication link with the hardware prototype, making possible the management of different operations pointing to the device’s sockets. A web application. It plays the user interface’s role, offering a link with the Clever Socket web service and allowing the device control. The application has a responsive design, making possible an optimal viewing experience in all kind of devices, from moviles to desktops equipments. 5 Índice de contenidos Agradecimientos ................................................................................................... 2! Resumen ............................................................................................................... 3! Abstract ................................................................................................................ 4! Índice de contenidos ............................................................................................. 5! Índice de ilustraciones ........................................................................................... 9! Índice de tablas .................................................................................................... 12! 1!Estructura del documento .............................................................................. 14! 2!Estructura del CD .......................................................................................... 15! 3!Introducción ................................................................................................... 15! 4!Estado del arte ............................................................................................... 16! 5!Justificación .................................................................................................... 19! 6!Objetivos generales y soluciones propuestas ................................................... 20! 7!Aportaciones ................................................................................................... 21! 8!Competencias desarrolladas ............................................................................ 22! 9!Metodología .................................................................................................... 25! 9.1!Metodología ágil .............................................................................. 26! 9.2!Buenas prácticas de programación ................................................... 28! 10!Recursos ........................................................................................................ 29! 10.1!Materiales .................................................................................... 29! 10.1.1!Arduino UNO Rev3 .................................................................................. 30! 10.1.2!Arduino WiFi Shield SD ........................................................................... 32! 10.1.3!Módulo de 4 relés de 5V ............................................................................ 34! 10.2! Software ....................................................................................... 36! 10.2.1!NetBeans 8.0 ............................................................................................ 36! 10.2.2!Arduino 1.0.5 ........................................................................................... 37! 10.2.3!MySQL Workbench 6.1 ............................................................................. 38! 10.2.4!Sequel Pro 1.0.2 ....................................................................................... 39! 10.2.5!Cocoa Rest Client 1.3.7 ............................................................................. 40! 10.2.6!Fritzing Beta 0.8.7 .................................................................................... 41! 10.2.7!Git 1.9.1 .................................................................................................. 42! 10.2.8!Bitbucket .................................................................................................. 42! 6 10.2.9!Google Drive y Google Docs ...................................................................... 43! 10.2.10!Lucidchart .............................................................................................. 44! 10.2.11!Moqups .................................................................................................. 45! 11!Análisis ......................................................................................................... 46! 11.1!Introducción ................................................................................. 46! 11.2!¿Qué problema queremos resolver y por qué? ................................... 46! 11.3!¿Qué solución planteamos? ............................................................ 48! 11.3.1!Del lado del hardware ................................................................................ 48! 11.3.2!Del lado del software ................................................................................. 50! 11.4!Especificación de los requisitos ....................................................... 57! 11.4.1!Requisitos funcionales ............................................................................... 57! 11.4.2!Requisitos no funcionales ........................................................................... 61! 12!Prueba del concepto ..................................................................................... 62! 13!Diseño ........................................................................................................... 63! 13.1!Arquitectura del hardware .............................................................. 63! 13.1.1!Esquema eléctrico del circuito .................................................................... 64! 13.1.2!Exterior de la caja .................................................................................... 64! 13.1.3!Interior de la caja ..................................................................................... 65! 13.2!Arquitectura del software ............................................................... 67! 13.2.1!Servicio Web Arduino ............................................................................... 68! 13.2.2!Servicio Web Clever Socket ........................................................................ 69! 13.2.3!Aplicación Web Clever Socket .................................................................... 71! 14!Implementación ............................................................................................ 73! 14.1!Del lado del software ..................................................................... 74! 14.1.1!Servidor Webduino .................................................................................... 74! 14.1.2!Archivo hosts ........................................................................................... 75! 14.1.3!Servidor Apache ....................................................................................... 76! 14.2!Del lado del hardware .................................................................... 78! 14.2.1!Preparación de la caja .............................................................................. 78! 14.2.2!Disposición de los elementos y conexionado ................................................. 81! 15!Normativa y legislación ................................................................................ 86! 15.1!Reglamento que afecta al TFG ....................................................... 86! 15.2!Licencias del software .................................................................... 86! 15.2.1!Licencia del MIT ...................................................................................... 87! 15.3!Utilización de cookies .................................................................... 88! 15.3.1!¿Qué es una cookie ? ................................................................................. 90! 15.3.2!Tipos de cookies que utilizamos .................................................................. 91! 7 15.3.3!¿Cómo administrar cookies en el navegador? .............................................. 91! 15.4!Ley Orgánica de Protección de Datos (LOPD) ................................. 92! 15.4.1!Deberes del responsable ............................................................................. 93! 15.4.2!Inscripción de ficheros .............................................................................. 93! 16!Proyección futura del trabajo ....................................................................... 95! 17!Conclusiones ................................................................................................. 98! 18!Fuentes de información ................................................................................. 99! 18.1!Consultas terminológicas ................................................................ 99! 18.2!Apartado sobre metodología ........................................................... 99! 18.3!Apartado sobre análisis .................................................................. 99! 18.4!Recursos ...................................................................................... 99! 18.4.1!Materiales ................................................................................................ 99! 18.4.2!Software .................................................................................................. 99! 18.4.3!Implementación ...................................................................................... 100! 18.5!Normativa y legislación ................................................................ 100! 18.6!Proyección futura del trabajo ....................................................... 100! 19!Anexos ........................................................................................................ 101! 19.1!Anexo I: Manual de usuario Clever Socket .................................... 101! 19.1.1!Introducción ........................................................................................... 101! 19.1.2!El dispositivo .......................................................................................... 101! 19.1.3!Bases de enchufes ................................................................................... 102! 19.1.4!La aplicación web ................................................................................... 103! 19.2!Anexo II: Configuración de NetBeans para desarrollo de código para Arduino ............................................................................................... 108! 19.2.1!Requisitos .............................................................................................. 108! 19.2.2!Configuración de NetBeans ...................................................................... 109! 19.3!Anexo III: Actualización de firmware Arduino WiFi Shield ............ 111! 19.3.1!Instalación de Ports ................................................................................ 112! 19.3.2!Instalación dfu$programmer ................................................................... 113! 19.3.3!Preparar archivos para la actualización del firmware ................................. 113! 19.3.4!Conexión con el ordenador y actualización ................................................ 115! 19.4!Anexo IV: Presupuesto ................................................................ 116! 19.5!Anexo V: Plantillas de casos de uso .............................................. 116! 19.6!Anexo VI: Diagramas y operaciones del Servicio Web Arduino ....... 127! 19.6.1!Diagrama de casos de uso ........................................................................ 127! 19.6.2!Diagramas de actividad ........................................................................... 128! 19.6.3!Diagramas de secuencia .......................................................................... 130! 8 19.6.4!Operaciones ........................................................................................... 131! 19.7!Anexo VII: Diagramas y operaciones del Servicio Web Clever Socket 134! 19.7.1!Diagrama de casos de uso ........................................................................ 134! 19.7.2!Diagramas de actividad ........................................................................... 135! 19.7.3!Diagramas de secuencia .......................................................................... 139! 19.7.4!Diagrama y estructura de la base de datos ............................................... 146! 19.7.5!Operaciones ........................................................................................... 151! 19.8!Anexo VIII: Diagramas de la Aplicación Web Clever Socket ........... 161! 19.8.1!Diagrama de casos de uso ........................................................................ 161! 19.8.2!Diagrama de actividad ............................................................................. 162! 19.8.3!Diagrama de secuencia ............................................................................ 164! 19.8.4!Diagrama y estructura de la base de datos ............................................... 166! 19.9!Anexo IX: Prototipo de interfaz de usuario ................................... 169! 19.10!Anexo X: Plantilla de Licencia del MIT ....................................... 171! 15 nuestro trabajo y cómo debemos proceder para estar seguros de que atendemos a su cumplimiento. ● Proyección de futuro y conclusiones: Después de haber transitado el camino que nos ha traído hasta aquí, estaremos en disposición de apuntar formas de mejora, y pensamientos sobre futuras modificaciones que puedan engrandecer nuestro trabajo. Además, reflexionaremos sobre qué ha significado para nosotros la tarea realizada. ● Fuentes de información y anexos: No nos olvidaremos de aportar las fuentes de información de las cuales hemos bebido durante nuestro camino. Incluyendo al final, aquellos contenidos que por su extensión, aun siendo relevantes, hemos considerado oportuno desplazar a este punto, intentando facilitar así la lectura del documento y reducir en lo posible su complejidad. 2 Estructura del CD Este documento viene acompañado de un CD. La estructura y el contenido digital del disco son las siguientes: ● EII-GII-2014-07-01-TFT-GonzalezDeChavesPerez_OQuesadaArencibia_A-DIPEIMPA.pdf: Respaldo digital en formato PDF de este documento. ● resumen.txt: Resumen del trabajo en español. ● abstract.txt: Resumen del trabajo en inglés. ● source: ● arduino-clever-socket: Código fuente del Servicio Web de Arduino. ● api-clever-socket: Código fuente del Servicio Web de Clever Socket. ● web-clever-socket: Código fuente de la Aplicación Web de Clever Socket. 3 Introducción Este trabajo de fin de grado (en adelante, “TFG”) aborda el análisis, el diseño y la implementación de un prototipo de regleta de enchufes denominado Clever Socket. Su gobierno es llevado a cabo de forma remota a través de una red inalámbrica de tipo LAN o WAN y de un conjunto software. El tándem hardware y software ofrece el control sobre las fases de encendido y apagado de un grupo de enchufes. Para ello, hace uso entre otros componentes electrónicos, de la placa de desarrollo electrónico Arduino UNO y su módulo de expansión Arduino WiFi Shield. 16 La gestión sobre el control del dispositivo es realizada a través de una aplicación web, que posibilita la selección del enchufe objeto de control y permite su encendido, apagado y conmutado. El conjunto de funcionalidades y procedimientos ofrecidos por el dispositivo están gestionados a través de un servicio web ad hoc de tipo RESTful, disponible para cualquier sistema software de terceros que desee comunicarse con el aparato. 4 Estado del arte En la actualidad, existen diversos dispositivos que nos permiten conectar y desconectar nuestros aparatos de la red de suministro eléctrico. Desde sencillas regletas de enchufes con interruptores para su encendido y apagados, enchufes con sistemas de programación, o artefactos provistos de control remoto que facilitan el encendido o apagado de nuestros equipos eléctricos. Con el incremento de los precios en el consumo de la electricidad, cada vez son más los ciudadanos que se preocupan por ejercer un uso controlado del suministro eléctrico, así como de los distintos aparatos del hogar que se conectan a la red. Por este motivo, son diversos los fabricantes que han introducido en el mercado dispositivos para el control del consumo eléctrico, facilitando la tarea de ejercer un uso comedido y responsable de la electricidad. En el campo de las regletas de enchufes, encontramos artefactos que además de ofrecer interruptores para permitir el encendido y apagado de los conectores, ofrecen también otro tipo de opciones y funcionalidades, como la conexión de conectores RJ45 y RJ11, USB, conectores para cables de antena de televisión, etc., así como protección contra picos de tensión eléctrica que los dispositivos enchufados a estos conectores pueden sufrir. Se muestran a continuación algunas imágenes de diversos sistemas de regleta de enchufes existentes en el mercado: 17 Ilustración 1: Base de enchufe individual Ilustración 2: Múltiples bases de enchufe Ilustración 3: Múltiples bases de enchufe con protección contra picos de tensión En el lado de los sistemas de enchufes programables también existe diversidad en la oferta. Desde conectores con temporizadores analógicos muy sencillos (ilustración 1), a sistemas digitales más sofisticados y que permiten una amplia variedad de programas para la temporización (ilustración 2) o lectura de sensores (ilustración 3). Véanse a continuación algunas imágenes representativas de este tipo de enchufes: Ilustración 4: Temporizador analógico Ilustración 5: Temporizador digital Ilustración 6: Temporizador digital con sensor de temperatura Por último, el mercado ofrece también sistemas de enchufes que ofrecen su conmutación a través de dispositivos de control remoto. Habitualmente este tipo de aparatos operan a través de radio frecuencia. Pero también han aparecido recientemente algunos enchufes que pueden ser controlados a través de la conexión WiFi en el hogar. Algunos de estos dispositivos nos permiten incluso llevar un control sobre el consumo eléctrico de los aparatos conectados a ellos. Algunos ejemplos de estos aparatos: 18 Ilustración 7: Enchufe controlado a través de radio frecuencia Ilustración 8: Enchufe controlado a través de WiFi Ilustración 9: Enchufe con control de consumo eléctrico Los precios de todos estos dispositivos van en relación al nivel de complejidad y de funcionalidades ofrecidos. Desde precios muy asequibles para sistemas sencillos para el control del encendido y el apagado de sus enchufes, a precios bastante más elevados para otros sistemas de mayor complejidad tecnológica y con mayor número de funcionalidades y capacidades. Debido al auge y a la popularización de la electrónica, los precios de los distintos componentes electrónicos ha ido disminuyendo. Cada vez resulta más habitual encontrar componentes y dispositivos electrónicos con mayores prestaciones y funcionalidades, sin que por ello se vea afectado el bolsillo del consumidor. Si atendemos al campo de la electrónica de consumo, observamos cómo en los últimos años, han ido apareciendo componentes electrónicos dotados de cierta inteligencia que permiten a usuarios intermedios y amateurs, llevar a cabo proyectos de gestión y control electrónico cada vez más avanzados. De forma particular, hablamos de sistemas sofisticados como la popular placa Raspberry Pi (ilustración 10), o la más sencilla –pero también potente en prestaciones– placa Arduino UNO (ilustración 11). La placa Raspberry Pi es un dispositivo que en sí mismo, es un pequeño ordenador. Decimos pequeño ordenador, aunque dentro de sí encierre la potencia de equipos informáticos mucho más aparatosos hace unos años atrás. Además, a esto hay que añadir la ridícula horquilla existente en su relación prestaciones/precio. 19 Ilustración 10: Raspberry Pi Ilustración 11: Arduino UNO Por otro lado, en los últimos tiempos, se ha ido incrementando el número de trabajos electrónicos llevados a cabo con un pequeño dispositivo, la placa Arduino. Arduino es un proyecto liderado por un pequeño equipo de desarrolladores italianos que actualmente es conocido a nivel mundial. Sus prestaciones, su reducido tamaño y su ridículo precio han hecho que se popularice en tiempo récord. Además, a todo ello, hay que añadirle el hecho de la existencia de shields o complementos, que acopladas a la placa, multiplican de forma exponencial las funcionalidades y prestaciones del equipo. Hoy día cualquier usuario medio, puede llevar a cabo proyectos de gran complejidad técnica y envergadura, sobre todo atendiendo a dicha complejidad desde el escalón de la vanguardia tecnológica de hace unos pocos años atrás. 5 Justificación Aunque existan ya, como hemos visto, una gran cantidad de dispositivos que nos ayudan a controlar el consumo y a ejercer un uso más sostenible y responsable de la electricidad, observamos todavía la oportunidad de ofrecer una propuesta capaz de mejorar la oferta actual, o al menos así lo pensamos. A continuación intentamos razonar y plantear los motivos por los cuales creemos justificable el desarrollo de este trabajo: ● Los equipos actuales de bajo costo son en la actualidad muy limitados en prestaciones. ● Aquellos dispositivos con múltiples funcionalidades todavía hoy continúan teniendo un precio elevado que los aleja del consumidor medio. ● Aunque se ha empezado a explorar el terreno del control de conectores de forma remota –incluso haciendo uso de la tecnología WiFi– todavía es poco convencional encontrar equipos que se conecten a través de redes locales o Internet. ● La opción que planteamos tiene un coste razonable, que podría reducirse de forma significativa una vez superada la etapa de prototipado. ● Vamos a ofrecer funcionalidades avanzadas de una manera que para el usuario sea fácil de gestionar. 20 ● Al estar conectado a internet, ofrecemos la posibilidad de no cerrarse exclusivamente al control de los dispositivos desde el hogar, sino también a través de la distancia, desde cualquier punto conectado a través de Internet. ● Ofrecemos un API que permite el crecimiento futuro del proyecto, permitiendo que otros sistemas software se aprovechen de la pasarela para hacer uso de los procedimientos de encendido y apagado de los enchufes de la regleta. 6 Objetivos generales y soluciones propuestas En un primer momento, a la hora de plantearnos la idea de este proyecto, pensamos en qué objetivos necesitaría cubrir nuestro trabajo para satisfacer las necesidades y demandas del usuario. El perfil de persona a quién va dirigida nuestra propuesta es el del ciudadano medio, comprometido con el uso eficiente de las fuentes de energía de consumo actuales, el del sujeto preocupado por el medio ambiente, por la economía doméstica y por la forma en cómo la tecnología pueda ayudar dando respuesta a estas demandas. Pensando en lo anterior, definimos y nombramos a continuación, qué objetivos generales se impone este proyecto como propósitos y metas a conquistar: ● Ofrecer una herramienta de uso sencillo y accesible. ● Gestionar las funcionalidades del sistema desde equipos de sobremesa hasta terminales móviles. ● Desarrollar una propuesta económicamente viable. ● Definir y acotar el número de funcionalidades; plantear un producto en el que primen la eficacia y necesidad de las soluciones. ● Aprovechar la tecnología existente para reducir la complejidad y tiempo de desarrollo. ● Atender a la problemática de la seguridad en las comunicaciones. ● Maximizar la flexibilidad del producto, pensar en su escalabilidad, y dejar abierto el producto para una posible evolución. ● Conseguir tiempos de respuesta cortos en las peticiones de los usuarios. ● Diseñar un producto energéticamente eficiente. ● Entregar un prototipo funcional. Definidas de forma concisa las metas, pasamos a la siguiente fase, pensar en las soluciones necesarios para alcanzar los objetivos. Estas fueron las soluciones planteadas para dar respuesta a nuestros objetivos: ● Desarrollar una interfaz de usuario clara y sencilla. 21 ● Ofrecer una solución que permita su ejecución desde cualquier sistema operativo con navegador web. ● Hacer uso de hardware económico, basando la idea en el uso de la infraestructura ofrecida por la plataforma Arduino. ● Plantear funcionalidades básicas, como encender o apagar un interruptor. ● Seguridad. ● Entregar un servicio web que permita la comunicación con terceros. ● Desarrollar un código limpio, que permita su comprensión y fácil modificación. ● Evitar funcionalidades innecesarias o redundantes que ralenticen la respuesta final del sistema. ● Diseñar un esquema electrónico con pocos componentes. ● Realizar un montaje sencillo que pueda ser llevado a cabo en poco tiempo. 7 Aportaciones De la realización de este trabajo, han surgido en paralelo diversos desarrollos. Desde el pequeño servicio web para la tarjeta Arduino, al servicio web orientado al dispositivo Clever Socket, a la propia aplicación que explota este último servicio. Hemos aportado valor con el desarrollo del servicio web para Arduino. Aún siendo conscientes de que queda mucho camino por recorrer en este apartado, creemos estar pisando un camino poco transitado hasta el momento. Durante nuestra etapa de análisis, no encontramos un solución ad hoc que permitiera establecer una comunicación para conocer y cambiar el estado de los pines de la tarjeta. Un servicio web de tipo RESTful que facilitara el desarrollo de aplicaciones en torno al ecosistema Arduino. Funcionalidad básica, que en nuestra opinión, no se ha explotado de forma suficiente hasta el momento. En este sentido, gracias al servicio web específico de Clever Socket, abrimos una ventana a futuros desarrollos. Con este canal de comunicación, será posible en el futuro llevar a cabo nuevos proyectos que solamente tengan la preocupación de comunicarse con el servicio. Posibilitando que terceras partes hagan provecho de nuestro desarrollo. Creemos que nuestro producto final, tal cual se entrega, ofrece valor. Ya en su etapa de prototipo es capaz de llevar a cabo su funcionalidad principal, permitir y cortar el suministro eléctrico de los aparatos conectados al dispositivo a través de una red LAN o WAN. Gracias a nuestros dispositivo, se logra deslocalizar el interruptor de encendido y apagado de cualquier aparato eléctrico. Coloca este interruptor en nuestros bolsillos a través de los teléfonos móviles inteligentes, aprovecha en definitiva las ventajas que ofrecen los sistemas automáticos y la inteligencia del software desarrollado sobre ellos. 22 Con todo, creemos que nuestra principal aportación ha sido plantear la idea. El punto de inicio sobre el que continuar desarrollando futuros proyectos que lleguen mucho más lejos. 8 Competencias desarrolladas Las tareas de investigación, análisis, diseño e implementación llevadas a cabo para la realización de este trabajo han permitido que hayamos desarrollado y cubierto las siguientes competencias propuestas a alcanzar por la asignatura de Trabajo de Fin de Grado para el curso 2013-2014: ● G1. Poseer y comprender conocimientos en un área de estudio (Ingeniería Informática) que parte de la base de la educación secundaria general, y se suele encontrar a un nivel que, si bien se apoya en libros de texto avanzados, incluye también algunos aspectos que implican conocimientos procedentes de la vanguardia de su campo de estudio. ● G2. Aplicar sus conocimientos a su trabajo o vocación de una forma profesional y posean las competencias que suelen demostrarse por medio de la elaboración y defensa de argumentos y la resolución de problemas dentro de su área de estudio. ○ Justificación G1. y G2. Se plasma en el documento y en nuestra labor, una metodología de trabajo propia de la Ingeniería Informática. Los pasos dados, así como las soluciones planteadas manifiestan la necesidad del uso de los conocimientos y capacidades propios de nuestro área de conocimiento. ● G3. Reunir e interpretar datos relevantes (normalmente dentro de su área de estudio) para emitir juicios que incluyan una reflexión sobre temas relevantes de índole social, científica o ética. ○ Justificación G3. Hemos realizado un análisis del estado del arte, así como de las necesidades reales a día de hoy y de la oferta existente. ● G4. Transmitir información, ideas, problemas y soluciones a un público tanto especializado como no especializado. ○ Justificación G4. Tanto en la elaboración de este documento, como en el resultado de nuestro trabajo, se ha hecho el esfuerzo por aunar la sencillez y la precisión en el lenguaje, utilizando los términos más adecuados en cada momento. ● G5. Desarrollar aquellas habilidades de aprendizaje necesarias para emprender estudios posteriores con un alto grado de autonomía. 23 ○ Justificación G5. El estudio de las herramientas y soluciones alcanzadas a lo largo de este trabajo nos han ayudado a adquirir conocimientos y habilidades que harán posible una mayor eficiencia y autonomía en tareas de grado similar o superior en el futuro. ● N1. Comunicarse de forma adecuada y respetuosa con diferentes audiencias (clientes, colaboradores, promotores, agentes sociales, etc.), utilizando los soportes y vías de comunicación más apropiados (especialmente las nuevas tecnologías de la información y la comunicación) de modo que pueda llegar a comprender los intereses, necesidades y preocupaciones de las personas y organizaciones, así como expresar claramente el sentido de la misión que tiene encomendada y la forma en que puede contribuir, con sus competencias y conocimientos profesionales, a la satisfacción de esos intereses, necesidades y preocupaciones. ○ Justificación N1. Tanto en la redacción de este documento, como en la preparación de la presentación oral de este trabajo, se ha desarrollado la competencia a través de la búsqueda de formas de comunicación y transmisión de ideas y conceptos cercanas y accesibles para el público objetivo, tanto profano como ilustrado en la materia. ● N2. Cooperar con otras personas y organizaciones en la realización eficaz de funciones y tareas propias de su perfil profesional, desarrollando una actitud reflexiva sobre sus propias competencias y conocimientos profesionales y una actitud comprensiva y empática hacia las competencias y conocimientos de otros profesionales. ○ Justificación N2. A la hora de reunir información y durante el proceso de elaboración de nuestro trabajo, hemos procurado consultar opinión experta en los momentos que estimamos oportuno, antes de tomar decisiones trascendentes que afectasen al desarrollo del trabajo. ● N3. Contribuir a la mejora continua de su profesión así como de las organizaciones en las que desarrolla sus prácticas a través de la participación activa en procesos de investigación, desarrollo e innovación. ○ Justificación N3. Hemos plasmado nuestro interés en mejorar el ejercicio de nuestra profesión y en favorecer la colaboración con otros grupos de investigación a través del trabajo conjunto llevado a cabo con algunos de los miembros del Instituto Universitario de Ciencias y Tecnologías Cibernéticas. 24 ● N4. Comprometerse activamente en el desarrollo de prácticas profesionales respetuosas con los derechos humanos así como con las normas éticas propias de su ámbito profesional para generar confianza en los beneficiarios de su profesión y obtener la legitimidad y la autoridad que la sociedad le reconoce. ○ Justificación N4. A través del ejercicio profesional de nuestra actividad y de la realización de nuestra propuesta, hemos procurado reportar un beneficio comunitario, ofreciendo una solución que favorezca el uso comedido y razonado de un bien común, como es la energía eléctrica. ● T1. Capacidad para concebir, redactar, organizar, planificar, desarrollar y firmar proyectos en el ámbito de la ingeniería en informática que tengan por objeto, de acuerdo con los conocimientos adquiridos según lo establecido en apartado 5 de la resolución indicada, la concepción, el desarrollo o la explotación de sistemas, servicios y aplicaciones informáticas. ● T2. Capacidad para dirigir las actividades objeto de los proyectos del ámbito de la informática, de acuerdo con los conocimientos adquiridos según lo establecido en apartado 5 de la resolución indicada. ● T3. Capacidad para diseñar, desarrollar, evaluar y asegurar la accesibilidad, ergonomía, usabilidad y seguridad de los sistemas, servicios y aplicaciones informáticas, así como de la información que gestionan. ● T5. Capacidad para concebir, desarrollar y mantener sistemas, servicios y aplicaciones ● informáticas empleando los métodos de la ingeniería del software como instrumento para el aseguramiento de su calidad, de acuerdo con los conocimientos adquiridos según lo establecido en apartado 5 de la resolución indicada. ● T6. Capacidad para concebir y desarrollar sistemas o arquitecturas informáticas centralizadas o distribuidas integrando hardware, software y redes, de acuerdo con los conocimientos adquiridos según lo establecido en apartado 5 de la resolución indicada. ○ Justificación T1., T2., T3., T5. y T6. Véase la justificación de las competencias G1. y G2. ● T7. Capacidad para conocer, comprender y aplicar la legislación necesaria durante el desarrollo de la profesión de Ingeniero Técnico en Informática y manejar especificaciones, reglamentos y normas de obligado cumplimiento. ○ Justificación T7. Durante el desarrollo de este trabajo se ha procurado en todo momento atender a las recomendaciones y exigencias establecidas por los reglamentos, normas y legislación vigentes. 31 Intensidad en DC por pin de 3,3V 50mA Memoria flash 32KB (ATmega328), 0,5KB utilizados por el bootloader (gestor de arranque) SRAM 2KB (ATmega328) EEPROM 1KB (ATmega328) Velocidad de reloj 16MHz Tabla 1: Características técnicas Arduino UNO Conexiones Hemos visto que la Arduino UNO dispone de 6 entradas analógicas. Los pines de estas entradas se encuentran serigrafiados en la placa, en un rango que va desde la entrada A0 a la A1. Estos pines ofrecen una resolución de 10 bits, o lo que es lo mismo, 1024 valores posibles. Estos pines están pensados para ser utilizados como entrada de datos, pudiendo acceder a la lectura de sus valores a través de la función analogRead(). Por otro lado, disponemos de 14 pines digitales, serigrafiados en el rango que va de 0 a 13. Pero además, algunos de estos pines –concretamente el 3, 5, 6, 9, 10 y 11– pueden ser utilizados en modo de salida PWM a través de la función analogWrite(). Pero, ¿si son pines digitales, por qué se llama a la función analogWrite() y no a la función digitalWrite()? Esto tiene sentido si entendemos qué es una salida PWM. La modulación por ancho de pulsos –conocida también como PWN– es un ingenio que a través de la variación del ciclo de trabajo de una señal periódica logra emular en algunos casos el comportamiento de una señal analógica. De modo que se hace posible, por ejemplo, efectuar un efecto de atenuación o fading de un diodo LED. Vemos en el gráfico, además, pines destinados a la alimentación. Tenemos pines a tierra (GND), pines a 3,3 y 5 V, e incluso un pin de alimentación de voltaje variante (Vin), que cambia su salida en función de la fuente de alimentación que se conecte a la placa a través del conector de alimentación tipo jack. 32 Ilustración 13: Conexiones Arduino UNO Existen otros pines –como por ejemplo el pin de reinicio– cuya descripción detallada no es objeto de este trabajo. (Para mayor información, puede ser consultado el sitio web http://arduino.cc/en/Main/ArduinoBoardUno) 10.1.2 Arduino WiFi Shield SD El Arduino WiFi Shield SD es otro de los componentes fundamentales de nuestro prototipo. Esta extensión –acoplada de forma directa a la placa Arduino UNO– nos va a permitir conectar nuestra placa a internet de forma inalámbrica. La última versión de este accesorio de Arduino está basado en el circuito encapsulado –de consuma ultrabajo– HDG204, que ofrece la conexión Wireless LAN 802.11b/g. Además de un microcontrolador Atmel 32UC3 que posibilita la comunicación con la placa a través de los protocolos de red UDP y TCP. 33 Ilustración 14: Frontal y reverso de la placa Arduino WiFi Shield Características técnicas Requisito Tarjeta Arduino Voltaje operativo 5V Vía de conexión Redes 802.11b/g Conexión con Arduino Puerto SPI (a través de las cabeceras ICSP) Actualización firmware A través del puerto Mini-USB Diagnóstico A través de conector FTDI Otros Ranura para tarjetas micro SD Tabla 2: Características técnicas Arduino WiFi Shield Conexiones Pines reservados por la placa Es preciso reservar algunos pines digitales de la placa Arduino UNO para el uso de este shield. Los pines 11, 12 y 13 son utilizados por Arduino para la comunicación con el microcontrolador WiFi y el lector de tarjetas micro SD. El pin número 10 es utilizado por el microcontrolador HDG204 y el pin 4 por el lector SD. Por último el pin 7 es utilizado como pin de negociación entre el WiFi shield y la tarjeta Arduino. 34 Ilustración 15: Conexiones de la placa Arduino WiFi Shield 10.1.3 Módulo de 4 relés de 5V Para el encendido y apagado de los enchufes vamos a hacer uso de un sistema de 4 relés, que operan a 5V –el mismo voltaje al que operan las salidas digitales de la tarjeta Arduino–. “El relé o relevador es un dispositivo electromecánico. Funciona como un interruptor controlado por un circuito eléctrico en el que, por medio de una bobina y un electroimán, se acciona un juego de uno o varios contactos que permiten abrir o cerrar otros circuitos eléctricos independientes.”3 3 http://es.wikipedia.org/wiki/Rel%C3%A9, 2014 35 Ilustración 16: Módulo de 4 relés para Arduino Características técnicas Número de relés 5 Intensidad en DC por canal 10ª Voltaje operativo 5V Dimensiones 7,7x5,0x1,8cm Peso 59gr Tabla 3: Características técnicas módulo de 4 relés para Arduino Cada uno de los relés tiene 3 entradas: común, normalmente abierto y normalmente cerrado. Además la placa dispone de 6 pines: 1 por cada relé, 1 para la toma a tierra y 1 pin para la alimentación a 5V. Los pines asociados a cada relé se denominan canales, al pasar corriente por un canal su relé asociado pasa de conectar el conector común y normalmente cerrado a conectar el común y el normalmente abierto. Estado que vuelve a recuperarse al dejar de pasar corriente por el canal. 36 Ilustración 17: Funcionamiento de un relé 10.2 Software 10.2.1 NetBeans 8.0 El IDE de nuestra elección para el desarrollo de código de nuestras distintas aplicaciones ha sido NetBeans. NetBeans IDE permite de forma rápida y sencilla desarrollar aplicaciones Java de escritorio, para móviles, aplicaciones web, así como aplicaciones HTML5 con HTML, JavaScript y CSS. El IDE además ofrece un gran conjunto de herramientas para desarrolladores de PHP y C/C++. Es gratuita y de código abierto y tiene una gran comunidad de usuarios y desarrolladores alrededor del mundo. Un IDE es mucho más que un editor de texto. El Editor NetBeans indenta líneas, identifica palabras, paréntesis, llaves y corchetes, así como resalta código fuente de forma sintáctica y semántica. Además ofrece plantillas de código, consejos en la codificación, y herramientas para la refactorización. El editor soporta diferentes lenguajes de programación, desde Java, C/C++, XML y HTML, a PHP, Groovy, Javadoc, JavaScript y JSP. Y además, como el editor ofrece extensiones, es posible añadir soporte para otros muchos lenguajes. 37 Ilustración 18: NetBeans IDE 8.0 Para poder desarrollar código sobre Arduino, así como para poder cargar los programas en la memoria interna de la placa por vía del puerto serie, hemos tenido que llevar a cabo algunos pasos, que se detallan en los anexos en el apartado Anexo II: Configuración de NetBeans para desarrollo de código para Arduino. 10.2.2 Arduino 1.0.5 Arduino suministra una plataforma de desarrollo orientada a la programación de código, así como a la carga de este en sus diferentes dispositivos. Además de ofrecer un IDE de desarrollo escrito en JAVA, ofrece también diferentes librerías que hacen más sencillo el desarrollo de aplicaciones sobre la plataforma. Así como diferentes ejemplos predefinidos para entender mejor el uso de las librerías. El lenguaje de programación de Arduino se basa en C/C++. En nuestro caso, no hemos hecho uso del IDE de Arduino para la codificación, ya que es muy limitado y no ofrece las múltiples funcionalidades para el desarrollo que ofrece NetBeans. Sin embargo, sí hemos hecho uso de las librerías, así como de los diferentes ejemplos que vienen predefinidos sobre el uso de éstas. 38 Ilustración 19: Arduino IDE 1.0.5 10.2.3 MySQL Workbench 6.1 Esta es la herramienta software que hemos utilizado para realizar el diseño de nuestras bases de datos. MySQL Workbench es una herramienta visual unificada para arquitectos, desarrolladores y administradores de bases de datos. Esta herramienta permite a administradores de bases de datos, desarrolladores o arquitectos de la información diseñar de forma visual, modelar, generar y gestionar bases de datos. Incluye todo lo que un modelador de información necesita para crear modelos de entidadrelación complejos, ingeniería directa y reversa, así como la posibilidad de llevar a cabo tareas de gestión y documentación que normalmente requerirían mucho tiempo y esfuerzo. 39 Gracias a esta herramienta, hemos podido realizar de forma sencilla el diseño de nuestras bases de datos y llevar a cabo la implementación de su modelo. Además, gracias a su sistema de ingeniería directa y reversa, hemos podido sincronizar los cambios en el diseño y el modelo. Facilitando la tarea de hacer modificaciones en la estructura de la base de datos. Ilustración 20: MySQL Workbench 6.1 10.2.4 Sequel Pro 1.0.2 Hemos elegido Sequel Pro como cliente para la realización de consultas a nuestras bases de datos. Sequel Pro es una fantástica herramienta para la gestión de bases de datos. Permite realizar modificaciones en la estructura, cambios en campos, inserción de nuevos registros, etc. Sin embargo, el uso principal que nosotros le hemos dado a esta aplicación, es la realización de consultas, ya que permite de un modo muy sencillo y directo llevar a cabo esta tarea. 40 Ilustración 21: Sequel Pro 1.0.2 10.2.5 Cocoa Rest Client 1.3.7 Esta es la aplicación que hemos elegido para realizar las consultas y pruebas a nuestros servicios web de tipo REST. Cocoa Rest Client es una aplicación cliente de código abierto, desarrollada para Mac OS y destinada al testeo de comunicación entre extremos HTTP/REST. Entre las funcionalidades principales de esta aplicación, destacamos las siguientes: ● La posibilidad de realizar llamadas de tipo GET, PUT, POST, DELETE y HEAD. ● Establecer cabeceras así como mostrar su contenido en las respuestas de las comunicaciones. ● Detección y formateado automático de contenido XML y JSON. ● Guardado rápido de las URLs, cuerpo y cabeceras de consultas realizadas. 47 Para ello, hemos realizado en primera instancia un estudio acerca de la situación del estado actual, sobre cómo la tecnología está dando respuesta al problema en este momento. El estudio anterior, nos ha impulsado a pensar en nuevas soluciones, propuestas más innovadoras y viables. Después de descartar otras opciones más complejas, nos decantamos por utilizar un sistema hardware y software apoyado completamente en la plataforma de desarrollo electrónico Arduino. Los motivos que nos llevaron a tomar la decisión de elegir esta plataforma, se fundamentan principalmente en los siguientes aspectos: ● Es una plataforma de desarrollo de código abierto. ● Está basada en una placa con un sencillo microcontrolador. ● Posee un entorno de desarrollo para crear software (programas) para la placa. ● Lenguaje de programación ampliamente extendido, C. ● Amplia comunidad internacional respaldando el proyecto. ● Gran cantidad de módulos, paquetes y librerías existentes. ● Sencillez de prototipado electrónico. ● Modularidad y facilidad a la hora de ampliar las funcionalidades básicas de la placa, a través de distintas ampliaciones denominadas shields. La placa de desarrollo Arduino, ofrece una serie de pines de conexión, a través de los cuales se hace posible interactuar con ella. Estos pines pueden ser configurados como entradas o como salidas. Además, es posible elegir entre pines analógicos y pines digitales. En los pines digitales se pueden establecer los valores HIGH y LOW, que significan 5V y 0V respectivamente. En cambio, en los pines analógicos se puede diferenciar cualquier valor intermedio entre los 5V y los 0V. La resolución entre los valores máximos y mínimos difiere de un microprocesador a otro. Arduino únicamente puede distinguir 1024 niveles en ese rango de voltaje. 48 Se pueden ver a continuación dos ejemplos de código, que muestran lo sencillo que resulta el trabajo con los pines analógicos y digitales: Ejemplo 1: Configuración del pin digital número 8 como salida, y valor a HIGH. pinMode(8,7OUTPUT);7//"establece"el"pin"8"como"salida digitalWrite(8,7HIGH);7//"pone"el"valor"del"pin"8"a"HIGH Ejemplo 2: Configuración del pin analógico 4 como entrada, y lectura de su valor. pinMode(4,7INPUT);7//"establece"el"pin"4"como"entrada analogRead(4);7 7 //"lee"valor"de"tensión"del"pin"4 Tabla 4: Características placa Arduino Todo lo anterior, nos ha llevado a pensar en Arduino como una gran opción para llevar adelante nuestra idea de proyecto. 11.3 ¿Qué solución planteamos? 11.3.1 Del lado del hardware Como hemos comentado, Arduino ofrece multitud de módulos y opciones de ampliación. En la actualidad el modelo básico de Arduino (Arduino UNO) no ofrece comunicación a través de redes tipo LAN o WAN de forma directa. Por ese motivo, se hace necesario incorporar algún tipo de módulo de expansión. Existe una gran oferta en lo relativo a módulos de conectividad para Arduino, diferentes fabricantes y diferentes opciones. Nosotros estudiamos principalmente dos posibilidades: ● Arduino Ethernet Shield ● Arduino WiFi Shield El motivo por el que descartamos otras alternativas y nos centramos en estas opciones, se basa fundamentalmente en la amplia documentación existente para trabajar con ellos, así como la gran cantidad de código libre disponible para su aprovechamiento. Además, cabe destacar que ambas placas son ensambladas y certificadas por Arduino, lo que nos ofrece mayores garantías. 49 Ambas opciones son interesantes, y ambas ofrecen ventajas e inconvenientes. Así que para la elección final entre una o otra placa, tuvimos que valorar las siguientes ventajas y desventajas: Arduino Ethernet Shield Ventajas: ● Precio reducido. ● Buena documentación. ● Librería “Ethernet Library” proporcionada por Arduino. ● Gran cantidad de código libre existente para su utilización. Desventajas: ● No posee conexión inalámbrica. Arduino WiFi Shield Ventajas: ● Buena documentación. ● Librería “WiFi Library” proporcionada por Arduino. ● Buena cantidad de código libre existente para su utilización. ● Conectividad inalámbrica. Desventajas: ● Precio superior. Comparativamente, ambos shields poseen características similares, y ambos son buenas opciones. Sin embargo, nosotros nos decantamos finalmente por el el shield Arduino WiFi Shield. El motivo para dicha elección fue fundamentalmente el factor de la conectividad inalámbrica proporcionado por el shield. 50 Ilustración 28: Arduino UNO y Arduino WiFi Shield Tras tomar una decisión acerca de qué sistema utilizar para permitir la comunicación entre la placa Arduino y la red de comunicación, necesitamos buscar una solución para poder gobernar el encendido y apagado de las bases de los enchufes. Para ello, pensamos en la opción de utilizar relés, una solución efectiva y económica. La utilización de relés en el prototipado con Arduino es algo común y de uso ampliamente extendido, de modo que existe gran oferta de sistema ad hoc para trabajar con nuestra placa de desarrollo. En la sección de recursos materiales se puede ver la opción elegida. 11.3.2 Del lado del software Por el lado del software nos propusimos algunos objetivos generales: ● Aportar una interfaz sencilla de comunicación con el sistema de enchufes. ● Permitir la conectividad a través de Internet. ● Ofrecer un servicio web que ofrezca la posibilidad de comunicarse con el sistema desde diferentes aplicaciones (web, móvil, etc.). ● Modularizar el diseño, de manera que exista una correcta separación, en función a la responsabilidad de cada capa. De esta forma, y para dar respuesta a estas necesidades, pensamos conveniente establecer los siguientes niveles de abstracción o capas: ● Servicio web a bajo nivel del lado del sistema Arduino. ● Servicio web a alto nivel para la comunicación entre las aplicaciones y el servicio web de Arduino. ● Interfaz de usuario a partir de una aplicación web ad hoc. 51 Diagrama 1: Diagrama de despliegue Servicio Web Arduino El shield Arduino WiFi Shield tiene la habilidad de poder desplegar un servidor HTTP. Gracias a esta característica nos planteamos la posibilidad de desarrollar un servicio web de comunicación directa con la placa, para la lectura y escritura de sus pines. En este sentido, podría obviarse la necesidad de hacer uso de la capa intermedia –servicio web de Clever Socket– que hemos propuesto. Sin embargo, la escasez de memoria y potencia del microcontrolador ATmega328 de la placa, desaconsejan el desarrollo de un servicio web complejo de comunicación. Además, tener un servicio web para cada propósito hace que respetemos uno de los principios perseguidos por el agilismo, el principio de responsabilidad única. Por este motivo, hemos pensado desarrollar un servicio web muy simple y de bajo nivel que se encuentre disponible en el servidor HTTP desplegado por la Arduino WiFi Shield. Con la única responsabilidad de aceptar peticiones de lectura y escritura de los pines analógicos y digitales de la placa. Para llevar a cabo dicha tarea, hemos explorado la posibilidad de desarrollar nuestro propio servicio web desde cero, haciendo uso de la librería “WiFi Library”. Sin embargo, nos hemos dado cuenta de la dificultad de crear un servicio web eficiente con las limitaciones ofrecidas por el sistema hardware. Analizando diferentes posibles soluciones que pudieran adaptarse a nuestras necesidades, encontramos un proyecto desarrollado bajo licencia del MIT, llamado Webduino, con algunas de las siguientes características: ● Analizador de parámetros URL 52 ● Soporte para los métodos HTTP: GET, HEAD, POST, PUT, DELETE, PATCH ● Interfaz JSON/RESTful ● Autenticación básica http Este proyecto software tiene amplio recorrido, habiendo sido lanzada su primera versión a comienzos del año 2009. Su código está bien testado y documentado, y cubre todas nuestras exigencias para el nivel en el que nos encontramos. Por este motivo decidimos desarrollar nuestro servicio web Arduino bajo esta solución software. Servicio Web Clever Socket A este nivel nos planteamos la opción de prestar un servicio web de tipo REST para la gestión del sistema de enchufes. Este servicio debe tener un nivel de abstracción superior al servicio web del sistema Arduino. En contrapartida al anterior servicio, no vamos a operar directamente sobre los pines de la placa Arduino, en su lugar, se tendrá una visión superior, en esta capa nos vamos a abstraer hasta el nivel de los enchufes (o como también serán mencionados a lo largo de este documento, sockets). De modo que al utilizar este servicio, no estaremos pensando en la comunicación directa con la placa Arduino, sino que estaremos pensando en una comunicación con el sistema global de enchufes, donde el shield WiFi y la placa Arduino son un elemento más. A la hora de decantarnos por una tecnología para el diseño y codificación de este servicio, estudiamos diferentes opciones. Teníamos en mente la idea de encontrar una solución simple, ya que el servicio que se va a prestar es muy sencillo, y no necesita de artefactos muy complejos. Nos interesaba una opción que permitiera levantar un servicio RESTful de forma rápida y sencilla, pero que a la vez, fuese potente, suficientemente testada. Barajamos distintas opciones de frameworks como : ● BulletPHP ● Fat-Free Framework ● Limonade ● Phalcon ● Recess PHP ● Silex ● Slim ● Tonic 53 ● Wave Framework ● Zaphpa Y finalmente, después de analizar ventajas e inconvenientes de unos y otros, nos terminamos decantando por el Slim Framework. Ilustración 29: Slim Framework Slim Framework es definido por sus desarrolladores como un micro framework para PHP, que ayuda en el proceso de desarrollo de aplicaciones web y APIs de forma no sólo rápida sino también potente. Algunas de sus características que nos hicieron pensar en él como candidato, son: ● Uno de los micro frameworks más ligeros y rápidos disponibles ● Buena documentación ● Provee de todas las características que este tipo de framework debe tener, ni más, ni menos ● Al contrario de lo que ocurre con otros frameworks, existe un gran seguimiento del proyecto, muchas fuentes de información disponibles en la red, desde la propia página oficial hasta páginas de terceros, incluyendo vídeo tutoriales en YouTube. La manera que tiene Slim Framework de establecer los métodos y rutas de comunicación es muy sencilla. Véase un ejemplo de su utilización: <?php $app7=7new7\Slim\Slim(); $app$>get(‘/hello/:name’,7function7($name)7{ 54 7777echo7“Hello,7$name”; }); $app$>run(); De esta forma al hacer una solicitud de tipo GET a la dirección /hello/World, el sistema responderá con un: Hello, World. Del mismo modo que hemos utilizado el método GET en el ejemplo anterior, podemos utilizar el resto de métodos estándar de HTTP, como POST, PUT o DELETE. Tabla 5: Características de Slim Framework Este framework cumple satisfactoriamente con nuestras exigencias. Por ello, para el desarrollo de nuestro API, haremos uso de él. Interfaz de usuario La interfaz de usuario es un elemento importante dentro de nuestro sistema software. Es la ventana de comunicación entre el usuario y nuestro sistema de enchufes, una abstracción de los elementos físicos del montaje hardware al entorno virtual, donde el usuario podrá interactuar. Desde un primer momento, pensamos que la interfaz de usuario debía cumplir con las siguientes características: ● Sencillez de uso, manejo intuitivo. ● Baja complejidad en lo relativo a funcionalidades y opciones. ● Correcto visionado en un amplio rango de dispositivos; incluyendo ordenadores de escritorio, tabletas digitales o smartphones. Nuevamente en esta ocasión, para encontrar la mejor solución tecnológica, realizamos una labor de investigación para encontrar la opción que más se pudiese adaptar a nuestras preferencias. Teniendo en cuenta que disponemos de un API para la comunicación con el sistema de enchufes, el abanico de posibilidades para el desarrollo de la interfaz de usuario es bastante 55 amplia. Serían válidos tanto soluciones que pasan por aplicaciones de escritorio, aplicaciones nativas para terminales móviles hasta aplicaciones web. Pensando en el propósito y dimensión de este trabajo, del tiempo con el que contamos para su elaboración y de nuestra intención de poder llegar con él a un espectro amplio de dispositivos, decidimos finalmente que la opción tecnológica más conveniente es la de una aplicación web, que tenga además un diseño responsive. Eligiendo este tipo de diseño, tenemos la certeza de que los usuarios no tendrán ningún tipo de problema a la hora de visualizar la interfaz, independientemente del dispositivo o la resolución utilizados, ya que la visualización se adaptará automáticamente a las particularidades del aparato. En un principio, barajamos también la idea de hacer uso de una opción de tipo adaptative. Esta alternativa, aunque tiene el mismo propósito que la anterior, difiere de la primera en que el sistema detecta desde qué dispositivo se realiza la petición, y en función de ello envía un contenido u otro adaptado a las características propias del dispositivo. De modo que, con la idea en mente de llevar a cabo un diseño responsive, encontramos una solución que se adapta muy bien a nuestras necesidades, Bootstrap. Ilustración 30: Bootstrap front-end framework Bootstrap es un framework del lado del front-end, pensado enteramente para llevar a cabo diseños que cumplan con el principio responsive. Detrás de este proyecto se encuentran los desarrolladores de Twitter, y aporta muchos puntos a favor que nos han hecho decantarnos por él como solución tecnológica: ● Contiene plantillas de diseño con tipografía, formularios, botones, cuadros, menús de navegación y otros elementos de diseño basado en HTML5 y CSS3. ● Extensiones en JavaScript para diverso tipo de acciones y manejo de eventos. ● Es uno de los proyectos más populares en GitHub. ● Se encuentra en contínuo desarrollo y existe gran cantidad de documentación. ● Soporte para dos de los preprocesadores de CSS más populares del mercado, Less y Sass. 56 Resuelta la solución del lado del front-end pasamos a estudiar la mejor opción para del lado del back-end. En este terreno, existen multitud de posibilidades, muchas de ellas completamente válidas y que se podrían adaptar muy bien a nuestras necesidades. De forma que en este punto, sopesamos sobre todo la idea de encontrar un producto que tuviera detrás una buena documentación, que hubiese sido utilizada con éxito en un gran número de proyectos, y que tuviese una buena comunidad de desarrolladores detrás. Además, nos planteamos nuevamente la idea de encontrar un producto con el cuál poder desarrollar nuestra aplicación de una forma rápida, con poca complejidad, con ligereza. Conocíamos de antemano algunos frameworks muy populares como Zend, CakePHP, CodeIgniter o Symfony. Pero queríamos tomar la decisión más adecuada para nuestro propósito y comparando las características de unos y otros, llegamos a conocer un nuevo framework, derivado de Symfony y que en los últimos tiempos se ha ido haciendo tremendamente popular, Laravel. Ilustración 31: Laravel PHP framework Algunas de sus características son: ● Curva de aprendizaje relativamente pequeña. ● Potente ORM basado en el patrón ActiveRecord para el trabajo con la capa de persistencia. ● Su sistema de enrutamiento es muy sencillo. ● Tiene una gran comunidad de desarrolladores detrás. ● Trae un fantástico sistema de plantillas. ● Al estar desarrollado como una capa por encima de componentes básicos de Symfony, su código está testeado y es muy confiable. 63 Ilustración 32: Esquema eléctrico de la prueba de concepto Con este prototipo hemos podido realizar pruebas de código sencillas, que nos han permitido confirmar y verificar nuestras hipótesis. 13 Diseño 13.1 Arquitectura del hardware En este apartado vamos a cubrir el diseño realizado, previo a la implementación del prototipo. Desde el conexionado del circuito eléctrico, a la preparación de la caja que albergará el montaje. 64 13.1.1 Esquema eléctrico del circuito Ilustración 33: Esquema eléctrico del prototipo 13.1.2 Exterior de la caja La caja en la cuál se introducirá el montaje, requiere de un acondicionamiento. En la tapa superior, colocaremos primero el juego de enchufes, luego el interruptor de encendido/apagado y por último el diodo LED de estado de conexión a la red WiFi. Para ello, hemos realizado el diseño que se muestra a continuación: 65 Ilustración 34: Plantilla de recorte de la tapa de la caja 13.1.3 Interior de la caja Con el diseño del exterior de la caja, nos resta diseñar la forma en la cual irán configurados los componentes electrónicos en su interior. El interior de la caja alberga los siguientes elementos: ● Placa Arduino UNO + Arduino WiFi Shield ● Módulo de 4 relés ● Transformador ● Regleta de conexionado Entre los componentes y el conexionado, no disponemos de demasiado espacio en el interior de la caja, por ese motivo la disposición en que son colocados es muy importante. 66 Además, es también relevante conseguir un cierto grado de robustez en el conjunto, la caja debe poder soportar ligeros golpes y movimientos sin alterar la configuración de la estructura. Para dar respuesta a estas necesidades, hemos optado por colocar un tablero de contrachapado de 5mm de espesor en el interior, fijado a la base de la caja, sobre el que reposan atornillados los componentes del montaje. Después de diferentes pruebas de distribución, mostramos a continuación la plantilla con la versión final: 67 Ilustración 35: Plantilla con la disposición de los componentes electrónicos en el interior de la caja 13.2 Arquitectura del software Para el desarrollo del apartado del software, se ha decidido establecer una subdivisión de tres niveles o capas que se detallarán a continuación (ordenados de menor a mayor nivel de abstracción): ● Servicio Web Arduino: Comunicación con la placa Arduino a bajo nivel. Atiende peticiones sobre las entradas y salidas de la placa a través de un API tipo REST y el 68 formato de comunicación estándar JSON. Disponible (en el entorno local) en la dirección arduino.cleversocket.es. ● Servicio Web Clever Socket: Comunicación con el sistema de enchufes. Permite la comunicación con el Servicio Web Arduino a través de un API de tipo REST, utilizando el formato de comunicación estándar JSON. Disponible (en el entorno local) en la dirección api.cleversocket.es. ● Interfaz de usuario: Aplicación web para el manejo del sistema de enchufes. Hace uso del Servicio Web Clever Socket. Disponible (en el entorno local) en la dirección web.cleversocket.es. Ilustración 36: Componentes software de Clever Socket 13.2.1 Servicio Web Arduino Por su extensión, los diagramas UML de casos de uso, actividad y secuencia, así como las operaciones del servicio web disponibles han sido desplazados al Anexo VI: Diagramas y operaciones del Servicio Web Arduino. Definición Peticiones HTTP permitidas ● GET - Utilizada para la obtención de recursos ● PUT - Utilizada para la actualización de recursos Autenticación de las peticiones Para autenticar las peticiones con el servicio web se utiliza la autenticación de acceso básica HTTP. 69 La autenticación de acceso básica es un método diseñado para permitir a un programa cliente, proveer credenciales en la forma de usuario y contraseña. Cabe comentar que este sistema de autenticación es muy básico en términos de seguridad. Webduino implementa únicamente este sistema para la autenticación debido fundamentalmente a las limitaciones ofrecidas por el hardware. Las credenciales son enviadas al servidor codificadas en base64. Esta codificación es comparada con la que se almacena en el servidor, dando acceso al servicio en caso de coincidencia. Respuestas del servidor ● 200 OK - La consulta fue satisfactoria ● 401 Unauthorized - La autenticación falló o el usuario no tiene permiso para la operación solicitada ● 500 Internal Server Error - Error interno en el servidor Operaciones GET /pins : Devuelve una lista de los valores de los pines analógicos y digitales. PUT /pins : Modifica el valor de uno o varios pines. 13.2.2 Servicio Web Clever Socket Por su extensión, los diagramas UML de casos de uso, actividad y secuencia, así como la estructura de la base de datos y las operaciones del Servicio Web Clever Socket, han sido desplazados al apartado Anexo VII: Diagramas y operaciones del Servicio Web Clever Socket. Definición Peticiones HTTP permitidas ● GET - Utilizada para la obtención de recursos ● PUT - Utilizada para la actualización de recursos Autenticación de las peticiones Todos los usuarios disponen de credenciales para establecer comunicación con el servicio. Estos credenciales están compuestos de dos claves: 70 ● Una clave pública o accessKey ● Una clave privada o secretKey El servicio utiliza un esquema personalizado HTTP basado en un hash del mensaje del código de autenticación. La autenticación requiere de la concatenación de algunos elementos seleccionados de la petición (ruta, tipo de contenido y fecha) para formar un string. Después, haciendo uso de la clave privada o secretKey, se calcula el HMAC de ese string. A esta última operación, la denominamos de manera informal, firma del string, ya que simula las características de seguridad reales de una firma. En cada petición, será necesario enviar la cabecera Authorization. Esta cabecera tiene la siguiente sintaxis: {accessKey}:{signature} La firma, o signature, debe estar formado como se muestra a continuación: $path7=7$verb7.7‘/’7.7‘{option}’;7 $stringToSign7=7urlencode($path7.7‘{headers/Content$Type}’7.7 ‘{headers/Date}’);7 $signature7=7base64_encode((hash_hmac(‘sha1’,7$stringToSign,7 ‘{secretKey}’))); Tabla 7: Pseudocódigo de la obtención de la firma Respuestas del servidor ● 200 OK - La consulta fue satisfactoria ● 401 Unauthorized - La autenticación falló o el usuario no tiene permiso para la operación solicitada ● 404 Not found - El elementos solicitado en la petición no fue encontrado ● 500 Internal Server Error - Error interno en el servidor ● 503 Service unavailable - No fue posible establecer comunicación con el Servicio Web Arduino 71 Operaciones GET /sockets : Devuelve una lista de los sockets disponibles e información sobre sus estados. GET /sockets/{id} : Devuelve el socket con el {id} solicitado e información sobre su estado. PUT /sockets/{id} : Modifica el estado del socket con el {id} indicado. GET /tasks : Muestra las tareas programadas. GET /tasks/{id} : Devuelve la tarea con el {id} solicitado. POST /tasks : Añade una nueva tarea. DELETE /tasks/{id} : Elimina la tarea con el {id} solicitado. GET /logs : Muestra los registros de actividad. GET /logs/{id} : Devuelve el registro de actividad con el {id} solicitado. 13.2.3 Aplicación Web Clever Socket Por su extensión, los diagramas de casos de uso, actividad y secuencia, así como la estructura de la base de datos, han sido desplazados al apartado Anexo VIII: Diagramas de la Aplicación Web Clever Socket. Los prototipos realizados para la interfaz de usuario, pueden encontrarse en el Anexo IX: Prototipo de interfaz de usuario. 72 Diagramas de despliegue del sistema Diagrama 5: Diagrama de despliegue del sistema 79 Ilustración 38: Detalle del dibujo de la plantilla sobre la caja Con el trazado realizado sobre la tapa, empezamos a realizar las perforaciones. Para ello nos ayudamos de un sierra de mano que nos facilitó la tarea. Ilustración 39: Detalle de las perforaciones en la tapa de la caja Una vez abierto el espacio para introducir las bases de los enchufes, nos dimos cuenta de que sería más conveniente poder introducir las bases por el interior de la caja en lugar de desde arriba, de tal forma que al atornillar el embellecedor por la parte superior, no sobresaliese demasiado, dejando mucha holgura. Por ello, tomamos la decisión de realizar dos aberturas en los extremos superior e inferior para poder dejar paso a los conectores de toma a tierra. 80 Ilustración 40: Frontal y reverso de la tapa de la caja Finalmente, tras colocar y atornillar las dos bases a la superficie de caja, y tras embutir el interruptor, colocamos lo embellecedores. Ilustración 41: Frontal de la caja con las bases de enchufe y el interruptor instalados 81 14.2.2 Disposición de los elementos y conexionado Los componentes electrónicos, como ya vimos en el apartado del diseño, van a ir situados sobre un tablero de contrachapado de 5mm. Este tablero además, estará sujeto a la base de la caja por 4 tornillos. Tenemos una plantilla con la disposición de los elementos en el interior de la caja. Para mayor comodidad a la hora de trasladar el diseño al tablero, hemos impreso la plantilla. Ilustración 42: Plantilla con la disposición de los elementos en el interior de la caja Con la plantilla impresa, nos queda trasladar sus puntos corte y perforación al tablero. Para ello, hemos empezado recortando el contorno y dibujando sobre el tablero las líneas de corte. 82 Ilustración 43: Detalle del recorte de la plantilla del interior de la caja Ya con las medidas dispuestas sobre el tablero, pasamos a realizar el corte haciendo uso de una pequeña sierra de mano. Ilustración 44: Recorte del tablero sobre el que se instalarán los componentes Con la base recortada, hemos superpuesto la plantilla sobre el tablero para marcar los puntos a perforar. Huecos en los cuales, irán atornillados los componentes. 83 Ilustración 45: Plantilla sobre el tablero de componentes Con los puntos marcados, hemos procedido a realizar los huecos y situado los componentes en su posición. Ilustración 46: Componentes colocados sobre el tablero 84 Antes de fijar de forma definitiva todas las partes, hemos cortado los cables necesarios que van a unir las salidas del módulo de relés con la regleta para que sea luego más sencillo. Ilustración 47: Detalle de la regleta de conexiones Ahora ya, podemos terminar de atornillar la placa Arduino, el módulo con los 4 relés, la regleta de conexionado y el transformador. Quedando conectado el módulo de relés con la regleta. Ilustración 48: Componentes en el interior de la caja 85 En la imagen de la derecha vemos ya el transformador colocado en la carcasa y conectado al cable de alimentación. Además, se puede ver el shield WiFi incorporado encima de la placa Arduino UNO, y conectado al módulo de relés a través de los conectores macho a hembra. Quedaba pendiente todavía colocar el LED de estado de conexión. Lo hemos embutido en la tapa de la caja. Por otro lado, para conectar sus terminales a los pines de la placa Arduino, hemos aprovechado nuestros conectores macho a hembra. Para ello, nos deshicimos de los extremos hembra, y soldamos los hilos de cable a los del diodo LED. Por último, para asegurar la unión, utilizamos tubo termorretráctil. Ilustración 49: Detalle del cable y del piloto LED Finalmente, después de montar la clavija de enchufe del cable de alimentación y de cerrar la caja, este fue el resultado final: Ilustración 50: Resultado final del montaje del dispositivo Clever Socket 86 15 Normativa y legislación 15.1 Reglamento que afecta al TFG En base a los Estatutos de la Universidad de Las Palmas de Gran Canaria, según se publica en el DECRETO 30/2003, de 10 de marzo, Artículo 133: 1. La realización de un proyecto fin de carrera o tesina llevará consigo, necesariamente, la elaboración de un trabajo en el ámbito disciplinario elegido, en régimen de tutoría. El Consejo de Gobierno establecerá un reglamento que defina e incentive la tutoría de proyectos y tesinas. El plan de estudios correspondiente establecerá la forma de evaluación de ese proyecto fin de carrera o tesina. 2. En virtud del artículo 7 del Real Decreto Legislativo 1/1996, de 12 de abril, por el que se aprueba el Texto Refundido de la Ley de Propiedad Intelectual, el proyecto fin de carrera se considera una obra en colaboración entre el estudiante y el tutor o tutores, en su caso. 3. La explotación industrial de un proyecto fin de carrera debe ser objeto de convenio entre la Universidad y el organismo o empresa que la realizará. Para fomentar la realización de proyectos fin de carrera con empresas, la Universidad podrá, en el convenio citado, ceder la propiedad industrial de los trabajos contenidos en el proyecto fin de carrera. 15.2 Licencias del software En este trabajo se hace uso principalmente de cuatro elementos software de terceros: ● Webduino ● Slim Framework ● Laravel PHP Framework ● Twitter Bootstrap Todos ellos comparten la misma licencia de software, The MIT License (MIT). “Una licencia de software es un contrato entre el licenciante (autor/titular de los derechos de explotación/distribuidor) y el licenciatario del programa informático (usuario consumidor /usuario profesional o empresa), para utilizar el software cumpliendo una serie de términos y condiciones establecidas dentro de sus cláusulas. Las licencias de software pueden establecer entre otras cosas: la cesión de determinados derechos del propietario al usuario final sobre una o varias copias del 87 programa informático, los límites en la responsabilidad por fallos, el plazo de cesión de los derechos, el ámbito geográfico de validez del contrato e incluso pueden establecer determinados compromisos del usuario final hacia el propietario, tales como la no cesión del programa a terceros o la no reinstalación del programa en equipos distintos al que se instaló originalmente.”8 15.2.1 Licencia del MIT Condiciones La condición de uso de la licencia del MIT es que la nota de copyright y la parte de los derechos sean incluídas en todas las copias o partes sustanciales del software. De no cumplirse esta condición, la licencia quedaría invalidada. Ilustración 51: Página de la licencia del software Derechos Se concede permiso de forma gratuita a cualquier persona que obtenga una copia de este software y de los archivos de documentación asociados (el “Software”), para utilizar el Software sin restricción, incluyendo sin limitación los derechos de usar, copiar, modificar, 8 http://es.wikipedia.org/wiki/Licencia_de_software, 2014 88 fusionar, publicar, distribuir, sublicenciar, y/o vender copias de este Software, y para permitir a las personas a las que se les proporcione el Software a hacer lo mismo. Limitación de responsabilidad El software se proporciona “tal cual”, sin garantía de ningún tipo, expresa o implícita, incluyendo pero no limitado a garantías de comercialización, idoneidad para un propósito particular y no infracción. En ningún caso los autores o titulares del copyright serán responsables de ninguna reclamación, daños u otras responsabilidades, ya sea en un litigio, agravio o de otro modo, que surja de o en conexión con el software o el uso u otro tipo de acciones en el software. Puede consultar la plantilla de la licencia en el apartado Anexo X: Plantilla de Licencia del MIT. 15.3 Utilización de cookies El apartado segundo del artículo 22 de la Ley 34/2002, de 11 de julio, de servicios de la sociedad de la información y de comercio electrónico (en adelante LSSI), tras su modificación por el Real Decreto-ley 13/2012, de 30 de marzo, establece que: 2. Los prestadores de servicios podrán utilizar dispositivos de almacenamiento y recuperación de datos en equipos terminales de los destinatarios, a condición de que los mismos hayan dado su consentimiento después de que se les haya facilitado información clara y completa sobre su utilización, en particular, sobre los fines del tratamiento de los datos, con arreglo a lo dispuesto en la Ley Orgánica 15/1999, de 13 de diciembre, de Protección de Datos de Carácter Personal. Cuando sea técnicamente posible y eficaz, el consentimiento del destinatario para aceptar el tratamiento de los datos podrá facilitarse mediante el uso de los parámetros adecuados del navegador o de otras aplicaciones, siempre que aquél deba proceder a su configuración durante su instalación o actualización mediante una acción expresa a tal efecto. Lo anterior no impedirá el posible almacenamiento o acceso de índole técnica al solo fin de efectuar la transmisión de una comunicación por una red de comunicaciones electrónicas o, en la medida que resulte estrictamente necesario, para la prestación de un servicio de la sociedad de la información expresamente solicitado por el destinatario. 95 Derecho de información en la recogida de los datos Los usuarios de nuestro servicio, a quienes vayamos a solicitar sus datos personales, deberán ser debidamente informados de manera expresa, precisa e inequívoca. Por lo que habrá que informar al usuario de: “...la existencia de un fichero o tratamiento de datos de carácter personal, de la finalidad de la recogida de éstos y de los destinatarios de la información.”, “...el carácter obligatorio o facultativo de sus respuesta a las preguntas que les sean planteadas.”, “...las consecuencias de la obtención de los datos o de la negativa a suministrarlos.”, entre otros preceptos. Otros principios sobre la protección de datos La Ley estipula además otros principios, en los cuales no profundizaremos, pero que nosotros como responsables de la información de carácter personal de los usuario deberemos atender, como son: ● El consentimiento del afectado. ● Los datos especialmente protegidos. ● La seguridad de los datos. ● El deber de secreto. ● La comunicación de datos. ● El acceso a los datos por cuenta de terceros. 16 Proyección futura del trabajo Durante el transcurso de este trabajo, tan solo hemos ido depositando las primeras piedras de un camino que, esperamos, puede tener un largo recorrido. Con la finalización de nuestro prototipo por un lado, hemos demostrado su viabilidad. Por otro lado, hemos podido entrever acciones futuras de mejora, y también, funcionalidades e incorporaciones de elementos que podrían incrementar las capacidades del dispositivo. En el futuro, nos gustaría poder mejorar algunos aspectos de nuestro trabajo, tanto en el lado del hardware como del software: En lo que atañe a la parte física del trabajo, al dispositivo, hay mucho por hacer. El resultado de nuestro trabajo es un prototipo que, aún siendo funcional, no garantiza la robustez que de un producto final se pueda esperar. Además, el precio de las partes que forman el conjunto es superior al que debería tener un dispositivo de estas características para una posible comercialización. 96 Por otro lado, sería necesario realizar un rediseño de la disposición de los componentes en el interior de la caja, así como de su aspecto exterior. El tamaño y el peso del dispositivo son superiores a lo deseable. Actualmente, aunque se ha intentado cuidar la colocación de cada elemento, su configuración es susceptible de mejora, haciendo más sencilla la apertura y cierre de la caja para su mantenimiento. En el apartado del aspecto exterior, nos gustaría poder trabajar en un diseño más elaborado y atractivo. Reducir el tamaño del equipo se haría necesario, así como asemejar el aspecto final del producto al de otros dispositivos de este tipo existentes en el mercado. Creemos que sería conveniente trabajar en detalles estéticos que lo hicieran destacar y sobresalir sobre el resto. No descartamos en un futuro realizar una selección diferente de los componentes internos. Creemos conveniente continuar estudiando alternativas que se adapten de mejor manera a nuestros propósitos, pudiendo además reducir los costes globales. Como propuesta de futuro, nos gustaría poder trabajar sobre la idea de utilizar una tarjeta Raspberry Pi, que dé más estabilidad y seguridad en la capa de comunicación. Creemos que sería conveniente también, valorar alternativas en los dispositivos específicos de comunicación, como la posibilidad de utilizar routers de muy reducido tamaño, conocidos también como mini routers, que llegan a lograr tamaños tan ajustados como los de una tarjeta de crédito, o lo que es prácticamente lo mismo, el tamaño de una placa Arduino. Ilustración 55: Mini router TP-Link WL-WR702N Utilizar un router de estas características, permitiría prescindir de la Arduino WiFi Shield, utilizando en su lugar la Arduino Ethernet Shield. Consiguiendo así, reducir el precio del conjunto y añadir mayor robustez del lado del software (hay que tener en cuenta que la tarjeta Arduino Ethernet Shield se encuentra actualmente más distribuida entre la 97 comunidad Arduino, y su librería “Ethernet.h” ha recibido mayores mejoras de estabilidad y funcionalidad que su homóloga “WiFi.h”). En el caso de incorporar un mini router y hacer uso de la tarjeta Raspberry Pi, se podría prescindir de complementos accesorios, ya que la tarjeta Raspberry Pi incorpora de serie un tarjeta de red Ethernet y junto con un router tendríamos todo lo necesario para un proyecto como el nuestro. Estas son solo algunas posibles modificaciones y líneas de investigación sobre las que nos gustaría poder trabajar en el futuro para mejorar en el aspecto hardware. En el camino del software también hay mucho por recorrer. Nos gustaría trabajar más en el aspecto de la seguridad. Actualmente el servidor web que ejecuta Webduino no ofrece las garantías de seguridad necesarias. Aunque hemos trabajado en el aspecto de la seguridad en la capa del Servicio Web Clever Socket –incluyendo el uso de autenticación HMAC– el Servicio Web Arduino por contra, ofrece únicamente un sistema de autenticación de acceso básico (HTTP Basic Access Authentication). El Servicio Web Clever Socket también es susceptible de mejora. Nos gustaría mejorar en el aspecto del manejo de errores y excepciones. Incrementar el número de funcionalidades, así como ofrecer mayores opciones en cada una de ellas. En el apartado de la aplicación web, queda por incorporar un sistema de gestión de usuarios. Mejorar aspectos en el apartado de la programación de tareas y la gestión de los registros. Quedan por explorar nuevas aplicaciones y usos en conjunción con el servicio RESTful de Clever Socket. La posibilidad de abrir el dispositivo a aplicaciones de terceros, hace el desarrollo de aplicaciones futuras ilimitado. Nos resulta de especial interés el nexo entre nuestro dispositivo y los dispositivos móviles de última generación. Pudiendo aprovechar, por ejemplo, el uso de sus sensores para disparar determinados eventos. Creemos que sería posible explotar el factor de la movilidad, gracias al hecho de que la mayoría de nosotros llevamos a todas partes uno de estos dispositivos en el bolsillo. Este factor, junto con el acceso a internet, posibilitan multitud de posibles usos que ahora mismo se nos escapan. Para concluir y como última idea, mencionar la posibilidad de desarrollar una aplicación para la carga de baterías de nuestros dispositivos electrónicos, como móviles, tabletas, ordenadores portátiles, etc. Una aplicación nativa que a través de la medida de su propio estado de carga, 98 pudiera comunicarse con el Servicio Web Clever Socket para una vez alcanzado el nivel máximo de carga, desconectarse del suministro eléctrico. 17 Conclusiones La tecnología está haciendo más sencilla nuestras vidas día a día. Acciones que en el pasado eran inevitablemente manuales, hoy pueden ser ejecutadas de forma automática por dispositivos provenientes del ingenio humano. Nosotros, con este trabajo, hemos intentado poner nuestro granito de arena para continuar abonando un terreno fértil, que en el futuro traerá consigo nuevos y sorprendentes avances en el campo de la automática. Nuestra andadura comenzó pensando en posibles formas y maneras de aportar valor. Para nosotros, era esencial encontrar una parcela sobre la que fuera justificado realizar una propuesta de trabajo. Después de analizar diferentes opciones, llegamos a la idea de poder aunar nuestros conocimientos en el desarrollo de software con nuestra pasión por los dispositivos electrónicos de última generación. De ahí nació la propuesta de este trabajo que, con esfuerzo e ilusión, se ha convertido en algo real y de lo que podemos estar orgullosos. Gracias a la introducción en los últimos tiempos de dispositivos electrónicos de reducido tamaño y precio, proyectos como el presente son hoy posibles. El gran respaldo que ofrece la comunidad de usuarios de Arduino y el auge del intercambio de información en internet, nos han servido de base de lanzamiento para nuestro proyecto. No solo el desarrollo actual de la electrónica ha significado un gran apoyo. La existencia de frameworks y aplicaciones que facilitan de forma significativa la labor del desarrollador de software nos han ayudado a seguir adelante. Cuando creímos en la utilidad de poder manejar el encendido y el apagado de nuestros aparatos domésticos a través del ordenador o del teléfono móvil, no éramos conscientes de todo el trabajo y el esfuerzo que esta tarea, aparentemente baladí, traería consigo. Han sido muchas horas dedicadas a este trabajo, muchas vigilias antes del sueño pensando en cómo resolver determinadas situaciones. Pero sin duda, nunca antes hasta ahora, después de haber recorrido el camino, después de haber disfrutado con cada éxito y sufrido con cada adversidad, hemos sido conscientes del placer por el trabajo hecho. Desde el planteamiento de la idea, su verificación, su diseño, su desarrollo y su implementación, han pasado muchas cosas. Todas sin duda valorables. 99 Creemos que con esta labor hemos madurado en lo técnico, en lo teórico y en lo personal. No podemos por más que agradecer la oportunidad, que con pretexto de este trabajo, se nos ha brindado. Esperamos que el futuro nos siga aportando nuevas excusas que nos hagan afrontar tareas similares, que nos llenen de ilusión y nos ayuden a contribuir con nuestro esfuerzo a una sociedad mejor. 18 Fuentes de información 18.1 Consultas terminológicas ● Diccionario de la Real Academia de la Lengua Española - http://lema.rae.es/drae/ ● WordReference - http://www.wordreference.com/ 18.2 Apartado sobre metodología ● Metodología - http://es.wikipedia.org/wiki/Metodolog%C3%ADa ● Método - http://es.wikipedia.org/wiki/M%C3%A9todo ● Ingeniería del Software, apartado sobre la metodología - http://es.wikipedia.org/wiki/Ingenier%C3%ADa_de_software#Metodolog.C3.ADa ● Principios del Manifiesto Ágil - http://agilemanifesto.org/iso/es/principles.html ● Object Oriented Design - http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod 18.3 Apartado sobre análisis ● Best available PHP RESTful micro frameworks - http://www.gajotres.net/bestavailable-php-restful-micro-frameworks/ ● Actor ~ UML - http://es.wikipedia.org/wiki/Actor_(UML) 18.4 Recursos 18.4.1 Materiales ● Relé o relevador - http://es.wikipedia.org/wiki/Rel%C3%A9 18.4.2 Software ● Características de NetBeans 8.0 - https://netbeans.org/features/index.html 100 ● Configuración NetBeans para programar para Arduino - https://code.google.com/p/arduino-netbeans/ ● Entorno de desarrollo Arduino - http://www.arduino.cc 18.4.3 Implementación ● Dirección MAC - http://es.wikipedia.org/wiki/Direcci%C3%B3n_MAC ● Virtual Hosting - http://httpd.apache.org/docs/2.0/es/vhosts/ 18.5 Normativa y legislación ● Guía sobre el uso de las cookies - http://www.agpd.es/portalwebAGPD/canaldocumentacion/publicaciones/common/G uias/Guia_Cookies.pdf ● Ley 34/2002, de 11 de julio, de servicios de la sociedad de la información y de comercio electrónico - https://www.boe.es/buscar/pdf/2002/BOE-A-2002-13758consolidado.pdf ● Licencia de software - http://es.wikipedia.org/wiki/Licencia_de_software ● Licencia del MIT - http://es.wikipedia.org/wiki/Licencia_MIT ● MIT license - http://opensource.org/licenses/mit-license.php 18.6 Proyección futura del trabajo ● Mini router TP-Link WL-WR702N - http://www.tplink.com/us/products/details/?model=TL-WR702N 101 19 Anexos 19.1 Anexo I: Manual de usuario Clever Socket 19.1.1 Introducción El siguiente manual pretende servir de guía para el usuario novel, acercándose de forma clara y sencilla a las principales propiedades y funcionalidades del sistema. El manual comienza con una breve introducción hacia las principales características del dispositivo. Ofreciendo indicaciones sobre su correcta puesta en funcionamiento e instrucciones de utilización. Posteriormente, continuará con el apartado referido a la utilización de la aplicación web, que como interfaz, permitirá al usuario asumir el control del sistema hardware. 19.1.2 El dispositivo El dispositivo Clever Socket constituye la parte física del sistema. A él se conectan los distintos aparatos cuyo control de encendido y apagado quiera llevarse a cabo. En su panel frontal, se pueden distinguir cuatro bases de enchufe, un interruptor de encendido y apagado y un piloto LED de estado. En la siguiente imagen podemos ver en detalle la disposición de sus partes: 102 Ilustración 56: Partes del dispositivo 19.1.3 Bases de enchufes Se cuenta con cuatro bases de enchufes. Cada base está preparada para soportar una intensidad de corriente de hasta 16 A. Según el marco europeo de normalización, estas bases entran dentro del tipo F, y son también conocidas como shuckos (origen, Alemania). Están preparadas para clavijas gruesas de hasta 4,8 mm de diámetro y poseen toma de tierra lateral por contacto y superior por recepción. Se encuentran numeradas de arriba a abajo y de izquierda a derecha. Siendo la base situada en la esquina superior izquierda la número 1 y la base situada en la esquina inferior derecha la número 4. El dispositivo soporta la utilización de todas las bases de manera simultánea sin por ello verse afectado su funcionamiento. Piloto de estado Existe una piloto luminoso de estado en la parte derecha del panel frontal, sobre el interruptor de encendido y apagado. Este diodo LED indica, al momento de iluminarse, que el dispositivo Clever Socket ha conseguido conectarse de forma satisfactoria a la red WiFi, y que por tanto, está listo para ser utilizado y gestionado a través de la aplicación web. Interruptor de encendido/apagado Este interruptor de dos estados –encendido y apagado–, es un interruptor de tipo bipolar, que permite la conexión y desconexión completa de todo el circuito interno del dispositivo Clever Socket. De tal modo que, al estar apagado, no permite la circulación de corriente a ninguno de los dispositivos conectados. 103 Una vez encendido, puede observarse cómo el el interruptor se ilumina con una luz de color rojo. Esta luz, de igual forma, desaparece al pasar a la fase de apagado. No puede darse por hecho, que una vez encendido el interruptor, el dispositivo se encuentra completamente operativo; es necesario esperar unos segundos hasta que el aparato consiga conectarse a la red inalámbrica y el piloto de estado esté encendido. 19.1.4 La aplicación web A través de la aplicación web, el usuario podrá gestionar las distintas fases de encendido y apagado de las bases de enchufe del dispositivo Clever Socket. Vamos a continuación a dar un repaso por los diferentes elementos que componen la interfaz de usuario. Página principal Ilustración 57: Página principal de la Aplicación Clever Socket La página principal, es una página de bienvenida. Donde el usuario llegará nada más acceder a la aplicación. Desde aquí se resumen algunas de las características y funcionalidades principales del servicio. 104 Además, el usuario tiene la opción de acceder al panel de control de Clever Socket a través del botón “Acceder” o haciendo clic en el enlace de la barra de navegación del mismo nombre. Página de los Sockets Ilustración 58: Página de Sockets de la Aplicación Clever Socket En esta página, el usuario podrá ver todos los sockets disponibles en el sistema. Podrá operar sobre el encendido y el apagado de cada uno de ellos. Además de conocer en todo momento, cuál es el estado actual de cada dispositivo conectado. Para encender o apagar cualquiera de los dispositivos, el usuario tiene dos opciones: 1. Hacer clic sobre el icono representativo de base de enchufe. 2. Hacer clic en botón deslizante “ON” u “OFF” que se encuentra debajo de cada socket. Si el usuario opta por la primera opción, la acción que ejecutará el sistema, será la de conmutar el estado de encendido o apagado. Es decir, si el interruptor se encuentra apagado, se encenderá y si se encuentra encendido se apagará. Las opciones “ON” y “OFF” representan los estados de encendido y apagado respectivamente. 111 //7... COM_PORT7=7/dev/tty.usbmodem411 //7... ARDUINO_BASE_DIR7=7/Applications/Arduino.app/Contents/Resources/Java //7... INCLUDE_LIBS=EEPROM;SPI;WiFi;WiFi/utility;Streaming;Sha; //7... Tabla 14: Configuración del Makefile Ahora, ya podremos compilar y subir nuestros programas a la memoria interna de nuestra placa Arduino. Uso de la consola para leer el puerto serie Si queremos además poder leer por consola el puerto serie, tendremos que incluir la siguiente librería: #include7<HardwareSerial.h> Así como inicializar el puerto serie: Serial.begin(9600); De modo que podremos hacer: Serial.println(“Hello7World!); Para leer el puerto serie desde la consola, podemos utilizar el siguiente comando (suponiendo que nuestro dispositivo está conectado al puerto /dev/tty.usbmodem411: ~7screen7/dev/tty.usbmodem411 Para salir de la aplicación Screen, pulsaremos la combinación de teclas “Cmd+A”, y posteriormente pulsaremos la tecla “k”, nos preguntarán si estamos seguros de que queremos salir, pulsamos “y” y habremos salido de la aplicación. 19.3 Anexo III: Actualización de firmware Arduino WiFi Shield Una de las primeras cosas que tuvimos que hacer nada más adquirir el componente de expansión Arduino WiFi Shield, fue actualizar su firmware. Por algún motivo, la instalación del software que trae de fábrica viene con errores conocidos y reportados por la comunidad. 112 Desde la propia compañía Arduino, recomiendan de manera imperiosa realizar esta actualización. A continuación explicamos los pasos que tuvimos que dar para realizar la actualización del firmware del shield (la actualización se ha realizado desde un Mac OS 10.9.3): 19.3.1 Instalación de Ports Lo primero que tenemos que hacer es comprobar si tenemos instalado en nuestro equipo el gestor de paquetes “MacPorts”. Para ello podemos ejecutar el siguiente comando en el terminal: Ilustración 64: Versión de Ports Si tras ejecutar el comando “$ port7$v” obtienes un mensaje como el anterior, puedes pasar al siguiente paso, ya que tendrás instalado el gestor. En caso contrario, explicamos a continuación cómo instalarlo: Acudimos a la página http://www.macports.org/install.php. Aquí se nos dice que debemos tener instalado Xcode y el conjunto de herramientas desde línea de comandos Xcode Command Line Tools. La instalación de Xcode no reviste complicación ya que puede ser realizada directamente desde la App Store. Sin embargo, para instalar Xcode Command Line, tendremos que hacer lo siguiente: 1. Introducir el siguiente comando en el terminal: $ xcode$select—install y continuar con la instalación. 113 2. O acceder a la dirección (necesitaremos tener una cuenta de desarrollador) https://developer.apple.com/downloads/index.action y descargar el paquete de instalación. Una vez instalados estos dos componentes, debemos aceptar la licencia de Xcode, para ello, tan solo debemos introducir el siguiente comando y seguir las instrucciones: $7sudo7xcodebuild7$license Ahora ya estamos preparados para descargarnos y ejecutar el programa de instalación de MacPorts Pro. Para ello descargamos la versión de nuestro sistema operativo; en nuestro caso: https://distfiles.macports.org/MacPorts/MacPorts-2.3.0-10.9-Mavericks.pkg 19.3.2 Instalación dfu+programmer Ahora que tenemos MacPorts instalado, podemos instalar el programa que nos ayudará a actualizar el firmware de nuestro shield ejecutando el siguiente comando: $7sudo7port7install7dfu$programmer 19.3.3 Preparar archivos para la actualización del firmware Ahora, simplemente, debemos cerciorarnos de que tenemos instalada la última versión del software de Arduino. Para ello, podemos abrir el IDE de Arduino, hacemos clic sobre la opción de la barra de herramientas “Arduino” y a continuación sobre “Acerca de Arduino”, veremos algo similar a esto: 114 Ilustración 65: Versión Arduino IDE Si como nosotros, tienes la versión 1.0.5 o posterior, enhorabuena, tienes en tu equipo los archivos necesarios para actualización del firmware, si no, puedes descargarte la última versión del software de Arduino desde http://arduino.cc/en/Main/Software. 115 Ahora, para preparar los archivos necesarios para la actualización, accede a la ruta /Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/firmwares desde el terminal y ejecuta los siguientes: 7$7mkdir7wifi$shield 7$7cp7wifishield/binary/*7wifi$shield/ 19.3.4 Conexión con el ordenador y actualización Ya tenemos todo preparado en nuestro equipo para realizar la instalación. Ahora solo resta, conectar el Arduino WiFi Shield a nuestro equipo a través del puerto Mini USB. Hay que tener en cuenta dos cosas: 1. El Arduino WiFi Shield no debe estar montado sobre la placa Arduino. 2. El DFU programming jumper J3 debe estar conectado como se muestra en la imagen siguiente: Ilustración 66: Detalle del jumper J3 para la programación DFU Accedemos al directorio /Applications/Arduino.app/Contents/Resources/Java//hardware/arduino/firmwares/wifishie ld/scripts y ejecutamos el siguiente comando desde terminal: $7sudo7sh7ArduinoWifiShield_upgrade_mac.sh7$a7 /Applications/Arduino.app/Contents/Resources/Java7$f7shield Si todo fue correctamente, deberíamos ver un mensaje como el siguiente: Done.7Remove7the7J37jumper7and7press7the7RESET7button7on7the7shield. Thank7you! 116 19.4 Anexo IV: Presupuesto A continuación se detalla el presupuesto de los distintos componentes utilizados para la elaboración del prototipo Clever Socket: Cantidad Componente Precio 1 x Arduino UNO Rev3 21,19 € 1 x Arduino WiFi Shield SD 73,08 € 1 x Módulo 4 relés 5V 12,71 € 8 x Jumper de conexión para placa protoboard, macho a hembra 1,62 € 1 x Alimentador electrónico universal 9V, 2A 8,64 € 1 x Caja estanca con conos, 220x170x85mm 9,50 € 2 x Base enchufe doble, 16A, 250V 12,80 € 1 x Regleta de conexión 2,10€ 1 x Clavija enchufe, patas de 4,8mm, 16A, 250V 1,30 € 1 x Interruptor conmutador luminoso rojo de dos circuitos 2,85 € 4 x Terminal plano hembra 6,4mm, aislado, azul 2,5mm 0,80 € 1 x Diodo LED 5mm, 5V, azul, con cable de 18cm 0,54 € 1 x Termorretráctil corto 0,64 € 24 x Arandela plana, 3mm 0,22 € 24 x Tornillo DIN965 cabeza plana 0,48 € 24 x Tuerca 934 0,48 € 1 x Cable manguera 3x1,5mm blanco, 4,5m 4,50 € 1 x Tablero contrachapado 600x300x5mm 2,65 € Total (bruto): 156,10 € Tabla 15: Presupuesto de los componentes del prototipo 19.5 Anexo V: Plantillas de casos de uso Nombre Identificarse ID UR.1 Creado por Óscar A. Fecha 26/04/2014 Modificada por Fecha modificación Actor principal: Usuario registrado Personal involucrado o intereses: 1. Usuario registrado: El usuario quiere poder identificarse para poder acceder a los servicios ofrecidos para su dispositivo Clever Socket. 117 Descripción: El usuarios se identifica a través de la página de acceso a la aplicación web. Trigger: El usuario hace clic en el enlace “Acceder” disponible desde el menú principal. Precondición: 1. Estar registrado en el sistema. Postcondición: 1. El usuario se encuentra identificado y es dirigido hacia el panel de control de Clever Socket. Flujo normal: 1. El usuario hace clic en el enlace “Acceder”. 2. El usuario introduce sus credenciales. 3. El sistema da la bienvenida al usuario y lo dirige hacia la página principal del panel de control. Flujo alternativo: 1. … 2. El usuario introduce sus credenciales. a. El correo electrónico y/o la contraseña no son correctos. i. El sistema muestra un mensaje advirtiendo del error. Excepción: El dispositivo Clever Socket no se encuentra conectado o disponible. El sistema muestra un mensaje alertando de que el servicio no se encuentra disponible en ese momento. Includes: Requisitos especiales: Notas: Tabla 16: Caso de uso "Identificarse" Nombre Ver sockets ID UR.2 Creado por Óscar A. Fecha 26/04/2014 118 Modificada por Fecha modificación Actor principal: Usuario registrado Personal involucrado o intereses: 1. Usuario registrado: El usuario quiere poder ver los sockets disponibles, así como obtener información sobre ellos y sus estados. Descripción: El sistema muestra los sockets disponibles del usuario, así como sus nombres y si estos se encuentran encendidos o apagados. Trigger: El usuario accede a la sección de “Sockets” en el panel de control. Precondición: 1. El usuario debe estar identificado. Postcondición: 1. Se muestran los sockets disponibles e información relativa a ellos. Flujo normal: 1. El usuario accede a la sección Sockets dentro del panel de control. 2. El sistema muestra los sockets disponibles e información sobre cada dispositivo y su estado. Flujo alternativo: 1. El usuario accede a la sección Sockets dentro del panel de control. b. No existen sockets registrado del usuario. i. El sistema no muestra dispositivos y sus estados. Excepción: Se pierde conexión con el dispositivo Clever Socket a través del servicio web. El sistema muestra un mensaje alertando de que el servicio no se encuentra disponible en ese momento y el usuario es sacado del panel de control, perdiendo la identificación. Includes: 1. Caso de uso “Identificarse”. Requisitos especiales: Notas: 119 Tabla 17: Caso de uso "Ver sockets" Nombre Encender socket ID UR.3 Creado por Óscar A. Fecha 26/04/2014 Modificada por Fecha modificación Actor principal: Usuario registrado Personal involucrado o intereses: 1. Usuario registrado: El usuario quiere poder encender un socket que se encuentra en estado “OFF” (apagado). Descripción: El usuario solicita al sistema encender un socket que se encuentra en el estado de “OFF” (apagado). El socket objeto de la acción es encendido. Trigger: El usuario hace clic sobre la opción “ON” (encendido) en la sección de “Sockets”. Precondición: 1. El usuario debe estar identificado. 2. El estado del socket debe ser “OFF” (apagado). Postcondición: 1. El estado del socket pasa a ser “ON” (encendido). Flujo normal: 1. El usuario hace clic sobre la opción “ON” (encendido) del socket objeto de la acción. 2. El sistema cambia el estado del socket de “OFF” a “ON”. Flujo alternativo: Excepción: Se pierde conexión con el dispositivo Clever Socket a través del servicio web. El sistema muestra un mensaje alertando de que el servicio no se encuentra disponible en ese momento y el usuario es sacado del panel de control, perdiendo la identificación. Includes: 1. Caso de uso “Identificarse”. 120 Requisitos especiales: Notas: Tabla 18: Caso de uso "Encender socket" Nombre Apagar socket ID UR.4 Creado por Óscar A. Fecha 26/04/2014 Modificada por Fecha modificación Actor principal: Usuario registrado Personal involucrado o intereses: 1. Usuario registrado: El usuario quiere poder apagar un socket que se encuentra en estado “ON” (encendido). Descripción: El usuario solicita al sistema apagar un socket que se encuentra en el estado de “ON” (encendido). El socket objeto de la acción es apagado. Trigger: El usuario hace clic sobre la opción “OFF” (apagado) en la sección de “Sockets”. Precondición: 1. El usuario debe estar identificado. 2. El estado del socket debe ser “ON” (encendido). Postcondición: 1. El estado del socket pasa a ser “OFF” (apagado). Flujo normal: 1. El usuario hace clic sobre la opción “OFF” (apagado) del socket objeto de la acción. 2. El sistema cambia el estado del socket de “ON” a “OFF”. Flujo alternativo: Excepción: Se pierde conexión con el dispositivo Clever Socket a través del servicio web. El sistema muestra un mensaje alertando de que el servicio no se encuentra disponible en 127 Notas: Tabla 24: Caso de uso "Ver registros" 19.6 Anexo VI: Diagramas y operaciones del Servicio Web Arduino 19.6.1 Diagrama de casos de uso Diagrama 7: Casos de uso del Servicio Web Arduino 128 19.6.2 Diagramas de actividad Lectura de los pines Diagrama 8: Diagrama de actividad de la lectura de pines, Servicio Web Arduino 129 Escritura de los pines Diagrama 9: Diagrama de actividad de la escritura de pines, Servicio Web Arduino 130 19.6.3 Diagramas de secuencia Lectura de los valores de los pines Diagrama 10: Diagrama de secuencia de la lectura de los valores de los pines, Servicio Web Arduino 131 Escritura de los valores de los pines Diagrama 11: Diagrama de secuencia de la escritura de los valores de los pines, Servicio Web Arduino 19.6.4 Operaciones /pins Método GET 132 Verbo /pins Descripción Devuelve una lista de los valores de los pines analógicos y digitales. Ejemplo GET7http://arduino.cleversocket.es/pins //"Request //"Response 200 Content$Type:7application/json { 7777a0:7260, 7777a1:7263, 7777a2:7316, 7777a3:7415, 7777a4:7465, 7777a5:7432, 7777d0:70, 7777d1:70, 7777d2:70, 7777d3:70, 7777d4:70, 7777d5:70, 7777d6:70, 7777d7:70, 7777d8:70, 7777d9:70 } Tabla 25: Operación GET /pins Método PUT Verbo /pins Descripción Modifica el valor de uno o varios pines. Opciones ● Establecer valor de pin analógico: ○ a{id}={0|1} ● Establecer valor de pin digital: ○ d{id}={0|1} Ejemplo PUT7http://arduino.cleversocket.es/pins 133 //"Request Content$Type:7application/x$www$form$urlencoded d2=1&d3=1&d4=0&d5=1&d6=1 //"Response 200 Content$Type:7application/json { 7777a0:7260, 7777a1:7263, 7777a2:7316, 7777a3:7415, 7777a4:7465, 7777a5:7432, 7777d0:70, 7777d1:70, 7777d2:71, 7777d3:71, 7777d4:70, 7777d5:71, 7777d6:71, 7777d7:70, 7777d8:70, 7777d9:70 } Tabla 26: Operación PUT /pins 134 19.7 Anexo VII: Diagramas y operaciones del Servicio Web Clever Socket 19.7.1 Diagrama de casos de uso Diagrama 12: Diagrama de casos de uso del Servicio Web de Clever Socket 135 19.7.2 Diagramas de actividad Lectura del estado de los sockets Diagrama 13: Diagrama de actividad de la lectura del estado de los sockets, Servicio Web Clever Socket Encendido/apagado de un socket Diagrama 14: Diagrama de actividad del encendido/apagado de un socket, Servicio Web Clever Socket 136 Conmutado de un socket Diagrama 15: Diagrama de actividad del conmutado de un socket, Servicio Web Clever Socket 143 Lectura de tareas Diagrama 24: Diagrama de secuencia de la lectura de tareas, Servicio Web Clever Socket 144 Crear tarea Diagrama 25: Diagrama de secuencia de crear tarea, Servicio Web Clever Socket Eliminar tarea Diagrama 26: Diagrama de secuencia de eliminar tarea, Servicio Web Clever Socket 145 Lectura de registros Diagrama 27: Diagrama de secuencia de lectura de registros, Servicio Web Clever Socket 146 19.7.4 Diagrama y estructura de la base de datos Diagrama 28: Base de datos api-clever-socket api-clever-socket SET7@OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS,7UNIQUE_CHECKS=0; SET7@OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS,7 FOREIGN_KEY_CHECKS=0; SET7@OLD_SQL_MODE=@@SQL_MODE,7 SQL_MODE=’TRADITIONAL,ALLOW_INVALID_DATES’; $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$7Schema7api$clever$socket 147 $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ CREATE7SCHEMA7IF7NOT7EXISTS7‘api$clever$socket‘7DEFAULT7CHARACTER7 SET7utf87; USE7‘api$clever$socket‘7; $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$7Table7‘api$clever$socket‘.‘users‘ $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ CREATE7TABLE7IF7NOT7EXISTS7‘api$clever$socket‘.‘users‘7( 77‘id‘7INT7NOT7NULL7AUTO_INCREMENT, 77‘accessKey‘7VARCHAR(20)7NOT7NULL, 77‘secretKey‘7VARCHAR(40)7NULL, 77PRIMARY7KEY7(‘id‘)) ENGINE7=7InnoDB; $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$7Table7‘api$clever$socket‘.‘sockets‘ $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ CREATE7TABLE7IF7NOT7EXISTS7‘api$clever$socket‘.‘sockets‘7( 77‘id‘7INT(11)7NOT7NULL7AUTO_INCREMENT, 77‘name‘7VARCHAR(20)7NOT7NULL, 77‘pinId‘7CHAR(5)7NOT7NULL, 77‘pinType‘7ENUM(‘analog’,’digital’)7NOT7NULL, 77‘userId‘7INT7NOT7NULL, 77PRIMARY7KEY7(‘id‘), 77INDEX7‘name‘7(‘name‘7ASC), 77INDEX7‘fk_sockets_users1_idx‘7(‘userId‘7ASC), 148 77INDEX7‘pinId‘7(‘pinId‘7ASC), 77CONSTRAINT7‘fk_sockets_users1‘ 7777FOREIGN7KEY7(‘userId‘) 7777REFERENCES7‘api$clever$socket‘.‘users‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION) ENGINE7=7InnoDB AUTO_INCREMENT7=75 DEFAULT7CHARACTER7SET7=7utf8; $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$7Table7‘api$clever$socket‘.‘tasks‘ $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ CREATE7TABLE7IF7NOT7EXISTS7‘api$clever$socket‘.‘tasks‘7( 77‘id‘7BIGINT7NOT7NULL7AUTO_INCREMENT, 77‘userId‘7INT7NOT7NULL, 77‘socketId‘7INT(11)7NOT7NULL, 77‘action‘7ENUM(‘on’,’off’,’toggle’)7NULL, 77‘minute‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘hour‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘day‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘month‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘weekday‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘year‘7CHAR(4)7NULL7DEFAULT7‘*’, 77‘createdAt‘7TIMESTAMP7NULL7DEFAULT7NOW(), 77‘updatedAt‘7TIMESTAMP7NULL7DEFAULT7NOW(), 149 77‘expired‘7TINYINT(1)7NULL7DEFAULT70, 77‘deleted‘7TINYINT(1)7NULL7DEFAULT70, 77PRIMARY7KEY7(‘id‘), 77INDEX7‘fk_tasks_users1_idx‘7(‘userId‘7ASC), 77INDEX7‘fk_tasks_sockets1_idx‘7(‘socketId‘7ASC), 77CONSTRAINT7‘fk_tasks_users1‘ 7777FOREIGN7KEY7(‘userId‘) 7777REFERENCES7‘api$clever$socket‘.‘users‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION, 77CONSTRAINT7‘fk_tasks_sockets1‘ 7777FOREIGN7KEY7(‘socketId‘) 7777REFERENCES7‘api$clever$socket‘.‘sockets‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION) ENGINE7=7InnoDB; $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$7Table7‘api$clever$socket‘.‘logs‘ $$7$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ CREATE7TABLE7IF7NOT7EXISTS7‘api$clever$socket‘.‘logs‘7( 77‘id‘7BIGINT7NOT7NULL7AUTO_INCREMENT, 77‘userId‘7INT7NOT7NULL, 77‘socketId‘7INT(11)7NOT7NULL, 77‘action‘7ENUM(‘on’,’off’,’toggle’)7NOT7NULL, 77‘oldStatus‘7ENUM(‘on’,’off’)7NOT7NULL, 150 77‘newStatus‘7ENUM(‘on’,’off’)7NOT7NULL, 77‘createdAt‘7TIMESTAMP7NULL7DEFAULT7NOW(), 77‘taskId‘7BIGINT7NULL, 77‘sessionId‘7MEDIUMTEXT7NOT7NULL, 77PRIMARY7KEY7(‘id‘), 77INDEX7‘fk_logs_users1_idx‘7(‘userId‘7ASC), 77INDEX7‘fk_logs_tasks1_idx‘7(‘taskId‘7ASC), 77INDEX7‘fk_logs_sockets1_idx‘7(‘socketId‘7ASC), 77CONSTRAINT7‘fk_logs_users1‘ 7777FOREIGN7KEY7(‘userId‘) 7777REFERENCES7‘api$clever$socket‘.‘users‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION, 77CONSTRAINT7‘fk_logs_tasks1‘ 7777FOREIGN7KEY7(‘taskId‘) 7777REFERENCES7‘api$clever$socket‘.‘tasks‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION, 77CONSTRAINT7‘fk_logs_sockets1‘ 7777FOREIGN7KEY7(‘socketId‘) 7777REFERENCES7‘api$clever$socket‘.‘sockets‘7(‘id‘) 7777ON7DELETE7NO7ACTION 7777ON7UPDATE7NO7ACTION) ENGINE7=7InnoDB; SET7SQL_MODE=@OLD_SQL_MODE; 151 SET7FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS; SET7UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS; Tabla 27: Definición de la base de datos api-clever-socket 19.7.5 Operaciones /sockets Método GET Verbo /sockets Descripción Devuelve una lista de los sockets disponibles e información sobre sus estados. Cabeceras ● Content-Type: ○ application/x$www$form$urlencoded7 ● Date:7 ○ RFC78507(ejemplo:7Tue,7037Jun72014709:49:077GMT) ● Authorization: ○ {accessKey}:{signature}7 Ejemplo GET7http://api.cleversocket.es/sockets //"Request"headers Content$Type:7application/x$www$form$urlencoded Authorization:7 5EB929317E2F1A678C17:ZGJiMWQ3ZmMxN2FjZWY5MWUxNDQwNTEwNDY2ZTgyMG Q0NDc5ZGEwZQ== Date:7Tue,7037Jun72014709:49:077GMT //"Response 200 Content$Type:7application/json { 7777“sockets”7:7[ 7777{ 77777777“id”:71, 77777777“type”:7“socket”, 77777777“name”:7“Socket71”, 152 77777777“pin”:7{ 777777777777“id”:72, 777777777777“value”:70, 777777777777“type”:7“digital” 77777777} 7777}, 7777//7... 7777] } Tabla 28: Operación GET /sockets Método GET Verbo /sockets/{id} Descripción Devuelve el socket con el {id} solicitado e información sobre su estado. Cabeceras ● Content-Type: ○ application/x$www$form$urlencoded7 ● Date:7 ○ RFC78507(ejemplo:7Tue,7037Jun72014709:49:077GMT) ● Authorization: ○ {accessKey}:{signature}7 Ejemplo GET7http://api.cleversocket.es/sockets/3 //"Request"headers Content$Type:7application/x$www$form$urlencoded Authorization:7 5EB929317E2F1A678C17:ZGJiMWQ3ZmMxN2FjZWY5MWUxNDQwNTEwNDY2ZTgyMG Q0NDc5ZGEwZQ== Date:7Tue,7037Jun72014709:49:077GMT //"Response 200 Content$Type:7application/json { 7777“socket”:7{ 77777777“id”:73, 77777777“type”:7“socket”, 77777777“name”:7“Socket73”, 77777777“pin”:7{ 777777777777“id”:75,