Desarrollo e implementación utilizando Arduino y Zigbee con un sensor ultrasónico para control de nivel de llenado TITULACIÓN: Ingeniería Técnica Industrial en Electricidad AUTOR: Juan Jesús Almansa Madrigal DIRECTOR: Antonio Lázaro FECHA: Septiembre del 2013. 1 El presente proyecto tiene información confidencial, es una versión íntegra de un proyecto realizado en una empresa, por lo que hay datos que no serán públicos. Índice Sección 1: Objetivos, alcance y antecedentes del proyecto .............................................................. 6 1.1 Objetivo del proyecto......................................................................................................... 6 1.2 Alcance ............................................................................................................................... 6 1.3 Antecedentes ..................................................................................................................... 6 Sección 2: Introducción teórica.......................................................................................................... 7 2.1 Fundamentos de Radio ...................................................................................................... 7 2.1.1 Espectro Electromagnético ........................................................................................ 7 2.1.2 Ecuación de transmisión en espacio libre .................................................................. 8 2.1.3 RSSI ............................................................................................................................. 9 2.2 Redes de sensores inalámbricas WSN.............................................................................. 10 2.3 Motas ..................................................................................................................................... 11 2.3.1 2.4 Elementos básicos de una Mota .............................................................................. 11 Introducción a Zigbee....................................................................................................... 12 2.4.1 Historia y curiosidades ............................................................................................. 13 2.4.2 Características técnicas de Zigbee [3] ...................................................................... 14 2.4.2.1 Frecuencias de trabajo y rango de velocidades ....................................................... 14 2.4.2.2 Tipos de dispositivos ............................................................................................ 15 2.4.2.3 Topologías de red................................................................................................. 16 2.4.2.4 Capas de Zigbee.................................................................................................... 17 2.4.2.5 Seguridad de red ...................................................................................................... 21 2.4.2.5 Profundidad de red .............................................................................................. 22 2.4.3 Coexistencia de redes inalámbricas ......................................................................... 23 2.4.4 El futuro de Zigbee ................................................................................................... 24 2.5 Introducción a Arduino .................................................................................................... 25 2.5.1 ¿Qué es Arduino? ..................................................................................................... 25 2.5.2 ¿Qué significa que Arduino sea Open Hardware?[4]............................................... 25 2.5.3 ¿Por qué Arduino?.................................................................................................... 26 2.6 Las placas Arduino............................................................................................................ 27 2.6.1 ¿Qué significa que una placa sea Arduino?.............................................................. 27 2.6.2 Placas de entradas y salidas ..................................................................................... 27 2.6.3 "Shields" y otras placas de terceros ......................................................................... 29 2.6.4 Construir nuestro propio Arduino............................................................................ 30 2.6.5 ¿Cómo obtener una placa Arduino? ........................................................................ 31 2 2.6.6 2.7 Elección de placa Arduino: El Arduino UNO............................................................. 31 2.6.6.1 El porqué de la elección ....................................................................................... 31 2.6.6.2 Características ...................................................................................................... 32 2.6.6.3 Esquema y pines................................................................................................... 33 El entorno de trabajo ....................................................................................................... 34 2.7.1 El entorno de desarrollo y los drivers de la placa para Windows ............................ 34 2.7.2 Descargar y ejecutar un ejemplo de aplicación Arduino ......................................... 37 2.8 2.7.2.1 Editor .................................................................................................................... 37 2.7.2.2 Compilador........................................................................................................... 39 2.7.2.3 Cargar y depurar................................................................................................... 40 2.7.2.4 Compilar con Atmel AVRISP mkII ......................................................................... 41 Lenguaje de programación Arduino................................................................................. 43 2.8.1 Introducción e historia ............................................................................................. 43 2.8.2 Funciones básicas y operadores............................................................................... 44 2.8.2.1 Estructuras ........................................................................................................... 44 2.8.2.2 Variables............................................................................................................... 46 2.8.2.3 Funciones ............................................................................................................. 47 2.8.3 Uso de librerías......................................................................................................... 49 2.8.3.1 Librerías Estándar................................................................................................. 49 2.8.3.2 Librerías de terceros............................................................................................. 50 Sección 3: Memoria descriptiva ....................................................................................................... 52 3.1 Hardware: Componentes de un sensor inalámbrico ....................................................... 52 3.1.1 Antenas y transceptores Zigbee............................................................................... 52 3.1.1.1 Módulos Xbee ...................................................................................................... 53 3.1.1.2 Datos E/S .............................................................................................................. 56 3.1.1.3 Elección de la antena Xbee .................................................................................. 57 3.1.2 Arduino Uno ............................................................................................................. 59 3.1.2.1................................................................................................................................... 59 3.1.3 Sensor de ultrasonidos............................................................................................. 61 3.1.3.1 Requerimientos iniciales ...................................................................................... 62 3.1.3.2 Elección de los componentes............................................................................... 63 3.1.3.3 Descripción del sensor elegido............................................................................. 63 3.1.3.4 Características técnicas ........................................................................................ 66 3.1.3.5 Conexionado......................................................................................................... 66 3 3.1.3.6 Ajustes .................................................................................................................. 67 3.1.3.7 Aplicaciones.......................................................................................................... 67 3.1.4 Baterías..................................................................................................................... 67 3.1.5 Adaptador Xbee a placa protoboard de Sparkfun ................................................... 69 3.1.6 Adaptador Xbee Shield............................................................................................. 69 3.1.7 Caja de Control:........................................................................................................ 71 3.2 Software ........................................................................................................................... 72 3.2.1 Programación de los módulos Xbee: X-CTU............................................................. 72 3.2.2 Procesado de datos: MySQL..................................................................................... 75 3.2.2.1 Aplicaciones.......................................................................................................... 75 3.2.2.2 Lenguajes de programación ................................................................................. 75 3.2.2.3 Características adicionales ................................................................................... 75 3.2.3 3.3 Aplicación Visual:...................................................................................................... 77 Implementación de hardware y software........................................................................ 77 Sección 4. Memoria de Cálculo ........................................................................................................ 79 4.1 Diagramas de flujo del software ...................................................................................... 79 4.2 Potencia consumida ......................................................................................................... 81 Sección 5: Casos experimentales ..................................................................................................... 82 5.1 Lectura de la corriente consumida en los diferentes ciclos de trabajo ........................... 82 5.2 Lectura de medidas del sensor ultrasónico...................................................................... 83 5.3 Lectura del RSSI: Outdoor ................................................................................................ 83 5.4 Comunicación emisor-receptor Xbee............................................................................... 85 Sección 6: Planos.............................................................................................................................. 87 6.1 Plano placa Arduino ......................................................................................................... 88 6.2 Fotografía placa base (interior End Device) ..................................................................... 89 6.3 Plano Pila.......................................................................................................................... 90 6.4 Fotografía del módulo Coordinador................................................................................. 91 6.5 Planos Xbee Explorer USB ................................................................................................ 92 6.6 Fotografía caja comunicación .......................................................................................... 93 6.7 Plano caja de comunicación ............................................................................................. 94 Sección 7: Presupuesto .................................................................................................................... 95 7.1 Precios unitarios............................................................................................................... 95 7.2 Precios descompuestos.................................................................................................... 96 7.2.1 Capítulo 1: Estudios previos ..................................................................................... 96 4 7.2.2 7.3 Capítulo 2: Diseño y montaje del hardware............................................................. 96 Resumen del presupuesto................................................................................................ 97 Sección 8: Conclusiones ................................................................................................................... 98 Sección 9: Bibliografía .................................................................................................................... 101 Sección 10: Anexo .......................................................................................................................... 103 10.1 Código fuente................................................................................................................. 103 10.2 Código fuente ejemplo para probar sensor ultrasónico SRF05 ..................................... 106 5 Sección 1: Objetivos, alcance y antecedentes del proyecto 1.1 Objetivo del proyecto El presente proyecto tiene la finalidad de mostrar la viabilidad de utilización de un micro-controlador Atmel de Arduino, un sensor ultrasónico y un sistema de comunicación sin hilos basado en protocolo Zigbee, con el objetivo final de controlar el nivel de llenado de los contenedores situados en la calle de forma remota, permitiendo así una gestión de recogida de residuos óptima y eficiente. Se detallará la tecnología empleada para la construcción de un primer prototipo, con comparaciones y pruebas realizadas, así como la recepción y registro de datos mediante una caja de comunicación. En primer lugar, el proyecto se centrará en describir dos grandes bloques que lo componen, como son Arduino y Zigbee. Se hará un estudio teórico sobre sus características, así como el funcionamiento en el entorno de programación y configuración de los mismos. Seguidamente, se describirán el hardware y el software utilizado en todas las fases del proyecto, así como su implementación. Finalmente, se explican una serie de casos experimentales, como la lectura del consumo en diferentes ciclos de trabajo (dormido o despierto), lecturas de la señal de potencia recibida (RSSI) y distancias de comunicación inhalámbrica, y se adjuntan planos y fotografías de las partes fundamentales del proyecto, así como un presupuesto resumido. 1.2 Alcance El alcance del proyecto es la realización de un circuito impreso, que conectada al sensor ultrasónico colocado en el techo del contenedor, sea capaz de medir y procesar las distancias de llenado, y a la vez de comunicarse inalámbricamente con un receptor de radiofrecuencia o coordinador conectado a un PC situado en una caja de comunicaciones remota. 1.3 Antecedentes La empresa IGS Software tiene cierta experiencia en el desarrollo e investigación en hardware y software, habiendo fabricado algún prototipo anterior para otro tipo de proyecto, basado en Arduino. Se trabaja desde el diseño PCB y correspondiente soldado de componentes, hasta el software cargado al micro-controlador, en este caso uno del fabricante Atmel. En el proyecto actual se ha escogido los módulos Xbee para el envío y recepción datos, integrándolo con sensor ultrasónico y un micro-controlador en una única PCB. 6 Sección 2: Introducción teórica 2.1 Fundamentos de Radio 2.1.1 Espectro Electromagnético Las ondas de radio son una porción del “espectro electromagnético”. Sucede que la energía que transporta una onda electromagnética depende de la constante de Planck. La constante de Planck relaciona la energía de los fotones con la frecuencia de la onda lumínica según la fórmula: E=h· c (1) Donde c= 299.272.458 m/s; h≈6.626 J·s. Figura 1. Clasificación del espectro de radiofrecuencia. Dentro del espectro electromagnético tenemos los rayos gamma de alta potencia que llegan de las supernovas, los rayos X, los microondas para cocinar nuestros alimentos, los infrarrojos que nos producen una sensación de calor, la luz visible que nos sirve para poder captar información y procesarla en el cerebro y también las ondas de radio. Las ondas de radio son mucho más largas que las ondas de luz y muchas pueden viajar a través de materiales tales como: ropa, muebles o paredes. Las ondas de radio se pueden propagar muy bien por el vacío y por lo tanto son ideales para las comunicaciones en las que las conexiones con cable no son tan prácticas. Dentro del espectro electromagnético podemos ver que las frecuencias de ondas de radio ocupan la porción energética situada entre 3 kHz y 300 GHz. Dentro de este amplio espectro, podemos subdividir la radio en varias bandas de frecuencias: 7 Tabla 1. Clasificación del espectro de radiofrecuencia. 2.1.2 Ecuación de transmisión en espacio libre La problemática de las comunicaciones con radio es que requieren de mucha potencia en comparación con aquellas que viajan a través de cable. La razón de esto es fácil de entender. Como la radio irradia desde una fuente hacia el espacio, gran cantidad de energía se atenúa, sin que esta energía haya sido utilizada. Una buena comparación con esta idea podrían ser las ondas que se dispersan cuando tiramos una piedra en un estanque. Pasa lo mismo con el sonido, ya que sólo podemos entender un susurro desde una cierta distancia, pero nos es imposible entenderlo si estamos a varios metros. Como ventaja los sistemas radio requieren menos infraestructura, y pueden desplegarse y configurarse más rápidamente que los sistemas basados en comunicaciones por hilos. 8 Estos fenómenos se pueden explicar con la ecuación de transmisión en espacio libre. Esta ley dice que, para fenómenos ondulatorios tales como el sonido y la luz, la intensidad disminuye con el cuadrado de la distancia con respecto al punto en donde se origina. Dicho de otra forma, cada vez que se dobla la distancia desde la fuente, se requieren cuatro veces la cantidad de energía para mantener la señal. Figura 2. La ley del cuadrado inverso. Esta ley puede ser explicada por la ecuación: ( )= ( · · · ² ) · ² (2) Dónde Gt y Gr son las ganancias de cada antena, λ es la longitud de onda y d la distancia que hay entre las dos antenas. De hecho, las redes en malla Zigbee están diseñadas pensando en la ecuación de transmisión en espacio libre. Los dispositivos Zigbee no tienen baterías de alta capacidad para hacer llegar señales a grandes distancias, sino que en realidad hay muchos dispositivos en malla y cada uno de ellos hace de repetidor del siguiente para llegar al destinatario final, con objeto de “no desintegrar” la señal de la fuente. De esta forma utilizando una red zigbee se pueden conseguir alcances grandes sin necesidad de utilizar elevadas potencias de transmisión que serían inviables por normativa y por consumo. 2.1.3 RSSI El RSSI (de las siglas Received Signal Strength Indicator en inglés) es un parámetro que da idea de la potencia de recepción de señales de radio. En realidad es una medida de la potencia recibida por el receptor. Dependiendo del dispositivo se devuelve de diferentes formas, por ejemplo expresada en dBm o en niveles. La relación entre el RSSI y la distancia se puede determinar de acuerdo con la siguiente expresión basada en la ecuación en espacio libre: RSSI [dBm] = -(10·n· log10(d)+A) (3) 9 Dónde cada parámetro es: - n: La pendiente de la señal. - A: El valor absoluto del RSSI a 1 m de distancia. - d: La distancia entre antenas. En Xbee el rango de valores posibles de RSSI va de -40 dBm a -95dBm. Por lo tanto, en este último caso la señal de recepción en wattios valdrá: -95 = 10 ·log (P / 1mW) �P = 3.16 ·10-10 mW = 31.6 pW Lo que da idea de la sensibilidad de estos receptores. 2.2 Redes de sensores inalámbricas WSN Los entornos inteligentes representan el siguiente paso en la evolución de los servicios en edificios, hogar o sistemas automáticos de transporte. Mark Weiser lo describe como “un mundo físico que es rico e invisible, con sensores, actuadores, pantallas y elementos computacionales, integrados perfectamente en los objetos cotidianos de nuestras vidas” [19]. Figura 3. Esquema típico de una WSN Las posibilidades de esta tecnología yacen tanto en la realización de aplicaciones “nuevas” dónde la tirada de cable es complicada ya sea por el coste o las dificultades técnicas, como en las aplicaciones ya existentes, pero en el que la tecnología inalámbrica 10 puede ofrecer un valor añadido. De esta forma podemos tener aplicaciones tan variadas como control medioambiental o control de espacios inteligentes. Algunas características de las redes de sensores inalámbricas son: - Patrón de flujo de datos: Periódicamente cada nodo envía sus lecturas a un almacén central de datos. Estos almacenes pueden estar distribuidos, de forma que tendríamos una arquitectura de almacenes distribuida. - Restricciones energéticas: Uno de los grandes desafíos de esta tecnología está en la alimentación de los nodos. Los nodos están diseñados para tener tanto un bajo consumo como reducidos ciclos de trabajo. La fiabilidad de la red dependerá en gran medida de este factor. Las redes de sensores inalámbricas (Wireless Sensor Networks en inglés) prometen cambiar la forma de obtener la información a nivel global. Se prevé que las redes de sensores estarán formadas por miles de nodos sensoriales diminutos. Las redes de sensores inalámbricas no serán redes cerradas que harán aplicaciones concretas, sino que seguramente estarán conectadas a Internet. 2.3 Motas Aunque el concepto de sensores inalámbricos ya hace mucho tiempo que existe, el concepto de motas podríamos decir que es relativamente nuevo. La idea de las “motas” proviene de los Estados Unidos y se refiere a dispositivos extremadamente pequeños (de aquí el nombre), conectados inalámbricamente unos con otros y pasándose información del tipo: temperaturas, humedades, almacenaje de sus baterías, etc. 2.3.1 Elementos básicos de una Mota En una mota podemos diferenciar los siguientes componentes: Figura 4. Esquema básico de una mota. Micro controlador: Es el elemento que procesa los datos recogidos por los sensores y controla la funcionalidad del nodo. 11 Memoria Externa: Almacenamiento de datos del nodo. En general, la cantidad de memoria necesaria depende de cada aplicación. Sensor: Es el dispositivo que es capaz de producir alguna señal eléctrica a un cambio físico como por ejemplo temperatura o humedad. Batería: Aporta la energía al nodo para su funcionamiento, tanto cuando está dormido como cuando está activo. Figura 5. Aporte de energía de la batería a los diferentes módulos. Transceptor: Es el encargado de funciones tanto de transmisión como de recepción de datos. En la figura 6 podemos ver el diagrama de bloques de un transceptor conectado a un sensor. Figura 6. Esquema del transceptor y su conexión con un sensor. 2.4 Introducción a Zigbee En el desarrollo del proyecto utilizaremos Zigbee como protocolo de comunicaciones para la implementación de los sensores inalámbricos que veremos más adelante. A continuación se realizarán una serie de consideraciones relativas a este protocolo de comunicación. 12 2.4.1 Historia y curiosidades El nombre de Zigbee deriva de los patrones erráticos comunicativos que tienen las abejas (bees) entre las flores durante la recogida de polen. Los zumbidos de las abejas evocan en redes inalámbricas invisibles. Zigbee surge de la necesidad de desarrollar una tecnología inalámbrica fiable, pero de no muy alta transferencia de datos. De esta forma, en 1998, un conjunto de empresas se asociaron para desarrollar un estándar de comunicaciones que complementara a Wi-fi y Bluetooth. Fue terminado y publicado por el IEEE en Mayo de 2003. Desde el punto de vista del Hardware, podemos decir que Zigbee ha sido cuidadosamente optimizado para el bajo coste a gran escala. Tiene pocas partes analógicas y utiliza circuitos digitales siempre que sea posible. Desde el punto de vista técnico, Zigbee es un estándar que define un conjunto de protocolos de comunicación de baja velocidad de datos de corto alcance de redes inalámbricas [1]. Zigbee está basado en dispositivos inalámbricos que operan a 868 MHz, 915 MHz y 2.4 GHz. La técnica de modulación es Direct Sequence Spread Spectrum (DSSS), que tiene un máximo rango de velocidad de unos 250 kbit /s. Por lo tanto, a modo resumen podemos catalogar a Zigbee como un protocolo: - Basado en el estándar 802.15.4. - Con aplicaciones WPAN (Wireless Personal Area Network) - Con gran soporte desde la industria: Honeywell, Mitsubishi Electric, Motorola, Philips, Samsung, etc. - Bajo coste. - Bajo consumo. - Instalación fácil y barata. - Redes flexibles y extensibles. Seguidamente podemos ver un cuadro de comparación entre WiFi, Bluetooth y Zigbee: 13 Tabla 2. Cuadro comparativo entre WiFi, Bluetooth y Zigbee. En resumen…Mientras la tecnología Bluetooth está orientada a la movilidad del usuario y a eliminar el cableado entre los dispositivos de corta distancia, Zigbee está orientado hacia el control remoto y a la automatización. Bluetooth por lo tanto tiene por objetivo eliminar los cables entre dispositivos que están muy cerca entre sí, como por ejemplo entre el teléfono móvil y un ordenador portátil, mientras que Zigbee podría ser una red de sensores inalámbricos que se conecten sin cables a una estación de control. 2.4.2 Características técnicas de Zigbee [3] 2.4.2.1 Frecuencias de trabajo y rango de velocidades En el estándar Zigbee se definen tres bandas de frecuencia distintas: - 868–868.6 MHz (banda de 868 MHz) - 902- 928 MHz (banda de 915 MHz) - 2400 – 2483.5 MHz (banda de 2.4 GHz) La banda de 2.4 GHz es usada en el mundo entero mientras que las de 868 MHz y 915 MHz se usan en Europa y América del Norte respectivamente. Esto otorga a los diseñadores libertad para tomar sus propias decisiones sobre qué bandas de frecuencia son mejores para sus aplicaciones. En general, podemos decir que las aplicaciones de 2.4 GHz permiten un ancho de banda más grande y más canales. Sin embargo, la coexistencia con otros sistemas que funcionan con 2.4 GHz como WLAN y Bluetooth debe ser tenida en cuenta. El tamaño de las antenas en sistemas de 2.4 GHz es también menor respecto a las otras dos bandas de frecuencias. 14 Tabla 3. Bandas de frecuencia en Zigbee. 2.4.2.2 Tipos de dispositivos IEEE 802.15.4 y Zigbee definen diferentes tipos de dispositivos. Por un lado, IEEE 802.15.4 define el FFD (de Full Function Device en inglés), que es un dispositivo de funcionalidad completo. A su vez, este tipo de dispositivos pueden funcionar como coordinadores de área (PAN) o dispositivos normales. Por otro lado, también define los RFD (de reduced-function device en inglés), que son dispositivos de funcionalidad reducida. La figura 8 nos permite ver las clasificaciones Zigbee e IEEE 802.15.4 y sus analogías. Figura 7. Tipos de dispositivos Zigbee / IEEE 802.15.4 Zigbee Coordinator: Es el dispositivo más completo. Controla el ruteado y la administración de la red. Hay uno por red. 15 Zigbee Router: Se encarga de interconectar los dispositivos mediante técnicas de encaminamiento y direccionamiento. Zigbee End Device: Es un elemento pasivo de la red, ya que no transmite información de manera autónoma; simplemente dispone de la funcionalidad mínima para ser capaz de responder a peticiones de dispositivos superiores (coordinador o router). Gracias a esto y a la poca memoria que necesita es muy económico. Además, su batería puede durar años debido a que se pasa dormido la mayor parte del tiempo. 2.4.2.3 Topologías de red Zigbee permite tres topologías de red: Pair: La forma más sencilla de la red es con dos nodos. Uno de ellos debe ser un coordinador. El otro puede ser bien un router o bien un end device. Star: En esta topología el coordinador es el centro de la red y es el que se conecta en círculo con los demás dispositivos (End devices). Por lo tanto, todos los mensajes deben pasar por el coordinador. Dos end devices no pueden comunicarse entre sí directamente. Figura 8. Topologías de red. Mesh: La configuración cuenta con nodos router y con un nodo coordinador. Se trata de una topología no jerárquica en el sentido de que cualquier dispositivo puede interactuar con cualquier otro. 16 Este tipo de topología permite que, si en un momento un nodo o camino fallan en la comunicación, ésta pueda seguir rehaciendo los caminos. La gestión de los caminos es tarea del coordinador. Cluster Tree: Es una variación de la topología malla, por lo que no la consideramos realmente como una cuarta topología. En este diseño, los routers forman una columna vertebral con los dispositivos finales, que están agrupados en torno a los routers. De todas las topologías antes analizadas, la más ventajosa y característica del protocolo Zigbee es la Mesh. El poder hacer routing dinámico permite a este tipo de topología ganar sobre todo en fiabilidad en las comunicaciones. Figura 9. Enrutado de topología Mesh. Figura 10. Ventajas de enrutado de topología Mesh. Es adecuado destacar la importancia de actuar como un equipo. En baloncesto los jugadores necesitan coordinarse entre ellos. En Zigbee pasa un poco lo mismo. Los dispositivos pueden conectarse de muchas formas diferentes para dar “fuerza” a la red. 2.4.2.4 Capas de Zigbee Las capas del protocolo Zigbee están basadas en el modelo OSI (Open Systems Interconnection). Aunque el modelo OSI específica siete capas, Zigbee utiliza cuatro capas. 17 La ventaja de dividir un protocolo en capas es que, si el protocolo cambia, es más fácil cambiar una capa que el protocolo entero. Figura 11. Capas del protocolo Zigbee. El estándar Zigbee define sólo las capas de red, aplicación y seguridad, y adopta del estándar IEEE 802.15.4 las capas PHY y MAC. El estándar fue desarrollado por el comité 802 del IEEE y fue inicialmente lanzado en el 2003. Capa PHY Es la capa más cercana al hardware y es donde tiene lugar el control y las comunicaciones del transceptor. Esta capa es la responsable de activar la transmisión y recepción de paquetes del sistema. Además, también selecciona el canal de frecuencia y se asegura que éste no es usado por otros dispositivos de la red. Capa MAC La capa MAC tiene la misión de proveer servicios a las capas superiores para que éstas se encarguen tanto del manejo de los datos que son transferidos en una red WSN como de las primitivas para que un sistema operativo administre estas dos capas (capa física y de enlace de datos). Los servicios que la capa MAC ofrece son dos: • MAC Data Service. • MAC Management Service. 18 Estos dos servicios también son llamados MAC sublayer management entity (MLME) y son accedidos por MAC common part sublayer service access point (MCPSSAP), y la MAC management access point (MLME-SAP) respectivamente. Figura 12. Proceso de asociación. Capa NWK La capa NWK hace de interfaz entre la capa MAC y la capa APL y es la responsable de gestionar la formación de redes y del routing. El routing es el proceso de seleccionar el camino a través del cual el mensaje será lanzado hasta la destinación del dispositivo al que va dirigido. En esta capa se brindan los métodos necesarios para: iniciar la red, unirse a la red, enrutar paquetes dirigidos a otros nodos en la red y proporcionar los medios para garantizar la entrega del paquete al destinatario final. El Zigbee Coordinator y los routers son los responsables de este proceso. El coordinador Zigbee también asigna en la capa NWK las direcciones a los dispositivos en su red. Capa APL Esta es la capa más alta del protocolo en una red inalámbrica Zigbee y alberga los objetos de la aplicación. Los fabricantes creadores de Zigbee desarrollaron esta capa para poder personalizar un mismo dispositivo para varias aplicaciones, por lo que podemos decir que esta capa es la que hace a los dispositivos versátiles. Además, puede haber hasta 240 objetos de aplicación en un único dispositivo. El estándar Zigbee ofrece la opción de utilizar perfiles en el desarrollo de la aplicación. Un perfil de aplicación permite la interoperabilidad entre productos desarrollados por diferentes fabricantes. Por ejemplo, si dos fabricantes utilizan el mismo perfil de aplicación, sus productos serán capaces de interactuar como si hubieran sido fabricados por el mismo fabricante. La capa de aplicación de Zigbee determina varias características de dispositivos, incluyendo la funcionalidad requerida para los dispositivos. La estructura general de la capa se muestra en la figura 14: 19 Figura 13. Descripción de la capa de aplicación. La estructura de la capa de aplicación se divide en dos componentes: descripción de dispositivos y clusters. Por un lado, los clusters son un conjunto de atributos agrupados, cada cluster es un número de 16 bits, llamado “cluster identifier”, que a su vez tiene una pila dónde puede almacenar atributos, tales como el valor actual de temperatura, si el sensor está dormido, etc. Por otro lado, la descripción de dispositivos ofrece información más ligada a Zigbee, tal como si el dispositivo es un Router o un End Device, frecuencia de operación, energía de la batería, etc. Clusters y Device Description agrupados forman la capa de aplicación, que es un número de 16 bits llamado “profile identifier”. La Zigbee Alliance define los “profile identifier” mostrados en la figura 15: 20 Figura 14. Perfiles definidos por la Zigbee Alliance. Además de estos pueden existir perfiles privados definidos por un fabricante determinado. El perfil Smart Energy, por ejemplo, define varios tipos de dispositivos incluyendo un portal de servicios energéticos, pantallas en el hogar, etc., definiendo una funcionalidad requerida para cada dispositivo. 2.4.2.5 Seguridad de red La seguridad en las comunicaciones inalámbricas es una preocupación normal para los consumidores. Éstas las podríamos dividir en dos aspectos: por un lado, la confidencialidad de datos y por otro, la autenticación de datos. Para resolver el problema de la confidencialidad, el estándar IEEE 802.15.4 soporta el uso del Advanced Encryption System (AES), para codificar el mensaje. El AES consiste básicamente en un algoritmo de cifrado que modifica un mensaje con una cadena de bits 21 conocida como la clave de seguridad, y sólo el destinatario será capaz de recuperar el mensaje original. Figura 15. Ejemplo de radio intrusión. Por lo que respecta a la autenticación de datos, en criptografía, un código de autenticación de mensajes (MIC), es una pequeña pieza de información que se utiliza para autenticar un mensaje. 2.4.2.5 Profundidad de red La profundidad de un dispositivo en una red se define como el número mínimo de saltos necesarios para alcanzar el coordinador ZigBee. Por lo tanto, la profundidad máxima de la red es entonces el número de saltos del Coordinador al dispositivo más alejado de la red. Figura 16. Número de capas de un Zigbee. En la figura 17 vemos el número de capas de profundidad ZigBee. En ella vemos como tenemos el coordinador del que dependen los diferentes routers de la red. A la vez, de los routers cuelgan los End Device. Lo que caracteriza una red se determina en realidad por tres parámetros: - La profundidad de red. - El número máximo de “hijos” que un “padre” puede aceptar. - La profundidad que ocupa el dispositivo en la propia red. 22 2.4.3 Coexistencia de redes inalámbricas La tecnología inalámbrica está cada vez más presente en nuestras vidas, con tecnologías como WiFi, Bluetooth, y ahora Zigbee. Todas estas tecnologías operan en la banda de 2.4 GHz. Para el desarrollo de estas tecnologías en el mercado competitivo e innovador de los dispositivos inalámbricos, es crucial la coexistencia pacífica de las tecnologías que permitan a cada usuario cumplir con los objetivos de la comunicación. En este apartado hacemos una evaluación de la coexistencia entre WiFi y Zigbee. En la figura 19 se ve como Zigbee (estándar IEEE 802.15.4), WiFi (estándar 802.11b) y Bluetooth se solapan. El estándar IEEE 802.15.4 divide la banda de 2.4 GHz en 16 canales de 2 MHz de ancho y 5 MHz de separación, tal como se muestra en la figura 18: Figura 17. Espectro de 2.4 GHz del estándar IEEE 802.15.4 Por otro lado, Bluetooth usa 79 canales de 1 MHz cada uno, de forma que tampoco hay solapamiento entre sus canales y la señal que modulan en cada uno de ellos. Figura 18. Coexistencia entre WiFi y Zigbee. 23 Una vía para evitar interferencias puede ser la de seleccionar canales que no se superpongan. En concreto, los canales 15, 16, 21 y 22 del estándar IEEE 802.15.4 no se superponen con los canales 1, 7 y 13 del estándar 802.11b. Por lo tanto, es en estos canales dónde tendríamos la menor interferencia posible con los canales de WiFi. 2.4.4 El futuro de Zigbee Es probable que el rol que Zigbee jugará en el futuro de las comunicaciones vaya creciendo con el tiempo. Zig-bee tiene muchos puntos a su favor como estándar gestionado diseñado para ofrecer robustas características de seguridad, permitir muchos nodos, y soportar interoperabilidad e independencia de los distribuidores. También incorpora características que permiten un rendimiento sobresaliente con un consumo de energía relativamente bajo. Un ejemplo de las aplicaciones con las que puede tener futuro Zigbee puede ser la aplicación que hizo la empresa JPM ingenieros de La Rioja, que desarrolló un sistema para mantener el control de los viñedos mediante redes de sensores Zigbee. Este sistema tiene un coste de implantación muy bajo comparado con la instalación de una estación meteorológica tradicional, que necesita una gran inversión. La hace especialmente adecuada para agricultores con pequeñas extensiones de terreno o para aquellos que las tienen separadas entre sí. Como puntos negativos, sin embargo, podemos decir citar por ejemplo la no interoperabilidad entre fabricantes, lo que va a dificultar mucho una implementación del estándar a gran escala. Además, aunque el protocolo fue lanzado hace ya unos años, todavía no ha tenido el auge que se le esperaba, y hoy en día la mayor parte del negocio Zigbee se centra en kits de desarrollo para ingenieros de RF. Los mercados potenciales son diversos y tienden a ser de un valor total inferior. 24 2.5 Introducción a Arduino La mayor parte de esta sección es una recopilación de la información disponible en la página web del proyecto Arduino y de la entrada de la Wikipedia que hace referencia a Arduino, la otra parte pertenece a la siguiente referencia[6]. 2.5.1 ¿Qué es Arduino? “Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en software y hardware flexibles y fáciles de usar. Se creó para artistas, diseñadores, aficionados y cualquiera interesado en crear entornos u objetos interactivos.”(Página principal de la web del proyecto Arduino [2]). Arduino es una plataforma de hardware libre (Open Source Hardware, OSHW) basada en una placa con un micro-controlador y un entorno de desarrollo. El hardware consiste en una placa con un micro-controlador Atmel AVR y varios puertos de entrada/salida, tanto digitales como analógicos, así como salidas PWM y de comunicaciones, para el control de objetos físicos (LEDs, servos, botones, etc.). Los micro-controladores más usados son el ATmega328 y el ATmega168 para las placas básicas, el ATmega1280 para la de mayor capacidad y el ATmega8 para las placas más antiguas. Todos estos micro-controladores incluyen un cargador de arranque (bootloader) de manera que sea lo más simple posible empezar a trabajar con ellos. El micro-controlador en la placa Arduino se programa mediante el lenguaje de programación Arduino (basado en Wiring[2]). 2.5.2 ¿Qué significa que Arduino sea Open Hardware?[4] El hardware open-source (de fuente abierta o libre) comparte muchos de los principios y metodologías del software libre y de código abierto. Algunos de los principios que se pretenden promover para considerar productos físicos como open hardware son los siguientes: Publicar la documentación, incluyendo los archivos de los diseños mismos, que debe permitir su modificación y distribución. Especificar que porción del diseño es abierta en caso de que no se liberen todos sus componentes. Ofrecer el software para el visionado de los archivos de diseño y de la documentación, para que se pueda escribir el código open-source fácilmente. Ofrecer una licencia que permita producir derivados y modificaciones, además de su re-distribución bajo la licencia original, así como su venta y manufactura. La licencia no debe restringir que se venda o comparta la documentación necesaria. No pide una tarifa por su venta o la de sus derivados. La licencia no debe discriminar a ningún grupo o persona. 25 La licencia no debe de restringir a ningún campo o actividad el uso de la obra. Es decir, no se puede limitar su uso únicamente para negocios o prohibir sea utilizado para investigación nuclear. El licenciamiento de la obra no puede depender de un producto en particular. La licencia no debe restringir otro hardware o software, es decir que no puede insistir en que otros componentes de hardware o software externos a los dispositivos sean también open-source. La licencia tiene que ser neutral, ninguna disposición de la misma debe de basarse en una tecnología específica, parte o componente, material o interfaz para su uso. Cumpliendo con estas premisas, los diseños y esquemas de Arduino se distribuyen bajo licencia “Creative Commons Attribution-ShareAlike 2.5”[5]. Al seguir este tipo de licencias, donde toda la información es pública, todas las placas pueden ser construidas por uno mismo o bien comprarlas ya montadas. El software puede ser descargado de forma gratuita. Los ficheros de diseño de referencia (CAD), al estar disponibles bajo una licencia abierta, pueden ser libremente adaptados a las necesidades particulares. 2.5.3 ¿Por qué Arduino? Hay distintas soluciones comerciales que facilitan el trabajo de programar un micro-controlador y poder interactuar con ellos, como podrían ser Parallax Basic Stamp[6], BX-24 de Netmedia[7], Phidgets[8] o Handyboard del MIT[9] por citar algunos. Arduino, además de simplificar este proceso intenta ofrecer otras ventajas: Asequible - Las placas Arduino son más asequibles comparadas con otras plataformas de micro-controladores. La versión más cara de un módulo de Arduino puede ser montada a mano, e incluso ya montada cuesta bastante menos de 60€ . Multi-Plataforma - El software de Arduino funciona en los sistemas operativos Windows, Macintosh OSX y Linux. La mayoría de los entornos para micro-controladores están limitados a Windows. Entorno de programación simple y directo - El entorno de programación de Arduino es fácil de usar para principiantes y lo suficientemente flexible para los usuarios avanzados. Software ampliable y de código abierto - El software Arduino está publicado bajo una licencia libre, y preparado para ser ampliado por programadores experimentados. El lenguaje puede ampliarse a través de librerías de C++, y si se está interesado en profundizar en los detalles técnicos, se puede dar el salto a la programación en el lenguaje C en el que está basado. De igual modo se puede añadir directamente código en C en los programas. Hardware ampliable y de Código abierto - Arduino está basado en los micro-controladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los planos de los módulos están publicados bajo licencia Creative Commons, por lo que diseñadores de circuitos con experiencia pueden hacer su propia versión del módulo, ampliándolo u 26 optimizándolo. Incluso usuarios relativamente inexpertos pueden construir la versión para placa de desarrollo para entender cómo funciona y ahorrar algo de dinero. 2.6 Las placas Arduino 2.6.1 ¿Qué significa que una placa sea Arduino? Figura 19. Logo oficial de Arduino “Arduino” es el nombre del proyecto “micro-controlador Arduino oficial”, alojado en http://arduino.cc. Aunque el nombre "Arduino" no está oficialmente registrado, generalmente es respetado por la comunidad como propiedad del equipo Arduino. Al tratarse de OSHW existen multitud de proyectos y placas basadas en Arduino que pueden ser totalmente compatibles con este, o que han sufrido ligeras modificaciones, ya sea para hacerlas específicas para ciertos trabajos o bien para reducir su coste. "Freeduino"[10] es un nombre que identifica las variantes del proyecto Arduino que no fueron creadas por el equipo oficial de desarrollo Arduino. Algunos de estos freeduinos serían Boarduino, uDUINO, iDuino, ArduPilot,...[20] 2.6.2 Placas de entradas y salidas Existe una gran variedad de placas Arduino, y de todas ellas se han hecho varias revisiones. Figura 20. En la parte superior Arduino MEGA y en la inferior Arduino UNO Las placas Arduino oficiales a día de hoy son [12]: Arduino UNO. Es una placa Arduino que se conecta al PC a través de un cable USB estándar. 27 A través de esta conexión la alimentación y, además, permite programarla y utilizarla. Arduino UNO es la última revisión de este tipo de placas que se conectan al USB. Entre las múltiples revisiones que se han hecho encontraríamos la Duemilanove, Diecimila, NG (Nuova Generazione) o Extreme. Arduino Mega Es una placa Arduino similar a la USB, pero más grande y potente. La última revisión posee el chip ATmega2560. Tiene mayor número de pines de entradas y salidas digitales, más pines PWM, entradas analógicas, etc. Arduino Mega ADK El Arduino ADK es una placa similar al Arduino Mega, pero con una interface USB para conectar con teléfonos basados en Android. Arduino Pro Es una placa similar al Arduino UNO, pero diseñada con la intención de instalaciones semipermanentes. La placa se entrega sin los distintos conectores o “headers”, es compatible con las distintas extensiones de Arduino, y existe una versión de 3.3V para ser alimentado con baterías. Arduino Ethernet Similar al Arduino UNO, sin soporte USB, pero con un conector RJ-45 para dar soporte Ethernet. Existe la posibilidad de tomar la alimentación de la propia Ethernet. Arduino Fio Un Arduino orientado para usarlo como nodo inalámbrico. Posee conectores para un módulo Xbee (módulo inalámbrico)[13], un conector para una batería LiPo (Polímeros de litio), y un circuito para cargar la batería. Arduino LilyPad Una placa Arduino circular, reducida al máximo, diseñada para ser cosida a la ropa o a otro tipo de soporte flexible. Necesita un adaptador adicional para comunicarse con el PC. Arduino BT El Arduino BT contiene un módulo bluetooth integrado para las comunicaciones móviles. Arduino Nano El Arduino Nano es un todo-en-uno, diseño compacto para usar en una placa de prototipo. Arduino Serial 28 Las versiones serial de Arduino se vendieron principalmente como kits no ensamblados o solo PCBs para que lo montara uno mismo, ya sea a modo de aprendizaje o para reducir costes. Arduino Mini El Arduino Mini es la placa compacta de Arduino. Para reducir espacio, la comunicación con el PC se hace a través de un adaptador de USB a Arduino Mini. Arduino Pro Mini Igual que el Arduino Mini, pero sin los “headers” ni lo conectores montados, con la intención de tenerlo en instalaciones semipermanentes o permanentes. Arduino Single-Sided Serial También conocido como "Severino". Esta es la versión de la placa Arduino de una sola cara, haciéndola fácil de hacer a mano. No fue manufacturada, sino que fue publicada en la web de Arduino para que la gente se la pudiese hacer ellos mismos a modo de aprendizaje de todo el proceso de grabación de PCB. El objetivo de Arduino y sus placas es ofrecer a la gente la posibilidad de seguir la filosofía DIY (Do it yourself). 2.6.3 "Shields" y otras placas de terceros Las shields son placas que se colocan encima de la placa Arduino y que amplían una nueva función para que sea controlada desde Arduino, para controlar diferentes aparatos, adquirir datos, etc. Figura 21. Arduino con tres "shields" A continuación se citan las shields oficiales de Arduino, pero existe multitud de shields de terceros. Arduino Ethernet Shield Esta shield permite a una placa Arduino conectarse a una red Ethernet y tener acceso a y desde Internet. Arduino Wireless Proto Shield 29 Esta shield le da a una placa Arduino la posibilidad de comunicarse de manera inalámbrica basándose en los módulos Xbee[13], y ofrece al usuario una pequeña área para soldar componentes (prototipage). Arduino Wireless SD Shield Igual que la anterior, pero dando soporte para acceder a una tarjeta de memoria tipo SD. Arduino Motor Shield Esta shield permite a Arduino controlar motores eléctricos de corriente continua, servos y motores paso a paso, y leer encoders. Arduino Proto Shield Esta shield ofrece al usuario un área para soldar componentes. Uno de los principales distribuidores y desarrolladores de shields es Sparkfun, aunque no el único. Esta página web “http://shieldlist.org/” intenta mantener una lista de todas las shields de Arduino, tanto las oficiales como las no oficiales. A parte de las shields existe un buen número de plataformas que están listas para ser controladas por una placa Arduino. Entre estas plataformas, quizás una de las más vistosas seria: RobotShop Rover Es una pequeña plataforma móvil diseñada entorno a Arduino. Los usuarios pueden personalizar su móvil añadiendo funcionalidad. Figura 22. RobotShop Rover 2.6.4 Construir nuestro propio Arduino Al ser OSHW puede montarse los distintos módulos uno mismo. La placa Arduino Single-Sided Serial (cara simple y mono capa) o Severino ha sido diseñada para que sea especialmente fácil de grabar el PCB y montar los distintos componentes. 30 Figura 23. Arduino Single-Sided Serial o Severino Se puede encontrar una extensa documentación, incluyendo un detallado manual, en la página web oficial [21]. 2.6.5 ¿Cómo obtener una placa Arduino? Se puede adquirir una placa Arduino desde uno de los distribuidores oficiales, o a través de múltiples tiendas online de electrónica. En la página principal de Arduino se puede encontrar una extensa lista de distribuidores en función del país o región. Después de evaluar la mayoría de ellos por variedad, disponibilidad, precio y gastos de envío, me inclino por recomendar las siguientes: Tienda BricoGeek.com [24] ELECTAN Electrónica y Robótica [25] 2.6.6 Elección de placa Arduino: El Arduino UNO 2.6.6.1 El porqué de la elección Uno de los principales objetivos de este proyecto es evaluar las capacidades de Arduino a través de la realización de un pequeño proyecto. Para lograr este objetivo se debía trabajar con un módulo real, pero no era el caso de estudio el montaje ni la depuración de los posibles errores del hardware, con lo que se optó por la compra de módulo ya montado. Como punto de partida, teniendo en cuenta que no necesitábamos gran cantidad de entradas y salidas, se decidió usar una placa Arduino que tuviera todo lo necesario para empezar a trabajar al coste más acotado posible. La actual revisión que mejor encaja con estas características es el Arduino UNO. 31 Figura 24. Arduino UNO, vista frontal Figura 25. Arduino UNO, vista trasera 2.6.6.2 Características La descripción completa del Arduino UNO se puede encontrar en su página web oficial. Este es un resumen de las principales características: Micro controlador ATmega328 Voltaje de funcionamiento 5V Voltaje de entrada (recomendado) 7-12V Voltaje de entrada (limite) 6-20V Pines E/S digitales 14 (6 proporcionan salida PWM) Pines de entrada analógica 6 Intensidad máxima por pin 40 mA Intensidad en pin 3.3V 50 mA Memoria Flash 32 KB (ATmega328) de las cuales 0,5 KB las usa el gestor de arranque (boot loader) SRAM 2 KB (ATmega328) EEPROM 1 KB (ATmega328) Velocidad de reloj 16 Mhz El Arduino UNO puede ser alimentado vía la conexión USB o con una fuente de alimentación externa. El origen de la alimentación se selecciona automáticamente. Además, algunos de los pines tienen funciones especializadas: Serie: Pin 0 (RX) y 1 (TX). Usados para recibir (RX) y transmitir (TX) datos a través de puerto serie TTL. Estos pines están conectados a los pines correspondientes del chip de FTDI responsable de la conversión USB-toTTL. Interrupciones Externas: Pin 2 y 3. Estos pines se pueden configurar para que interrumpan la ejecución del programa al detectar un flanco o un nivel. PWM: Pin 3, 5, 6, 9, 10, y 11. Proporciona una salida PWM (Pulse-width 32 modulation, modulación por ancho de pulsos) con temporizadores de 8 bits de resolución. SPI: Pin 10 (CS/SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines proporcionan comunicación SPI (Serial Peripheral Interface). LED: Pin 13. Hay un LED integrado en la placa conectado al pin digital 13, cuando este pin tiene un valor HIGH(5V) el LED se enciende y cuando este tiene un valor LOW(0V) el LED se apaga. 6 entradas analógicas, cada una de ellas proporciona una resolución de 10bits (1024 valores). Por defecto se mide de tierra a 5 voltios, aunque es posible cambiar la cota superior de este rango usando el pin AREF. I2C: Pin 4 (SDA) y 5 (SCL). Soporte del protocolo de comunicaciones I2C /TWI. AREF. Este pin proporciona un voltaje de referencia para las entradas analógicas. Reset. Si en este pin se suministra un valor bajo (0V) se reinicia el microcontrolador. El ATmega328 en las placas Arduino UNO viene precargado con un gestor de arranque (boot loader) que permite cargar nuevo código sin necesidad de un programador por hardware externo. La carga de un nuevo código se realiza a través del entorno de desarrollo Arduino y la conexión serie/USB. También es posible saltar el gestor de arranque y programar directamente el microcontrolador a través del puerto ICSP (In Circuit Serial Programming). En tal caso, se debe utilizar un programador externo. 2.6.6.3 Esquema y pines Los esquemas completos del Arduino UNO se pueden encontrar en su página web oficial. En la siguiente imagen se puede ver la correspondencia de pines entre el ATmega168/328 y Arduino. 33 Figura 26. Pines de Arduino contra ATmega328 2.7 El entorno de trabajo Para empezar a trabajar debemos instalar todo el entorno necesario en el PC. Vamos a describir brevemente este proceso en un entorno Windows. Existe gran cantidad de guías acerca de cómo realizar este proceso, incluyendo una explicación en la propia página del proyecto Arduino[22]. Debo indicar que este proyecto se ha realizado con la versión 1.0 del entorno de programación Arduino. Esta es la primera versión no “Alfa” del entorno Arduino, y presenta grandes cambios en comparación de las anteriores. La mayoría de cambios son a nivel estético (distribución de iconos en las barra de herramientas, esquema de colores,…), pero hay un gran cambio a nivel funcional, los ficheros Arduino han pasado de tener extensión .pde a extensión .ino Estos últimos cambios implican que la mayor parte de la documentación que se encuentra en internet a día de hoy es incorrecta o desfasada con la revisión actual del entorno software de Arduino. 2.7.1 El entorno de desarrollo y los drivers de la placa para Windows La descarga: Descargamos la última versión del software Arduino de la página oficial [26]. El paquete de software Arduino está contenido en un único fichero comprimido. No es necesario instalarlo, simplemente lo extraemos en la carpeta deseada asegurándonos que mantenemos la estructura de subcarpetas. Los controladores (drivers): Seguiremos instalando los drivers de nuestro Arduino. Para realizar este paso necesitaremos conectar el Arduino a nuestro PC, simplemente con un cable USB tipo A-B (el comúnmente usado por las impresoras). Los drivers necesarios para utilizar la placa Arduino junto con su entorno se encuentran en la subcarpeta “\drivers” del paquete que acabamos de extraer. Una vez conectemos nuestra placa Arduino en nuestro PC, deberemos indicarle a Windows que debe buscarlos en esta carpeta. Dependiendo de la versión de Windows usada, y de la variante de la placa Arduino, este proceso puede variar e incluso no funcionar del modo esperado (especialmente Windows 7). En tal caso, nos dirigimos al “Administrador de dispositivos” y veremos algo parecido a esto: 34 Figura 27. Arduino en el administrador de dispositivos de Windows En este caso, nos dirigiremos al dispositivo desconocido, el Arduino Uno. Con el botón derecho actualizaremos el software del controlador indicándole la ruta donde hemos extraído el software de Arduino\drivers. Deberemos aceptar la advertencia de que este software no está firmado por Microsoft. Una vez finalizado este proceso, deberíamos ver un nuevo puerto de comunicaciones, en nuestro caso el COM3, que será nuestro Arduino, ya que este driver se comporta como un puerto serie en el PC, con lo que nos añade uno nuevo sobre el último. El IDE (“Integrated Development Environment” o "entorno de desarrollo integrado"): Ya tenemos nuestro PC y nuestra placa Arduino listos para trabajar. En la raíz de la carpeta donde hemos extraído el software Arduino deberíamos encontrar un “arduino.exe”, lo ejecutamos y nos abrirá el entorno de trabajo: el IDE. Para facilitar futuros accesos podemos crear un “acceso directo”. Una vez abierto el entorno Arduino se debería ver algo como esto: 35 Figura 28. Entorno SW de Arduino Antes que nada debemos saber que un “sketch”, o boceto, es el nombre que usa Arduino para un programa. Es la unidad de código que se sube y se ejecuta en la placa Arduino. El concepto de sketch o boceto, sería el equivalente a proyecto. Un “sketch” puede contener múltiples archivos (pestañas). Cuando un sketch es compilado, todas las pestañas serán concatenadas juntas para formar el archivo principal del sketch. Arduino puede utilizar librerías y código C/C++. Las pestañas .c o .cpp se compilaran por separado y deberán ser incluidas en el sketch usando #include. Es importante configurar correctamente la placa Arduino que vamos a utilizar, y a través de qué puerto de comunicaciones estará conectada. Para tal efecto, debemos ir al menú “Tools” escoger el submenú “Board” e indicar la placa que usaremos, en nuestro caso “Arduino Uno”. En el mismo menú “Tools”, submenú ”Serial Port”, seleccionaremos el puerto correspondiente, en nuestro caso “COM3”. La barra de herramientas nos proporciona un acceso rápido a las siguientes funciones: 36 2.7.2 Descargar y ejecutar un ejemplo de aplicación Arduino Tenemos conectado la placa Arduino en nuestro PC. Hemos instalado los drivers y ejecutado el IDE de Arduino. Conocemos los conceptos básicos acerca de los bocetos de Arduino. Verifiquemos ahora que nuestra placa y el PC funcionan correctamente. 2.7.2.1 Editor En el IDE Arduino, seleccionaremos el menú “File”, submenú “Examples” (o bien directamente, el icono “Open ”) y dentro de “1.Basics” seleccionaremos el boceto (“sketch”) “Blink”. 37 Figura 29. Acceso a los ejemplos a través del menú Figura 30. Acceso a los ejemplos a través de la barra de herramientas Esto nos abrirá una nueva ventana con el código de este boceto, el objetivo del cual no es más que encender y apagar el LED de test, montado en la placa Arduino, cada segundo (secuencia infinita de un segundo encendido, un segundo apagando. Blink). 38 Figura 31. Ejemplo de código Arduino 2.7.2.2 Compilador Como se puede observar en la “Ilustración 13: Ejemplo de código Arduino“, el código necesario para realizar tal acción es bastante simple. Ahora solo falta comprobar que realmente es correcto. Para tal cosa, simplemente pulsando sobre el icono “Verify” , el IDE de Arduino va a verificar y compilar el código escrito en la ventana activa. El entorno Arduino siempre compila el código de las pestañas de la ventana activa como un único boceto. El resultado debería ser correcto y lo veremos en el “área de estado” o de “notificaciones”: Aquí nos indica el estado del proceso, el tamaño de memoria usada y la disponible en la placa Arduino. Figura 32. Resultado de verificación correcto. 39 Si modificamos el código del ejemplo para forzar un error en la fase de verificación/compilación, nos encontraríamos con esto: Figura 32. Resultado de verificación incorrecto. Hemos remplazado la llamada a la función “PinMode” por “PinModo”, y hemos eliminado el “;” del final de la llamada a la función “delay(1000)”. Al compilar, el entorno Arduino nos advierte de estos errores en la zona de estado, indicando los errores detectados, así como las líneas en que se encuentran. 2.7.2.3 Cargar y depurar Si volvemos al código original, y lo compilamos, ya solo nos falta un paso para poder probarlo en nuestra placa Arduino: Cargar el código. Con la placa Arduino conectada al PC a través del puerto USB, y teniendo configurado correctamente en el entorno nuestra placa Arduino y el puerto de comunicaciones, pulsaremos sobre el icono “Upload”. En breves instante, la barra de estado se completará y nos indicará que el proceso ha finalizado. En ese momento, el entorno genera un “reset” a la placa Arduino, y el código empieza a ejecutarse. En nuestro caso, veremos como el LED de test montado en la placa Arduino empieza a encenderse y apagarse cada segundo. Para poder depurar el código, y así ver en qué punto de la ejecución se encuentra, Arduino nos brinda un gran herramienta: el “monitor serie”. El monitor serie sirve para que nos podamos comunicar entre el PC y nuestra placa Arduino. Las posibilidades de este pueden ser enormes, pero de momento lo usaremos de la forma más simple posible. Modificaremos el código del ejemplo de “Blink” añadiendo unas llamadas al monitor serie, de manera que durante la ejecución podremos ver en el PC qué punto del código se está ejecutando en la placa Arduino. Código “Blink” original Código “Blink” con depuración a través del monitor serie. void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(1000); 40 } void setup() { pinMode(13, OUTPUT); Serial.begin(9600); } void loop() { digitalWrite(13, HIGH); Serial.println(HIGH); delay(1000); digitalWrite(13, LOW); Serial.println(LOW); delay(1000); } Compilamos y cargamos el código de nuevo, y ahora pulsamos sobre el icono del “serial monitor”. Esto nos ha abierto el monitor serie y, en él, podemos ver como escribe un “1” o un “0” al ejecutar la función correspondiente. Figura 33. Monitor de comunicación serie integrado en el entorno Arduino 2.7.2.4 Compilar con Atmel AVRISP mkII Figura 34. Compilador Atmel AVRISP mkII conectado a Arduino 41 Esta herramienta se utiliza para las actualizaciones de los microcontroladores Atmel 8 bits AVR, con interfaz ISP o PDI. Utilizando el software incluido AVR Studio ®, los diseñadores pueden programar dispositivos megaAVR utilizando la interfaz del proveedor de Internet, los dispositivos tinyAVR utilizando la interfaz de TPI y dispositivos XMEGA AVR utilizando la interfaz de PDI y tiny AVR. La ayuda en línea de AVR Studio contiene la información más actual y una lista completa de los dispositivos compatibles. Es la herramienta utilizada por nosotros para cargar el software a nuestro microcontrolador “Atmega328P-AU”, situado en la placa base del módulo “End Device”, utilizando el siguiente conector, y conectando los pines al micro anteriormente citado: Figura 35. Conector donde acoplaremos compilador AVRISP mkII. A continuación vemos como se clasifica cada pin del conector para programación: Figura 36. Pines de conexión en conector ISP 6 pin. 42 Antes de cargar el software, debemos seleccionar el compilador utilizado en “Tools”, como vemos seguidamente, a la vez que hay que seleccionar “Cargar usando programador” en el momento de compilar: Figura 37. Entorno Arduino para seleccionador compilador. 2.8 Lenguaje de programación Arduino 2.8.1 Introducción e historia La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en el lenguaje de programación de alto nivel Processing[3], este a su vez está basado en Java. El compilador usado por la plataforma de Arduino es el GNU AVR, bajo Windows es el WinAVR [27]. Este compilador está dedicado para los procesadores AVR y está configurado para compilar C y C++. Las librerías del estándar C implementadas en este compilador son avr-libc[15] y están optimizadas para los procesadores AVR. 43 Adicionalmente Arduino tiene un gran conjunto de funciones ya implementadas para realizar de un modo fácil tareas comunes como hacer una espera activa, leer un puerto digital o escribir en él, entre muchas otras. 2.8.2 Funciones básicas y operadores Todo programa Arduino debe contener, de manera obligatoria, al menos dos funciones básica: setup() y loop(). La función setup() se ejecuta cuando se inicia un boceto (el programa o sketch). Se emplea para iniciar variables, establecer el estado de las entradas y salidas, inicializar librerías, etc. Esta función se ejecutará una única vez después de que se conecte la placa Arduino a la fuente de alimentación, o cuando se pulse el botón de reinicio de la placa. Después de ejecutar la función setup(), la función loop() se ejecuta de manera consecutiva e ininterrumpida. Cuando se llega al final de esta función, se vuelve a ejecutar desde el principio hasta que se vuelva a reiniciar la placa. En el interior de esta función es donde se pone el código para controlar de forma activa la placa Arduino. Los siguientes subapartados tienen el objetivo de dar una visión rápida acerca del lenguaje de programación Arduino, pero no se pretende entrar en el detalle del lenguaje de programación. Para tal efecto hay multitud de manuales disponibles por la red, entre ellos y por citar algunos: Página de referencia del lenguaje del proyecto Arduino [28] Sección de tutoriales de TronixStuff [29] Manual del “Starter Kit” de Earthshine Electronics. [30] 2.8.2.1 Estructuras Al estar basado en Processing, Java y/o C, las estructuras de control son muy similares a ellos y entre ellos. Sintaxis básica ; (punto y coma. Delimitador de línea de código) {} (llaves. Delimitador de bloques de código) // (comentarios en una línea) /* */ (comentarios en múltiples líneas) #define (definición de precompilador) #include (inclusión de código externo) Estructuras de control if (comparador si-entonces) if...else (comparador si...si no) for (bucle con contador) switch case (comparador múltiple) while (bucle por comparación booleana) 44 do... while (bucle por comparación booleana) break (salida de bloque de código) continue (continuación en bloque de código) return (devuelve valor a programa) goto (salta a una etiqueta) Operadores Aritméticos = (asignación) + (suma) - (resta) * (multiplicación) / (división) % (resto) ++ (incremento en uno) -- (decremento en uno) += (suma y asignación) -= (resta y asignación) *= (multiplicación y asignación) /= (división y asignación) Operadores de comparación == (igual a) != (distinto de) < (menor que) > (mayor que) <= (menor o igual que) >= (mayor o igual que) Operadores Booleanos && (y) || (o) ! (negación) Operadores de acceso a punteros * operador de indirección & operador de referencia Operaciones a nivel de bits & (and - 'y' a nivel de bits) | (or - 'o' a nivel de bits) ^ (xor a nivel de bits) ~ (not a nivel de bits) << (desplazamiento de bits a la izquierda) >> (desplazamiento de bits a la derecha) &= (and - 'y' a nivel de bits y asignación) |= (or - 'o' a nivel de bits y asignación) 45 2.8.2.2 Variables Los tipos de los datos, su uso y declaración, es muy similar a otros lenguajes de programación, como el C o Java. Constantes Las constantes que vienen predefinidas en el lenguaje de Arduino se usan para facilitar la lectura de los programas. HIGH | LOW (estado de un pin de E/S digital) INPUT | OUTPUT (comportamiento de un pin de E/S digital) true | false (estado de un resultado lógico) Tipos de Datos Las variables pueden ser declaradas en cualquier punto del programa y, si no se indica lo contrario, valen cero. boolean (Booleano. Puede ser cierto o falso. Ocupa 8 bits en memoria) char (Carácter. Almacena un único ASCII, tiene signo y ocupa 8 bits en memoria) unsigned char (Carácter sin signo). byte (Dato de 8 bits, sin signo) int (Entero de 16 bits, con signo) unsigned int (Entero de 16 bits, sin signo) word (Palabra. Equivalente a unsigned int) long (Entero de 32 bits con signo) unsigned long (Entero de 32 bits sin signo) float (Valor en coma flotante de 32 bits. Se debe evitar usar estos tipos ya que consumen mucho tiempo de CPU, espacio de código y pueden ocasionar problemas en comparaciones, ya que por ejemplo 6.0 dividido por 3.0 puede no ser igual a 2.0 1) double (En Arduino, es lo mismo que float) array (Vector de elementos) void (Vacío) String (Des de la versión 0019 existe la clase String() que permite manipular cadenas de caracteres de un modo sencillo, permitiendo concatenaciones o gestión automática del fin de cadena. Hasta ese momento el uso de string se limitaba a vectores de caracteres sobre los cuales se debía tener en cuenta el final de cadena /0 para poder usarlo con funciones tipo print()). Se debe tener en cuenta que el uso de float se realiza a través de librerías sw, y que además la propia codificación IEEE-754 que usa el tipo float tiene limitaciones. 1 Conversión Estas son una serie de funciones que permiten el cambio entre tipos. char(x) – Convierte el valor de tipo x a carácter. byte(x) – Convierte el valor de tipo x a byte. int(x) – Convierte el valor de tipo x a int. 46 long(x) – Convierte el valor de tipo x a long. float(x) – Convierte el valor de tipo x a float. Ámbito de las variables y calificadores Las variables en el lenguaje de programación usado por Arduino, al igual que el C, tienen una propiedad llamada ámbito. Al contrario de lo que pasa en lenguajes como BASIC en los que todas las variables son globales. En Arduino solo las declaradas fuera de una función son globales. En el caso de declararse dentro de una sección de código delimitada por llaves “{…}”, como el caso de una función, la variable se libera al salir de esta sección y se vuelve a crear con el valor inicial al volver a entrar en esta sección. Esto se debe tener especialmente en cuenta al declarar variables dentro de la función loop(). static – Estática – Las variables que se declaran como estáticas sólo se crearan e inicializarán la primera vez que se ejecute el bloque de código en el que están contenidas. volatile – Volátil – Una variable debe ser declarada volatile siempre que su valor pueda ser modificado por algo más allá de la sección del código en el que aparece. En Arduino, el único lugar en el que se podría dar el caso es en secciones de código asociadas a interrupciones. const – Constante – Es un calificador de variable que modifica el comportamiento de la misma, haciendo una variable de "sólo-lectura". Sería equivalente a utilizar #define. 2.8.2.3 Funciones Aquí se muestran muchas funciones ya implementadas en el entorno Arduino para simplificar la tarea de desarrollo para problemas comunes. Muchas de ellas están limitadas a ser usadas en pines concretos y pueden necesitar de argumentos que no se detallan en este apartado. Para información adicional se puede consultar la página de referencia del lenguaje del proyecto Arduino [28]. E/S Digital pinMode(pin, modo) – configura el pin a modo de entrada o salida digitalWrite(pin, valor) - escritura digital digitalRead(pin) – devuelve una lectura digital E/S Analógica analogReference(tipo) – configura el tipo de referencia analógica analogRead(pin) – devuelve una lectura analógica analogWrite(pin, valor) – “escritura analógica”. Generará una onda cuadrada con el ciclo de trabajo que se le indique como parámetro (0-255 implica un ciclo de trabajo de 0 a 100%). La frecuencia de la señal PWM será de 490 Hz por diseño de Arduino. Proporciona una manera simple de implementar un control de intensidad luminosa sobre un LED. 47 E/S Avanzada tone(pin, frecuencia) - Genera una onda cuadrada de la frecuencia en Hz especificada. Opcionalmente se puede definir la duración del tono en ms. noTone(pin) – Deja de generar el tono en el pin especificado shiftOut(pinDatos, pinReloj, ordenBits, valor) - Desplaza un byte de datos bit a bit a través del SPI. pulseIn(pin, value) - Devuelve la anchura de un pulso en microsegundos empezando a medir cuando el pin se encuentra al nivel definido en value. Tiempo millis(). Tiempo des del arranque en ms. micros(). Tiempo des del arranque en us. delay(ms). Espera activa en ms. delayMicroseconds(us). Espera activa en us. Cálculo min(x, y) – Devuelve el mínimo de dos números. max(x, y) – Devuelve el máximo de dos números. abs(x) - Devuelve el valor absoluto constrain(x, a, b) – Devuelve x siempre que este entre a y b. En caso contrario devuelve los límites a o b. map(value, fromLow, fromHigh, toLow, toHigh) – Devuelve el valor de un “re-mapeo” de un rango hacia otro. Por ejemplo para realizar un cambio de escala de un valor de 0 a 1024 a un rango de 0 a 255. pow(base, exponente) – Devuelve el valor de un número elevado a otro número. sqrt(x) – Devuelve la raíz cuadrada Trigonometría sin(rad) – Devuelve el seno cos(rad) - Devuelve el coseno tan(rad) - Devuelve la tangente Números aleatorios randomSeed(seed) – Inicializa el generador de números pseudoaleatorios. Se puede usar como semilla una entrada mínimamente aleatoria como analogRead() en un pin desconectado. random() – Devuelve un valor pseudoaleatorio. Bits y Bytes lowByte(x) – Devuelve el byte de menor peso (big-endian, el de más al derecha) de una variable highByte(x) - Devuelve el byte de mayor peso (big-endian, el de más al izquierda) de una variable bitRead(x, n) – Devuelve el valor del bit n en x. bitWrite(x, n, b) – Escribe b en el bit n de x. bitSet(x, n) – Pone a 1 el bit n de x. 48 bitClear(x, n) – Pone a 0 el bit n de x. bit(n) – Devuelve un byte con sus bits a cero a excepción del bit n. Por ejemplo, bit(0) devolvería un 1 en decimal, bit(1) un 2, bit(2) un 4 en decimal. Interrupciones externas attachInterrupt(inter, funcion, modo) – Con el parámetro inter indicamos que ISR externa vamos a configurar. Con el parámetro modo indicamos el motivo que la va a disparar (CHANGE, LOW, RISING o FALLING) y con el parámetro función, la función que va a ejecutarse al ser disparada. detachInterrupt(inter) – Desactiva la interrupción inter Interrupciones interrupts() - Habilita las interrupciones noInterrupts() - Desactiva las interrupciones Comunicación (estas dos son clases, con lo que no se pueden invocar directamente, sino que se debe invocar el método que necesitemos) Serial Stream 2.8.3 Uso de librerías El propio entorno Arduino contiene una serie de librerías integradas que facilitan enormemente las tareas más comunes en el mundo del “hobby electrónico”. Las Librerías proveen funcionalidad extra a nuestro sketch al trabajar con hardware o al manipular datos. Para usar una librería dentro de un sketch, puedes seleccionarla desde Sketch > Import Library (Importar Librería)[16]. 2.8.3.1 Librerías Estándar EEPROM - Para leer y escribir en memorias "permanentes". Ethernet - Para conectarse a una red usando el shield Ethernet. Firmata – Para comunicarse con aplicaciones en un PC que se comporta como servidor (host) usando el protocolo Firmata. LiquidCrystal - Para controlar Displays de cristal líquido (LCD) Servo - Para controlar servomotores. SoftwareSerial - Para la comunicación seria utilizando cualquier pin digital. Stepper - Para controlar motores paso a paso (Stepper motors). 49 Wire - Interfaz de dos cables, ó Two Wire Interface (TWI/I2C), para enviar y recibir datos a través de una red de dispositivos y sensores. 2.8.3.2 Librerías de terceros Si se desean usar librerías que no vienen junto con Arduino, es necesario instalarlas. Las librerías suelen entregarse en un fichero comprimido y suelen contener una carpeta propia con dos archivos, uno con sufijo ".h" y otro con sufijo ".cpp". Para instalarla se debe copiar el contenido del fichero comprimido en la carpeta “libraries” que se debería encontrar dentro de la carpeta sketchbook de Arduino. Al reiniciar el IDE de Arduino debería aparecer la nueva librería en el menú Sketch > Import Library. Estas son algunas de las librerías que se pueden encontrar y que están referenciadas en la propia página web del proyecto Arduino [16]. También se puede encontrar una lista alternativa en la Wiki de Arduino [31]. Comunicación (networking y protocolos): Messenger - Para procesar mensajes de texto mandados des del PC. NewSoftSerial - Versión mejorada de la librería SoftwareSerial. OneWire - Controla dispositivos (de Dallas Semiconductor) que usan el protocolo One Wire. PS2Keyboard - Lee caracteres de un teclado PS2. Simple Message System - Envía mensajes entre Arduino y la computadora. SSerial2Mobile - Envía mensajes de texto o emails usando un teléfono móvil (vía comandos AT a través de SoftwareSerial) Webduino - Librería de web server extensible (para usar con Arduino Ethernet Shield) X10 - Para enviar señales X10 a través de líneas de corriente AC. XBee - Para comunicaciones entre XBees en modo API. SerialControl - Para controlar remotamente otras Arduino a través de una conexión serial. Sensores: Capacitive Sensing – Implementa un sensor táctil capacitivo uniendo un pin de escritura con una resistencia relativamente alta (100kOhm – 50MOhm), una lamina de metal o cable y un condensador pequeño (20 - 400 pF) a un pin de lectura, detectando cambios en este al acercarse o tocar la lámina con el dedo. Debounce - Para una lectura filtrada de entradas digitales con rebotes (típicamente las entradas conectadas a botones). Displays y LEDs: Improved LCD library - Arregla errores de inicialización del LCD de la librería LCD oficial de Arduino. GLCD - Rutinas gráficas para LCDs basados en el chipset KS0108 o equivalentes. 50 LedControl - Para controlar matrices de LEDs o displays de siete segmentos con MAX7221 o MAX7219. LedDisplay - Control para marquesina de LED HCMS-29xx. Matrix - Librería para manipular displays de matrices de LED básicas. Sprite - Librería básica para manipulación de sprites para usar en animaciones con matrices de LEDs. Motores y PWM: TLC5940 - Manejador para el chip TLC5940 de Texas Instruments implementando el control de hasta 16 servomotores a la vez. Medición de Tiempo: DateTime - Librería para llevar registro de fecha y hora actual en el software. Metro - Útil para cronometrar acciones en intervalos regulares. MsTimer2 - Utiliza la interrupción del temporizador 2 para disparar una acción cada N milisegundos. Utilidades de cadenas de texto: TextString, PString, Streaming – Implementan métodos de salida más completos para cadenas de texto. Adicionalmente, muchos de los desarrolladores y distribuidores de shields generan sus propias librerías para utilizar las shields, de modo que la cantidad de librerías disponibles es enrome. Además, nosotros podemos crear nuestras propias librerías y utilizarlas para nuestros proyectos e incluso distribuirlas. A raíz del cambio mayor de versión (de alfa a 1.0) en el entorno de programación Arduino, muchas de las librerías de terceros han quedado obsoletas/desactualizadas por la inclusión de ficheros de encabezados (.h) que han sido renombrados en esta nueva versión, entre ellos “Wprogram.h” ha sido renombrado a “Arduino.h”, con lo que nos obligará a modificar el código de estas librerías incluyendo el nuevo fichero. 51 Sección 3: Memoria descriptiva 3.1 Hardware: Componentes de un sensor inalámbrico Para la construcción de un sensor inalámbrico deberemos conectar nuestro sensor a un módulo Xbee, que a su vez deberá tener una alimentación. Figura 38. Conexión Sensor y modulo Xbee. 3.1.1 Antenas y transceptores Zigbee La elección de la antena para la implementación del proyecto resulta clave. El criterio que elijamos depende de múltiples factores tales como el precio, ya que no podemos justificar pagar más por módulos que no ofrecen características ventajosas respecto a otros más baratos, pero también de la facilidad que ofrezcan al programar porque nos facilitará enormemente el desarrollo del proyecto. Otro aspecto también puede ser cuán aceptados están en el mercado. Estos dos últimos factores – grado de aceptación en el mercado y facilidad de programación-, los podemos verificar fácilmente discutiendo en foros de internet con usuarios con experiencia. En este apartado abordamos la elección de nuestra antena, evaluando algunos de los módulos Zigbee disponibles en el mercado en la actualidad. Cirronet ZMN2405/HP: Este es un módulo que ya ha sido utilizado en otros proyectos desarrollados en la escuela, por lo que el departamento conoce este dispositivo. Las ventajas son la experiencia previa del departamento con el dispositivo y la integración de un puerto USB. La principal desventaja es la dificultad que supone programar el módulo. Figura 39. Módulo ZMN2405-E. Jennic: Este fabricante dispone de dos familias de módulos, el JN5121 y el actual JN5139. Comparado con otros módulos, ofrecen más periféricos y mayor sensibilidad. En cuanto a los precios, el kit de programación cuesta unos 580 € dependiendo de dónde compremos. 52 Xbee: La principal ventaja de este módulo es el precio, que es el más barato de todos – al no ser necesaria la compra de un kit de desarrollo-, además también es el más extendido entre el público, lo que da la posibilidad de poder conseguir y compartir mucha información con usuarios. Como desventajas, en cambio, no dispone de microcontrolador. Tabla 4. Comparación entre módulos. *Precios basados en http://es.farnell.com/ y http://search.digikey.com Finalmente decidimos hacer el proyecto con las Xbee Pro, ya que aunque son más limitadas técnicamente por no disponer de micro-controlador, son mucho económicas al no necesitar un kit de desarrollo para poderlas programar (el software para programarlas es gratuito desde la página http://www.digi.com/es/. Además hemos comprobado que en Internet hay mucha bibliografía e información en foros, etc. El inconveniente del Xbee PRO es el mayor consumo en transmisión, siendo de 295 mA, mientras que en los otros módulos no pasa de 34 mA. El consumo en Tx depende de la potencia de salida, siendo de -10 dB en módulos de bajo consumo/corta distancia) 3.1.1.1 Módulos Xbee Los módulos Xbee son fabricados por la empresa Digi, proporcionan conectividad inalámbrica con otro dispositivo de la misma serie por un precio relativamente económico comparado con el de otros fabricantes. Digi ofrece dos series diferentes, la serie 1 y la serie 2, también conocida como Znet 2.5. Los módulos de la Serie 1 y la Serie 2 tienen el mismo pin-out, sin embargo no son compatibles entre sí ya que utilizan distintos chipset y trabajan con protocolos diferentes. La serie 1 está basada en el chipset de Freescale y está pensado para ser utilizado en redes punto a punto y punto a multipunto. Los módulos de la Serie 2 están basados en el chipset 53 de Ember, y están diseñados para ser utilizados en aplicaciones que requieren repetidores o una red mesh. Ambos módulos pueden ser utilizados en los modos AT y API. Con estos módulos se pueden diseñar aplicaciones de comunicación inalámbrica de bajo consumo energético, como las requeridas por el proyecto en el que nos embarcamos. La figura 22 ilustra cómo fluyen los bits de datos a través del módulo Xbee. Figura 40. Conexiones mínimas para conectar Xbee. Los datos entran en el módulo UART a través de la patilla DIN (pin 3) como una señal asíncrona y se almacenan en un buffer. Lo mismo sucede cuándo se quieren transmitir datos por DOUT (pin 4). Figura 41. Flujo de datos interno de un modulo Xbee. Hay básicamente 3 modos de operación de Xbee: Transparente, Comandos y API. 3.1.1.1.1 Modo comando Este modo permite ingresar comandos AT al módulo Xbee, para configurar, ajustar o modificar parámetros. Permite ajustar parámetros como la dirección propia o la de destino, así como su modo de operación entre otros aspectos. Para poder ingresar los comandos AT es necesario utilizar el Hyperterminal de Windows, el programa XCTU o algún micro-controlador que maneje UART y tenga los comandos guardados en memoria o los adquiera de alguna otra forma. 54 Figura 42. Ejemplo de comando AT. 3.1.1.1.2 Modo Transparente Este modo está destinado principalmente a la comunicación punto a punto, donde no es necesario ningún punto de control. También se usa para reemplazar alguna conexión serie por cable, ya que es la configuración más sencilla posible y no requiere una mayor configuración. Esta es la conexión que viene por defecto y es la más sencilla forma de configurar el módem. Básicamente todo lo que pasa por el puerto UART (DIN, pin 3), es enviado al módulo deseado, y lo que llega al módulo, es enviado de vuelta por el mismo puerto UART (DOUT, pin 2). Existen básicamente 4 tipos de conexión transparente. La diferencia principal radica en el número de nodos o puntos de acceso, y la forma en cómo éstos interactúan entre sí. 3.1.1.1.3 Modo de operación API Este modo es más complejo, pero permite el uso de tramas con cabeceras que aseguran la entrega de los datos, al estilo TCP. Extiende el nivel en el cual la aplicación del cliente, puede interactuar con las capacidades de red del módulo. Cuando el módulo Xbee se encuentra en este modo, toda la información que entra y sale, es empaquetada en tramas, que definen operaciones y eventos dentro del módulo. Así, una trama de Transmisión de Información (información recibida por el pin 3 o DIN) incluye: - Trama de información RF transmitida. - Trama de comandos (equivalente a comandos AT). Mientras que una trama de Recepción de Información incluye: - Trama de información RF recibida. - Comando de respuesta. - Notificaciones de eventos como Reset, Associate, Disassociate, etc. Entre las opciones que permite la API, se tienen: - Transmitir información a múltiples destinatarios, sin entrar al modo de Comandos. - Recibir estado de éxito/falla de cada paquete RF transmitido. - Identificar la dirección de origen de cada paquete recibido. Trama API: 55 Figura 43. Ejemplo de comando AT. El primer byte 0x7E indica el comienzo de la trama. Los dos bytes siguientes indican solamente la longitud de la trama de Datos (Data Frame) (es decir, toda la trama sin contar ni el byte 0x7E, ni el largo-Length, ni el byte Checksum). La estructura API que viene después se compone según vemos en la figura 26: Figura 44.Trama Xbee. Se ha visto que los módulos Xbee pueden ser configurados de dos formas diferentes además del modo comando, que son el modo transparente AT y el modo API. En el modo AT sólo nos permite la comunicación punto a punto entre dos Xbees. En el modo API, podemos enviar y recibir desde el Coordinador o cualquier elemento de red, la información que viene en cada trama es mucho más detallada. El modo API a la práctica nos permite tener más control de la red, ya que por ejemplo si la comunicación falla obtendremos un código de error. Entre las opciones que permite API se tienen: - Transmitir información a múltiples destinatarios, sin entrar al modo de Comandos. - Recibir estado de éxito/falla de cada paquete RF transmitido. - Identificar la dirección de origen de cada paquete recibido. 3.1.1.2 Datos E/S 3.1.1.2.1 Conversores A/D Para muestrear señales los módulos Xbee están equipados con conversores A/ D de 10 bits. Otra característica importante es el tiempo de muestreo que se puede modificar con el comando IR y las unidades en ms. Por ejemplo para pedir un tiempo de muestreo de 10 ms programaremos ATIR= 0x0A. Otra característica importante es el número de muestras que queremos tomar antes de enviar datos Esto se puede cambiar con el comando AT, teniendo en cuenta que podemos almacenar un máximo de 93 bytes y que cada muestra 56 ocupa 2 bytes, podremos llegar a tomar 43 muestras antes de enviar. El máximo tiempo de muestreo es de 1 muestra / ms. 3.1.1.2.2 Trama de Datos de E/S La trama de datos de E/S comienza con un byte de cabecera que define el número de muestras que son mandadas. Los últimos 2 bytes de la trama definen qué entradas están activas, ya que cada bit representa cada IO y ADC. Figura 45. I/O Data Un ejemplo de trama que hemos obtenido durante el proyecto sería: 7E 00 14 92 00 13 A2 00 40 6C 52 65 7C D0 01 01 00 00 81 01 BD 09 58 67 0x7E: Inicio de la trama. 0x00: Numero de bytes (MSB entre la longitud y el checksum) 0x14: Numero de bytes (LSB) 0x92: tipo de trama IO 0x00-0x65: Dirección 64-bits del remitente. 0x7C-0xD0: Dirección 16-bits del remitente. 0x01: Modo recepción activado. (Se aceptan paquetes) 0x01: Numero de muestras (en este caso una) 0x00-0x00: Máscara del canal digital 0x81: Máscara de canal analógico. 0x01-0xBD: Muestras analógicas 0x09-0x58: Muestra Vss 0x67: checksum Por lo tanto tenemos un valor de tensión (0x0958): 2.8V. La fórmula para obtener los valores analógicos de la trama se puede obtener de la siguiente forma: Valor= Muestra_AD 1024 · 1200 mV (4) 3.1.1.3 Elección de la antena Xbee Se comenzaron a hacer las pruebas iniciales con una antena o módulo XBee de 1mW de potencia, serie 1, con conector a antena por U.fl, ya que era la disponible en la empresa y, además la más económica, su precio oscila los 17 €. Una vez comprobado que la combinación Arduino-Xbee-sensor daban buenos resultados, y éstos se ajustaban a las exigencias presentadas, procedimos a las pruebas de distancia en la transmisión-recepción de datos sin hilos, donde se vio que tendríamos que recurrir a una antena de mayor alcance. Se sabía que había un modelo superior a éste y, 57 evidentemente, de mayor coste, el XBee Pro (su precio oscila los 28 €), con el cual comparamos a continuación: Tabla 5. Comparativa de prestaciones entre Xbee. En la tabla 6 vemos las prestaciones que ofrecen ambos módulos. Las Xbee Pro ganan en cuanto al alcance en la transmisión al tener una potencia de salida bastante mayor. En cuanto a velocidades de transmisión, ambas son semejantes a 250 kbps. Por otro lado, por lo que se refiere a las características técnicas, podemos ver como las Xbee Pro tienen como desventaja, su mayor consumo (295 mA en la transmisión de datos de las Xbee Pro frente a unos 45 mA en las Xbee, y 55 mA en la recepción para las Xbee Pro frente a 50 mA en las Xbee), esto hace que el tiempo de vida de las baterías en las Xbee Pro sea mucho menor. 58 Los factores de programación de cada antena no condicionan la elección, ya que ambas se programan exactamente igual desde X-CTU. Tampoco es un problema el disponer tanto de las librerías como de la interfaz gráfica, ya que ambos modelos utilizan las mismas. Considerando que nuestra prioridad era un mayor alcance en el envío de datos, y no nos bastaba con la primera, nos decantamos por las XBee 60mW U.FL Connection Series 1(802.15.4), siendo más complicada la elección de una batería adecuada. 3.1.2 Arduino Uno La placa Arduino Uno la utilizaremos para conectar con el módulo Xbee End Device y el Sensor ultrasónico, gracias a las placas adaptadoras de Libelium que veremos a continuación, y así poder enviar el volumen de llenado del contenedor por RF. Esto permitirá tener otro Cordinador como receptor en una caja de comunicaciones, y poder controlar desde un PC el estado de los contenedores. En este apartado hacemos un breve resumen de la placa que, en realidad, tiene más aplicaciones que las utilizadas en este proyecto. Arduino Uno es una placa basada en micro-controlador ATMEL AVR ATmega 328, con varias entradas y salidas tanto digitales como analógicas y con conexión USB. Además dispone de un entorno de desarrollo propio. Está pensada para fomentar y facilitar el uso de la electrónica para el público en general, desde escuelas hasta aficionados a la electrónica. La placa puede comunicarse con el PC bien mediante su propio entorno, bien utilizando otros tales como Processing o Macromedia Flash. El lenguaje de programación del micro-controlador está basado en C / C++, por lo que posee funciones de E/S analógica y digital, funciones aritméticas, manejo de interrupciones, comunicaciones por el puerto serie, etc. Las variables pueden ser, como en C, tipo int, char, word, long o float. Las instrucciones de control también son parecidas (if...else, for, while, etc) 3.1.2.1 Hardware La principal ventaja de la placa Arduino es que es open-hardware, por lo que puede ser usada libremente para cualquier proyecto sin tener que pagar licencia para ello. Las características básicas de la placa son: Parámetro Voltaje operativo Voltaje de entrada recomendado Voltaje de entrada límite Pines de entrada y salida digital Pines de entrada analógica Intensidad de corriente Memoria Flash Dato 5V 7-12 V 6-20 V 14 (6 proporcionan PWM) 6 40 mA 32KB (2KB reservados para el bootloader) 59 SRAM EEPROM Frecuencia de reloj 2 KB 1 KB 16 MHz Tabla 6. Características técnicas de Arduino. En la figura 28 vemos el esquemático del Hardware del equipo: Microcontrolador Botón de Reset Port B digital Port D digital Port C analog Conector de potencia Figura 46. Esquema Hardware de la placa Arduino Uno. Las características técnicas de la placa son: Microcontrolador Atmel ATmega328P 8-bit AVR CPU RISC instruction set (assembly) 32KB of program memory 20 MHz max. freq. (Usually 16 MHz) Peripherals voltages ranging from 0V-3.3V Timers, Counters, Watch dog 6 PWM channels Serial USART Digital SPI/I2C communication Analog-to-Digital Converter (ADC) Port B 6 usable pins Port D 8 usable pins 60 ‘Digital’ Port -> only binary 3 can be PWM 3 can be PWM Digital Port C 6 usable pins ‘Analog’ Port -> can write/read voltages ranging from 0V-3.3V 3.1.2.1 Conexión con modulo Xbee Figura 47. Conexión Arduino con Xbee Pro 3.1.3 Sensor de ultrasonidos La mayoría de los sensores de ultrasonido que podemos encontrarnos en el mercado tienen la función de detectar un objeto a la distancia a través de un sistema de onda sonora en la cual se mide el tiempo que transcurre la emisión de dicho sonido y la percepción del eco correspondiente la cual es la que determina la distancia a la cual se encuentra un intruso. Uno de los mejores ejemplos que podemos citar para que podamos entender en una forma más clara el funcionamiento de los sensores de ultrasonido es el vuelo de los murciélagos, ya que después de todo, el sistema está inspirado en estos pequeños mamíferos. Como ya sabemos todos, los murciélagos son ciegos por ello deben desplazarse a través del eco de sus sonidos; de esta manera debemos decir que el murciélago, para detectar el lugar en el cual se encuentra un obstáculo y no chocar contra él, emite una serie de sonidos cuyo eco rebota en dicho obstáculo y de esta manera, al recibir el eco, lo detectan y pueden esquivarlo. El sensor con el que trabajaremos es un medidor de distancias de bajo costo por ultrasonidos, donde la detección del objeto se consigue midiendo el tiempo que tarda en rebotar un haz de ultrasonidos sobre la superficie de un objeto. Uno de los enemigos que tiene este sistema de sensores de ultrasonido es el falso eco, el cual se produce, cuando el objeto en donde el disparo se supone que tiene que rebotar en forma de eco, cambia de lugar. Suele pasar en entornos metálicos también, que 61 se produzcan falsas medidas, hay que buscar la posición óptima del sensor para que este fenómeno no se produzca. 3.1.3.1 Requerimientos iniciales La idea principal de nuestro proyecto es conocer el nivel de llenado de los contenedores de basura ubicados en la calle, para lo que barajamos varias opciones con el objetivo de poder ser lo más exactos posible en la medida de ese nivel, y luego poder informar a los camiones o a un centro de control. Lo primero que había que hacer es encontrar el sensor más adecuado para nuestro proyecto, entonces encontramos que había una primera idea de cómo funcionaría el sistema de recogida de desechos, el cual podemos observar en la siguiente imagen: Figura 48. Sistema de recogida de deshechos. Como podemos observar en la anterior imagen, nos informa de sensores volumétricos mediante ultrasonidos (sensor ultrasónico) y de sensores de infrarrojos, como si cada uno de ellos sirviera para distintos tipos de contenedor. Esta idea o conjunto no acababa de valer exactamente, se debía encontrar la manera más exacta y eficiente para nuestra medida de nivel de llenado, ya fuera utilizando los dos a la vez (cosa que supondría un mayor gasto económico), o decidiéndose por uno de ellos. Se analizaron las ventajas e inconvenientes y se decidió por empezar a probar, y consecuentemente desarrollar, el sensor de ultrasonidos, ya que pensamos que nos podría dar una lectura más exacta, o menos errónea que el sensor infrarrojos, el cual al ir colocado a los lados nos podría dar más lecturas falsas. 62 3.1.3.2 Elección de los componentes Para la realización de este proyecto, se ha partido de la placa Arduino UNO; la más básica, pero no por ellos menos versátil, de las placas Arduino. También disponemos en la oficina de placas Arduino Duemilanove, las cuáles nos permiten extraer el microcontrolador Atmel manualmente, y poder trabajar con él en una protoboard o placa de pruebas. Como ya disponíamos de esta placa controladora, teníamos que implementarla con el sensor, el cual decidimos que sería de ultrasonidos; vimos que había ejemplos de uso con Arduino, y nos decidimos a empezar a probar con los más económicos, el de un solo cilindro(SRF02) y el de 2 cilindros(SRF05). Por último, una vez comprobado que el micro-controlador recibe las medidas correctas del sensor ultrasonidos, falta conseguir que estas lecturas se envíen de manera inhalámbrica desde el sensor hacia un receptor colocado a una cierta distancia del contenedor. La solución más cercana de la que se disponía son los módulos Xbee de Digi, que funcionan a una frecuencia de 2,4 GHz y pensamos que en relación calidad-precio era lo más apropiado. Empezamos con el Xbee Serie 1, para comprobar que se envían las medidas correctamente, y así fue, pero vemos que al querer transmitir a más distancia se nos queda corto, por lo que acabamos utilizando un Xbee Pro S1 60mW, de mucha más potencia que el anterior, aunque también mayor consumo, cosa muy importante ya que la vida del sensor depende de una batería, no va conectado a la red ni panel solar. Una vez conseguido nuestro objetivo, tenemos que conseguir que el gasto del proyecto sea el mínimo, a la vez que el tamaño del prototipo, cosa que en el caso del sensor y del Xbee no es posible, ya que son circuitos ya integrados y hay que acoplarlos así a Arduino. Por lo tanto, hay que escoger de todo el conjunto de la placa Arduino, únicamente los componentes necesarios para que, conectados al sensor y a Xbee, nos funcione con la misma eficiencia y exactitud que en un principio. La diferencia sería que, en vez de gastarnos más de 20 € en una placa Arduino, nos gastemos 5€ en los componentes imprescindibles. 3.1.3.3 Descripción del sensor elegido Consiste en un medidor ultrasónico de distancias de bajo costo desarrollado por la firma DEVANTECH Ltd. El módulo SRF05 es una evolución del módulo SRF04 y está diseñado para aumentar la flexibilidad, aumentar el rango de medida y reducir costes. Es totalmente compatible con el SRF04 y el rango de medida se incrementa de 3 a 4 metros. Se muestra en la figura 1. 63 Figura 49. Esquema Hardware de la placa del sensor SRF05. Dispone de un nuevo modo de operación que se selecciona simplemente conectando el pin “Mode” a GND. Dicho modo permite al SRF05 emplear un único pin de E/S que sirve tanto para dar la orden de inicio o disparo, como para obtener al medida realizada (ECO). Cuando el pin de “Modo” no se emplea y se deja sin conectar, el SRF05 trabaja de la misma manera que el SRF04. Esto es, la señal de disparo y la salida de ECO se realizan por pines diferentes. El SRF05 incluye una pequeña temporización tras el pulso ECO de salida, que permite que controladores lentos como Basic Stamp y Picaxe puedan ejecutar sus correspondientes instrucciones. Modo 1, Compatibilidad con SRF04 Este modo emplea patillas separadas, una para aplicar el pulso de inicio o Trigger y otra para leer la anchura del pulso del ECO medido. Todos los programas realizados para el SRF04 deben funcionar perfectamente en este modo, que se selecciona simplemente dejando la patilla “Mode” sin conectar (igual que en el SRF04). Tal y como se muestra en el diagrama de tiempos de la figura 2, el modo de empleo es muy sencillo. Externamente se aplica, por parte del usuario, un pulso de disparo o trigger de 10 μS de duración mínima. Se inicia la secuencia. El módulo transmite un tren de pulsos o “burst” de 8 ciclos a 40KHz. En ese momento la señal de salida ECO pasa a nivel “1”. Cuando la cápsula receptora recibe la señal transmitida como consecuencia de haber rebotado en un objeto (eco), esta salida pasa de nuevo a nivel “0”. El usuario debe medir la duración del pulso de esta señal, es decir, el tiempo en que la señal eco se mantiene a “1”. 64 Figura 50. Diagrama de tiempos en el modo1 Con objeto de que el módulo se estabilice, se debe dejar un lapsus de tiempo de unos 20mS mínimo entre el momento en que la señal de eco pasa a “0” y un nuevo pulso de disparo que inicie el siguiente ciclo o medida. Esto permite realizar medidas cada 50mS o lo que es igual a 20 medidas por segundo. La duración del pulso eco de salida varía entre 100μS y 25mS, en función de la distancia entre las cápsulas del módulo y el objeto. La velocidad del sonido es de 29.15 μS/cm que, como realiza un recorrido de ida y vuelta, queda establecida en 58.30μS/cm. Así pues el rango mínimo que se puede medir es de 1.7 cm (100μS/58) y el máximo d e 431 cm (25mS/58). Modo 2, Patilla única para trigger y ECO Este modo permite emplear una única patilla para generar la señal de disparo o trigger y también para realizar la medida de la anchura del pulso de salida del ECO, lo que ahorra patillas en el micro-controlador central. Para emplear este modo basta con conectar la patilla “Mode” con GND. La señal de ECO aparecerá entonces en la misma patilla por la que se aplicó la señal de trigger. Esa patilla se debe configurar primero como salida para generar el disparo y luego como entrada para leer la duración del ECO. La sentencia PULSIN de los controladores mas populares realiza esta reconfiguración de forma automática. Ver la figura 30. 65 Figura 51. Diagrama de tiempos en el modo2 3.1.3.4 Características técnicas 3.1.3.5 Conexionado El módulo emplea tan sólo 5 conexiones que se pueden realizar soldando directamente 5 cables o bien mediante un conector de 5 vías con paso de 2.54mm. Estas se muestran en la figura 31. Figura 52. Conexiones SRF05 66 Figura 53. Conexiones SRF05 con Arduino 3.1.3.6 Ajustes El módulo SRF05 viene perfectamente ajustado y calibrado de fábrica, por lo que no necesita de ningún tipo de ajuste. Su funcionamiento se puede verificar aplicando una serie de pulsos por la entrada de disparo. Con ayuda de un osciloscopio se puede medir la anchura de la señal eco de salida. Esta anchura, representada en μS y dividida entre 58.30 nos permite calcular la distancia del objeto. 3.1.3.7 Aplicaciones El módulo SRF05 es capaz de generar una señal lógica de salida cuya duración determina la distancia de un objeto. Las aplicaciones son numerosas, citamos unas cuantas a modos de ejemplo: • Aplicaciones de control conde se deba actuar en función de la distancia o tamaño de objetos diversos. • Alarmas activadas cuando el intruso se aproxima a una determinada distancia. • Microbótica en donde es necesario que se actúe en función de la distancia que separa al robot de cualquier otro objeto. 3.1.4 Baterías Las baterías son uno de los elementos fundamentales en el diseño de nuestro sensor inalámbrico, tanto por el diseño de la propia placa como la capacidad de otorgar autonomía a nuestro sensor. En este apartado hacemos un breve resumen de los parámetros a tener en cuenta en nuestra elección, comparamos las baterías disponibles y finalmente seleccionamos la más idónea para nuestra aplicación. - La tensión que aporta: Los requerimientos de diseño imponen que nuestra batería presente una alimentación entre 2.8 V y 3.4 V, que es el rango de tensiones de alimentación de las Xbee. 67 - La capacidad de la batería, que la medimos en mAh. Este es un factor de vital importancia ya que de esta manera podemos medir la vida que tendrá la aplicación. Por ejemplo, si la batería tiene una capacidad de 250 mAh, y provee una corriente media de 2 mA a la carga, en teoría la batería podría otorgar una vida de 125 horas a nuestro equipo. - El diseño en la placa base: la batería no debe ocupar demasiado espacio y al mismo tiempo debe poder integrarse bien con el resto del hardware. - El modo en que consume energía el sensor. Si el sensor consume un determinado valor de corriente continuamente no es lo mismo que hacerlo a picos. Figura 54. Ejemplo del modo de funcionamiento. En cuanto al tipo de baterías las podemos clasificar según diversos criterios: capacidad, voltaje, etc. En nuestro caso tanto el tamaño como la capacidad de la batería resultan esenciales, ya que se supone que el espacio ocupado por el sensor será pequeño, pero sobretodo se desea que su autonomía sea la mayor posible. Entre las diferentes formas de batería tenemos: pilas de botón, pilas cilíndricas y pilas rectangulares. De todas ellas elegimos las pilas cilíndricas de litio, ya que son las que más capacidad de carga nos ofrecen, a pesar de ser las de mayor tamaño. Finalmente la pila seleccionada ER34615T, 3.6V, 19 Ah, es la mejor en cuanto a la relación capacidad / precio. Se han hecho pruebas de vida de la batería, a la vez que los cálculos correspondientes expuestos en el presente proyecto, y se han cumplido con creces las exigencias de durabilidad de la pila, durando más de 4 años para el funcionamiento que nosotros queremos darle al sensor. Figura 55. Pila cilíndrica seleccionada. 68 3.1.5 Adaptador Xbee a placa protoboard de Sparkfun La separación de los pines de los módulos Xbee se rige por el sistema métrico (concretamente es de 2mm), por lo que no pueden ser puestos directamente sobre una placa protoboard, cuya separación se basa en el sistema imperial (pulgadas). El fabricante Sparkfun ofrece estas pequeñas placas que adaptan la separación de las patas para poder ser acopladas a una placa protoboard (ver figura 36). Figura 56. Esquema de pines del adaptador a protoboard. Y Regleta de 10 pines. El motivo de hacernos con estas pequeñas placas adaptadoras es poder trabajar con las Xbee en la fase de diseño para poderlas adaptar a nuestra placa protoboard, antes de adaptarlas a la placa PCB. 3.1.6 Adaptador Xbee Shield Uno de los problemas que teníamos que afrontar en el desarrollo del proyecto era poder acoplar los módulos Xbee al PC para poder leer los datos. La Xbee Shield, acoplada a una placa Arduino permite solventar este problema. Esta placa, creada por la empresa Libelium permite la comunicación de los módulos Xbee con el micro de Arduino, tanto para aplicaciones remotas (por ejemplo si queremos montar un router inalámbrico con microcontrolador) como para aplicaciones locales con PC (que es nuestro caso, ya que la queremos usar para el Coordinador). Dispone además de pines digitales (pin 2 a 7) y pines analógicos. La Xbee Shield tiene dos jumpers que determinan como se conecta el módulo Xbee a la placa Arduino. Existen dos posiciones posibles, la posición Xbee y la posición USB. La posición Xbee conecta el pin DOUT del módulo Xbee al pin Rx del microcontrolador del Arduino, y el pin DIN está conectado al TX. Notar que los pines RX y TX del 69 Micro-controlador están todavía conectados a los pines TX y RX respectivamente. Sin embargo, en esta posición el micro-controlador sólo será capaz de recibir datos desde el módulo Xbee y no desde el USB del ordenador. La posición USB conecta el pin DOUT del módulo Xbee al pin RX del chip FTDI, y el pin DIN del módulo Xbee al pin TX del chip FTDI. Por lo tanto, en esta posición podemos conectar directamente el módulo Xbee al ordenador. Un punto importante es que deberá quitarse el micro-controlador del módulo Arduino. Figura 57. Adaptador Xbee Shield de Libelium. Una de las desventajas de la placa es que no permite una comunicación con Arduino al PC directamente, ya que es preciso extraer el micro-controlador. Otro problema es que el botón de reset no puede resetear los módulos Xbee, que en ocasiones podría resultar una opción más que interesante. En cuanto a las ventajas, aunque en el mercado se ofrecen otras placas de similares características, la más extendida y, seguramente más cómoda, es ésta, por lo que la hemos elegido para nuestro proyecto, ya que tiene más fácil manejo que las otras. 70 3.1.7 Caja de Control: La Caja de Control realiza la función de recibir los datos correspondientes a los sensores de contenedor. Recibe los datos y gestiona éstos para que puedan ser visualizados posteriormente por el usuario encargado de la gestión. La Caja de Control puede albergar la Base de Datos aunque se recomienda que ésta se encuentre no físicamente en el Punto de Control sino en las Oficinas o Instalaciones del usuario de Gestión. Cada Unidad o Caja de Control permite controlar un total de 128 sensores siempre y cuando estos se encuentren a un radio no superior a los 200m. Se alimenta gracias a la corriente de una farola o gracias a alimentación por Placa Solar ya que su funcionamiento requiere un sistema de alimentación seguro al transmitir la información cada hora vía GPRS, M2M, WI-FI o Ethernet a la Sala de Control. Principales Características de la Caja de Control: - Permite Controlar un Máximo de 128 Sensores - Preparada para su funcionamiento en exterior, IP57 y conectores IP68. - Dispone de Procesador Interno y Modulo GPRS sin Conversores agregados. - Temperatura de Trabajo: de 70 a -30º C (con calefacción interna). Figura 58. Esquema ejemplo de comunicación de caja control con contenedores. 71 3.2 Software 3.2.1 Programación de los módulos Xbee: X-CTU X-CTU es el software oficial para programar radios Xbee. Este software permite al usuario la posibilidad de bajar nuevo firmware de la página de Digi, programar parámetros a la radio o testear la comunicación fácilmente. En este apartado repasamos de forma rápida como funciona para centrarnos más adelante en la programación de una radio en modo Sleep. Básicamente, el programa se compone de una serie de funciones muy útiles que repasamos a continuación. Cuando abrimos el programa X-CTU, veremos que tenemos cuatro pestañas: - PC Settings: Ofrece la posibilidad de seleccionar el puerto COM a través del que irá conectada nuestra radio, así como los ajustes típicos de la comunicación serie (Baudrate, Flow Control, Data Bits, Parity y Stop Bits). Ofrece también la posibilidad de habilitar el modo API y el response timeout. Figura 59. Pestaña PC Settings. 72 - Range Test: Tras establecer los parámetros de comunicación en la pestaña PC Settings y que el Xbee está comunicando con otro, la opción del Range Test puede dar idea de cuan fuerte llega la señal y la tasa de fiabilidad en la comunicación visualizando el número de paquetes correctos y erróneos que llegan. - Terminal: Esta pestaña permite leer y escribir las tramas que llegan al módulo Xbee. Permite leerlas en modo hexadecimal para poderlas interpretar. Figura 60. Pestaña Terminal. - Modem Configuration: Esta es la interfaz para leer / escribir parámetros de un Xbee. Desde esta pestaña también es posible actualizar el firmware disponible desde la página de Digi. 73 Figura 61. Pestaña Modem Configuration. Las pestañas más útiles son PC Settings y Modem Configuration. Range Test y Terminal también pueden ayudarnos en casos en los que queramos chequear la comunicación. 74 3.2.2 Procesado de datos: MySQL 3.2.2.1 Aplicaciones MySQL es muy utilizado en aplicaciones web, como Drupal o phpBB, en plataformas (Linux/Windows-Apache-MySQL-PHP/Perl/Python), y por herramientas de seguimiento de errores como Bugzilla. Su popularidad como aplicación web está muy ligada a PHP, que a menudo aparece en combinación con MySQL. MySQL es una base de datos muy rápida en la lectura cuando utiliza el motor no transaccional MyISAM, pero puede provocar problemas de integridad en entornos de alta concurrencia en la modificación. En aplicaciones web hay baja concurrencia en la modificación de datos y en cambio el entorno es intensivo en lectura de datos, lo que hace a MySQL ideal para este tipo de aplicaciones. Sea cual sea el entorno en el que va a utilizar MySQL, es importante monitorizar de antemano el rendimiento para detectar y corregir errores tanto de SQL como de programación. 3.2.2.2 Lenguajes de programación Existen varias interfaces de programación de aplicaciones que permiten, a aplicaciones escritas en diversos lenguajes de programación, acceder a las bases de datos MySQL, incluyendo C, C++, Pascal, Delphi (via dbExpress), Eiffel, Smalltalk, Java (con una implementación nativa del driver de Java), Lisp, Perl, PHP, Python, Ruby, Gambas, REALbasic (Mac y Linux), (x)Harbour (Eagle1), FreeBASIC y Tcl; cada uno de estos utiliza una interfaz de programación de aplicaciones específica. También existe una interfaz ODBC, llamado MyODBC que permite a cualquier lenguaje de programación que soporte ODBC comunicarse con las bases de datos MySQL. También se puede acceder desde el sistema SAP, lenguaje ABAP. 3.2.2.3 Características adicionales Inicialmente, MySQL carecía de elementos considerados esenciales en las bases de datos relacionales, tales como integridad referencial y transacciones. A pesar de ello, atrajo a los desarrolladores de páginas web con contenido dinámico, justamente por su simplicidad. Poco a poco los elementos de los que carecía MySQL están siendo incorporados tanto por desarrollos internos, como por desarrolladores de software libre. Entre las características disponibles en las últimas versiones se puede destacar: Amplio subconjunto del lenguaje SQL. Algunas extensiones son incluidas igualmente. Disponibilidad en gran cantidad de plataformas y sistemas. Posibilidad de selección de mecanismos de almacenamiento que ofrecen diferente velocidad de operación, soporte físico, capacidad, distribución geográfica, transacciones... Transacciones y claves foráneas. Conectividad segura. 75 Replicación. Búsqueda e indexación de campos de texto. MySQL es un sistema de administración de bases de datos. Una base de datos es una colección estructurada de tablas que contienen datos. Esta puede ser desde una simple lista de compras a una galería de pinturas o el vasto volumen de información en una red corporativa. Para agregar, acceder a y procesar datos guardados en un computador, usted necesita un administrador como MySQL Server. Dado que los computadores son muy buenos manejando grandes cantidades de información, los administradores de bases de datos juegan un papel central en computación, como aplicaciones independientes o como parte de otras aplicaciones. MySQL es un sistema de administración relacional de bases de datos. Una base de datos relacional archiva datos en tablas separadas en vez de colocar todos los datos en un gran archivo. Esto permite velocidad y flexibilidad. Las tablas están conectadas por relaciones definidas que hacen posible combinar datos de diferentes tablas sobre pedido. MySQL es software de fuente abierta. Fuente abierta significa que es posible para cualquier persona usarlo y modificarlo. Cualquier persona puede bajar el código fuente de MySQL y usarlo sin pagar. Cualquier interesado puede estudiar el código fuente y ajustarlo a sus necesidades. MySQL usa el GPL (GNU General Public License) para definir qué puede hacer y qué no puede hacer con el software en diferentes situaciones. Si usted no se ajusta al GPL o requiere introducir código MySQL en aplicaciones comerciales, usted puede comprar una versión comercial licenciada. Las siguientes características son implementadas únicamente por MySQL: Permite escoger entre múltiples motores de almacenamiento para cada tabla. En MySQL 5.0 éstos debían añadirse en tiempo de compilación, a partir de MySQL 5.1 se pueden añadir dinámicamente en tiempo de ejecución: Los hay nativos como MyISAM, Falcon, Merge, InnoDB, BDB, Memory/heap, MySQL Cluster, Federated, Archive, CSV, Blackhole y Example Desarrollados por partners como solidDB, NitroEDB, ScaleDB, TokuDB, Infobright (antes Brighthouse), Kickfire, XtraDB, IBM DB2). InnoDB Estuvo desarrollado así pero ahora pertenece también a Oracle Desarrollados por la comunidad como memcache, httpd, PBXT y Revision Agrupación de transacciones, reuniendo múltiples transacciones de varias conexiones para incrementar el número de transacciones por segundo. 76 3.2.3 Aplicación Visual: La Aplicación Visual se instala en un Servidor externo al sistema y permite monitorizar los datos referentes a los estados de contenedores. Podrá visualizarse así cada contenedor, las calles o el estado general sobre el mapa, incluyendo datos como son: Tipo de Contenedor, Localización (Si se ofrecen previamente). Permite la posibilidad de visualizar los datos en un entorno Web, sin necesidad de ubicar la aplicación en una estación de trabajo físicamente. Permite generar informes gracias a los datos almacenados en la Base de Datos del sistema. Es integrable con aplicaciones terceras para Smartphones tipo ANDROID o IOS ya sea en formato de nueva aplicación o en aplicación Web. Figura 62. Ejemplo aplicación visual. 3.3 Implementación de hardware y software Funcionamiento: El funcionamiento básico del Sensor consiste en detectar el estado del contenedor y transmitir ésta información que podrá determinar una variación de estado en %: Esta información se transmite por el sensor cada 60 minutos (secuencia parametrizable) y se recibe por la unidad de control, situada a una distancia no superior a 100m. La Unidad de Control recibe el estado del sensor y lo convierte en información visible para el usuario, enviando ésta a través de Wi-Fi o GPRS. 77 Figura 63. Ejemplo ejemplo sistema de control de llenado. Los Contenedores envían la información vía Radiofrecuencia, ésta se recibe en la Caja de Control) y se transmite vía GPRS o WI-FI a la Sala de Control donde se gestiona. La información queda almacenada en la Base de Datos de acceso libre tipo MySQL. La información de los Sensores podrá ser empleada para mostrarse en la Aplicación Visual, dónde podrá consultarse el estado de cada uno de los Sensores. Podrán generarse Informes posteriormente a través de la Base de Datos ya sea por: Localización (Calle, Zona, Ciudad)/ Location Data Contenedor /Cointainer Data Estado / ContainerState Data Los informes podrán generarse combinando cualquier de los datos anteriores con la variable Tiempo (Ejemplo Estado Contenedores en fecha: 12.12.12) La información de cada Unidad de Control es recogida en un punto tercero mostrando un mapa completo de la ciudad o ciudades controladas y el total de contenedores monitorizados. 78 Sección 4. Memoria de Cálculo La memoria de cálculo se basa en los elementos explicados en la memoria descriptiva. Por lo tanto, en esta parte de la memoria veremos los cálculos realizados tanto para los elementos hardware como el software, esto es, cálculo de componentes, el desarrollo de la interfaz gráfica, etc. 4.1 Diagramas de flujo del software En esta sección mostramos los diagramas de flujo que gobiernan el sistema de monitorización y guardado de datos que corre en el PC. Esquema básico del software del PC Figura 64. Esquema general del software en PC Raspberry 79 Esquema básico del software del sensor Figura 65. Esquema general del software en placa base End Device 80 4.2 Potencia consumida Para la alimentación del módulo se ha escogido una batería de 3.6V, 19A, de litio tipo cilíndrica. Teniendo en cuenta las características de la pila, los cálculos de la vida de ésta son: Debemos tener en cuenta los ciclos de trabajo de las Xbee. Si definimos: Tcm = Tiempo consumo normal Tcd = Tiempo consumo dormido Icm = Intensidad consumo normal Icd = Intensidad consumo dormido Y aplicamos que el consumo es: = · · (5) Por ejemplo, para Tcd = 3598s y Tcm = 2s e Icm = 64,04mA y Icd=0,46mA, tendremos que: = · , · , = 0,476 mA Consumo = 0,476 mA Si tenemos en cuenta que disponemos de una batería de 19 A/h, la vida de la batería sería: Vida batería = 19000 / 0,476 = 39915,97 h ≈ 1663 días ≈ 4,5 años 81 Sección 5: Casos experimentales En otros proyectos que se centran en Zigbee principalmente, suelen hacer pruebas para medir el RSSI (Receive Signal Strength Indication), que indica la fuerza o potencia de la señal recibida. En nuestro proyecto no hemos entrado a medir este parámetro, ya que tenemos ejemplos anteriores donde vemos la relación de distancia y nivel de RSSI, por lo que he decidido quedarme con estas demostraciones o conclusiones, sin necesidad de hacer nuevas pruebas, sino probar hasta que distancia hay comunicación entre emisor y receptor RF y que no se pierdan datos o medidas. Antes de hacer estas pruebas de comunicación, se hicieron las pruebas de medidas del sensor de ultrasonidos, tanto fuera del contenedor como dentro de él, ya que en el interior del contenedor podríamos tener problemas de rebote del eco, y consecuentemente obtener falsas medidas. 5.1 Lectura de la corriente consumida en los diferentes ciclos de trabajo Para medir la lectura consumida en los diferentes ciclos de trabajo, hemos utilizado un multímetro Fluke. Hemos programado el micro-controlador para que el sensor envíe una señal cada 10 segundos, y el resto del tiempo esté descansando, cosa que en el futuro cambiará, ya que nos interesará que envíe una medida cada hora aproximadamente, por el tema de la vida de la pila o batería, y no es necesario estar sabiendo cada segundo o minuto el estado de los contenedores. Para medir la intensidad de corriente, debemos poner el multímetro en modo amperímetro, colocando las pinzas donde toque y eligiendo la escala más adecuada. A continuación, se abre el circuito para permitir conectar el multímetro en serie, como en el siguiente esquema: Figura 66. Colocación amperímetro en el circuito Figura 67. Multímetro Fluke I despierto≈ 64,06mA / I dormido≈ 0,46 mA Por lo tanto, aplicando la ecuación 5, podemos determinar en esta configuración cuál será el tiempo estimado de la batería: 82 = · , · , = 0,476 mA Vida batería = 19000 / 0,476 = 39915,97 h ≈ 1663 días ≈ 4,5 años 5.2 Lectura de medidas del sensor ultrasónico Para saber que sensor ultrasónico utilizar en el presente proyecto, se comprobó que éstos daban medidas suficientemente exactas para cumplir con futuras exigencias puestas en saber el nivel de llenado del contenedor. Se compararon dos de los más económicos, el SRF02 (un cilindro) y el SRF05 (dos cilindros), viendo que el último es el más exacto y estable en la medida. Gracias a las placas Arduino, se pudo conectar el sensor ultrasónico a los dos pines de alimentación y datos para que el micro procese los datos recibidos por el mismo sensor, cargando un software de ejemplo básico, el cual ordena al sensor que entregue una medida cada tanto tiempo [apartado 10.2]. Acoplando una “Shield” o placa adaptadora para unir los módulos Xbee a una placa Arduino, se puede tener un emisor y un receptor, de manera que el coordinador irá conectado al PC mediante USB y se ven las medidas recibidas por el puerto serie a través del programa X-Ctu. 5.3 Lectura del RSSI: Outdoor [18] RSSI es la abreviatura en inglés de Receive Signal Strength Indication (Indicador de fuerza de la señal recibida). Es un parámetro muy útil en comunicaciones inalámbricas ya que mide el nivel de potencia de las señales de comunicación. El RSSI se mide en dBm. Los valores RSSI leídos por las Xbee Pro oscilan entre -36 a -100 dBm mientras que los de las Xbee lo hacen entre -23 y -92 dBm. Experimentos realizados en un proyecto anterior de la universidad que profundiza en el tema de comunicación inhalámbrica Zigbee, llamado “Red de sensores Zigbee” [18]: 1) Medida de RSSI en el exterior: El estudio llevado a cabo se basa en la recolección de muestras del RSSI a diferentes distancias. Se han tomado 140 muestras en cada punto, desde distancias de 1m a 23 m espaciadas con un paso 1 m entre cada toma de muestra. 83 Tabla 14. Tabla resumen del experimento. En la tabla 14, los valores RSSI mostrados se corresponden con el valor de la media de las muestras tomadas. La media en función de la distancia, se muestra en la figura 62. 84 Figura 68. RSSI vs distancia. En la tabla 14, los valores RSSI mostrados se corresponden con el valor de la media de las muestras tomadas. Por otro lado, como era de esperar la potencia de la señal recibida (RSSI) va disminuyendo con respecto a la distancia. La curva de la figura 62 representa la media de los valores RSSI en una cierta distancia en función de la distancia. En resumen, el RSSI es un buen parámetro para seguir tendencias de la señal. Las conclusiones extraídas de este experimento son: - Se pone de manifiesto que un valor de RSSI obtenido en un instante puntual no es un valor fiable (por ejemplo si con ello quisiéramos calcular la distancia a la que nos encontramos del módulo), pero en cambio es un buen indicador para seguir la tendencia de la señal. 5.4 Comunicación emisor-receptor Xbee En este apartado se veremos las pruebas de distancia que se han realizado entre emisor y receptor de radiofrecuencia, para saber si es suficiente para el tipo de proyecto que queremos realizar. En las especificaciones técnicas de la antena o módulo Xbee Pro S1 que utilizamos, nos dice que esta distancia llega a ser hasta 1 Km, cosa que pensamos que no es del todo cierta, ya que depende de varios factores esta comunicación. Uno de los factores sería el meteorológico, siendo lo más favorable un tiempo despejado y sin viento. Al intervenir factores como viento o lluvia la comunicación varía considerablemente. Otro factor a tener muy cuenta después de las pruebas realizadas, es la posición del receptor, cuanto más elevado esté respecto el emisor o emisores mejor, tiene más alcance. 85 Destacar que las pruebas realizadas son en exterior, con árboles, naturaleza y algún coche entre emisor y receptor, pudiendo decir que es una comunicación en campo abierto, sin edificios ni grandes muros entre medio. 86 Sección 6: Planos La relación de planos de elementos para el módulo End Device es el siguiente: Plano Descripción Plano 1 Planos de la placa Arduino Uno Plano 2 Fotografía del módulo End Device Plano 3 Planos de la pila La relación de planos de elementos para el módulo Coordinador es el siguiente: Plano Descripción Plano 4 Planos placa Xbee Explorer Usb Plano 5 Fotografías del módulo Coordinador La relación de planos de la caja de comunicaciones es el siguiente: Plano Descripción Plano 6 Fotografía caja de comunicación Plano 7 Plano de la caja de comunicación 87 6.1 Plano placa Arduino Figura 69. Plano de la placa Arduino Uno. 88 Fotografía placa base (interior End Device) C O N FI D EN C IA L 6.2 Figura 70. Placa Base para el módulo End Device. En la figura 71 vemos las partes básicas de las que se compone un módulo End device: - Xbee. - Placa base con jumper de conexión y pistas de interconexionado a los diferentes submódulos. - Sensor de ultrasonidos. - Pila. 89 6.3 Plano Pila Figura 71. Planos de la pila. 90 6.4 Fotografía del módulo Coordinador Figura 72. Fotografía del diseño del Coordinador. En la figura 70 vemos las partes básicas de las que se compone un módulo coordinador: - Antena Xbee - Placa Xbee Explorer Usb. - XBee Pro 60mW U.FL Connection - Series 1 (802.15.4) - Cable miniUSB a USB - Latiguillo U.FL a SMA 91 6.5 Planos Xbee Explorer USB Figura 73. Circuito de la placa Xbee Explorer USB 92 6.6 Fotografía caja comunicación Figura 74. Fotografía interior caja de comunicación. 93 O N FI D EN C IA L Plano caja de comunicación C 6.7 Figura 75. Plano de caja de comunicaciones. 94 Sección 7: Presupuesto En este presupuesto se pretende mostrar el coste de la realización del proyecto en sí mismo, dedicado a los estudios previos y al diseño del hardware. Precios unitarios UD DESCRIPCIÓN h Ingeniero Técnico Industrial u Arduino UNO con ATMega328 HW002 u Xbee shield HW003 u Xbee Pro s1 60 mW u.fl connection(802.15.4) HW004 u Xbee Explorer Usb HW005 u Low cost Ultrasonic Ranger HW006 u Atmega328P-AU HW007 u Crystal 32.768KHz HW008 HW009 IA C EN D FI HW010 C u u HW011 u Resistencia SMD 1K 0.125W Condensador cerámico SMD 22pF, 50V Condensador cerámico 0.1uF, 25V Regulador de tensión 3.3V, 1A HW012 HW013 u u Conector hembra 2.54mm,5 vías AVRisp mkII HW014 u Pila-batería HW015 u Antena para Xbee HW016 u Caja de comunicaciones con GPRS u PRECIO 10,00 DIEZ EUROS 21,90 VENTIÚN EUROS con NOVENTA céntimos 19,50 DIECINUEVE EUROS con CINCUENTA céntimos 28,72 VEINTIOCHO EUROS con SETENTA Y DOS céntimos 18,88 DIECIOCHO EUROS con OCHENTA y OCHO céntimos 14,79 CATORCE EUROS con SETENTA Y NUEVE céntimos 2,83 DOS EUROS con OCHENTA Y TRES céntimos 0,54 CINCUENTA Y CUATRO céntimos 0,01 UN céntimo 0,038 TRES con OCHO céntimos 0,052 CINCO con DOS céntimos 0,75 SETENTA Y CINCO céntimos 0,15 QUINCE céntimos 32,25 TREINTA Y DOS EUROS con VEINTICINCO céntimos 15,04 QUINCE EUROS con CUATRO céntimos 6,55 SEIS EUROS con CINCUENTA Y CINCO céntimos 290,00 DOSCIENTOS NOVENTA EUROS L CÓDIGO IT001 HW001 O N 7.1 95 7.2 Precios descompuestos 7.2.1 Capítulo 1: Estudios previos CÓDIGO IT001 UD DESCRIPCION Ingeniero Técnico Industrial h CANTIDAD 50,00 PRECIO 10 SUBTOTAL 500,00 IT001 h 70,00 10 700,00 10 800,00 recopilando información acerca de Arduino y su entorno de programación Ingeniero Técnico Industrial recopilando información acerca de sensores volumétricos(ultrasonidos e infrarrojos) Ingeniero Técnico Industrial recopilando información acerca de ATmega328P 80,00 IT001 Ingeniero Técnico Industrial recopilando información acerca de Zigbee 80,00 IA L IT001 800,00 EN C 10 2.800,00 2,00 % Costes Indirectos FI D Suma de la partida O N TOTAL PARTIDA 56,00 2856,00 7.2.2 Capítulo 2: Diseño y montaje del hardware UD DESCRIPCIÓN h Ingeniero Técnico Industrial u Arduino UNO con ATmega328 u Xbee shield u Xbee Pro s1 60 mW u.fl connection(802.15.4) u Xbee Explorer Usb u Low cost Ultrasonic Ranger u Atmega328P-AU u Crystal 32.768KHz u Resistencia SMD 1K 0.125W u Condensador cerámico SMD 22pF, 50V u Condensador cerámico C CÓDIGO IT001 HW001 HW002 HW003 HW004 HW005 HW006 HW007 HW008 HW009 HW010 96 CANTIDAD 40 1,00 PRECIO 10,00 21,90 SUBTOTAL 400,00 21,90 1,00 2,00 19,50 28,72 19,50 57,44 1,00 1,00 1,00 1,00 1,00 18,88 14,79 2,83 0,54 0,01 18,88 14,79 2,83 0,54 0,01 2,00 0,038 0,076 2,00 0,052 0,104 u HW012 u HW013 u HW014 u HW015 HW016 u u 1,00 0,75 0,75 1,00 0,15 0,15 1,00 32,25 1,00 15,04 15,04 1,00 1,00 6,55 290,00 6,55 290,00 Suma de la partida 848,56 Envío y manipulación 10,00 IA L HW011 0.1uF, 25V Regulador de tensión 3.3V, 1A Conector hembra 2.54mm,5 vías Programador Atmel AVRisp mkII Pila-batería cilíndrica de litio 3.6V, 19Ah Antena para Xbee Caja de comunicaciones (con GPRS incluido) Resumen del presupuesto EN 7.3 858,56 C TOTAL PARTIDA RESUMEN IMPORTE Estudios previos 2856,00 Diseño y montaje del hardware 858,56 D CAPÍTULO Capítulo 1 Capítulo 2 FI TOTAL EJECUCIÓN MATERIAL C O N 13 % Gastos Generales 6% Beneficio Industrial TOTAL EJECUCIÓN POR CONTRATO 18 % IVA TOTAL PRESUPUESTO LICITACIÓN 97 3714,56 482,89 22,29 4219,74 759,55 4979,29 Sección 8: Conclusiones El objetivo principal de este proyecto ha sido el estudio de los sensores inalámbricos en sus diferentes fases, desde el diseño a su modo de funcionamiento con Arduino, así como el estudio del protocolo de comunicación Zigbee, tanto en lo referente al estudio teórico de las tramas de comunicación hasta las pruebas prácticas llevadas a cabo en diferentes entornos, con la finalidad de conseguir la monitorización del nivel de llenado de contenedores. Para llevar a cabo los objetivos fijados, hemos dividido el proyecto en tres fases: La primera fase se ha dedicado al funcionamiento y posterior diseño de nuestro sensor inhalámbrico, compuesto por: un sensor ultrasónico, una placa Arduino y una antena o módulo Xbee. Una vez encontrado el sensor adecuado, se conectan los pines correspondientes a la placa Arduino, la cual interconectamos mediante una placa Xbee Shield al módulo Xbee(End Device) para transmitir los datos enviados por el sensor. El micro-controlador Atmel de Arduino se encarga de procesar éstos datos y Xbee de enviar por radiofrecuencia, para más tarde ser recibidos por otro receptor Xbee (Coordinator), el cual está conectado mediante USB a un PC donde podemos controlar el estado del sensor. Ésta era la parte “fácil”, ya que se disponen de adaptadores como los que hemos nombrado anteriormente, foros donde nos dan ayuda en las conexiones, y ejemplos de códigos fuentes para comprobar el correcto funcionamiento del sensor; pero nuestro objetivo era tener un prototipo montado sobre una PCB, el cual debía ser lo más económico y reducido posible, en cuanto a componentes, tamaño y consumo, por lo que teníamos que experimentar sobre “protoboard”, y encontrar el montaje deseado. La segunda fase se ha dedicado a montar el circuito deseado en una “protoboard”, donde podemos añadir y extraer los componentes necesarios, individual y fácilmente en la mayoría de casos. Tenemos el módulo Xbee y el sensor ultrasónico, los cuales se conectarán íntegramente a la placa PCB definitiva, sin ser reducido ni modificado su aspecto. Pero en el caso de la placa Arduino, es donde debemos centrarnos en escoger los componentes que nos interesaran para la realización de nuestro sensor inhalámbrico. En un proyecto anterior realizado en la empresa, ya se tuvo que recurrir al proceso de escoger únicamente los componentes necesarios de la placa Arduino, en montaje superficial o PCB. Aprovechamos este montaje y nos centramos en reducir el consumo y, en vez de trabajar a 5V, hacerlo a 3,3V, ya que el módulo de comunicación inhalámbrica Xbee tiene un rango aproximado de 2,8V a 3,6V. El problema era que en las especificaciones técnicas de nuestro sensor ultrasónico SRF05 dice que se alimenta a 5V, por lo que vemos que deberemos trabajar con 2 tensiones distintas, debiendo así hacer uso de 2 reguladores de tensión. Esto no ayudaba al tema de reducir el consumo, ya que el regulador de tensión es de los componentes que más consume en el circuito. Entonces probamos de alimentar nuestro sensor ultrasonidos a 3,3V y comprobar que las medidas recibidas por Xbee en nuestro PC eran correctas o se veían afectadas por la falta de tensión porque, tanto nuestro micro-controlador Atmel de la placa Arduino como la antena Xbee pueden funcionar a 3,3V, siempre que el micro vaya acompañado de un clock o cristal de una frecuencia adecuada(a menos frecuencia, más rango de tensión se engloba). 98 Y con suerte, nuestro sensor funciona a ésta tensión también, por lo que podemos utilizar un solo regulador de tensión. Después de realizar las pruebas necesarias, cambiándole el software al micro-controlador una y otra vez para conseguir las medidas del sensor en el tiempo deseado, durmiendo el Xbee para que no se active hasta que el sensor envíe la medida, etc., hay que adaptarlo a una PCB para su posterior encapsulado y montaje en el contenedor, a la vez que hay que tener una caja de comunicación para la recepción y tratamiento de datos. En la tercera fase se ha diseñado una placa base, que conectada a Xbee y a un sensor ultrasónico, nos constituye un módulo End Device, instalado en el techo del contenedor. Éste enviará los datos a un coordinador, situado en una caja de comunicaciones que recibirá los datos y los procesará mediante una CPU, a la vez que habrá una base de datos registrando el número y estado del contenedor. La curva de aprendizaje de Arduino es realmente rápida. Dispone de gran cantidad de documentación oficial y no oficial. La comunidad de usuarios es muy grande, accesible y colaborativa. Hay gran cantidad de ejemplos de uso y proyectos hechos con licencia abierta, cosa que permite reaprovechar todo lo que ya funciona. El hecho de haber definido una manera estándar de crear extensiones, las shields, ha permitido crear una gran cantidad de placas accesorias para cubrir la mayoría de necesidades habituales en proyectos de electrónica. Estas extensiones se consiguen a través de los mismos canales de distribución. Estas suelen entregarse con ejemplos de uso o incluso librerías de código integrables en el entorno Arduino, con lo que amplifican mucho el potencial de la plataforma. El nivel de abstracción de cómo funcionan los circuitos electrónicos o como se deben programar los dispositivos es muy alto. Esto permite realizar operaciones complejas sin gran esfuerzo. En contra, estas limitado al comportamiento proporcionado por las librerías o por la funcionalidad de la circuitería de la que dispones. El desempeño de estas librerías o extensiones no siempre es el más óptimo y hay veces que es necesario realizar modificaciones. Pero incluso en estos casos el soporte que se puede encontrar en la comunidad de usuarios es muy grande y no debe suponer un gran escollo para la realización del proyecto. En cualquier caso, siempre podemos crear nuestras propias librerías, dando así soporte a nuevas funcionalidades o mejoras de rendimiento. En estos casos sí que es necesario un mayor nivel de conocimientos de electrónica o de programación, pero el alcanzar este nivel puede hacerse de un modo muy progresivo. Enlazando con el segundo objetivo que nos habíamos marcado en la realización de este PFC, podemos decir que las capacidades lectivas o formativas de la plataforma Arduino son muy grandes. El hecho de interactuar con el mundo real de un modo directo, puede generar una mayor curiosidad en el alumnado. Esto permite adquirir unos conocimientos de electrónica o programación de un modo muy ameno. 99 El hecho que el coste de una placa sea razonablemente bajo, y el hardware muy robusto, puede facilitar el acceso a este por gran parte de centros, permitiendo su uso durante un largo camino formativo. Se podría decir que tiene un bajo coste por el rendimiento que puede ofrecer. 100 Sección 9: Bibliografía Referencias y webs consultadas: [1] ZigBee Multi Profile ZigFest, Home http://www.zigbee.org/ [2] Arduino, Home Page http://www.arduino.cc/es/ [3] http://en.wikipedia.org/wiki/ZigBee [4] http://en.wikipedia.org/wiki/Wireless_sensor_network [5] http://en.wikipedia.org/wiki/Sensor_node [6] PFC “Ejemplo de aplicación con Arduino: medida de caudal”, Ingeniería Técnica Industrial en Electrónica Industrial. Autor: Josep Fernández Daroca; Director: José Luís Ramírez Falo [7] Xbee Explorer Usb XBee Pro 60mW U.FL Connection - Series 1 (802.15.4) http://sparkfun.com/ [8] Software programa de diseño de circuitos impresos PCB http://www.designspark. com/ [9] Sensores ultrasonidos SRF02 y SRF05 http://www.robot-electronics.co.uk/es.farnell.com/ [10] Datasheet EVE - ER34615T - BATTERY, LITHIUM, 3.6V, D, TABS es.farnell.com/ [11] Datasheets components integrados en PCB es.rs-online.com/ [12] Datasheets components integrados en PCB es.mouser.com [13] Antena 2.4GHZ RP-SMA http://www.bricogeek.com [14] Diseño y montaje en protoboard con Arduino. http://www.instructables.com [15] Programming with Arduino IDE & AVRISP MKII http://www.stevenjohal.com [16] Datasheet programador Atmel AVRISP mkII http://www.atmel.com 101 [17] Proyecto Arduino, Download the Arduino Software http://arduino.cc/en/Main/Software [18] PFC ”Red de sensores Zigbee”, Ingeniería en Automática y Electrónica Industrial Autor: Antón Girod Fortuño; Director: Ramón Villarino Villarino. [19] Wireless Sensor Networks - A Market Research Report http://blogs.dolcera.com/blog/2009/08/02/wireless-sensor-networks-a-report/ [20] Freeduino, Home Artículo digital <http://www.freeduino.org/> [21] Arduino team. Placa Arduino monocapa <http://arduino.cc/es/Main/ArduinoBoardSerialSingleSided3> [22] BricoGeek, Tienda, Artículo digital http://www.bricogeek.com/shop/ [23] Electan, electrónica y robótica, Home http://www.electan.com [24] Proyecto Arduino, Download the Arduino Software http://arduino.cc/en/Main/Software 102 Sección 10: Anexo 10.1 Código fuente #include <avr/sleep.h> #include <avr/power.h> //Sensor Brossa SB Prova 1.0 int dista = 0; int distb = 0; int distfinal = 0; int comprobar = 0; int contador = 0; byte addDH = 0; //no permite 1 en ninguna posicion del byte byte addDL = 4; //no permite 1 en ninguna posicion del byte // configuarció connexió SFR05 int ecoPin = 2; int disparoPin = 3; 3 unsigned long pulseTime = 0; Micro Seconds unsigned long distance = 0; the distance(mm) int alsensor= 9; sensor L IA // stores the pulse in C // variable for storing EN // pin de alimentacion al // tiempo a // tiempo a O N FI D // Configuració Sleep int tdespertar = 0; desboradar timer2 int tiempo = 1; despertar el uC 17-- 1 minut int wakexbee = 10; int entrada = 0; int numconte = 99; // SB ECO pin digital 2 // SB Disparo pin digital // Clock externo de 32,686kHz SIGNAL(TIMER2_OVF_vect){ tdespertar++; despertar } C //augmentamos el tiempo a void setup() { pinMode(disparoPin, OUTPUT); output pinMode(ecoPin, INPUT); pinMode(alsensor, OUTPUT); salida // set disparoPin 3 as // set ecoPin 2 as input // set pin alsensor como pinMode (wakexbee, OUTPUT); delay (5000); digitalWrite (wakexbee, HIGH); Serial.begin(9600); // initialize the serial port, lets you view the distances being pinged if connected to computer //Setup TIMER2 103 TCCR2A = 0x00; TCCR2B = (1<<CS22)|(1<<CS21)|(1<<CS20); //Set CLK/1024 or overflow interrupt every 8s ASSR = (1<<AS2); //Enable asynchronous operation TIMSK2 = (1<<TOIE2); //Enable the timer 2 interrupt sei(); // Enable global interrupts*/ } C O N FI D EN C IA L void loop() { if ((tdespertar<tiempo)&&(entrada==0)) { sleepNow(); } if ((tdespertar==tiempo)&&(entrada==0)) { entrada = 1; // Activar el XBee digitalWrite (wakexbee, LOW); } if (entrada==1) { contador=contador+1; digitalWrite(alsensor, HIGH); // habilita la alimentacion del pin del sensor while (comprobar==0) // Finalització del Periode de lectures { digitalWrite(disparoPin, HIGH); // envia un pols de XX microsegons delayMicroseconds(30); // espera XX microsegons abans d'aturar-lo digitalWrite(disparoPin, LOW); // atura el pols pulseTime = pulseIn(ecoPin, HIGH); // Look for a return pulse, it should be high as the pulse goes low-high-low dista = pulseTime/58; // Distance = pulse time / 58 to convert to cm. delay(1000); digitalWrite(disparoPin, HIGH); // envia un pols de XX microsegons delayMicroseconds(30); // espera XX microsegons abans d'aturar-lo digitalWrite(disparoPin, LOW); // atura el pols pulseTime = pulseIn(ecoPin, HIGH); // Look for a return pulse, it should be high as the pulse goes low-high-low distb = pulseTime/58; // Distance = pulse time / 58 to convert to cm. delay(3); if (((distb-dista<=5)||(dista-distb<=5)||(dista==distb))) { comprobar=1; } } distfinal = distb; // Calcula la distancia mitjana if (distfinal>400) { distfinal=0; } 104 delay(500); Serial.write(byte(1)); Serial.write(byte(addDH)); Serial.write(byte(addDL)); //Serial.print(contador,DEC); //Serial.print(" Contenedor:" ); //Serial.print(numconte,DEC); //Serial.print(" "); int cx, dx, ux, tx; tx = distfinal; cx = tx / 100; // Calculamos cuantas centenas tiene nuestro número ... tx = tx - (cx * 100); // y se lo restamos dx = tx / 10; // Calculamos cuantas decenas tiene nuestro número ... tx = tx - (dx * 10); // y se lo restamos ux = tx / 1; // Y por último calculamos cuantas unidades tiene nuestro número. IA L Serial.write(byte(cx + 0x30)); Serial.write(byte(dx + 0x30)); Serial.write(byte(ux + 0x30)); EN C Serial.write(byte(lowByte(1+addDH + addDL + cx+0x30 + dx+0x30 + ux+0x30)|2)); // Serial.write(byte (13)); // Escriu la // Indica les unitats*/ //imprime salto de linea FI D //Serial.print(distfinal,DEC); distancia mitjana //Serial.print(" cm"); //Serial.println(""); delay(500); } } C O N digitalWrite(alsensor, LOW); tdespertar=0; entrada=0; comprobar=0; // Poner el XBee dormir digitalWrite (wakexbee, HIGH); void sleepNow() // here we put the arduino to sleep { /* Now is the time to set the sleep mode. In the Atmega8 datasheet * http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf on page 35 * there is a list of sleep modes which explains which clocks and * wake up sources are available in which sleep modus. * * In the avr/sleep.h file, the call names of these sleep modus are to be found: * * The 5 different modes are: * SLEEP_MODE_IDLE -the least power savings * SLEEP_MODE_ADC * SLEEP_MODE_PWR_SAVE * SLEEP_MODE_STANDBY 105 * SLEEP_MODE_PWR_DOWN -the most power savings * * For now, we want as much power savings as possible, so we * choose the according * sleep modus: SLEEP_MODE_PWR_DOWN * * Timer 2 overflow interrupt is only able to wake up the ATmega in PWR_SAVE * */ set_sleep_mode(SLEEP_MODE_PWR_SAVE); // sleep mode is set here sleep_enable(); register // enables the sleep bit in the mcucr // so sleep is possible. just a safety pin sleep_mode(); // here the device is actually put to sleep!! // THE PROGRAM CONTINUES FROM HERE AFTER WAKING UP // first thing after waking from sleep: // disable sleep... // Executa el programa IA L sleep_disable(); C } //Sensor Brossa SB Prova 1.0 D const int numOfReadings = 10; lectures per periode EN 10.2 Código fuente ejemplo para probar sensor ultrasónico SRF05 O N FI int readings[numOfReadings]; lectures // nombre de // vector de // index del vector int total = 0; // acumulació total C int arrayIndex = 0; <= nombre de lectures int distfinal = 0; de les lectures // distància mitjana // configuarció connexió SFR05 int ecoPin = 2; digital 2 // SB ECO pin int disparoPin = 3; digital 3 // SB Disparo pin unsigned long pulseTime = 0; in Micro Seconds // stores the pulse unsigned long distance = 0; storing the distance(mm) // variable for // Configuració LED Indicador opcional 106 int redLEDPin = 9; connected to digital PWM pin 9 // Red LED, int redLEDValue = 255; // stores the value of brightness for the LED (0 = fully off, 255 = fully on) // Setup lectures void setup() { // sets pin 9 as pinMode(disparoPin, OUTPUT); as output // set disparoPin 3 pinMode(ecoPin, INPUT); input // set ecoPin 2 as IA L pinMode(redLEDPin, OUTPUT); output // create array loop C to iterate over every item in the array EN for (int thisReading = 0; thisReading < numOfReadings; thisReading++) { D readings[thisReading] = 0; } } // Executa el C programa O N FI Serial.begin(9600); // initialize the serial port, lets you view the distances being pinged if connected to computer void loop() { digitalWrite(disparoPin, HIGH); XX microsegons // envia un pols de delayMicroseconds(30); microsegons abans d'aturar-lo // espera XX digitalWrite(disparoPin, LOW); // atura el pols pulseTime = pulseIn(ecoPin, HIGH); // Look for a return pulse, it should be high as the pulse goes low-high-low distance = pulseTime/58; time / 58 to convert to cm. // Distance = pulse 107 total= total - readings[arrayIndex]; antiga del total // extreu la lectura readings[arrayIndex] = distance; lectura // guarda la nova total= total + readings[arrayIndex]; lecutra al total // afegeix la nova arrayIndex = arrayIndex + 1; següent lectura // Passa a la delay(3); milisegons per la següent lectura (SEGURETAT) // Espera YY if (arrayIndex >= numOfReadings) Periode de lectures // Finalització del L { // Inicialitza EN C distfinal = total / numOfReadings; distancia mitjana IA arrayIndex = 0; l'index de mesures // Calcula la // Escriu la Serial.println(" cm"); unitats // Indica les FI D Serial.print(distfinal,DEC); distancia mitjana } C } O N delay(10000); // Temps de repos del lector (MODIFICABLE: 5min =300.000 miliseconds!!)) 108