Desarrollo e implementación utilizando Arduino y Zigbee

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