Trabajo SD 2015II 1

UNIVERSIDAD

DE

PIURA

FACULTAD DE INGENIERÍA

“

Protocolo de comunicación ZigBee para transmisión de datos

Simón Rodríguez Ingrid Mirelli Vega Cruz Carlos Diego Villegas Chipana Juan Diego Zapata Casariego César Gabriel ASESOR: Marlon Villegas Flores Piura, Octubre 2015

”

Resumen Teniendo como conocimientos los elementos para que se lleve a cabo la comunicación (emisor, receptor, canal, contexto, código) haremos una analogía de cómo es que se realiza la comunicación de nuestro trabajo: EMISOR: Sensores de humedad y temperatura DHT-11 RECEPTOR: Microcontrolador Arduino NANO, Coordinador CODIGO: Protocolo XBee, Comunicación serial CANAL: Ondas generadas por los módulos XBee a través del medio ambiente MENSAJE: Lectura de temperatura y humedad CONTEXTO: Medio de cultivo, invernadero, etc. Los sensores toman la lectura de temperatura y humedad y son enviadas en voltaje, esta lectura es recepcionada por el Arduino UNO de cada sensor la cual decodifica y la acondiciona para poder ser mostrada en las Pantallas LCD 16x2, a su vez cada Arduino UNO envía la data codificada al Módulo XBee para que este se encargue de acondicionarla para enviarla inalámbricamente al Módulo XBee coordinador, este dará la la data obtenida al Arduino NANO para poder tomar la lectura de los sensores en otro ambiente y así poder monitorear las condiciones en las que se encuentra el medio de cultivo o ambiente que necesitamos controlar. Al mismo tiempo el Arduino NANO almacenará las lecturas en una memoria micro SD a través del Micro SD Card. El Arduino NANO estará conectado a una PC la cual nos mostrará unas gráficas de las lecturas gracias a un software NET BEANS.

Resumen Teniendo como conocimientos los elementos para que se lleve a cabo la comunicación (emisor, receptor, canal, contexto, código) haremos una analogía de cómo es que se realiza la comunicación de nuestro trabajo: EMISOR: Sensores de humedad y temperatura DHT-11 RECEPTOR: Microcontrolador Arduino NANO, Coordinador CODIGO: Protocolo XBee, Comunicación serial CANAL: Ondas generadas por los módulos XBee a través del medio ambiente MENSAJE: Lectura de temperatura y humedad CONTEXTO: Medio de cultivo, invernadero, etc. Los sensores toman la lectura de temperatura y humedad y son enviadas en voltaje, esta lectura es recepcionada por el Arduino UNO de cada sensor la cual decodifica y la acondiciona para poder ser mostrada en las Pantallas LCD 16x2, a su vez cada Arduino UNO envía la data codificada al Módulo XBee para que este se encargue de acondicionarla para enviarla inalámbricamente al Módulo XBee coordinador, este dará la la data obtenida al Arduino NANO para poder tomar la lectura de los sensores en otro ambiente y así poder monitorear las condiciones en las que se encuentra el medio de cultivo o ambiente que necesitamos controlar. Al mismo tiempo el Arduino NANO almacenará las lecturas en una memoria micro SD a través del Micro SD Card. El Arduino NANO estará conectado a una PC la cual nos mostrará unas gráficas de las lecturas gracias a un software NET BEANS.

Índice Resumen ................................................................................................................................. 2 Índice ................................................................................................ ...................................... 3 Introducción .................................................. ...................................................................................................... .......................................................................... ...................... 1 Objetivos.............................................. .................................................................................................. ................................................................................... ............................... 2 Objetivo Principal ........................................................................................... .................... 2 Objetivos Específicos ......................................................................................................... 2 Capítulo I ................................................................................................................................ .......................................................................................... ...................................... 3 Alcance ................................................ .................................................................................................... ................................................................................... ............................... 3 1.1.

Sensor 1................................................... ........................................................................................................ ................................................................. ............ 3

1.1.1.

Arduino UNO .................................................... ................................................................................................... ............................................... 3

1.1.1.1.

Mapeo ............................................... ..................................................................................................... ......................................................... ... 5

1.1.2.

Módulo XBee Router 1 .............................................. .................................................................................... ...................................... 6

1.1.3.

Adaptador USB-XBee ................................................ ...................................................................................... ...................................... 7

1.1.4.

Sensor DHT11 ................................................... .................................................................................................. ............................................... 8

1.1.4.1.

Comunicación del sensor ...................................................... ........................................................................ .................. 10

1.1.5.

Pantalla LCD 16x2 ..................................................... ......................................................................................... .................................... 12

1.1.6.

Placa diseñada para ser compatible con Arduino UNO. ................................ 13

1.2.

Sensor 2................................................... ........................................................................................................ ............................................................... .......... 13

1.2.1.

Potenciómetro 50K ..................................................... ......................................................................................... .................................... 13

1.2.2.

Placa diseñada para ser compatible con Arduino UNO ................................. 14

1.3.

Central ..................................................... .......................................................................................................... ............................................................... .......... 15

1.3.1.

Arduino NANO ................................................. .............................................................................................. ............................................. 15

1.3.2.

Adaptador SD Card .................................................... ........................................................................................ .................................... 16

1.3.3.

Placa diseñada para ser compatible con Arduino NANO .............................. 16

Capítulo II ..................................................... ......................................................................................................... ........................................................................ .................... 18 Diseño .................................................. ...................................................................................................... ................................................................................. ............................. 18 2.1. Software .......................................................................................... ........................... 18 2.1.1.

Programación de los Sensores ...................................................... ........................................................................ .................. 18

2.1.2.

Programación del Coordinador ..................................................... ....................................................................... .................. 19

2.2.

Hardware ................................................. ...................................................................................................... ............................................................... .......... 20

2.2.1.

Placa Central (Coordinador) ................................................ ........................................................................... ........................... 20

2.2.2.

Sensor 1 ................................................... ......................................................................................................... ........................................................ 21

2.2.3.

Sensor 2 ................................................... ......................................................................................................... ........................................................ 22

Capítulo III ........................................................................................................................... 24 Implementación ......................................................................................... ........................... 24 3.1.

Toolchain de Arduino ............................................... ............................................................................................ ............................................. 24

3.1.1.

Funcionamiento de la plataforma y sus herramientas .................................... 25

3.2.

Toolchain de NetBeans (Java) .................................................... ............................................................................... ........................... 26

3.3.

IDE (Ambiente de Desarrollo Integrado) .................................................... .............................................................. .......... 28

3.3.1.

Arduino. ................................................... ......................................................................................................... ........................................................ 28

3.3.1.1.

Programa Sensor 1 .............................................. .................................................................................. .................................... 28

3.3.1.1.1. Código Sensor 1 ............................................... ................................................................................... .................................... 28 3.3.1.2.

Programa Sensor 2: ...................................................... ................................................................................. ........................... 30

3.3.1.2.1. Código Sensor 2 ............................................... ................................................................................... .................................... 30 3.3.1.3.

Programa Central: ............................................... ................................................................................... .................................... 31

3.3.1.3.1. Código Coordinador .................................................. ............................................................................. ........................... 32 3.3.2.

Netbeans. ................................................. ....................................................................................................... ........................................................ 36

Capítulo IV ........................................................................................................................... ....................................................................................... .................................... 38

Pruebas .............................................................................................................................................. 38 4.1.

Recepción de datos en comunicación multipunto sin microcontrolador. .................. ........................ ...... 38

4.2.

Recepción de datos en comunicación multipunto con microcontrolador y sensores. sensores. ..... 39

4.3.

Implementación del sistema de comunicación con dispositivos dispositivos de monitoreo. .............. .............. 39

4.4.

Recepción de datos en la central empleando el software en Java para verificar su

funcionamiento. ............................................................................................................................ 39 4.5.

Recepción de datos en la central empleando empleando el software en Java Java y guardando guardando datos en el

módulo SD card con registro de hora y fecha. ............. ...................... .................. .................. .................. .................. ................... ................... ........... 39 4.6.

Implementar las tarjetas electrónicas de los dispositivos y probar su funcionamiento. (Se

repiten las pruebas anteriores ya con el e l hardware terminado). ............... ........................ ................... ................... ................ ....... 40 Conclusiones ..................................................................................................................................... 41 Referencias ........................................................................................................................................ 43 Anexos ............................................................................................................................................... 44 Anexo A: Cronograma de actividades y tareas .................. ........................... .................. .................. .................. .................. ................... .............. .... 45 Anexo B: Diseño de Maqueta ........................................................................................................ 46 Materiales ................................................................................................................................. 46 Diseño ........................................................................................................................................ 47

Introducción Nuestro proyecto ha sido concebido en los invernaderos, la tecnología de riego tecnificado es muy utilizada en la actualidad, porque permite el monitoreo de parámetros fundamentales, tales como humedad y temperatura, las cuales son consideraciones básicas para poder implementar un biohuerto o un invernadero especial para el cultivo de flores. Para ello, se debe plantear desde un principio los objetivos que se pretenden alcanzar y los beneficios que con ellos queremos obtener. Por ello, el propósito del proyecto ha sido implementar un prototipo estándar, con el protocolo de comunicación ZigBee, con aplicación en modelos de invernaderos usados para reducir la influencia de factores adversos, como temporada, plagas, vientos, tormentas, lluvias, etc., que limitan la producción y la calidad de los cultivos. De esta manera incluyen el control de las variables ambientales y hacen uso eficiente del agua. Con la finalidad de mejorar la eficiencia, se adquiere una red de inalámbrica de sensores WSN para poder monitorear y accionar sistemas de control. Hay diferentes tecnologías para desarrollar WSN, sin embargo, la tecnología conocida como ZigBee es una de la más generalizadas y utilizadas. Esta es el estándar más aceptado hoy para usar en redes de sensores y actuadores que deban operar a batería. El sistema desarrollado en el presente proyecto se compone de dos Nodos Sensor y un Dispositivo Coordinador, emisor y receptor respectivamente. El nodo sensor es, básicamente, una unidad de adquisición de datos, y es responsable de recoger datos de las variables climáticas tales como temperatura y humedad relativa, transmitiéndolos al coordinador de módulos a través de ZigBee. En el capítulo I desarrollamos el alcance de nuestro proyecto, es decir todo los elementos que integra nuestra maqueta simulando un problema así como su respectiva solución a través del protocolo de comunicación ZigBee. En el capítulo II desarrollamos el software y hardware desarrollados en nuestro proyecto, explicando los códigos realizados así como detallando el hardware adicional utilizado. En el capítulo III explicamos los Toolchain usados para nuestro proyecto, siendo estos Arduino y NetBeans utilizando el lenguaje de programación Java. En el capítulo IV detallamos las pruebas desarrolladas a lo largo de nuestro proyecto, mencionando algunos problemas que tuvimos en su desarrollo así como las soluciones que se realizaron para las mejoras. 1

Objetivos Nuestro proyecto está orientado únicamente en la transmisión de datos pero con la aplicación específica del diseño y construcción de un dispositivo final ZigBee para lectura remota de medidas en un modelo de invernadero, específicamente humedad y temperatura. A continuación, se detallarán los objetivos principales y específicos convenidos en este informe final.

Objetivo Principal Implementar un prototipo de sistema de monitoreo de parámetros ambientales en un invernadero, mediante un protocolo de comunicación ZigBee, ya que en la actualidad estos dispositivos electrónicos, son la mejor alternativa para redes WPAN, gracias al bajo consumo energético, el bajo costo y la practicidad en su diseño.

Objetivos Específicos -

Diseño y construcción de un dispositivo final ZigBee para lectura remota de medidas en un modelo de invernadero, con libertad de colocar cualquier cultivo.

-

Descripción del Toolchain de Arduino, ya que esta plataforma fue utilizada para generar el código fuente de nuestro proyecto.

-

Creación del código para los sensores y el coordinador.

-

Adaptar, configurar y programar el dispositivo ZigBee coordinador, el cual va interconectado a un Arduino y el dispositivo ZigBee Router, que actúa como terminal con los sensores, resguardando lo datos recogidos en una memoria.

-

Comprobación mediante pruebas experimentales la recepción de datos en comunicación multipunto sin controlador, con controlador y sensores

-

Adquirir data del monitoreo mediante el sistema de comunicación ZigBee de parámetros, tales como: humedad relativa y temperatura, que son las más influyentes en este tipo de aplicación. Con el fin de que un usuario compruebe su comportamiento y puedan ser controladas según el requerimiento.

-

Evaluación de acuerdo a las especificaciones del sistema y el alcance de la comunicación de sensores, actuadores y otros dispositivos pequeños entre ellos.

-

Diseño de un prototipo que será un modelo estándar para poder controlar mediante el protocolo ZigBee cualquier cultivo, bajo los parámetros de medición de humedad y temperatura. 2

1. Capítulo I Alcance En el presente proyecto hemos empleado diversos dispositivos, los cuales han ayudado a realizar el funcionamiento del protocolo de comunicación así como desarrollar mejoras en la implementación del proyecto para facilitar las condiciones de uso para el usuario. A continuación vamos a mencionar y explicar los diferentes dispositivos usados para nuestra red, siendo sus elementos una central (coordinador) y dos nodos (sensores).

1.1. Sensor 1 1.1.1.

Arduino UNO

El Arduino UNO es un microcontrolador basado en el ATmega328P, el cual consta de 14 pines de entrada/salida digitales, de los cuales 6 pueden utilizarse como salidas PWM, 6 entradas analógicas, un cristal de cuarzo de 16 MHZ, conexión USB, un conector de alimentación, un encabezado ICSP y un botón de reset. Hemos elegido trabajar con la placa Arduino UNO, por ser la placa más robusta de la familia Arduino & Genuino, habiendo tenido la oportunidad de haber realizado diferentes pruebas para determinar la mejor alternativa óptima para el proyecto. Recomendaciones sobre el Arduino UNO: -

Puede ser alimentado a través de la conexión USB o por una fuente de alimentación externa seleccionada.

-

Cuenta con un polyfuse (fusible) reajustables que protege los puertos USB del nuestro computador, no proporciona una capa adicional de protección.

3

-

Funciona con un suministro entre 6-20V.

-

Se recomienda un rango de alimentación entre 7-12V debido a que si se suministrara menos de 7V el PIN de 5V suministra menos de 5V y la junta se vuelva inestable y a más de 12V el regulador de voltaje se sobrecalienta dañando la placa.

-

Cada uno de los 14 PINES Digitales puede utilizarse como entrada y salida utilizando el pinMode (), digitalWrite () y digitalRead () funciones, operan a 5V y cada uno de estos pines pueden recibir o proporcionar una corriente de 20mA.

Tabla 1. Ficha técnica Arduino UNO Ficha técnica ATmega328P Microcontroladores 5V Tensión de funcionamiento 7-12V Voltaje de entrada (recomendado) 6-20V Voltaje de entrada (límite) 14(6 proporcionan salida PWM) PINES Digitales 6 PWM Digital PINES 6 PINES de entrada analógica 20mA Corriente DC por E/S Pin 50mA Corriente DC de 3.3V PIN 32KB (ATmega328P) 0.5KB utilizado Memoria Flash para el gestor de arranque 2KB (ATmega328P) SRAM 1KB (ATmega328P) EEPROM 16MHz Velocidad de reloj 68.6mm Largo 53.4mm Ancho 25g Peso Fuente: Elaboración propia

4

1.1.1.1.

Mapeo

Figura 1. Mapeo entre los pines de Arduino y puertos ATmega328P.

Fuente: www.arduino.cc [1] Figura 2. Componentes del Arduino UNO

Fuente: www.element14.com [2] 5

1.1.2.

Módulo XBee Router 1

Los módulos XBee son pequeños chips azules los cuales cuentan con la capacidad de comunicarse de forma inalámbrica unos con otros. Existen muchos tipos de módulos XBee, siendo su particular ventaja los pines similares con los que estos cuentan, ya que alimentación, tierra y los pines de comunicación (Tx y Rx) se encuentran en la misma posición, haciendo que los chips sean totalmente intercambiables para la mayoría de aplicaciones. Estos módulos son soluciones integradas que brindan un medio inalámbrico para la interconexión y comunicación entre dispositivos. Utilizan el protocolo de red llamado IEE 802.15.4 para crear redes FAST POINT-TO-MULTIPOINT (punto a multipunto); o para redes PEERT-TO-PEER (punto a punto). Fueron diseñados para aplicaciones las cuales requieren un alto tráfico de datos, baja latencia y una sincronización de comunicación predecible. ZigBee es un protocolo de alto nivel de comunicación inalámbrica para su utilización con radio fusión digital de bajo consumo. Su objetivo son las aplicaciones que requieren comunicaciones seguras con baja tasa de envío de datos y maximización de la vida útil de sus baterías. Las características más relevantes de este protocolo son su bajo consumo, su topología en red en malla y su fácil integración. Hemos optado por utilizar XBee Serie 2 porque nos brinda un mejor protocolo de salida de energía y de datos, nos permite crear redes de malla complejas y por tanto una comunicación fiable y simple entre el microcontrolador, Arduino. Tabla 2. Ficha técnica XBee Serie 2 Ficha técnica 250kbps Max Velocidad de Datos 6 PINES Entradas ADC de 10 bits 8 PINES Digitales Modo transparente, comandos AT y modo Modos de trabajo API 96dBm Sensibilidad del receptor 2mW (3dBm) Potencia de transmisión 40mA TX Pico de corriente 40mA RX corriente 3.3V Alimentación Fuente: Elaboración propia

6

Figura 3. XBee Pinout

Fuente: www.instructables.com [3]

1.1.3.

Adaptador USB-XBee

El adaptador USB-XBee se utiliza para conectar módulos XBee al puerto USB del ordenador. Este conversor tiene hasta dos finalidades: -

Configurar los módulos XBee

-

Usar al PC como interfaz de comunicación inalámbrica a través del cable miniUSB.

-

Características:

-

Configuración de parámetros XBee y otros módulos.

-

Conexión fácil a PC a través de cable miniUSB.

-

Software de configuración XBee X-CTU.

-

Permite el uso como adaptador USB-TTL.

-

Voltaje: +5V (a través de USB) 7

Figura 4. Adaptador USB-XBee

Fuente: www.electropro.pe [4]

1.1.4.

Sensor DHT11

Este sensor nos permite medir la humedad relativa y la temperatura y se caracteriza por tener una señal digital calibrada lo cual nos garantiza una alta calidad y fiabilidad a largo plazo ya que posee un microcontrolador de 8 bits. Para la medición de la humedad cuenta con un sensor tipo resistivo que trabaja correctamente entre 20-95% y para la medición de la temperatura presenta un sensor tipo NTC que trabaja entre 0-50°C. La interfaz que presenta de comunicación a través de único hilo hace que la integración de este sensor a nuestro proyecto sea rápida y fácil, posee la ventaja de poseer un tamaño reducido así como un bajo consumo, la desventaja es que nos proporciona medidas enteras. En comparación con el sensor DHT22, este sensor es menos preciso y menos exacto, su funcionamiento se da en un rango más pequeño de temperatura/humedad, pero su empaque es más pequeño y menos caro.

8

Figura 5. Ficha técnica Sensor DHT11 Ficha técnica DHT11 Modelo 3.3-5V Fuente de alimentación Señal digital a través de un solo bus Señal de salida Resistor polímero Elemento sensor Humedad 20-95% y temperatura 0-50°C Rango de medición Humedad +-4% y temperatura +-2°C Exactitud Humedad +-1% y temperatura +-1°C Resolución o la sensibilidad Humedad +-1% y temperatura +-1°C Repetibilidad +-1%RH Histéresis de humedad +-0.5%RH/año Estabilidad a largo plazo Promedio 2 segundos Promedio de detección Totalmente intercambiable Intercambiabilidad 12*15.5*5.5mm Dimensiones Fuente: Elaboración propia

Figura 6. Sensor DHT11

Fuente: felixmaocho.wordpress.com [5] 9

Figura 7. Esquema de conexión DHT11

Fuente: www.rduinostar.com [6]

1.1.4.1.

Comunicación del sensor

El microcontrolador inicia la comunicación configurando el pin como salida y enviando la señal de inicio. Esta señal consiste en establecer nivel bajo durante 18ms y nivel alto durante 20us-40us. A continuación ponemos el pin como entrada y el sensor responderá estableciendo un nivel bajo de 80us y un nivel alto de 80us. Una vez realizado esto el sensor enviará 5 bytes (40 bits) de forma continua. Figura 8. Diferencia de tiempo para la transmisión de "1s" y "0s"

Fuente: www.embedded-lab.com [7] 10

Los 5 bytes recibidos son los siguientes: -

Byte 0: es la parte entera de la humedad relativa. Byte 1: es la parte decimal de la humedad relativa. Byte 2: es la parte entera de la temperatura. Byte 3: es la parte decimal de la temperatura. Byte 4: es el checksum.

Como el sensor no emplea decimales entonces podemos ignorar la información delos bits 2 y 4 que son la parte decimal de la medición y por lo tanto nos quedamos con los bits 1y 3. El checksum se emplea para confirmar que la información recibida es correcta, y se calcula sumando los 4 bytes (byte 1, byte 2, byte 3 y byte 4) y cogiendo solo los 8 bits menos significativos del resultado. Cada uno de los bits se envía siguiendo esta estructura: cuando el sensor va a enviar un bit, pone el pin a “0” durante 50us, y luego lo pone a “1” durante 26-28us para señalizar un “0”, o durante 70us para señalizar un “1”.

Figura 9. Diferencia de tiempo para la transmisión de "1s" y "0s"

Fuente: http://embedded-lab.com [7] Figura 10. Señales de inicio, respuesta y datos en secuencia

Fuente: www.embedded-lab.com [7]

11

Una vez enviados todos los bits, el sensor pon e el pin de datos a “0” durante 50us y luego lo

deja a nivel 1, una vez terminada la transmisión, el sensor pasa al estado de bajo consumo de energía.

1.1.5.

Pantalla LCD 16x2

Una pantalla LCD es un dispositivo el cual está diseñado para mostrar información de manera gráfica. El término LCD hace referencia a Liquid Crystal Display. Generalmente las pantallas LCD están unidas a una placa de circuito y poseen pines de entrada/salida de datos. Arduino es capaz de utilizar las pantallas LCD para desplegar datos. Este display LCD consta de 2 filas por 16 columnas, lo cual nos permite imprimir caracteres en 2 filas en las cuales entran 16 caracteres. Figura 11. PINOUT de una pantalla LCD

Fuente: www.panamahitek.com [8] Estas pantallas constan de 16 pines. De izquierda a derecha en la Figura 10, sus usos son los siguientes: -

Pin 1: VSS o GND Pin 2: VDD o alimentación (+5V) Pin 3: Voltaje de contraste. Se conecta a un potenciómetro. Pin 4: Selección de registro. Aquí se selecciona el dispositivo para su uso. Pin 5: Lectura/Escritura. Dependiendo del estado (HIGH o LOW), se podrá escribir o leer datos en el LCD Pin 6: Enable. Es el pin que habilita o deshabilita el LCD. Pin 7 hasta Pin 14: Son los pines de datos por donde se envía o recibe información. Pin 15: El ánodo del LED de iluminación de fondo (+5V). 12

-

Pin 16: El cátodo del LED de iluminación de fondo (GND).

1.1.6.

Placa diseñada para ser compatible con Arduino UNO.

Se desarrolló un hardware compatible con Arduino Uno y las conexiones de los dispositivos anteriormente mencionados. Figura 12. Placa Sensor 1

Fuente: Elaboración propia

1.2. Sensor 2 Para el segundo nodo o Sensor 2 hemos utilizado los mismos elementos empleados para el Sensor 1, con la particularidad de haber establecido un Módulo XBee Router 2 y haber empleado un nuevo elemento descrito a continuación.

1.2.1.

Potenciómetro 50K

En nuestro proyecto hemos usado dos pantallas LCD, la cual una es nueva y ha sido usada para el Sensor 1, mientras que la otra pantalla LCD, la cual está desgastada, se ha usado para el Sensor 2.

13

En las pruebas la segunda pantalla LCD pero no mostraba los datos gráficamente, por eso se usó la alternativa de poder usar un potenciómetro con la finalidad de variar el contraste de la pantalla LCD, logrando de esta forma mostrar los datos deseados. Figura 13. Potenciómetro 50K

Fuente: es.wikipedia.org [9]

1.2.2.

Placa diseñada para ser compatible con Arduino UNO

Debido a que se ha usado el potenciómetro es necesario diseñar una nueva placa que sea compatible con el Arduino Uno considerando de esta manera el potenciómetro. Figura 14. Placa Sensor 2

Fuente: Elaboración propia 14

1.3. Central Para el Coordinador o la Central hemos utilizado de igual manera un Adaptador XBee, así como hemos establecido un Módulo XBee Coordinador, habiendo empleando nuevos elementos descritos a continuación.

1.3.1.

Arduino NANO

El Arduino NANO es una placa pequeña, completa y amigable por su facilidad de uso basado en el ATmega328 (Arduino Nano 3.x) o ATmega168 (Arduino Nano 2.x). Tiene una funcionalidad similar a la del Arduino Duemilanove, pero en paquete diferente. Esta carece solo de un conector de alimentación DC y funciona con un cable Mini-B USB en lugar de uno estándar. Tabla 3. Ficha técnica Arduino NANO Atmel ATmega168 or ATmega328 Microcontroladores 5V Tensión de funcionamiento 7-12 V Voltaje de entrada (Recomendado) 6-20 V Voltaje de entrada (Límite) 14 (of which 6 provide PWM output) Pines Digitales 8 Pines de entrada analógica 40 mA Corriente DC por E/S Pin 16 KB (ATmega168) or 32 KB (ATmega328) of which Memoria Flash 2 KB used by bootloader 1 KB (ATmega168) or 2 KB (ATmega328) SRAM 512 bytes (ATmega168) or 1 KB (ATmega328) EEPROM 16 MHz Velocidad de reloj 0.73" x 1.70" Dimensiones 45 mm Largo 18 mm Ancho 5g Peso Fuente: Elaboración propia Recomendaciones sobre el Arduino NANO: -

El Arduino Nano puede ser alimentado a través de la conexión USB Mini-B, a través del Pin 30 por medio de una alimentación externa no regulada 6-20V, o a través del Pin 27 por medio de una alimentación externa de 5V.

-

Cada uno de los 14 pines digitales en el Nano se puede utilizar como una entrada o salida, utilizando las funciones pinMode (), digitalWrite () y digital Read (). Cada pin puede proporcionar o recibir un máximo de 40mA y tiene una resistencia interna pullup de 20-50 kohms. 15

-

El Arduino Nano tiene una serie facilidades para la comunicación con un ordenador, otro Arduino y otro Microcontroladores.

1.3.2.

Adaptador SD Card

Es un módulo de lector de tarjeta Micro SD que permite guardar datos, la interfaz SPI vía el conductor del sistema de archivos, se comunica por el protocolo I2C. Detalles: -

El nivel de conversión de la placa que puede interactuar es 5V o 3.3V.

-

La fuente de alimentación es de 4.5V-5.5V. La interfaz de comunicación es un interfaz SPI estándar.

-

La interfaz de control consta de 6 pines, los cuales son: GND, VCC, MISO, MOSI, SCK, CS. GND es la tierra, VCC es la fuente de alimentación, MISO, MOSI, SCK es un bus SPI, CS es el pin de señal Chip Select. Figura 15. MicroSD Card Adapter (Catalex)

Fuente: www.dx.com [10]

1.3.3.

Placa diseñada para ser compatible con Arduino NANO

Se desarrolló un hardware compatible con Arduino Nano y las conexiones de los dispositivos anteriormente mencionados.

16

Figura 16. Placa Central


17

2. Capítulo II Diseño 2.1. Software 2.1.1.

Programación de los Sensores

Los módulos ZigBee, cada uno de ellos tiene una dirección única de 64bits que viene grabada de fábrica. Por otro lado, la red ZigBee, utiliza para sus algoritmos de ruteo direcciones de 16 bits, cada vez que un dispositivo se asocia a una red Para nuestro proyecto estos módulos XBee se han ajustado para usarse en redes de configuración punto a punto. Como ya se ha especificado los módulos XBee son de Serie 2, los cuales nos permite hacer redes MESH, que son redes más complejas, permiten acceder a un punto remoto utilizando módulos intermedios para llegar como routers (Además los módulos automáticamente generaran la red entre ellos, sin intervención humana alguna, permitiendo la reparación de la red en caso de que algún nodo falle; al mismo tiempo la red por sí sola resuelve la mejor ruta para un determinado paquete). Para nuestro proyecto no hace falta hacer esta red MESH debido a que la distancia de punto a punto no son lo suficientemente grandes como para establecer una red como esta, pero queremos hacer un inciso en esto porque no debemos pensar como solo una simple transmisión de datos de punto a punto. La idea principal de la programación de los sensores se ve reflejada en el siguiente esquema.

18

Ilustración 1. Diagrama de Programación de los Sensores Nombre del Sensor Imprimir en LCD Variable Sensor DHT11

Lectura de entradas digitales

Variable Sensor

Imprimir en puerto serial

Data Sensor # Tx Serial Xbee

Fuente: Elaboración propia El sensor nos dará una lectura de temperatura y humedad del ambiente al cual se verá expuesto, esta información digital (entrada digital) se podrá apreciar por cada 2 segundos en una pantalla LCD, donde aparecerá Sensor 1 (si corresponde a la lectura realizada por el sensor 1) y la variable (es la lectura de temperatura y humedad) lo mismo será para el Sensor 2 (si corresponde a la lectura realizada por el sensor 2) y su variable. Ahora no solo se imprimirá la lectura de temperatura y humedad en la pantalla LCD, si no también se imprimirá por medio de un puerto serial hacia el módulo XBee para ser luego transmitido al coordinador general y guardar la información.

2.1.2.

Programación del Coordinador

Modo de operación de transmitir y recibir se encuentra cuando al módulo le llega algún paquete RF a través de la antena (Modo Receive) o cuando se manda información serial al buffer del pin 3 (UART Data in) que luego será transmitida (Modo Transmit). La información transmitida puede ser Directa o Indirecta. En el modo Directo la información se envía inmediatamente a la dirección de destino. En el modo Indirecto la información es retenida durante un período de tiempo y es enviada sólo cuando la dirección de destino la solicita. Para nuestro proyecto se trata de una transmisión directa, porque se ha desarrollado una programación que consiste en que cada dos segundos nos muestre en el LCD los resultados obtenidos. El siguiente esquema tramamos de explicar de forma sencilla la idea que se tiene sobre la transmisión de datos desde el módulo XBee y la impresión de estos datos.

19

Ilustración 2. Diagrama de programación del Coordinador Imprime en Puerto Serial a PC

Puerto Serial Disponible

Si es "Sensor 1"

Data Sensor # Rx Serial XBee

Data guardada en memoria SD Almacena en Buffer

Decodificación del Buffer

Imprime en Puerto Serial a PC Si es "Sensor 2" Data guardada en memoria SD


2.2. Hardware 2.2.1.

Placa Central (Coordinador) Figura 17. Placa Central en ISIS PROTEUS


Figura 18. Placa Central en Ares Professional


2.2.2.

Sensor 1 Figura 19. Placa Sensor 1 en ISIS PROTEUS


Figura 20. Placa Sensor 1 en Ares Professional


2.2.3.

Sensor 2 Figura 21. Placa Sensor 2 en ISIS PROTEUS


Figura 22. Placa Sensor 2 en ISIS PROTEUS


23

3. Capítulo III Implementación 3.1. Toolchain de Arduino El entorno de desarrollo de Arduino tiene el siguiente esquema, como se aprecia en la figura con sus funciones específicas para el desarrollo del programa. Figura 23. Software Arduino

Fuente: Elaboración propia (Captura de pantalla) 24

En el cuadro del editor de texto escribiremos el código del programa que queramos que Arduino ejecute. En los botones de acceso rápido tenemos los siguientes iconos: Verifica si tu programa está bien escrito y puede funcionar. Carga el programa a la placa de Arduino tras compilarlo. Crea un programa nuevo. Abre un programa. Guarda el programa en el disco duro del ordenador. Abre una ventana de comunicación con la placa Arduino en la que podemos ver las respuestas que nuestro Arduino nos está dando. Finalmente, en el área de mensajes y la consola Arduino nos irá dando información sobre si la consola está compilando, cargando y sobre los fallos o errores que se produzcan tanto en el código como en el propio IDE.

3.1.1.

Funcionamiento de la plataforma y sus herramientas

El programa Arduino realiza algunas pequeñas transformaciones para asegurarse de que el código es correcto C o C ++ (dos lenguajes de programación comunes). A continuación, se pasa a un compilador (avr-gcc), lo que convierte el código legible en máquina instrucciones legibles (o archivos objeto). Luego, el código se combina con las bibliotecas estándar de Arduino que proporcionan funciones básicas como digitalWrite () o Serial.print (). El resultado es un solo archivo hexadecimal, que contiene los bytes específicos que deben ser por escrito a la memoria de programa del chip de la placa Arduino. Este archivo se carga en la placa: transmitida a través de la conexión USB serie o a través del gestor de arranque que ya están en el chip o con el hardware de programación externa. Comprendiendo el funcionamiento de los programas informáticos que tiene este entorno de Arduino, para nuestro proyecto se dio uso de las siguientes librerías en los programas de los dispositivos. Dht.h

 Librería que permite leer el dato por entrada digital del sensor dht11.

SoftwareSerial.h

 Librería

Time.h

 Librería

String.h

 Librería

que emplea funciones de comunicación serial con Arduino y PC. También permite crear puertos seriales virtuales. que nos permite ingresar y verificar datos de fecha y hora en tiempo real. que contiene la definición de todo tipo de variables, 25

funciones y operaciones de manipulación de memoria. SD.h

 Librería

para uso de escritura, lectura y registro de datos en Modulo

SD card. SPI.h

 Librería

de protocolo síncrono de data serial.

LiquidCrystal.h

 Librería

para uso de LCD.

3.2. Toolchain de NetBeans (Java) Para conocer un poco de esta plataforma, es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programación Java. La plataforma NetBeans permite que las aplicaciones sean desarrolladas a partir de un conjunto de software llamados módulos. Un módulo es un archivo Java que contiene clases de java escritas para interactuar con las APIs de NetBeans y un archivo especial (manifest file) que lo identifica como módulo. Las aplicaciones construidas a partir de módulos pueden ser extendidas agregándole nuevos módulos. La plataforma ofrece servicios reusables comunes para las aplicaciones de escritorio, permitiendo a los desarrolladores centrarse en la lógica de sus aplicaciones. Algunas de las características de la aplicación son: 

Gestión de la interfaz de usuario ( menús y barras de herramientas )



Gestión de configuración de usuario



Gestión de almacenamiento (guardar o cargar algún tipo de dato)



Gestión de ventana



Marco Asistente (soporta diálogos para a paso)



Librería visual de Netbeans



Herramientas de desarrollo integrado

26

Figura 24. Software NetBeans

Fuente: Elaboración propia (Captura de pantalla) Librerías usadas en la interfaz del programa “Grafica de Sensores XBee”. Arduino v2.5.0.jar Jfreechart-1.0.19.jar

 La

librería Arduino para Java es una compilación de métodos que permite comunicar aplicaciones en Java con Arduino.  Permite

hacer diferentes tipos de gráficos con plantillas preestablecidas y con opciones dinámicas en Java.

Jcommon-1.0.23.jar

 Es

una clase de librería en java usada para el soporte de la librería Freechart.

RXTXcomm.jar



Librería que permite establecer la comunicación serial con funciones específicas a través de los puertos COM disponibles.

27

3.3. IDE (Ambiente de Desarrollo Integrado) 3.3.1.

Arduino.

Se usó la plataforma Arduino 1.5.6 para la generación de código de fuente de 3 programas únicos del proyecto. Los dispositivos Central, Sensor 1 y Sensor 2 poseen su micro controlador que corre un programa en lenguaje C para ejecutar distintas funciones, a continuación se detallan los sketches desarrollados para los dispositivos.

3.3.1.1.

Programa Sensor 1

Descripción: -

Leerá datos de los sensores dht11 por sus pines digitales 5 y 6.

-

Almacenará los datos en valores enteros para luego ser enviados por el puerto serial.

-

Los pines Tx y Rx van conectados directamente con los pines del módulo XBee, usando el adaptador para adecuar el voltaje de entrada (3.3v).

-

El adaptador con el módulo XBee estarán conectados a los pines de 5v y GND del Arduino.

-

Los sensores estarán conectados a los pines de 3.3v para su alimentación.

3.3.1.1.1.

Código Sensor 1

// MODULO XBEE ROUTER - TRANSMISOR //librerias: #include #include "DHT.h" //Libreria usada para procesar el valor digital de los sensores DHT11. #include ; LiquidCrystal lcd(2,3,4,9,10,11,12); //Declaro Variables Globales #define DHTPINS1 7 // Pin de conexion del sensor1 #define DHTTYPE DHT11 // Tipos de DHT por parte de las librerias. //Uso de la libreria con la función --> dht( Pin conectado del sensor, Tipo de sensor) DHT dht1(DHTPINS1, DHTTYPE); float h1; float t1;

28

void setup() { //Conexión Puerto Serial Serial.begin(9600); // Velocidad de baudios lcd.begin(2,16); dht1.begin(); //Se inicia el Sensor 1 //Serial.println("Comenzando Transmision..."); //Serial.println("Enviando datos Temperatura y Humedad"); } void loop(){ //Declaración de variables enteras usando la funcion de leer humedad y temperatura: if(Serial.available()>0){ h1 = dht1.readHumidity(); //Se lee la humedad 1 t1= dht1.readTemperature(); // Se lee la temperatura 1 String trama1 = ""; trama1 = String("Sensor1") + "," + String(h1,1) + "," + String(t1) + ","; // adjuntamos la data en una cadena Serial.println(trama1); delay(2000); imprimirlcd(); }} void imprimirlcd () { lcd.clear(); lcd.setCursor(0,6); lcd.print("Sensor 1"); delay(2000); lcd.clear(); lcd.setCursor(0,0); lcd.print("Humedad ="); lcd.setCursor(9,0); lcd.print(h1,1); lcd.setCursor(15,0); lcd.print("%"); lcd.setCursor(0,1); lcd.print("Temp ="); lcd.setCursor(9,1); lcd.print(t1); lcd.setCursor(15,1); lcd.print("C "); }

29

3.3.1.2.

Programa Sensor 2:

Descripción: -

Leerá datos de los sensores dht11 por sus pines digitales 5 y 6.

-

Almacenará los datos en valores enteros para luego ser enviados por el puerto serial.

-

Los pines Tx y Rx van conectados directamente con los pines del módulo XBee, usando el adaptador para adecuar el voltaje de entrada (3.3v).

-

El adaptador con el módulo XBee estarán conectados a los pines de 5v y GND del Arduino.

-

Los sensores estarán conectados a los pines de 3.3v para su alimentación.

3.3.1.2.1.

Código Sensor 2

// MODULO XBEE ROUTER - TRANSMISOR //librerias: #include #include "DHT.h" //Libreria usada para procesar el valor digital de los sensores DHT11. #include ; LiquidCrystal lcd(2,3,4,9,10,11,12); //Declaro Variables Globales #define DHTPINS2 7 // Pin de conexion del sensor1 #define DHTTYPE DHT11 // Tipos de DHT por parte de las librerias. //Uso de la libreria con la función --> dht( Pin conectado del sensor, Tipo de sensor) DHT dht2(DHTPINS2, DHTTYPE); float h2, t2; void setup() { //Conexión puerto serial Serial.begin(9600); // Velocidad de baudios lcd.begin(2,16); dht2.begin(); //Se inicia el sensor 1 //Serial.println("Comenzando Transmision..."); //Serial.println("Enviando datos Temperatura y Humedad"); } void loop(){ 30

//Declaración de variables enteras usando la funcion de leer humedad y temperatura: if(Serial.available()>0) { h2 = dht2.readHumidity(); //Se lee la humedad 2 t2= dht2.readTemperature(); // Se lee la temperatura 2 String trama2 = ""; trama2 = String("Sensor2") + "," + String(h2,1) + "," + String(t2) + ","; Serial.println(trama2); delay(2000); // Cada 2 segundos imprimirlcd(); //Lo que veremos en el monitor serie será ---> Sensor2,41,30, }} void imprimirlcd () { lcd.clear(); lcd.setCursor(0,6); lcd.print("Sensor 2"); delay(2000); lcd.clear(); lcd.setCursor(0,0); lcd.print("Humedad ="); lcd.setCursor(9,0); lcd.print(h2,1); lcd.setCursor(15,0); lcd.print("%"); lcd.setCursor(0,1); lcd.print("Temp ="); lcd.setCursor(9,1); lcd.print(t2); lcd.setCursor(15,1); lcd.print("C "); }

3.3.1.3.

Programa Central:

Descripción: -

Recibirá datos de los sensores DHT11 por sus pines 5 y 6, usando la libreria SoftwareSerial, se programa para que esos pines funcionen como puerto serial. Recordar que por estos pines están conectados los pines de Tx y Rx del módulo coordinador.

-

Almacenará los datos recibidos en un buffer con un tamaño específico, usando algunas funciones de la libreria string. 31

-

Luego de recibir el dato con la longitud específica se procede a parsear o separar la trama recibida para extraer los datos de temperatura y humedad de cada sensor. Una variable de tipo long, almacenará los datos separados y luego serán almacenados en variables enteras independientes.

-

Luego se procede a escribir la información en una memoria SD Card, con las debidas conexiones de los pines al Arduino y haciendo uso de las librerias SD.h y SPI.h con sus respectivas funciones.

3.3.1.3.1.

Código Coordinador

** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 10 Nota: Algunas lineas de Serial.print estan comentadas porque fueron usadas como prueba para ver el funcionamiento del codigo por el monitor serie. // MODULO XBEE COORDINADOR - RECEPTOR //librerias SD card: #include #include //librerias ultilizadas: #include #include //Declaro los pines de TX y RX para mi serial port virtual en arduino. SoftwareSerial mySerial(5, 6); // RX, TX //*DECLARACIÓN DE VARIABLES //Variables usadas de MircoSD Card Adapter const int chipSelect = 10; //Pin 10 del arduino se establecerá como salida debido a la librería int contador1 = 0; //Numero de datos que serán almacenados int contador2 = 0; int i=0; //Variables usadas en la recepción #define MAX_BUFFER 200 // Almacenamos el estado como variable global int estado=LOW; 32

int estado_transf=LOW; // Almacenamos también el número de milisegundos anterior unsigned long momento_anterior=0; unsigned long bytes_recibidos=0; //data recibida: char *Indata; char *Sen1; char *Sen2; //Variables de Sensores 1 y 2 int h1 = 0; int t1 = 0; int h2 = 0; int t2 = 0; //Variable para almacenar los datos separados long valores[3]; // 0 - 3 : Variables separadas de la cadena recibida void setup() { Serial.begin(9600); mySerial.begin(9600); Serial.println("Comenzando Recepcion de prueba XBee - Arduino"); //Condiciones del Modulo SD card Serial.print("Inicializando sd card..."); pinMode(chipSelect,OUTPUT); // Establece el pin 10 como salida //delay(2000); if (!SD.begin(chipSelect)) // Si el pin10 falló en lectura de la tarjeta sd, imprime aviso fallo lectura... { Serial.print("Fallo lectura de tarjeta"); //delay(2000); return; } Serial.print("SD incializada ok."); //delay(2000); //Se inicia la Recepción. mySerial.println("C"); // Trama que activa los demas sensores.

33

} //Función que devuelve variable string especifica y un valor entero int serialGetString(char *string, int max) { unsigned i=0; char sIn; // Queremos que la cadena se rellene hasta max-2 para que en el carácter // max-1 (el último) podamos meter el terminador \0 --max; while (mySerial.available() && i
if(strncmp(Indata,"Sensor2",7) ==0) { Sen2 = strtok(Indata,"\n"); Serial.println(Sen2); //Imprime por el puerto serial al Programa Grafica Sensores parse_S2(); contador2++; sdcard_S2(); } } } void parse_S1() { //char signal[] = "125,0,255"; // Esto es lo que tengo que cambiar por lo que venga del puerto serie (ejemplo) char *result = NULL; int index = 0 ; //Iniciamos en la posicion 1 de la cadena Sen1 y Sen2 result = strtok(Sen1, ","); // Funcion strtok que separan las variables while( (result != NULL) && (index < 3) ) { // Mientras la variable sea diferente a NULL (vacia) y index menor a 4 (número de datos a separar) valores[index++] = atol(result); // Aqui se convierten en valores enteros y se almacenan en una variable de tipo long result = strtok( NULL, "," ); // Aqui vacia result para repetir el proceso. } //2 parametros de 1 sensores se almacenan en valores enteros h1 = valores[1]; t1 = valores[2]; } void parse_S2() { char *result = NULL; int index = 0 ; //Iniciamos en la posicion 1 de la cadena Sen1 y Sen2 result = strtok(Sen2, ","); // Funcion strtok que separan las variables while( (result != NULL) && (index < 3) ) { // Mientras la variable sea diferente a NULL (vacia) y index menor a 4 (numero de datos a separar) valores[index++] = atol(result); // Aqui se convierten en valores enteros y se almacenan en una variable de tipo long result = strtok( NULL, "," ); // Aqui vacia result para repetir el proceso. } //2 parametros de 1 sensores se almacenan en valores enteros //Sensor1,35,29 // con index = 1 h2 = valores[1]; //0 t2 = valores[2]; //0 } void sdcard_S1() { String dataString = ""; //Cadena vacia

35

dataString = String(contador1) + "," + String("Humedad S1") + "," + String(h1) + "," +String("Temperatura S1") + "," + String(t1) + ","; File dafile = SD.open("SENSOR1.txt", FILE_WRITE); if( dafile) { dafile.print(","); //Se puede colocar el tiempo de cada impresion dafile.println(dataString); dafile.close(); //Serial.println(dataString); // Imprimir para visualizar que se esta mandando al sdcard } else { Serial.println("Error al abrir datalog.text"); }} void sdcard_S2() { String dataString = ""; //Cadena vacia dataString = String(contador2) + "," + String("Humedad S2") + "," + String(h2) + "," +String("Temperatura S2") + "," + String(t2) + ","; File dafile = SD.open("SENSOR2.txt", FILE_WRITE); if( dafile) { dafile.print(","); //Se puede colocar el tiempo de cada impresion dafile.println(dataString); dafile.close(); //Serial.println(dataString); // Imprimir para visualizar que se esta mandando al sdcard } else { Serial.println("Error al abrir datalog.text"); }}

3.3.2.

Netbeans.

Esta plataforma nos permite hacer un desarrollo de un software más específico y flexible para las distintas aplicaciones que se requieran, por este motivo se eligió usar este software. La aplicación tendrá la función de monitorear los datos recibidos de los sensores.

36

Figura 25. Software desarrollado para realizar gráficas

Fuente: Elaboración propia (Captura de pantalla)

37

4. Capítulo IV Pruebas 4.1. Recepción de datos en comunicación multipunto sin microcontrolador. Con los 2 XBee programados anteriormente como Router y Coordinador, se agrega un XBee más a nuestra red de sensores. Todos los módulos están programados con su firmware ZigBee y versión actualizada, con el software XCTU nos permite ingresar los comandos respectivos y actualizar su versión de firmware. Ya tenemos programado un módulo XBee que tendrá la función de Coordinador y otro XBee con la función de Router. El nuevo módulo XBee también tendrá la función de Router para asi establecer nuestra red de 1 Coordinador con sus 2 nodos. Establecemos los parámetros de Router con su direccionamiento por defecto como lo indica la siguiente tabla:

PAN ID DH DL NI

Tabla 4. Comunicación Punto a Multipunto Coordinador Router 1 3223 3223 0 0 FFFF 0 COOR ROU Fuente: Elaboración propia

Router 2 3223 00 0 ROU2

Recordar que estamos trabajando en el modo comando AT para esta comunicación multipunto. Utilizamos el software y con la herramienta que ofrece su monitor serial, probamos la comunicación conectando los 3 módulos XBee a la PC. Los XBee Router enviarán paquetes de información al XBee Coordinador. Los paquetes se reciben correctamente en orden a

38

través del software XCTU. Un dato llega después de un corto y breve tiempo del otro. La comunicación es exitosa.

4.2. Recepción de datos en comunicación multipunto con microcontrolador y sensores. Se instalan los módulos XBee con sus debidas conexiones en el hardware del Arduino y se establece la comunicación por puerto serial, con el mismo objetivo de probar la comunicación pero ahora con los microcontroladores enviando datos de lectura del sensor. La comunicación es exitosa, se reciben las tramas de los sensores 1 y 2 sin tiempos de latencia. Se observó que se puede configurar los tiempos de envío de tramas y recepción. Con esta prueba ya se puede implementar los demás dispositivos para completar el funcionamiento del proyecto.

4.3. Implementación del sistema de comunicación con dispositivos de monitoreo. Se instalan las pantallas LCD en las entradas digitales del microcontrolador para su configuración. Se observa un problema de contraste en una de las pantallas, por este motivo se decide usar una resistencia variable de 50k con el objetivo de mejorar el display y muestreo de datos en los segmentos. Se muestra un resultado óptimo en el monitoreo de los sensores en sus pantallas incorporadas.

4.4. Recepción de datos en la central empleando el software en Java para verificar su funcionamiento. Ya teniendo nuestra red funcionando con la comunicación multipunto, se procede a avanzar con la siguiente fase, probar el funcionamiento de recepción de datos con el software desarrollado en NetBeans. Este programa está diseñado para recibir la data por el puerto COM designado. La central tiene su microcontrolador que es el Arduino Nano, se encargará de enviar la información por este puerto específico. Una vez establecida la comunicación PC y Central, se muestran los datos recibidos en cajas de texto del programa y también ofrece la opción de visualizar los datos de temperatura y humedad en gráficas con respecto al tiempo. En tiempo real se obtienen las gráficas de los sensores de manera exitosa, los sensores muestran los datos exactos de temperatura y humedad del ambiente.

4.5. Recepción de datos en la central empleando el software en Java y guardando datos en el módulo SD card con registro de hora y fecha.

39

Con el software y hardware ya funcionando, se realizan cambios en la programación del Arduino nano del dispositivo Central para añadir la función del módulo SD Card que nos dará el registro de temperatura y humedad de los sensores, con esto podremos guardar la información que se envía. Se instala este módulo al Arduino Nano ocupando 4 de sus entradas digitales y configuramos su comunicación I2C en la programación. Una vez terminada la conexión, se procede a escribir la data recibida de los sensores a una memoria SD con comandos de la librería SD y SPI que trabaja Arduino. Los datos son guardados en archivos de texto con éxito. Ya tenemos nuestra red funcionando con los dispositivos completos.

4.6. Implementar las tarjetas electrónicas de los dispositivos y probar su funcionamiento. (Se repiten las pruebas anteriores ya con el hardware terminado). Se procede a diseñar una placa compatible con los pines hembra del Arduino Uno y a la vez que se conecte con el sensor, módulo XBee y pantalla LCD. Esto se hace posible gracias a una librería de Arduino en el programa Proteus y Ares para el diseño de la tarjeta electrónica. En este caso, no se toman en cuenta los espacios que tienen los elementos en el diseño. Se hacen las conexiones respectivas en Proteus y luego se pasa a Ares para el diseño del circuito impreso. Se hacen los procesos para obtener las placas. Se trabajan 3 diseños para nuestro hardware de la red.

40

Conclusiones -

Para este proyecto se ha utilizado una comunicación Punto-Multipunto, es decir de un solo módulo XBee Coordinador puedo comunicarme con los demás módulos XBee Routers, usando el protocolo ZigBee, que es el protocolo de comunicación que utilizan los módulos XBee.

-

El sensor DHT-11 usa una señal de ancho de pulso (PWM), la cual al detectar una señal de alta magnitud indica valores lógicos, “1” o “0”, y al detectar una señal de magnitud baja indica el valor contrario, esta sería nuestra señal digital la cual nos da lectura del parámetro Humedad y Temperatura.

-

El Arduino realiza todo el procesamiento del código de lenguaje “C”, que consiste en un micro-controlador, que es un circuito integrado que sirve para acoplar el sensor, la pantalla LCD y el módulo XBee.

-

Hemos establecido en este proyecto dos Arduino (UNO) que tienen la función de codificar la trama que envían a un receptor, en este caso otro Arduino (NANO), que se encargará de decodificar la trama recibida.

-

Los Arduino que se encuentra en los sensores ocuparán a los XBee Router como transmisores, y el Arduino que se encuentra en el coordinador ocupará al XBee Coordinador como receptor de la data.

-

Los XBee han sido programas con comandos AT, que son tipos de comandos que se envían a un dispositivo para poder programar su funcionamiento. La programación que se utilizó para estos módulos fue establecer los parámetros de PAN ID (Área de red personal) y DL, DH (Direccionamientos), y NI (Identificador)

-

El Arduino de los sensores envía el dato a las pantallas LCD por medio de sus entradas digitales. Nota: Las pantallas LCD ocupan 7 entradas, 4 digitales, una RS que es registro, RW que es escribir, y E que es ENABLE que sirve para habilitar la pantalla LCD.

-

El Arduino coordinador se encargará de recibir toda la data de los sensores, la cual enviará por el puerto serial virtual, en este caso hemos usado dos puertos seriales, uno es usado por el módulo XBEE y otra para la PC.

41

-

Para la conexión de la PC con el Arduino coordinador, se estableció un puerto COM por defecto, el cual cumplirá la función de puerto USB que reconocerá el Arduino a la PC.

-

Se diseñó un Hardware ya desarrollado y simulado por el Software Proteus para la conexión de todos los dispositivos, imprimiéndolos en una placa de fibra de vidrio con las pistas impresas y los pines conectados para su presentación.

-

La representación gráfica de los datos puede tener diversos usos, como por ejemplo: si se consideramos que tengamos una data considerable, podemos llegar a estimar en que épocas del año el área controlada alcanza niveles significativos para una posible prevención en el cultivo o en el control de algún proceso.

-

Para nuestro proyecto no hace falta hacer una red MESH debido a que la distancia de punto a punto no son lo suficientemente grandes como para establecer una red como esta, pero queremos hacer énfasis en esto porque no debemos quedarnos con la simple idea que el módulo XBee implica solamente transmisión de datos de punto a punto.

-

Se pudo identificar que los módulos con tecnología ZigBee, son módulos inteligentes que tienen una funcionalidad variada y amplia, a pesar del tamaño reducido que presentan; y permiten un ahorro significativo de energía. Los módulos XBee de nuestro proyecto son de la serie 2, lo que nos permite formar redes más avanzadas, el verdadero objetivo del protocolo ZigBee; en cambio en nuestro caso, solamente podemos realizar comunicación punto a punto.

-

Durante la implementación del proyecto, pudimos notar que el módulo XBee no trabaja cuando el voltaje baja a niveles menores de 2.8V, pudimos notar además que son de fácil configuración e implementación, ya que no requiere de mucha circuitería adicional, sólo adaptadores de voltaje a sus entradas.

-

Los módulos XBee son bastante inmunes al ruido, celulares con llamadas entrantes, además de WI-FI, que podría interferir, al momento de usar la red inalámbrica los datos se transmitieron sin problema.

42

Referencias [1] [2]

https://www.arduino.cc/en/Hacking/PinMapping168 http://www.element14.com/community/groups/arduino/blog/2014/03/28/getting-toknow-arduino-part-1-hello-world [3] http://www.instructables.com/id/Use-xbees-series-2-to-control-amotor/step5/Connect-the-Xbee-to-the-arduino/ [4] http://electropro.pe/index.php?route=product/product&product_id=195 [5] https://felixmaocho.wordpress.com/2014/09/01/huerto-familiar-nebulizadorescontrol-economico-del-clima/ [6] http://rduinostar.com/documentacion/datasheets/dht11-overview/ [7] http://embedded-lab.com/blog/?p=4333 [8] http://panamahitek.com/uso-de-pantalla-lcd-con-arduino/ [9] https://es.wikipedia.org/wiki/Potenci%C3%B3metro#/media/File:Potentiometer.jpg [10] http://www.dx.com/es/p/spi-microsd-card-adapter-v0-9b-for-arduino-works-withofficial-arduino-board-246784#.ViSTe34ve00

43

Anexos

44

Anexo A: Cronograma de actividades y tareas Cronograma y Planificación Fecha

Actividades/Tareas

Responsable

Primera reunión grupal. Identificar el proyecto

Semana 17 al 23 de agosto

Semana 24 al 30 de agosto

Semana 31 de agosto al 6 de setiembre

Determinar problema a resolver

Todos

Asignar diversos puntos de información de los dispositivos a usar Búsqueda de proyectos similares

Ingrid Simón

Sensores

Carlos Vega

Comprar y adquirir dispositivos

Módulos XBee y Pantallas LCD Arduino UNO, y módulo y memoria SD

César Zapata Juan Diego Villegas

Cables Jumper

Ingrid Simón

Sensores

César Zapata

XBee

Carlos Vega

Arduino UNO

Juan Diego Villegas

Investigación de programación

Sensores

Semana 7 al 13 de setiembre

Primer avance de programación

XBee

Todos

Arduino UNO Comprar y adquirir dispositivos

Adaptadores XBee

Ingrid Simón

Comprar y adquirir dispositivos

Batería 9V

César Zapata

Planteamiento de diseño de maqueta para el problema

Todos

Corrección de programación

Carlos Vega

Elaboración y entrega primer informe

Todos


Semana previa a Exámenes Parciales

Todos

Semanas 21 de setiembre al 9 de octubre

Exámenes Parciales

Todos


Desarrollo físico de maqueta Programación en Arduino de la SD Card Elaboración informe final

Ingrid Simón y César Zapata Juan Diego Villegas Carlos Vega Todos

Entrega informe final

Todos

Compra de materiales para maqueta

Semana 12 al 16 de octubre

Semana 13 al 16 de octubre

45

Anexo B: Diseño de Maqueta Materiales -

3 tapas de vidrio acrílico transparente

-

3 cajas de paso de PVC de 10x10cm

-

Separadores con pernos

-

Tornillos

-

3 placas de fibra de vidrio de 10x10cm

- Espadines hembras, machos, machos en “L” -

1 potenciómetro de 50Kohm

-

Jumpers de colores pequeños y largos, hembra-hembra, hembra-macho, machomacho

-

1 tomacorriente triple

-

1 enchufe

-

1 cable para el enchufe

-

2 cables USB con conector CENTRONICS

-

2 cargadores de celular con puerto USB

-

2 cubos de vidrio semidoble de 15x15cm

-

2 plancha de Tecnopor de 15x15cm

-

1 mica transparente

-

1 barra de silicona

-

1 pinturas esmalte 46

-

1 tabla de madera de 45x60cm

-

2 Arduino UNO

-

1 Arduino NANO

-

3 módulos XBEE

-

2 pantallas LCD 16x2 segmentos

-

2 sensores DTH-11 con adaptador

-

1 micro SD Card

-

1 cable USB con entrada a conector micro USB

Diseño Para proteger cada nodo (Los dos sensores) y el coordinador, se ha utilizado cajas de paso de PVC de 10x10cm, las cuales han sido acondicionadas con orificios que permiten tener una conexión de alimentación con los Arduino, y los sensores puedan conectarse con el ambiente. Se ha utilizado planchas de vidrio acrílico transparente como cubiertas de las cajas de paso para así poder visualizar todos los componentes que contiene cada caja de paso (Arduino, pantalla LCD, módulo XBee, placa de fibra de vidrio) y que estén funcionando correctamente, lo que se puede verificar con las luces que destella cada componente. Para simular un ambiente en donde se va a medir los valores de humedad y temperatura, hemos usado cubos de vidrio cubiertos con tecnopor, los cuales aislarán del exterior a los sensores y así se podrán acondicionar ambientes distintos para hacer contrastes con las lecturas obtenidas de cada uno. Los cubos de vidrio simulan un terreno o un área de cultivo, que al utilizar tierra húmeda, podremos tomar lecturas de humedad y temperatura a la que se encuentra esta y así poder predecir el estado en el que se encuentra el cultivo. Para este trabajo se ha tratado de simular dos ambientes distintos.

47

Figura 26. Proceso de diseño de maqueta (1)

Fuente: Elaboración propia Figura 27. Proceso de diseño de maqueta (2)








Trabajo SD 2015II 1

Recommend Documents