Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
1
Universidad de Jaén
Escuela
Polit
écnic
a S
uperior
de L
inare
s
Universidad de Jaén
Escuela Politécnica Superior de Linares
Trabajo Fin de Grado
Trabajo Fin de Grado
______
TELEMONITORIZACIÓN Y
CONTROL DE UN SISTEMA
DE RIEGO POR GOTEO
MEDIANTE BOMBEO SOLAR
Alumno: Cristóbal López Montes
Tutor: Prof. D. Manuel Ángel Gadeo Martos
Depto.: Ingeniería de Telecomunicación
Junio, 2017
2
Escuela Politécnica Superior de Linares
Trabajo Fin de Grado
Curso 2016-2017
TELEMONITORIZACIÓN Y CONTROL DE UN
SISTEMA DE RIEGO POR GOTEO MEDIANTE
BOMBEO SOLAR.
Alumno: Cristóbal López Montes
Tutor: Prof. D. Manuel Ángel Gadeo Martos
Depto.: Ingeniería de Telecomunicación
Junio, 2017
Visto bueno a la defensa del TFG
Firma del autor Firma del tutor
Junio,2017
3
Índice
CAPÍTULO 1. RESUMEN .......................................................................... 11
CAPÍTULO 2. Introducción ......................................................................... 11
2.1. Introducción .............................................................................................................. 11
2.2 Estado del arte ............................................................................................................ 12
CAPÍTULO 3. OBJETIVOS ........................................................................ 13
CAPÍTULO 4. TECNOLOGÍAS UTILIZADAS ......................................... 14
4.1 Elección de tecnología de redes de sensores.............................................................. 14
4.1.1 Xbee ..................................................................................................................... 16
4.1.2 Elección de microcontrolador ............................................................................. 18
4.2 Sensores ..................................................................................................................... 20
4.2.1 Sensor de temperatura y humedad relativa en el ambiente ................................ 20
4.2.2 Sensor de humedad del suelo .............................................................................. 22
4.2.3 Sensor de luminosidad ........................................................................................ 23
4.3 Comunicaciones móviles ........................................................................................... 24
4.3.1 GSM ..................................................................................................................... 25
4.3.2 GPRS ................................................................................................................... 26
4.3.3 GPRS Shield SIM900 de Geeetech para Arduino ............................................... 27
4.3.3.1 Comandos Hayes .......................................................................................... 28
4.4 Servidor ...................................................................................................................... 28
4.4.1 Elección del servidor ........................................................................................... 29
4.4.2 Configuración del servidor ................................................................................. 29
4.5 Base de datos ............................................................................................................. 31
4.5.1 Elección del sistema gestor de base de datos. .................................................... 31
4.6 Aplicación web .......................................................................................................... 32
4.6.1 Entorno de desarrollo ......................................................................................... 32
4.6.1.1 Xampp ........................................................................................................... 32
4.6.1.2 Configuración de Apache Tomcat ................................................................ 33
4.6.2 Modelo Cliente-Servidor ..................................................................................... 34
4.6.2.1 HTTP ............................................................................................................ 35
4.6.3 Modelo Vista Controlador .................................................................................. 36
4.6.3.1 Servlets ......................................................................................................... 37
4
4.6.3.2 Programación Web ....................................................................................... 37
4.6.3.2.1 Lenguaje de programación para scripts ................................................ 38
4.6.4 Librerías de representación ................................................................................ 38
4.6.4.1 JFreeChart ................................................................................................... 38
4.6.4.2 HighCharts ................................................................................................... 39
4.6.4.3 Charts.js ........................................................................................................ 39
4.6.4.4 Google Charts .............................................................................................. 39
4.6.4.5 Elección ........................................................................................................ 39
4.6.5 Estructura de datos ............................................................................................. 40
4.6.5.1 XML .............................................................................................................. 40
4.6.5.2 JSON ............................................................................................................. 40
4.6.5.3 CSV ............................................................................................................... 41
4.6.5.4 Elección ........................................................................................................ 41
4.7 Algoritmo de decisión de riego .................................................................................. 42
4.7.1 Sistema fuzzy ....................................................................................................... 42
CAPÍTULO 5: IMPLEMENTACIÓN .......................................................... 45
5.1 Programación en Arduino .......................................................................................... 45
5.1.1 Adaptación de sensores ....................................................................................... 45
5.1.1.1 Sensor DHT11 .............................................................................................. 45
5.1.1.2 Sensor FC-28 ................................................................................................ 46
5.1.1.3 Sensor LDR ................................................................................................... 47
5.1.1.4 Librería Sensores .......................................................................................... 49
5.1.1.5 Librería Datos .............................................................................................. 50
5.1.2 Interfaz inalámbrica ............................................................................................ 51
5.1.2.1 Arranque ....................................................................................................... 52
5.1.2.2 Conexión con el servidor .............................................................................. 55
5.1.2.3 Sincronización de hora ................................................................................ 58
5.1.2.4 Modo sleep .................................................................................................... 59
5.1.3 Xbee ..................................................................................................................... 59
5.1.3.1 Modelo de red ............................................................................................... 60
5.1.3.2 Configuración de los dispositivos ................................................................ 60
5.1.3.3 Código en Arduino para incorporar Xbee. .................................................. 64
5.1.3.3.1 Dispositivo Final (End- Device) ............................................................ 64
5
5.1.3.3.2 Coordinador (Coordinator) ................................................................... 67
5.1.3.4 Ahorro de consumo ....................................................................................... 70
5.1.4 Modos de trabajo ................................................................................................ 70
5.1.5 Algoritmo de decisión de riego. .......................................................................... 72
5.1.5.1 Conjuntos borrosos ...................................................................................... 72
5.1.5.1.1 Temperatura ........................................................................................... 73
5.1.5.1.2 Humedad ambiente ................................................................................ 74
5.1.5.1.3 Humedad Suelo ...................................................................................... 74
5.1.5.1.4 Luminosidad ........................................................................................... 75
5.1.5.1.5 Salida ..................................................................................................... 75
5.1.5.2 Conjunto de reglas ....................................................................................... 76
5.1.5.3 Librería motorv2 .......................................................................................... 77
5.1.6 Esquema global ................................................................................................... 81
5.2 Servidor ...................................................................................................................... 85
5.2.1 Modelo ................................................................................................................. 85
5.2.2 Controlador ......................................................................................................... 86
5.2.2.1 Controlador de base de datos ....................................................................... 86
5.2.2.2 Servlets ......................................................................................................... 88
5.2.3 Vista ..................................................................................................................... 94
5.3 Montaje de la maqueta ............................................................................................... 96
5.3.1 Sensor de ultrasonidos HC-SR04 ........................................................................ 97
5.3.2 Caudalímetro YF-S201 ...................................................................................... 99
5.3.3 Motor ................................................................................................................. 101
5.3.4 Implementación del sistema de riego ................................................................ 102
CAPÍTULO 6. CONCLUSIONES Y LÍNEAS DE FUTURO .................... 109
6.1 Conclusiones ............................................................................................................ 109
6.2 Líneas de futuro ....................................................................................................... 109
CAPÍTULO 7. BIBLIOGRAFÍA ............................................................... 110
CAPÍTULO 8. ANEXOS ........................................................................... 117
8.1 Manuales .................................................................................................................. 117
8.1.1 Manual de usuario ............................................................................................ 117
8.1.2 Manual de mantenimiento ................................................................................. 124
8.2 Presupuesto .............................................................................................................. 132
6
8.3 Código ...................................................................................................................... 134
8.4 Pliego de condiciones .............................................................................................. 135
Índice de figuras
Figura 4.1 Módulo Xbee ...................................................................................................... 17
Figura 4.2 Red en estrella .................................................................................................... 18
Figura 4.3 Arduino Uno ....................................................................................................... 19
Figura 4.4 Arduino Due ........................................................................................................ 20
Figura 4.5 Sensor DTH11 ..................................................................................................... 21
Figura 4.6 Datos del sensor de humedad ............................................................................ 21
Figura 4.7 Datos del sensor de temperatura ....................................................................... 22
Figura 4.8 Sensor FC-28 ....................................................................................................... 22
Figura 4.9 Sensor GL5516 .................................................................................................... 23
Figura 4.10 Hoja de características GL5516 -1 .................................................................... 23
Figura 4.11 Hoja de características GL5516-2 ..................................................................... 24
Figura 4.12 GL5516: Variación de la resistencia con luminancia ........................................ 24
Figura 4.13 Arquitectura de red GSM ................................................................................. 26
Figura 4.14 Arquitectura de red GPRS ................................................................................. 27
Figura 4.15 Módulo GPRS .................................................................................................... 28
Figura 4.16 Dominios NO-IP ................................................................................................ 30
Figura 4.17 Abriendo puerto en el servidor ........................................................................ 31
Figura 4.18 Configuración puerto Apache -1 ...................................................................... 33
Figura 4.19 Configuración puerto Apache -2 ...................................................................... 33
Figura 4.20 Xampp sin arrancar los servicios ...................................................................... 33
Figura 4.21 Xampp con los servicios activos ....................................................................... 34
Figura 4.22 Ejemplo esquema cliente-servidor ................................................................... 34
Figura 4.23 Ejemplo comunicación HTTP ............................................................................ 36
Figura 4.24 Ejemplo de Annotation Chart ........................................................................... 39
Figura 4.25 Ejemplo archivo XML ........................................................................................ 40
Figura 4.26 Ejemplo de fichero JSON .................................................................................. 41
Figura 4.27 Ejemplo de fichero CVS. ................................................................................... 41
7
Figura 4.28 Definición de conjuntos borrosos para una entrada o salida .......................... 43
Figura 4.29 Esquema de un sistema "fuzzy" ....................................................................... 43
Figura 4.30 Aportación de cada regla a la salida ................................................................. 44
Figura 4.31 Suma de las partes y obtención del centro de gravedad ................................. 45
Figura 5.1 DHT11-1 .............................................................................................................. 45
Figura 5.2 DHT11-2 .............................................................................................................. 46
Figura 5.3 Conexionado DHT11 ........................................................................................... 46
Figura 5.4 Obtención humedad del suelo ........................................................................... 46
Figura 5.5 FC-28 Conexión con Arduino ............................................................................. 47
Figura 5.6 Adaptación LDR.................................................................................................. 48
Figura 5.7 Código LDR-1 ...................................................................................................... 49
Figura 5.8 Código LDR-2 ...................................................................................................... 49
Figura 5.9 Sensores.h .......................................................................................................... 50
Figura 5.10 Datos.h .............................................................................................................. 51
Figura 5.11 Conexionado SIM900 y Arduino Due ............................................................... 52
Figura 5.12 Activando el PIN ............................................................................................... 53
Figura 5.13 Esperando conexión con la red ........................................................................ 53
Figura 5.14 Activar servicio GPRS ........................................................................................ 53
Figura 5.15 Servicio de datos con el operador .................................................................... 53
Figura 5.16 Conexión inalámbrica GPRS.............................................................................. 53
Figura 5.17 IP local ............................................................................................................... 54
Figura 5.18 Configuración del procesador .......................................................................... 54
Figura 5.19 Reinicio Arduino ............................................................................................... 54
Figura 5.20 Creación petición HTTP .................................................................................... 55
Figura 5.21 Conexión TCP .................................................................................................... 55
Figura 5.22 Preparando transmisión ................................................................................... 56
Figura 5.23 Transmisión de datos ....................................................................................... 56
Figura 5.24 Cierre de conexión TCP ..................................................................................... 56
Figura 5.25 Extración de los datos de configuración-1 ....................................................... 57
Figura 5.26 Extración de los datos de configuración-2 ....................................................... 58
Figura 5.27 Sincronización con servidor NTP ...................................................................... 58
Figura 5.28 Conversión ASCII a INT..................................................................................... 59
8
Figura 5.29 Dormir SIM900 ................................................................................................. 59
Figura 5.30 Despertar SIM900 ............................................................................................. 59
Figura 5.31 Xbee acoplado a Arduino ................................................................................. 60
Figura 5.32 Configuración coordinador - 1 .......................................................................... 61
Figura 5.33 Configuración coordinador – 2 ......................................................................... 61
Figura 5.34 Configuración coordinador – 3 ......................................................................... 61
Figura 5.35 Configuración coordinador -4........................................................................... 62
Figura 5.36 Configuración coordinador -5........................................................................... 62
Figura 5.37 Configuración coordinador -6........................................................................... 62
Figura 5.38 Configuración dispositivo final -1 ..................................................................... 62
Figura 5.39 Configuración dispositivo final -2 .................................................................... 63
Figura 5.40 Configuración dispositivo final -3 ..................................................................... 63
Figura 5.41 Configuración dispositivo final -4 ..................................................................... 63
Figura 5.42 Configuración dispositivo final -5 ..................................................................... 63
Figura 5.43 Configuración dispositivo final -6 ..................................................................... 63
Figura 5.44 Pedir fecha -1 .................................................................................................... 65
Figura 5.45 Pedir Fecha -2 ................................................................................................... 66
Figura 5.46 recibirDatos () ................................................................................................... 67
Figura 5.47 Extraer Medida -1 ............................................................................................. 68
Figura 5.48 Extraer Medida -2 ............................................................................................. 69
Figura 5.49 Extraer Medida -3 ............................................................................................. 69
Figura 5.50 leerMedida () .................................................................................................... 70
Figura 5.51 Conjunto borroso trapezoidal .......................................................................... 72
Figura 5.52 motorv2.h ......................................................................................................... 78
Figura 5.53 motorInfiere () -1 .............................................................................................. 78
Figura 5.54 motorInfiere () -2 .............................................................................................. 79
Figura 5.55 pertenencia () ................................................................................................... 79
Figura 5.56 CalculaPeso () ................................................................................................... 80
Figura 5.57 Base reglas ........................................................................................................ 81
Figura 5.58 Diagrama de flujo del dispositivo final ............................................................. 82
Figura 5.59 Diagrama de flujo del coordinador -1 .............................................................. 83
Figura 5.60 Diagrama de flujo del coordinador -2 .............................................................. 84
9
Figura 5.61 Tabla arduino ................................................................................................... 85
Figura 5.62 Tabla deposito .................................................................................................. 85
Figura 5.63 Tabla medida .................................................................................................... 86
Figura 5.64 Database.java ................................................................................................... 87
Figura 5.65 IntroducirMedida() ........................................................................................... 87
Figura 5.66 Representar() .................................................................................................... 88
Figura 5.67 Senalizacion.java -1 .......................................................................................... 89
Figura 5.68 Senalizacion.java -2 .......................................................................................... 89
Figura 5.69 Senalizacion.java -3 .......................................................................................... 89
Figura 5.70 Senalizacion.java -4 .......................................................................................... 90
Figura 5.71 CsvParser.java ................................................................................................... 90
Figura 5.72 Parsear () ........................................................................................................... 91
Figura 5.73 ParsearDepos () ................................................................................................ 91
Figura 5.74 ListaMedidas.java ............................................................................................. 91
Figura 5.75 Deposito.java .................................................................................................... 92
Figura 5.76 Middle.java ...................................................................................................... 92
Figura 5.77 MostrarDatos.java ............................................................................................ 93
Figura 5.78 Añadir Servlet al archivo web.xml .................................................................... 93
Figura 5.79 Charset y CSS .................................................................................................... 94
Figura 5.80 Extraer Localizaciones ...................................................................................... 94
Figura 5.81 Extraer recomendaciones ................................................................................ 95
Figura 5.82 Extraer estado depósitos .................................................................................. 95
Figura 5.83 Ejemplo Google Charts-1 .................................................................................. 96
Figura 5.84 Ejemplo Google Charts -2 ................................................................................. 96
Figura 5.85 Funcionamiento HC-SR04 ................................................................................. 98
Figura 5.86 Conexión HC-SR04 ............................................................................................ 98
Figura 5.87 Flujo de agua según la frecuencia de pulsos .................................................... 99
Figura 5.88 Activación de las interrupciones .................................................................... 100
Figura 5.89 flujo () ............................................................................................................. 101
Figura 5.90 Conexión YF-S201 ........................................................................................... 101
Figura 5.91 Conexión Mosfet IRF520N .............................................................................. 102
Figura 5.92 Medida depósito ............................................................................................. 103
10
Figura 5.93 comprobarAgua () ........................................................................................... 104
Figura 5.94 Control del motor ........................................................................................... 105
Figura 5.95 comprobarDeposito () .................................................................................... 105
Figura 5.96 decidirRiego () ................................................................................................. 105
Figura 5.97 contador_pulsos () final .................................................................................. 106
Figura 5.98 procesoRiego () ............................................................................................... 107
Figura 5.99 Algoritmo de riego .......................................................................................... 108
Figura 8.1 Inicio ................................................................................................................. 118
Figura 8.2 Formulario selección de equipo ....................................................................... 118
Figura 8.3 Selección de gráfico a representar ................................................................... 119
Figura 8.4 Evolución Temperatura ................................................................................... 120
Figura 8.5 Tabla de medidas .............................................................................................. 121
Figura 8.6 Añadir nueva localización ................................................................................. 122
Figura 8.8 Formulario configuración ................................................................................. 123
Figura 8.9 Tabla estado de los depósitos ......................................................................... 124
Figura 8.10 Variables de entorno ...................................................................................... 125
Figura 8.11 Modificando Path ........................................................................................... 125
Figura 8.12 Instalando Xampp ........................................................................................... 126
Figura 8.13 Instalando Eclipse ........................................................................................... 126
Figura 8.14 Compiladores de Arduino ............................................................................... 127
Figura 8.15 Servidor Eclipse -1 .......................................................................................... 128
Figura 8.16 Servidor Eclipse -2 .......................................................................................... 129
Figura 8.17 Arranque del Servidor .................................................................................... 129
Figura 8.18 Configuración Coordinador -1 ........................................................................ 130
Figura 8.19 Configuración Coordinador -2 ........................................................................ 131
Índice de tablas
Tabla 4.1 Clases de Bluetooth……………………………………………………………. 16
Tabla 4.2 Comparativa de placas Arduino………………………………………………...18
Tabla 5.1 Consumo modos sleep Xbee……………………………………………………70
Tabla 5.2 Tabla de modos sleep de Arduino ……………………………………………...71
11
CAPÍTULO 1. RESUMEN
Este trabajo fin de grado tiene como propósito el diseño e implementación de una
estructura telemática para la telemonitorización y control de un sistema de riego por goteo
mediante bombeo solar. Para ello se han utilizado diversas herramientas para la obtención
de datos, su tratamiento, procesamiento y almacenamiento como sensores y
microcontroladores. Asimismo se han proveído de mecanismos de visualización y gestión
a través de una aplicación web.
Las conexiones entre equipos y el servidor web se han realizado mediante el uso de
distintos estándares de comunicación vía radio. Se ha considerado convenientes que,
debido a la necesidad de baterías o sistemas fotovoltaicos autónomos para alimentar los
equipos, ya que estos no van a tener acceso a la red eléctrica, minimizar el consumo de los
mismos.
Finalmente, para ofrecer un servicio automático de riego, se ha dotado al proyecto de un
sistema de decisión borroso basado en reglas.
CAPÍTULO 2. INTRODUCCIÓN
2.1. Introducción
Hoy en día, en la provincia de Jaén, véase [1], la agricultura es uno de los motores
de la economía. Existen alrededor de 590.000 hectáreas de olivos, siendo el cultivo
predominante, lo que supone en torno al veinticinco por ciento del total de la nación.
Uno de los problemas de estos cultivos es la insuficiente cantidad de agua
disponible para el regadío, lo que reduce la producción y se hace necesaria su
racionalización. Se han propuesto nuevos métodos llamados Riego Deficitario que
permiten optimizar el consumo de agua a la vez que se aumenta la cosecha, comparándolo
con un sistema tradicional de secano, véase [2].
Dentro de este marco de necesidades de sistemas que ahorren el consumo acuífero,
se propone la implementación de un sistema, que a través de la obtención de datos del
ambiente como pudiera ser la humedad del suelo o la temperatura, decidan los mejores
momentos para regar, a la misma que vez que deciden la cantidad deseable de agua.
Otro fenómeno que está tomando mucho impulso es el Internet de las Cosas, IoT,
véase [3], que consiste principalmente en permitir el acceso a Internet de multitud de
12
dispositivos, como sensores y actuadores, para ofrecer nuevos servicios, en nuestro caso, se
puede obtener información estratégica para los cultivos para monitorizar el estado del
terreno, y con estos datos, almacenados en un servidor web, proporcionar tanto un control
manual a través de una aplicación web o móvil como establecer algoritmo de riego
automático.
Estas aplicaciones del IoT a los cultivos están contempladas dentro de los objetivos
del denominado Horizonte 2020 de la Unión Europea, que consiste en un programa de
financiación para proyectos de investigación , véase [4]. Se desarrolla dentro del plan
Apolo, véase [5], cuyo objetivo es acercar la agricultura de precisión a los agricultores
europeos.
La agricultura de precisión, AP, se puede definir como la aplicación de las nuevas
tecnologías a la labranza, ofreciendo al agricultor información para mejorar su producción,
existe distintos campos de actuación como la localización de los vehículos a través de
geolocalización GPS, obtención de datos para realización de mapas de rendimiento o
asesoramiento en la toma de decisiones de riego. Para más información véase [6].
Para concluir, parte del equipamiento para la creación de este sistema se tiene que
colocar en localizaciones sin acceso a la red eléctrica, por lo que algunos autores
recomiendan, dado que nuestra región tiene altos niveles de irradiancia solar, el uso de
sistemas fotovoltaicos autónomos, SFA, véase [7], que nos permiten abastecer de energía a
nuestros equipos, a través de paneles fotovoltaicos, buscando a su vez un desarrollo
sostenible. Por otro lado, para trasladar mecánicamente el agua de los depósitos a su
destino, varios expertos proponen el uso de las técnicas de bombeo solar, que a grandes
rasgos consiste en la utilización de un sistema fotovoltaicos para alimentar el motor
encargado del bombeo de agua, véase [8].
2.2 Estado del arte
En la actualidad existen diversas opciones que nos ofrecen soluciones tanto para
implementar sistemas de riego automáticos como para el bombeo solar. Algunas de estas
empresas como Novedades Agrícolas S.A, véase [9], nos permite controlar nuestro cultivo
mediante el uso de sensores y actuadores, permitiendo monitorizar la información y
13
ejercer acciones conforme a esta a través de aplicaciones web, móviles o SMS. Además
permite elegir diversos modos de funcionamiento según las necesidades y características
del cliente. Este sistema está centralizado por un programador de riego encargado del
control del sistema, y la interacción con el mismo se realiza mediante su aplicación Starnet.
Servicios similares nos ofrece Electronobo S.L, véase [10], usando hardware propio
basados en sensores de humedad y en estaciones meteorológicas. Presentan diversas
soluciones para la interconexión del sistema como Ethernet, la red móvil GPRS o mediante
radioenlaces. Su arquitectura de red se basa en unidades remotas que toman medidas a
través de sus sensores y la envía a la unidad de central, la cual procesa la información,
envía las órdenes a las unidades remotas y conecta con el servidor.
En el ámbito del bombeo solar aparecen empresas que nos ofrecen soluciones como
Lorentz, véase [11], la cual nos ofrece desde las placas fotovoltaicas hasta los sistemas de
bombeo, diferenciándose los sistemas completamente fotovoltaicos con los híbridos que
obtienen energía de la red. Mencionar otras empresas dedicada a este sector como Atersol,
Krannich Solar o Monsol.
CAPÍTULO 3. OBJETIVOS
En este apartado se van a presentar las metas de este proyecto para la consecución
de un sistema de riego por goteo automatizado, se presentan tanto los objetivos iniciales
como otros que se han incorporado durante el proceso de realización del mismo para
otorgar de mayores funcionalidades:
Aprender conocimientos básicos sobre el riego por goteo mediante bombeo
solar.
Implementar una red de sensores inalámbrica.
Obtención de datos útiles para monitorizar y controlar el sistema.
Diseño de un protocolo de comunicaciones a través de Internet para el envío
de datos y control telemático del sistema.
Programación de una aplicación web con el que interactuar con el sistema.
Integración de un sistema de riego automático.
Ofrecer una solución global económica.
14
CAPÍTULO 4. TECNOLOGÍAS UTILIZADAS
4.1 Elección de tecnología de redes de sensores
Un sensor se define como un elemento cuyas características físicas, como su
resistencia o capacitancia, varían con un parámetro físico como puede ser la luz, la
temperatura o humedad. Se suele utilizar en conjunto de otros elementos, cuyo conjunto se
denomina red de adaptación, para transformar estas variaciones en cambios de voltaje o
intensidad.
Se define como una red de sensores, o WSN, en un conjunto de nodos con una
distribución espacial esparcida, utilizados para la extracción de información del medio,
[12].
Su arquitectura suele estar formada por dos elementos:
Nodos de medida: son el elemento más importante, ya que son los
encargados de obtener las medidas de los sensores, añadiendo también la
posibilidad de actuar conforme a éstas.
Gateways: actúan como nodo central, ya que da conectividad hacia el
exterior, además reciben los datos de los nodos de medida.
Existen diversas opciones para implementar estas redes de sensores, algunas de las
más destacadas son los Wapsmotes de Libelium, los Arduinos, denominados hardware
libre, o la solución basado en hardware de National Instruments.
Los Waspomotes de Libelium, [13], es un conjunto de soluciones propietarias
adaptable a multitud de escenarios, como las smart-cities o la agricultura de precisión, nos
ofrece diez tipos de microcontroladores propios con diversos tipos de memorias, entradas y
salidas digitales, así como serials. Además son dispositivos de bajo consumo. A su vez,
ofrece multitud de opciones para dar conectividad tanto a través de redes móviles con 4G,
3G o GPRS, Wi-Fi, Zigbee o Bluetooth. Así como una colección de 120 tipos de sensores
y placas solares adaptadas. Nos ofrece sus propios kits de desarrollo, SDK, y librerías,
APIs.
15
Arduino, véase [14], dispone de multitud de placas, orientadas desde aplicaciones
generales hasta específicas, su reducido precio, la facilidad para su uso al otorgarnos
herramientas para su desarrollo como el IDE de Arduino y un lenguaje de programación
propio similar a C++ basado en Processing, una extensa cantidad de librerías gratuitas por
parte de la comunidad. Asimismo, se puede utilizar cualquier sensor del mercado que no
esté integrado, y gracias a que es hardware libre, se le puede acoplar multitud de
dispositivos externos para añadirle más posibilidades como conectividad inalámbrica.
La última opción contemplada es National Instrument, [12], nos ofrece una serie de
gateways así como nodos con conectividad radioeléctricos, con capacidad de conexión de
elementos externos, principalmente sensores. Ambos basados en LabView, que es un
entorno de programación gráfico desarrollado por la misma empresa, utilizada en el control
y monitorización de sistemas principalmente,
Se ha optado por la opción de utilizar la tecnología Arduino, debido a que es una
opción con gran capacidad de adaptación, al permitirnos utilizar elementos de otros
fabricantes, al contrario que Libelium y parcialmente National Instrument, y a su vez, ser
una opción mucho más económica que las dos anteriores.
Usando esta tecnología, tanto el nodo como el gateway se implementarán sobre
Arduino.
Para la interconexión entre los nodos y el gateway se propone la utilización de una
solución que nos ofrezca un alcance razonable con una potencia de transmisión baja a un
precio reducido, siguiendo los objetivos de realizar una propuesta económica y de bajo
consumo.
En nuestro caso, los nodos van a estar compuestos por un Arduino junto a un
conjunto de sensores para la extracción de información, que tendremos que interconectar
con un hardware compatible. Entre las opciones posibles está usar módulos Wi-Fi,
Bluetooth y Xbee.
Bluetooth es una tecnología inalámbrica que trabaja en la banda ISM,
correspondiente a los 2,4 GHz, nos permite transmitir a bajas velocidades con poca
potencia, véase [15]. Existen tres clases según la potencia y alcance:
16
Tabla 4.1 Clases de Bluetooth.
Su consumo se puede verse en dispositivos como [16], que llegan a consumir hasta
160 mW.
Wi-Fi por otro lado, también trabaja en la banda de los 2.4 GHz, permitiendo altas
tasas binarias, su principal inconveniente es su elevado consumo, con radio de alcance
moderados, oscilando su consumo, como se puede observar en [17], que tiene un consumo
de 10 mW en modo sleep, y de 250 mW cuando está en funcionameiento.
Xbee, es una implementación comercial de Zigbee [18], usado para interconexión
de dispositivos orientado hacia el IoT, trabaja en la misma banda, transmitiendo a muy
bajas velocidades, 30Kbps, pero a cambio, se consigue grandes alcances, hasta cien
metros, con un consumo en modo sleep mínimo de 10 microwatios, y un consumo típico
de 100 mW.
En nuestra aplicación, la opción que se considera más adecuada es Xbee, ya que los
datos a transmitir son muy reducidos, nos permiten grandes alcances, y tiene consumo
reducido, véase [19].
4.1.1 Xbee
Este estándar para comunicaciones inalámbrica nos ofrece, aparte de lo expuesto
anteriormente, la posibilidad de realizar enlaces serial inalámbricos de forma transparente
y crear redes, tanto en estrella como malladas.
Nos permite crear redes dentro los 16 radio canales que nos ofrece, existiendo dos
principales modos de funcionamiento, el modo AT, que permite comunicar dos
dispositivos como si fuera una conexión serial, y el modo API, que a través de los
comandos Hayes introducidos anteriormente, permite la conmutación de paquetes.
17
Este mismo posee su propio algoritmo de encaminamiento, basándose en dos tipos
de direcciones, las primera utiliza una dirección de 64 bits, dividida en dos partes, el SH y
SL, que es única para cada equipo, la otra opción, es utilizar una dirección de 16 bits, MY,
únicamente válida dentro de la red a la que pertenezca el dispositivo.
En la topología existen tres tipos de equipos:
Coordinador: encargado de crear la red y de conmutar paquetes.
Router: exclusivamente conmuta paquetes.
End-Device (Dispositivo final): no tiene la capacidad de conmutar
paquetes.
Existen dos familias, la serie 1 y la serie 2, dado que tenemos accesibles los
modelos de la serie 1, se utilizarán estos.
La mayor diferencia de entre ambas series es la capacidad de la segunda de crear
redes malladas, desapareciendo los Routers, pero la configuración y funcionalidad son las
mismas, si quisiéramos ampliar a la serie 2, simplemente habría que configurar los equipos
intermedios como Router. Para más información véase [19].
Se muestra a continuación una serie de figuras relacionadas con lo expuesto:
Figura 4.1 Módulo Xbee
18
Figura 4.2 Red en estrella
4.1.2 Elección de microcontrolador
A continuación se va presentar en una tabla los principales modelos con sus
características técnicas, véase [20]:
Nombre CPU
MHz
Pines I/0
Analógicos
Pines
I0/PMW
Digitales
EEPR-
OM
[KB]
SRAM
[KB]
Flash
[KB]
UART
Serial
Voltajes
In/Out
Uno 16 6/0 14/6 1 2 32 1 12-7/5
Mega 16 16/0 54/15 4 8 256 4 12-7/5
Yun 16 12/0 20/7 1 2.5 32 1 5/5
Due 84 12/2 54/12 - 96 512 4 12-7/3.3
Tabla 4.2 Comparativa de placas Arduino
Nuestra red va a estar formada por dos tipos de elementos, por un lado los
dispositivos finales o nodos, cuya funcionalidad será la de capturar datos sensibles del
ambiente y esperar órdenes, y por otro lado, los coordinadores o gateways, estos
dispositivos toman las funciones de los anteriores, añadiéndoseles una capa de complejidad
19
ya que ellos procesarán los datos para la toma de decisiones y tendrán las tareas de
comunicación, tanto con los dispositivos finales como con el servidor.
Por lo tanto, para los primeros, utilizaremos los modelos Uno, que nos ofrece la
suficiente cantidad de pines tanto digitales como analógicos para conectar los sensores y
módulos de comunicación necesarios, como memoria y capacidad de procesamiento
suficiente para las operaciones a realizar.
En cambio, para los coordinadores, propondremos el uso de las placas Due, que nos
ofrecen una mayor velocidad de cómputo, memoria, pines, y conexiones serial, que nos
harán falta para conectarle dispositivos hardware adicionales.
Se procede a mostrar imágenes de los dispositivos elegidos:
Figura 4.3 Arduino Uno
20
Figura 4.4 Arduino Due
4.2 Sensores
En este apartado se va a tratar sobre los sensores elegidos para extraer parámetros
físicos estratégicos para monitorizar el estado del terreno. Se pueden tener en cuenta
multitud de parámetros, véase [21], pero debido a las limitaciones temporales y
presupuestarias, se ha decidido centrarse en las magnitudes más importantes a nuestro
juicio, como son la temperatura ambiente, luminosidad, humedad relativa en el ambiente y
humedad en el suelo.
Para le elección de los sensores se ha buscado un equilibrio entre la calidad y
precio, escogiendo dispositivos reconocidos y testeados, con un precio relativamente bajo.
4.2.1 Sensor de temperatura y humedad relativa en el ambiente
Para la medición de la temperatura y la humedad relativa se ha optado por un
dispositivo que integra ambos sensores, denominado DTH11.
Entre sus características resaltar que es un instrumento digital, que permite extraer
la humedad relativa ambiente, en el rango entre veinte y noventa por ciento, con un margen
de error del uno por ciento, con una velocidad de respuesta típica de diez segundos.
Asimismo, permite medir la temperatura dentro del rango cero a cincuenta grados
21
centígrados, con una resolución de un grado, y un tiempo de respuesta entre seis y treinta
segundos. Para más información véase [22].
Estos valores son aceptables para nuestra aplicación, ya que ambas magnitudes
físicas en nuestro entorno tienen una variación mucho menor que la que son capaces de
captar este dispositivo, y la tolerancia de la medidas no son lo suficientemente grandes
como para influir negativamente en nuestro sistema, por lo que se convierte en un
dispositivo ideal.
Seguidamente se muestra una sucesión de figuras del dispositivo y de su hoja de
características:
Figura 4.5 Sensor DTH11
Figura 4.6 Datos del sensor de humedad
22
Figura 4.7 Datos del sensor de temperatura
4.2.2 Sensor de humedad del suelo
Para extraer la humedad del suelo se ha elegido el dispositivo FC-28, su señal de
salida es un valor de voltaje inversamente proporcional a la conductividad del suelo, lo que
nos permite estimar la humedad del mismo, debido a la estrecha relación entre su humedad
y conductividad.
A mayor presencia de agua, menor corriente circulará por las patillas del sensor, y
nos ofrecerá un menor voltaje. Por lo tanto, se puede deducir que a máxima diferencia de
potencial el suelo estará totalmente seco, y cuando sea nulo, totalmente húmedo.
Este sensor carece de una hoja de características que nos permita estipular una
relación exacta entre humedad y voltaje, por lo que se debe calibrar manualmente según
los requisitos de cada proyecto. Para más información consulte [23].
Se muestra una imagen del sensor a continuación:
Figura 4.8 Sensor FC-28
23
4.2.3 Sensor de luminosidad
La obtención de la luminosidad se va a realizar con un sensor LDR modelo
GL5516, que es un fotoresistor cuya resistencia es variable con la luminosidad, siendo ésta
inversamente proporcional a la luz incidente, medida en lux. Para más información
consulte [24].
Este instrumento no es de alta precisión, por lo que tiene un margen de error alto,
pero eso no nos afecta, ya que nuestra aplicación no necesita saber con exactitud los
valores de luminancia, únicamente nos basta con una estimación para discriminar entre
niveles altos, medios y bajos de luminosidad.
Se muestra una serie de imágenes del sensor y su hoja de características:
Figura 4.9 Sensor GL5516
Figura 4.10 Hoja de características GL5516 -1
24
Figura 4.11 Hoja de características GL5516-2
Figura 4.12 GL5516: Variación de la resistencia con luminancia
4.3 Comunicaciones móviles
Los equipos de medida y procesamiento van a estar aislados de cualquier red
cableada, por lo que la comunicación entre el coordinador y el servidor se realizará a través
de una comunicación vía radio.
Existen diversas tecnologías inalámbricas, como el conjunto de estándares 802.11,
WiMax, radioenlaces, etc.
25
Se han descartado varias de estas opciones, por sus limitaciones de cobertura o por
la elevada inversión, habiéndose elegido finalmente el estándar de comunicaciones GPRS,
General Packet Radio Service, dado que nos ofrece una velocidad de transmisión
suficiente, gracias a que los datos a transmitir son del orden de centenares de bytes como
máximo, posee una cobertura muy amplia, al ser la misma que la que posee GSM, Global
System for Mobile, y con unos servicios brindados por los proveedores muy económicos.
4.3.1 GSM
En este apartado se va a redactar un breve resumen sobre la tecnología
GSM, ya que la tecnología objetivo, GPRS, está basada en ella.
Este estándar, denominado también de segunda generación, 2G, fue la primera
tecnología digital para radiofonía. Su rango de frecuencias se sitúa en dos bandas, en la de
900 MHz, y la de 1800 MHz, usando canales de 200KHz y técnicas de multiplexación en
el tiempo y en frecuencia. Destacar otros servicios adicionales como los mensajes, los
SMS, de gran éxito comercial. Para más información véase [25].
Su estructura está conformada por los siguientes elementos:
Estaciones móviles, MS, que son los usuarios finales.
Estaciones base, BTS, se encarga de la interfaz radio.
Controlador de estaciones base, BSC, como su nombre indica, maneja
varias estaciones, y se conecta con los centros de conmutación y las bases
de datos.
Centros de conmutación de servicios móviles, MSC, conmuta las llamas.
Pasarela o Gateway, denominada SMS-GMSC, enlaza la red móvil con la
red telefónica básica.
Un conjunto de base de datos interrelacionadas con información adicional.
Se presenta un esquema de la arquitectura de la red GSM:
26
Figura 4.13 Arquitectura de red GSM
4.3.2 GPRS
Una vez conocida la estructura básica de GSM, se procede a introducir la
tecnología GPRS.
GPRS es una ampliación de GSM que añade soporte a la red para la conmutación
de paquetes. La transmisión se realiza en los mismos canales de GSM cuando estos están
libres. Tiene unas tasas de velocidad teóricas máximas de 170Kbps, siendo en la práctica
de 60 Kbps. Véase [26].
Para permitir estos servicios se añaden nuevos elementos a la red GSM, destacando
los dos siguientes:
Servicing GPRS Support Node, SGSN, entre sus diversas funciones
destacan su interacción las estaciones móviles y la conmutación de los
paquetes.
Gateway GPRS Support Node, GGSN, es la puerta de enlace que permite
conectarse con otras redes como Internet.
27
Para concluir este apartado, se muestra la configuración final de la red móvil
introduciendo los elementos de GSM y GPRS:
Figura 4.14 Arquitectura de red GPRS
4.3.3 GPRS Shield SIM900 de Geeetech para Arduino
Para la elección de un hardware que permita el uso de la red GPRS se ha tenido en
cuenta que debe ser compatible con el Arduino Due que se va a utilizar.
Se he elegido el GPRS Shield 900 de Geetech, entre las características de este
dispositivo destacan ser bibanda, eso quiere decir que emite tanto en la banda de 900MHz
como de 1800MHz, un consumo máximo de dos watios mientras está transmitiendo, y de
6.75mW cuando está en modo reposo.
La conexión con el Arduino Due es a través de un serial, lo cual no es un
problema, ya que este incluye cuatro. Para su alimentación se necesita una fuente externa
de 5V porque los picos de consumo son elevados, y no podría haber problemas si se
comparte la misma con el coordinador.
La comunicación entre el módulo y el Arduino se realiza mediante una serie de
comandos que se presentarán a continuación. Para más información véase [27].
28
Se muestra una fotografía del dispositivo:
Figura 4.15 Módulo GPRS
4.3.3.1 Comandos Hayes
A la hora de configurar los módems GPRS y de interactuar con la red, se utiliza un
conjunto de instrucciones creadas por la empresa Hayes Microcomputer Products, véase
[28].
Hoy en día se encuentra en la mayoría de equipos módems, tanto GPRS como de
otras tecnologías, que se fabrican. Entre sus posibilidades se encuentran la selección de
parámetros de transmisión, establecer comunicaciones TCP con otros equipos así como
llamadas y enviar mensajes SMS.
4.4 Servidor
Dada la necesidad de almacenar los datos obtenidos para posteriormente
visualizarlos, a través de una aplicación web, tomar decisiones y modificar parámetros del
sistema, se va a necesitar un equipo que reciba los paquetes enviados por el coordinador y
los introduzca en una base de datos para su posterior procesamiento.
29
4.4.1 Elección del servidor
Existen múltiples opciones para implementar un servidor, se puede externalizar,
usando servicios de hosting a través de Internet, tanto de pago, como OVH, véase [29], que
nos ofrece el servicio pagando el dominio más el servidor web por tres euros más IVA
anuales. O gratuitos como, 000webhost, véase [30], que suelen tener limitaciones a menos
que pagues por servicios premium. También existe la posibilidad de crear el servidor en tu
propio equipo, con el inconveniente de la obligación de tener el equipo siempre encendido
y con conexión a Internet permanente.
Se ha decidido utilizar un servidor integrado en mi propio equipo personal, dado
que la conexión a Internet ya está contratada con unas velocidades de subida y bajada altas,
me ofrece un mayor control de forma directa sobre el mismo, y a su vez más opciones que
un servidor gratuito sin coste alguno.
4.4.2 Configuración del servidor
Durante el proceso de configuración del equipo se ha encontrado un problema, el
cual consiste en que el proveedor de servicios actualmente me está ofreciendo conexión a
Internet asignándome una dirección IP dinámica, como consecuencia mi IP pública varía
con el tiempo, no permitiéndome conectar el coordinador a mi equipo ya que no sé la
dirección IP que tengo, por lo que se ha recurrido a utilizar un servicio de DNS dinámico.
DNS, Domain Server Protocol, es un servicio formado por multitud de base de
datos con una topología en árbol, que traducen los nombres de las páginas web o dominio a
direcciones IP, para poder encaminar las peticiones al servidor. Para más información
véase [31].
Dado que mi servidor tiene una dirección IP dinámica, se va a tener que utilizar un
servicio de DNS dinámico, el cual varía la relación entre el dominio y la dirección IP
periódicamente.
Al igual que el web hosting, hay opciones de pago y gratuitas, las de pago nos
ofrece por una cuota la posibilidad de elegir el nombre del dominio que queramos, como
DynsDNS, [32], o gratuitos como NO-IP, [33], cuyas limitaciones son el número de
30
dominios, el nombre del dominio debe acabar por un nombre prefijado por ellos, y la
necesidad de confirmar el uso del host cada 30 días.
Dado que uno de los propósitos de usar un equipo propio como servidor es el
ahorro, se ha optado por una opción gratuita, como NO-IP, ya que el nombre del dominio
no es importante, la limitación de dominios no nos afecta ya que solo vamos a utilizar uno,
y mensualmente conectarse al correo para mantener el servicio no es una actividad pesada.
Una vez registrados, creamos un dominio con un nombre cualquiera, en nuestro
caso, se ha denominado "sistemariego.ddns.net", como se muestra en la siguiente figura:
Figura 4.16 Dominios NO-IP
Como se puede ver en la figura 4.14, hay un apartado IP/Target, el cual es nuestra
dirección IP, que varía con el tiempo, hemos de descargar e instalar una aplicación que nos
ofrecen para renovar ese campo de forma automática cuando cambie nuestra IP, bautizado
Dynaminc DNS Update Cliente (DUC), que funcionará en segundo plano. Para su
descarga ir al enlace [34].
Finalmente, queda abrir el puerto que vaya a utilizar nuestro servidor para recibir y
responder peticiones, para ello hemos de entrar a la configuración del router, vamos al
apartado "Port Range Forwarding" y abrimos el puerto 8084, que es el que va a utilizar
nuestro servidor. Indicar además que debemos asignar una IP privada fija al equipo para
poder redireccionar el tráfico continuamente. Se muestra el proceso en la siguiente imagen:
31
Figura 4.17 Abriendo puerto en el servidor
4.5 Base de datos
El almacenamiento de datos se debe se realizar en una estructura de ficheros
flexible que nos permita introducir, modificar y extraer información de forma organizada,
evitando duplicidades y errores.
Para ello se ha optado por una base de datos, que consiste en una serie de tablas
estructuradas que se interrelacionan entre sí mediante parámetros llamados "keys". Cada
una de estas tablas almacena un conjunto de datos de distinta índole que tiene algún tipo de
relación entre sí.
Toda la gestión de estas tablas y sus contenidos asociados se realizan a través de un
conjunto de instrucciones distintas para cada sistema gestor. Para más información véase
[35].
4.5.1 Elección del sistema gestor de base de datos.
Existen varios sistemas gestores en la actualidad, algunos de ellos como DB2 de
IBM son de pago [36], al igual que Microsoft Access [37], mientras que existen otros
gratuitos totalmente funcionales como MySQL [38].
Se ha seleccionado por MySQL por una serie de motivos tales como su gratuidad,
lo cual se adapta a nuestro objetivo de realizar un sistema económico, que es muy
utilizado, lo que implica que hay mucha documentación sobre él y también nos ofrece
herramientas gráficas como phpmyadmin.
32
4.6 Aplicación web
En el desarrollo de una aplicación web entran en juego varios factores, como
lenguajes de programación a utilizar, librerías, estructuras de datos y entornos de
desarrollo, de todos estos aspectos se tratarán a continuación.
4.6.1 Entorno de desarrollo
La elección de un entorno de desarrollo, IDE, está estrechamente relacionado con
las tecnologías a utilizar, por lo tanto, se hará una introducción de las mismas. Como
lenguajes de programación se va a utilizar Java en la parte del servidor, usando su versión
J2EE, HTML, Servlet, JavaScript y JSP para el desarrollo de los script y páginas web.
Existen multitud de IDEs que se adecuen a nuestras necesidades, como NetBeans,
Eclipse e IntelleJ Idea.
IntelleJ Idea, tiene dos modelos, uno de pago que incluye las herramientas para
utilizar MySQL y Javascript, y otro gratuito al que le faltan estas opciones, dado que no
cumple nuestros requisitos la versión gratuita, se descarta.
Tanto NetBeans como Eclipse nos ofrecen los módulos necesarios, aunque
NetBeans hay que descargarlos aparte mientras Eclipse los trae por defecto.
Finalmente, se optó por Eclipse, ya que tiene una gran cantidad de bibliotecas y es
un IDE muy utilizado en el sector, por lo que se veía positivo familiarizase con este
entorno. Para su descarga véase [39].
4.6.1.1 Xampp
Eclipse no cuenta con todo el software necesario para el desarrollo y ejecución de
una aplicación web, por lo que se ha de instalar de forma externa, aunque el propio IDE es
capaz de detectarlo e incorporarlo una vez esté en nuestro equipo.
Se puede instalar cada componente por separado, pero existen servicios que te
integran varios a la vez, como Xampp, éste paquete integra, entre otros, el contenedor de
Servlets Apache Tomcat , compatible con los servidores Apache que utiliza Eclipse, así
como el motor de base de datos MySQL MariaDB. Para más información, véase [40].
33
Tomcat es un complemento para Apache que nos permite ejecutar los Servlets de
nuestro servidor, aparte de otros elementos como WebSockets, véase [41].
4.6.1.2 Configuración de Apache Tomcat
El puerto por defecto de Apache Tomcat es el 8080, pero ya estaba está ocupado
por otro programa, por lo que se modificó al 8084, y también existen colisiones entre
HTTP y Tomcat al usar ambos el puerto 80, por lo tanto, hay que reconfigurar los puertos.
En el archivo de Apache "httdp.conf" debemos cambiar el puerto de escucha del 80
a otro libre, en mi caso he puesto el 81, véase [42], como se muestra a continuación:
Figura 4.18 Configuración puerto Apache -1
Por otro lado, dentro de la carpeta de Tomcat, en el directorio conf/server.xml, hay
que modificar el puerto de escucha al 8084, véase [43], como se muestra a continuación.
Figura 4.19 Configuración puerto Apache -2
Por último, para arrancar los servicios hay que entrar en Xampp y darles al botón
"Start", y después del proceso de arranque se podrá en verde. Se procede a mostrar los dos
estados:
Figura 4.20 Xampp sin arrancar los servicios
34
Figura 4.21 Xampp con los servicios activos
4.6.2 Modelo Cliente-Servidor
Las comunicaciones entre el coordinador y servidor se realizarán a cabo a través del
esquema cliente-servidor, en el cuál, el cliente realiza peticiones al servidor, y este las
responde, véase [44].
Para ello el cliente debe saber la dirección IP y el puerto al cual realizar las
peticiones, para el primer requerimiento se implementó el servicio anterior de DNS
dinámico. Para el segundo, se realizó un cambio de puertos en al apartado anterior, para
que respondiera al puerto 8084. Se procede a presentar una imagen ejemplo:
Figura 4.22 Ejemplo esquema cliente-servidor
35
4.6.2.1 HTTP
El protocolo que se va a utilizar para transportar las peticiones y las respuestas es
HTTP, Hyper Text Transfer Protocol, el cuál pertenece al nivel de aplicación del modelo
OSI.
Este protocolo está formado por una serie de cabeceras que nos permiten definir
parámetros, tanto de la petición como de la respuesta, así como añadir información
adicional, además de texto, este protocolo nos permite transmitir archivos multimedia.
Las peticiones pueden utilizar distintos métodos, siendo los principales, GET y
POST. Ambos sirven para acceder a un recurso del servidor, la diferencia es que el primero
codifica los datos adicionales en la URL, mientras que el segundo en un campo posterior a
las cabeceras, denominado Request body.
Las respuestas, aparte de una serie de cabeceras, se definen por la primera línea,
que nos da un código de estado, que nos indica la existencia de errores o no.
Posteriormente se añaden los datos requeridos en el Request body.
En la aplicación web a implementar se va a utilizar el método POST, ya que el
método GET solo nos permite transmitir un número limitado de datos, según el navegador
web sea capaz de leer. Igualmente, el método POST añade una capa de seguridad al no
mostrar en la URL los datos a transmitir. Para más información véase [45].
Se muestra en la siguiente figura un ejemplo:
36
Figura 4.23 Ejemplo comunicación HTTP
4.6.3 Modelo Vista Controlador
El paradigma de programación típico para las aplicaciones web es el de Modelo
Vista Controlador, véase [46], consiste en las tres capas que indica el propio nombre:
Modelo: trata sobre el almacenamiento de la información en la aplicación,
en nuestro caso, la base de datos con la información de los sensores, ya
determinada en apartados anteriores.
Vista: es la representación gráfica de la información al usuario, usando las
páginas web con los lenguajes HTML, JavaScript y JSP.
Controlador: encargada de interactuar con el usuario, hace de interfaz entre
Vista y Modelo, empleando Servlets y clases Java para interactuar con la
base de datos.
37
4.6.3.1 Servlets
En la parte de controlador se van a aplicar Servlets, que son aplicaciones ejecutadas
en el servidor, ampliando sus funcionalidades, su lenguaje de programación es Java lo que
potencia la compatibilidad entre diversos sistemas operativos.
Los Servlets son capaces de recibir peticiones HTTP, procesarlas y responderlas,
además permite realizar otras acciones como interactuar con base de datos, de forma
abstracta mediante el uso su propia API, que a través de sus librerías javax.servlet y
javax.servlet.http nos ofrecen todos los objetos y métodos necesarios.
Los Servlets son un objeto cuyo ciclo de estados viene dado por tres posibilidades,
creación, uso y destrución. Para más información véase [47].
En nuestro caso, se van a utilizar para recibir, procesar y enviar datos al
coordinador, y a su vez, interactuar con el usuario final a través del servicio web.
4.6.3.2 Programación Web
En la parte de vista, se suele aplicar un conjunto de lenguajes, tanto HTML,
HyperText Markup Language, que es un lenguaje de marcas que define la estructura de
una página web a través de directivas entre los símbolos "<" y ">", como otros como PHP
o JavaScript , que amplían las posibilidades HTML, al permitir páginas web dinámicas.
De forma conjunta a HTML, se puede utilizar JSP, JavaServer Pages, que es
archivo basado en Java que permite crear páginas HTML de forma dinámica,
transformando los JSP en Servlets para su ejecución en el servidor. [48].
Estos archivos suelen incluir código HTML en el cual se incrustan las directivas de
JSP, definidas entre los elementos "<%" y ">".
JSP por tanto, permite añadir una capa adicional de complejidad a HTML, que por
sí solo es limitado. Por ejemplo, permite con facilidad la programación de bucles, o extraer
datos de la base de datos para representarlos.
38
Un elemento muy importante que nos ofrece HTML, son los formularios, que
gracias a ellos nos permiten obtener información del usuario utilizando diversos métodos,
como botones, menús o cajas de texto.
Estos datos son enviados a un Servlet para que los procese, como se verá en el
apartado 5.2.2.2.
4.6.3.2.1 Lenguaje de programación para scripts
JavaScript, es un lenguaje de programación interpretado similar a Java, que permite
el desarrollo de script tanto, en el lado del cliente, esto quiere decir, que el encargado de
su ejecución es el navegador web del usuario, como en el servidor. Su uso se basa en la
utilización de objetos, normalmente incluidas en la API. [49].
Por otro lado, PHP, Hypertext Preproccesor, en un lenguaje permite ejecutar script,
en el lado del servidor, su código, al igual que JavaScript, se incrusta en el código HTML,
con las etiquetas "<?php" "?>". De forma nativa permite realizar consultas a base de datos
en una sola línea. [50].
Se ha optado por JavaScript, dado que nos ofrece un conjunto de herramientas
similar PHP, y la codificación de PHP usa comandos totalmente distintos a los vistos por
mí anteriormente, mientras que JavaScript, al ser similar en este aspecto a Java, es más
fácil de utilizar en mi caso.
4.6.4 Librerías de representación
Una de las funcionalidades de nuestra aplicación es la representación de los datos
obtenidos por los sensores, a través de tablas y gráficos, para tal finalidad de ha decidido
utilizar una librería que nos permitiese realizarlos de forma sencilla y con una apariencia
visual atractiva. Se van a introducir algunas de las soluciones encontradas.
4.6.4.1 JFreeChart
Esta librería gratuita es reconocida por su gran versatilidad, dado que contiene una
gran cantidad de modelos por defecto, con la posibilidad de personalizarlos. Está basada en
Java, véase [51]. Su inconveniente es que la guía de usuario es de pago.
39
4.6.4.2 HighCharts
Es una librería basada en JavaScript de alta calidad, utilizada por grandes empresas
como Facebook o AT&T, véase [52]. Como desventaja, hace falta contratar una licencia.
4.6.4.3 Charts.js
Destaca por estar diseñada específicamente para HTML5 y ser gratuita, ofrece ocho
tipos distintos de gráficos configurables, véase [53].
4.6.4.4 Google Charts
Esta API diseñada por Google es gratuita, ofreciéndonos una cantidad ingente de
estilos configurables, existiendo una opción llamada Annotation Charts, que nos permite
visualizar la variación de los datos a lo largo del tiempo, con exactitud de segundos, y con
la posibilidad de hacer zoom en la zona de interés, véase [54].
Figura 4.24 Ejemplo de Annotation Chart
4.6.4.5 Elección
Teniendo en cuenta nuestros objetivos, nos interesa una librería gratuita, y cuya
documentación sea accesible, descartando JFreeCharts y HighCharts. Además, nos debe
dar la posibilidad de configurarla, y mostrar la variación de los datos a lo largo del tiempo,
40
siendo Google Charts la que mejores resultados nos ofrece, siendo está la librería utilizada
finalmente.
4.6.5 Estructura de datos
El coordinador transmitirá los datos obtenidos por los sensores, para ello se ha de
transmitir en un formato ordenado al servidor, para poder extraerlos adecuadamente e
introducirlos a la base de datos. Para ello se presentan distintas opciones.
4.6.5.1 XML
Es un fichero de texto que almacena datos en objetos definidos en una estructura de
árbol, tiene una sintaxis propia, la estructura de los datos queda definida en un documento
aparte, existiendo los DTDs y los Schemas, según la forma de declararla, para más
información véase [55].
Para extraer los datos del servidor se realiza mediante un parser, que es un
programa que analiza el documento, conociendo a priori su estructura, y extrae la
información. Es un estándar amoldable a cualquier aplicación ya que permite transmitir
archivos aparte de texto.
Figura 4.25 Ejemplo archivo XML
4.6.5.2 JSON
Es un estándar para la transmisión de información en JavaScript, de fácil uso
gracias a que funciona de forma nativa en este lenguaje. Los datos se envían en pares, el
primero es el nombre de la variable, seguido de su valor. Sólo permite transmitir texto.
En la parte del servidor, viene preprogramado un parser por defecto, que nos
permite extraer la información de una forma más sencilla, véase [56].
41
Figura 4.26 Ejemplo de fichero JSON
4.6.5.3 CSV
Es un tipo de fichero cuyo fundamento es separar los datos por comas, es un
estándar muy sencillo y flexible.
Tanto para la escritura y lectura del fichero ha de conocerse de antemano la
estructura del mismo, siendo de difícil compresión humana al solo mostrarse los valores de
las variables. Véase [57].
Figura 4.27 Ejemplo de fichero CVS.
4.6.5.4 Elección
En nuestro sistema, cualquiera de las tres alternativas son capaces de soportar la
información a transmitir, ya que solo son valores de texto de las mediciones de los
sensores.
Por facilidad de uso JSON es la mejor opción, ya que es fácilmente integrable con
el lenguaje de servidor, pero existe un problema, que afecta tanto a XML como a JSON, y
es la limitación de memoria RAM, donde se almacenarán los datos a transmitir, JSON, y
sobre todo XML, necesita una gran cantidad de texto adicional, que no son capaces de
almacenar los Arduinos, debido a que los coordinadores deben de almacenar los datos
propios además de los provenientes de los dispositivos finales. Igualmente, los datos se
transmitirán en paquetes con varias medidas, lo que aumenta la cantidad de memoria RAM
necesaria.
Por lo tanto, se ha elegido la opción más sencilla, que aún con sus limitaciones,
cumple los requisitos de transmisión y memoria, CSV.
42
4.7 Algoritmo de decisión de riego
En esta sección se tratará el procedimiento para determinar cuándo y cuánto es
necesario regar.
Por la naturaleza del problema, el cual es variante, no siempre se riega bajo una
condiciones exactas que nos pueda ofrecer una fórmula, sino más bien, basándose en la
lógica y en la experiencia, se propone un método que nos permita plasmar estos
conocimientos en un algoritmo, usando un sistema "fuzzy".
4.7.1 Sistema fuzzy
Un sistema "fuzzy" o sistema borroso basado en reglas, véase [58], es un método
que busca plasmar el pensamiento humano mediante un conjunto de reglas léxicas
formadas por el par: "Si", "Entonces".
Ej: Si X es grande e Y es alto entonces Z es bueno.
El primer término, indica las condiciones necesarias para que se produzca una
acción o hecho, determinada por el segundo término.
Indicar que tanto las condiciones de entrada y de salida, son variables, a las cuales
se les asigna un subconjunto según su valor, pero estos subconjuntos no están definidos
con un grado de pertenencia binario, en el cual un valor puede pertenecer o no a un
subconjunto, sino que se aplica una clasificación progresiva, entre 0 y 1, siendo 0
totalmente externo y 1, totalmente perteneciente. Por lo tanto, un valor puede pertenecer a
dos subconjuntos con distintos grados de pertenencia. Se puede utilizar varios modelos
geométricos como triángulos y trapezoides para definir los subconjuntos, como se muestra
en la figura:
43
Figura 4.28 Definición de conjuntos borrosos para una entrada o salida
Un sistema fuzzy es un sistema formado por los siguientes bloques:
Entrada y salida: la entrada es uno o más parámetros que se toman, en
nuestro caso las mediciones de los sensores, y la salida, es un valor exacto
sobre la cantidad de agua a regar.
Una base de conocimientos, subdividida en dos áreas, la base de datos, que
contiene la definición de los conjuntos borrosos y la base de reglas, que
contiene el conjunto de reglas.
Normalizador: transforma los valores de entrada entre 0 y 1.
Desnormalizador: modifica el valor de salida para que sea un valor aplicable
a nuestra aplicación.
"Fuzzificador": a partir de los datos de entrada normalizados, consigue los
valores borrosos correspondientes con su grado de pertenencia.
"Defuzzificador": a partir de los valores borrosos de salida, extrae la salida
real del sistema.
"Motor inferencia": con los valores borrosos de entrada y la información de
la base de reglas, obtiene la salida borrosa del sistema.
Se muestra un esquema de bloques del algoritmo:
Figura 4.29 Esquema de un sistema "fuzzy"
44
El motor inferencia hará los cálculos usando el modo B-FITA: en el cual primero
calcula la aportación de cada regla para finalmente obtener el valor medio, que se utilizará
como salida. El método tiene los siguientes pasos:
Para cada regla, se obtiene el grado de pertenencia mínimo de los valores
borrosos de entrada.
Con este valor, se obtiene el grado de pertenencia al subconjunto borroso de
salida, calculando el valor mínimo entre ese valor y la función que define el
subconjunto borroso.
Finalmente, se suman las salidas individuales y se obtiene el centro de
gravedad de los datos, el cual será el valor de salida.
En las siguientes imágenes se representa gráficamente el proceso, para un ejemplo
dado:
Figura 4.30 Aportación de cada regla a la salida
45
Figura 4.31 Suma de las partes y obtención del centro de gravedad
CAPÍTULO 5: IMPLEMENTACIÓN
En este apartado se procede a mostrar los procedimientos y códigos utilizados con
las tecnologías explicadas en el capítulo anterior.
5.1 Programación en Arduino
En esta sección se procede a mostrar el código que va a ejecutarse en el
Arduino, tanto en el dispositivo final como en el coordinador.
5.1.1 Adaptación de sensores
Las acciones para tomar las medidas con los sensores es equivalente para ambos
microcontroladores. Según el sensor se realizará un código u otro.
5.1.1.1 Sensor DHT11
Para el uso de este dispositivo se ha utilizado la librería DTH11.h, el cual nos
permite obtener directamente la temperatura y humedad ambiente, aplicando la solución
propuesta en [59].
Se ha de incluir la librería y definir el pin para recibir los datos:
Figura 5.1 DHT11-1
46
Seguidamente, se ejecuta su método para extraer los datos a la vez que se obtiene
un código de estado que nos indica si existe algún error.
Figura 5.2 DHT11-2
El código nos dirá, si vale 0, que la medida es correcta, y si es 1, que ha habido un
error.
El conexionado con el Arduino y los elementos externos necesarios vienen
definidos en su hoja de características, véase [22]. Se muestra una imagen:
Figura 5.3 Conexionado DHT11
5.1.1.2 Sensor FC-28
Este sensor al ser analógico, se extrae a partir del pin correspondiente, un valor
entre 0 y 1023, siendo una aplicación lineal entre 0 y 5V. Siguiendo el método propuesto
en [23], extraemos este valor.
Figura 5.4 Obtención humedad del suelo
47
Su conexionado se muestra en la siguiente figura:
Figura 5.5 FC-28 Conexión con Arduino
5.1.1.3 Sensor LDR
Este sensor no nos permite obtener la luminosidad de forma directa, por lo que
tendremos que aplicar una configuración que varíe la tensión en función de la resistencia
del LDR, para así obtener el valor la resistencia del LDR, para finalmente, extraer los lux
en función de una fórmula que nos ofrece el fabricante.
𝛾 =log(𝑅10/𝑅100)
100/10(1)
Siendo R10 la resistencia a 10 Lux y R100 la resistencia a 100 Lux y γ el ratio de
variación. Si sustituimos 100 lux por un valor indeterminado y despejamos la luminancia
obtenemos:
𝑥 = 10 ∗ 10
log(𝑅10𝑅𝑥
)
𝛾 (2)
48
El circuito de muestreo es el siguiente:
Figura 5.6 Adaptación LDR
Si calculamos la tensión medida en el pin A1 observamos que se cumple la
siguiente ecuación:
𝑉𝑜𝑢𝑡 = 𝑉𝑖𝑛 ∗𝐿𝐷𝑅 + 𝑅1
𝐿𝐷𝑅 ∗ 𝑅1(3)
Siendo R1 la resistencia del esquemático, y Vin los 5V que nos ofrece el
Arduino. Si despejamos la resistencia del LDR, y la sustituimos en (2), tendremos
la luminosidad.
𝐿𝐷𝑅 = 𝑅1 ∗ (𝑉𝑖𝑛 − 𝑉𝑜𝑢𝑡
𝑉𝑜𝑢𝑡)(4)
49
En nuestra aplicación nos interesa poder discriminar entre valores elevados
de luminancia, aumentando en esa zona la resolución, que corresponde con valor
pequeños de resistencia, para 100 lux entorno a 1KΩ., por lo que se ha de utilizar
una resistencia pequeña, en mi caso, de 4.9 KΩ.
Se muestra el código en Arduino, primero definiendo todas las variables:
Figura 5.7 Código LDR-1
A continuación se lee el valor de tensión, y aplico la ecuación (4), para
seguidamente aplicar la ecuación (5).
Figura 5.8 Código LDR-2
5.1.1.4 Librería Sensores
Para facilitar el uso de los sensores he desarrollado una librería que permite ejecutar
los códigos anteriores a través de funciones, utilizando como parámetros de entrada todas
las variables necesarias, para darle versatilidad ante cualquier cambio.
Existen tres archivos, keywords.txt, únicamente se indica el nombre de las
funciones para que se resalten en el IDE. El archivo Sensores.h, que hace de cabecera, se
definen los métodos del objeto Sensores:
50
Figura 5.9 Sensores.h
En el fichero Sensores.cpp se desarrollan los métodos, siendo HumedadSuelo para
extraer la humedad del suelo, Luz2, para obtener la luminosidad, y HumedyTempAmb,
para extraer la temperatura y humedad ambiente, donde se repite el código de los tres
apartados anteriores.
5.1.1.5 Librería Datos
Se ha creado una librería para crear una clase llamada Datos, que nos permita
almacenar los datos tomados por un sensor, así como la fecha en la que se realizó la
medida, y el valor que nos da el sistema "fuzzy" para esas entradas.
Al igual que la librería Sensores, consta de tres archivos, el keywords.txt, el Datos.h
y Datos.cpp.
En Datos.h se definen sus atributos, y una serie de métodos, cuya funcionalidad es
asignar un valor a los atributos. Se presenta el archivo Datos.h, para ver la implementación
ver el anexo correspondiente.
51
Figura 5.10 Datos.h
5.1.2 Interfaz inalámbrica
En este apartado se tratará sobre la programación relativa al módulo GPRS y su
conexión con el servidor.
Se muestra una imagen de la conexión del módulo SIM900 con el Arduino Due:
52
Figura 5.11 Conexionado SIM900 y Arduino Due
En esta imagen se muestra la conexión entre las tierras de ambos elementos, en
azul, la conexión entre el serial del SIM900 y el Serial 1 del Arduino Due, que posee
cuatro, desde el 0, utilizado para la comunicación serial por el USB, hasta el 3.
En verde está señalada la alimentación del dispositivo.
5.1.2.1 Arranque
Inicialmente, al encender el módulo GPRS y el Arduino Due, se ha de ejecutar una serie de
comandos para inicializar la conexión a la red del operador, se ha utilizado parte del código de
[60].
Primero hay que presentar la función enviarAT, que nos permite enviar un
comando Hayes, siempre que no se necesite la respuesta al mismo, o cuando sea conocida
con anterioridad.
Primero se vacía el serial del módulo GPRS, y a continuación se envía el comando,
para finalmente leer la respuesta esperada, o esperar un tiempo prudencial para la ejecución
de la instrucción. Para ver su implementación véase el anexo con el código.
53
Una vez explicado este comando, se procede a indicar las instrucciones y su
función correspondiente, incluidas en la función conectar () del sketch del coordinador:
AT+CPIN=XXXX
Este comando nos permite desbloquear la tarjeta SIM introduciendo su PIN.
Figura 5.12 Activando el PIN
AT+CREG? y esperamos su respuesta igual a +CREG: 0,1.
Pregunta por el estado de conexión del dispositivo, se ejecutará hasta que se esté
conectado, indicado por una respuesta igual a +CREG: 0,1.
Figura 5.13 Esperando conexión con la red
AT+CGATT=1, activamos el servicio GPRS
Figura 5.14 Activar servicio GPRS
AT+CSTT=XXXX, YYYY, ZZZ. , nos permite transmitir datos a través de nuestro
operador, indicando el APN, usuario y contraseña.
Figura 5.15 Servicio de datos con el operador
AT+CIIR, pone en funcionamiento la conexión inalámbrica del módulo GPRS.
Figura 5.16 Conexión inalámbrica GPRS
54
AT+CIFSR, obtiene la dirección IP local.
Figura 5.17 IP local
Resaltar que durante el proceso de arranque se ha encontrado un problema, cuando
se inicia el módulo GPRS conectado al ordenador para visualizar las respuesta de los
comandos a través del serial, su funcionamiento es correcto.
Pero se dispone a utilizarlo de forma aislada del ordenador, junto al Arduino Due,
por algún motivo desconocido, no es capaz de unirse a la red móvil. Tras buscar
información con nulos resultados, se descubrió que si se reiniciaba el Arduino, conseguía
conectarse a red, por lo que se procedió a cambiar el algoritmo de arranque, para que si tras
un tiempo prudencial, no se conectaba, se reiniciara. Primero hay que activar la
posibilidad de reiniciar vía software a través de unas directivas para el procesador, y
después usar otra directiva para activarlo. Se usó el código disponible en [61].
Figura 5.18 Configuración del procesador
Figura 5.19 Reinicio Arduino
55
5.1.2.2 Conexión con el servidor
En este apartado se va a tratas las dos situaciones en las cuales el coordinador
contacta con el servidor, la primera es para enviarle un conjunto de medidas tomadas, y la
segunda, para recibir la configuración del servidor, ya que no se puede interactuar
directamente entre el servidor y el coordinador, al ser la dirección IP del módulo GPRS
local y dinámica, por lo que enviamos un mensaje de petición al servidor para que nos
devuelva la respuesta.
El código, que ha sufrido modificaciones y añadido funcionalidades para adaptarse
a nuestro caso, se puede visualizar en [60].
La transmisión de datos está definida en la función transmitirInfo(), que dados unos
datos, los envía al servidor, para ello primero forma el mensaje HTTP , indicando la
dirección IP y puerto del servidor, el servlet al cual va dirigido, las cabeceras con los datos
de longitud de paquete y tipo de archivo MIME, en este caso CSV.
Figura 5.20 Creación petición HTTP
Seguidamente se comprueba la conexión, y se establece una conexión TCP
mediante el comando AT+CIPSTART="Protocolo Transporte","IP o dominio","Puerto".
Figura 5.21 Conexión TCP
Posteriormente, se ejecuta el comando AT+CIPSEND= "longitud paquete", para
preparar los datos a transmitir, y esperamos que nos llegue la respuesta ">", que nos indica
que podemos empezar a transmitir.
56
Figura 5.22 Preparando transmisión
Finalmente, teniendo los datos en un vector de objetos Datos, llamado info, que son
un parámetro de entrada, se envían los datos. Para ello primero se limpia el buffer, y
después se envían los datos.
Figura 5.23 Transmisión de datos
Para cerrar la conexión, mediante el comando AT+CIPCLOSE, hay que indicar a la
conexión, cuando terminar de leer la respuesta, para ello desde el servidor de devuelve en
la respuesta de OK, el signo especial "*", para identificar el final del paquete.
Figura 5.24 Cierre de conexión TCP
57
En la segunda parte de esta sección, se va a mostrar cómo se recibe la configuración
del servidor, a través de la función configurar (). Se aprovecha que se va a realizar una
transmisión para enviar los litros consumidos en cada depósito y el porcentaje de agua que
queda en los mismos, esto se explicará en el apartado 5.3, que trata sobre el montaje de la
maqueta, al ser unas características adicionales.
Primero se forma el mensaje, indicando la ID que identifica a cada zona de cultivo,
y el Sub-ID, que identifica a cada equipo, siendo el 1 para el coordinador, y los superiores
para los dispositivos finales.
El procedimiento para la transmisión es el mismo que el explicado a transmitir,
cambiando el servlet que va a procesar la petición, y la respuesta, ya que en este caso
vamos a extraer información útil.
Estos datos son los tiempos de muestreo, que nos indica cada cuanto tomamos una
muestra, el tiempo de configuración, cada cuanto pedimos información al servidor, modos
de funcionamiento, y la fecha.
Se indica el inicio de los datos con el carácter "+" y el fin con "*", se extrae el
String comprendido entre esos valores, y se va extrayendo los valores, separados por
comas, conociendo a priori el orden de los mismos. Para ver el código completo ver
anexos.
Figura 5.25 Extración de los datos de configuración-1
58
Seguría la misma dinámica con todos los parámetros, hasta terminar, y pongo en
hora el reloj del Arduino usando la librería Time.h, como se muestra en esta imagen:
Figura 5.26 Extración de los datos de configuración-2
5.1.2.3 Sincronización de hora
A pesar que en el apartado anterior se ha mostrado como se sincronizar el reloj del
Arduino, aquí voy a explicar el procedimiento inicial de realizarlo, que funcionó con las
pruebas con Arduino Uno, pero sin saber el motivo, el Arduino Due no reaccionaba y tuve
que modificarlo, para ver los comandos véase [62].
Primero, mediante el comando AT+ CNTP="servidorNTP", sincronizaba el
módulo GPRS con la hora de la red móvil, y seguidamente con el comando AT+CLK?,
mostraba la hora, la cual extraía leyendo la respuesta sabiendo el formato de la respuesta
de antemano, usando el mismo método que en el apartado anterior.
Figura 5.27 Sincronización con servidor NTP
Dado que las respuestas de los comandos Hayes están codificadas en ASCII, debí
transformar su valor a un número entero.
59
Figura 5.28 Conversión ASCII a INT
5.1.2.4 Modo sleep
Para reducir el consumo se va a poner en modo reposo mediante el comando
AT+CLSK=2, cuya respuesta es OK.
Figura 5.29 Dormir SIM900
Para despertarlo, se utiliza el comando AAA.
Figura 5.30 Despertar SIM900
5.1.3 Xbee
En este apartado se va a tratar, tanto la configuración de los dispositivos finales y
como del coordinador, en nuestro caso uno de cada, y el código en Arduino relacionado.
Para la configuración de los dispositivos se ha utilizado el programa gratuito
XCTU, véase [63], que nos permite realizar estos cambios gráfica e intuitivamente.
El conexionado entre el Arduino y el módulo Xbee se realiza a través de una shield
compatible como se muestra a continuación:
60
Figura 5.31 Xbee acoplado a Arduino
5.1.3.1 Modelo de red
Como se ha explicado en el apartado 4.1.1, al utilizar la serie 1, no se va a poder
implementar una red mallada, sino una red en estrella, como se mostró en la figura 4.2.
Los dispositivos finales enviarán los datos al coordinador sin necesidad de routers
intermedios.
5.1.3.2 Configuración de los dispositivos
Utilizando la aplicación XCTU, se procederá a configurar los dispositivos, siendo
conectador al ordenador a través un adaptador USB compatible. Se ha seguido para ello la
documentación [19] y los ejemplos de la página web [64].
Primero mostrar la configuración del coordinador, ya que es el encargado de crear
la red y conmutar paquetes.
CH: indica el canal de radiofrecuencia, debe ser el mismo para todos los
equipos dentro de una red.
ID: es el identificador de la red, igual para todos los equipos que vayan a
formar parte de la misma.
DH: primeros 16 bits de la dirección de destino, para utilizar la dirección de
16 bits dentro de una red, dejar a 0.
DL: últimos 16 bits de la dirección de destino, en el coordinador no tiene
ningún efecto.
61
MY: dirección válida dentro de la red, de 16 bits.
Figura 5.32 Configuración coordinador - 1
SH, SL: dirección de 64 bits única en cada dispositivo Xbee, viene de
fábrica.
MM: indica el formato de las tramas MAC, debe coincidir en todos los
equipos, se ha dejado por defecto.
Figura 5.33 Configuración coordinador – 2
CE: muestra el modo de funcionamiento, en nuestro caso,
coordinador
Figura 5.34 Configuración coordinador – 3
SM: indica el funcionamiento del modo sleep, dado que el
coordinador no puede entrar en modo sleep al trabajar como router,
se deja desactivado.
ST: tiempo activo antes de dormir, da igual si SM=0.
SP: tiempo inactivo el coordinador entre diversas búsquedas de
dispositivos para añadir a la red, se deja a 0 para encontrar rápido los
dispositivos, ya a veces tarda demasiado tiempo.
62
Figura 5.35 Configuración coordinador -4
BD: velocidad de transmisión, debe coincidir con la velocidad del
serial, en este caso, 19,2 Kbps.
Figura 5.36 Configuración coordinador -5
AP: modo de funcionamiento, para el modo de conmutación de
paquetes, modo API.
Figura 5.37 Configuración coordinador -6
Ahora se muestra la configuración del dispositivo final, que tiene algunas
diferencias con el anterior.
A diferencia del coordinador, en el parámetro DL, hay que poner la
dirección de 16 bits del coordinador.
Figura 5.38 Configuración dispositivo final -1
63
Figura 5.39 Configuración dispositivo final -2
Se configura para que funcione como dispositivo final.
Figura 5.40 Configuración dispositivo final -3
El dispositivo final si puede entrar en modo sleep, por lo que se ha
configurado para que se pueda activar y desactivar mediante su pin
Hibernate.
El resto de parámetro del modo sueño son optativos, ya que está
controlado por el pin.
Figura 5.41 Configuración dispositivo final -4
Las velocidades de ambos elementos deben ser iguales.
Figura 5.42 Configuración dispositivo final -5
El modo de funcionamiento debe ser el mismo.
Figura 5.43 Configuración dispositivo final -6
64
5.1.3.3 Código en Arduino para incorporar Xbee.
Para facilitar el uso, se ha utilizado la librería Xbee-Arduino, que permite
comunicar los elementos sin necesidad de utilizar los comandos Hayes, existiendo dos
conjuntos de instrucciones, uno para cada serie. Asimismo, trae ejemplos que han hecho de
guía para esta parte, véase [65].
5.1.3.3.1 Dispositivo Final (End- Device)
Inicialmente se va a introducir el código del dispositivo final, ya que el código del
coordinador dependerá del formato de los mensajes de éste.
Indicar, que los mensajes se han de escribir byte a byte, por lo que si una variable
tiene más de un byte, hay que descomponerla para enviarlos por separados, y juntarlos en
el receptor.
Además, tras el envío del mensaje, el receptor devuelve otro mensaje de respuesta
en el que indica si ha llegado correctamente. Nos aprovecharemos de esta cualidad para
reenviar los paquetes que lleguen erróneos, o aquellos que no devuelvan el mensaje de
respuesta, se considerarán que se han perdido, y se volverá a enviar.
Se ha implementado un sistema de cabeceras, formado por los primeros 4 bytes,
para que el coordinador al recibir un paquete, sea capaz de discriminar su contenido y
actuar conforme a él.
En primer lugar, al arrancar, lo primero que hace es pedir la hora actual al
coordinador, para así asignarla a las medidas que realice, a través de la función pedirFecha
().
Primero, creada la cabecera correspondiente, igual a [0, 0, 0,0], se envía la petición
a la dirección de 16 bytes del coordinador, mediante el comando Tx16Request.
Posteriormente se busca paquetes en el buffer del Xbee mediante el comando
readPacket ().
Se va a utilizar los objetos Xbee, TX16Request, RX16Response, el primero para
ejecutar acciones con el Xbee, el segundo para crear el paquete de datos, y el último para
recibir y leer los mensajes, todos incluidos en la librería Xbee-Arduino.
65
Se mira si hay algún paquete almacenado con getResponse (), se obtiene el tipo de
paquete con getApiId () y se mira si es un mensaje de estado comparándolo con
TX_STATUS_RESPONSE, y si es así, se extrae su valor con getTxStatusResponse (), y
se comparada con SUCCESS para ver si es correcto. Si se cumple estas condiciones, el
mensaje ha llegado correctamente al coordinador.
Figura 5.44 Pedir fecha -1
A continuación, se procede a leer la respuesta, a veces, según la carga de trabajo del
Arduino y el Xbee, puede tardar un tiempo, o perderse el paquete, por lo que se lee
periódicamente el buffer. Se mira si es un paquete de datos comparando su API_ID con
RX_16_RESPONSE, que indica que es la respuesta de un equipo, que ha indicado la
dirección de destino con la dirección de 16 bytes.
Se extrae los bytes, de uno en uno, con el comando getData (), se comprueba que es
un paquete con la fecha al ver la cabecera, y se procede a extraer los datos, para finalmente
sincronizar la hora.
66
Figura 5.45 Pedir Fecha -2
Para pedir la configuración se utilizado la función configurarDevice (), siguiendo el
mismo procedimiento que en el caso anterior, con la diferencia de que cambia la cabecera,
que ahora es [1, 1, 0,0], y que extrae la información que pidió al servidor el coordinador,
para ver el código completo mirar el anexo correspondiente.
Indicar, que entre estos datos, existe una variable que nos indica si el usuario en el
servidor ha pedido una medida del estado actual, para lo que se usará una función especial
que tomará medidas de los sensores, tanto en el coordinador como en los dispositivos
finales, y las enviará al servidor, esta función se explicará más adelante.
Para transmitir las muestras de los sensores, se utilizará la función enviarMedida (),
que siguiendo el mismo procedimientos de los anteriores, envía una paquete con la
cabecera correspondiente, siendo la [1, 1, 1,1], pero además se envía otro byte adicional de
cabecera que indica si la medida se envía para transmitirla directamente al servidor, o se
acumula en el coordinador para enviarla en un paquete con varias más.
67
Otros datos a enviar, aparte de los propios de la medida, es el Sub-ID, para
identificar el dispositivo que ha realizado la medida.
Importante indicar, que dado que sistema "fuzzy" está implementado en el
coordinador, debido a su mayor potencia, el valor de riego se calcula en éste y se
retransmite al dispositivo final en la respuesta, de la que se extrae para realizar las acciones
correspondientes. Para ver el código completo ver el anexo correspondiente.
Si al recibir la configuración se necesita enviar una medida instantáneamente, se
ejecutará la función txMedidaOrden (), que toma una muestra de los sensores y llama a la
función enviarMedida () para enviarla al coordinador.
5.1.3.3.2 Coordinador (Coordinator)
En el coordinador, en cada iteración del bucle, se activa la función recibirDatos (),
que mira si hay paquetes en el buffer del Xbee, si hay un paquete, lo distingue por su
cabecera, y ejecuta un módulo distinto, además de obtener la dirección del transmisor para
enviar la respuesta.
Figura 5.46 recibirDatos ()
Cuando recibe una petición para sincronizar la hora de un dispositivo final, se
utiliza la función darHora (), que siguiendo el mismo esquema de las funciones del
apartado anterior, transmite la fecha instantánea y espera el comando de confirmación, para
ver el código completo ver el anexo correspondiente.
68
Si el paquete exige la configuración, se utiliza el comando darConf (), que funciona
igual que darHora (), pero cambiando los datos a transmitir, siendo los parámetros de
configuración del servidor.
Existe una diferencia, y es que si se ha dado la orden de transmitir una medida en el
servidor, se almacena en una variable booleana, si se ha transmitido ya la medida del end-
device o no, para evitar el caso, en el que el intervalo entre peticiones de configuración sea
menor que el de transmitir las muestras, se duplique la orden.
Finalmente, si es para recibir un paquete, la función devuelve un 2, para que en el
loop, se proceda a extraer la información.
Según si el byte que indica si es un mensaje normal o uno para transmitir
inmediatamente, se almacenará hasta llegar a un límite, en este caso 6, o se transmite
directamente.
Con la función leerMedida () se extrae la información del paquete, y con la función
transmitirInfo () explicada en el apartado 5.1.2.2, se envía los datos al servidor web situado
en la URL: sistemariego.ddns.net:8084.
Figura 5.47 Extraer Medida -1
69
Figura 5.48 Extraer Medida -2
Por otra parte, si el byte indica que hay que enviar directamente al servidor:
Figura 5.49 Extraer Medida -3
Ahora se procede a explicar cómo se extrae la información del paquete con el
método leerMedida ().
70
Esta función discrimina entre un tipo de mensaje u otro y llama a la función
sacarMedida (), la función que lee los bytes de información.
Figura 5.50 leerMedida ()
Finalmente, en sacarMedida (), conociendo a priori la estructura de los datos, se
extrae los distintos datos, y también se calcula el valor de riego y se devuelve al dispositivo
final, siguiendo el procedimiento de funciones anteriores, para ver el código completo ver
el anexo correspondiente.
5.1.3.4 Ahorro de consumo
Una de las grandes ventajas de Xbee es su bajo consumo en modo sleep, en torno a
30 uA. Por otro lado, la potencia de transmisión es de 0 dBm.
Para controlar el modo sleep mediante el pin Hibernate, simplemente hay que
ponerlo en HIGH para dormir, y en LOW para despertar. Se puede observar en la siguiente
tabla, véase [19], los consumos de xbee según su modo de funcionamiento en modo sleep:
Tabla 5.1 Consumo modos sleep Xbee
5.1.4 Modos de trabajo
Se ha integrado dos modos de funcionamiento, que solo afecta al modo de
funcionamiento del Arduino, ya que el Xbee y el módulo GPRS siempre entran y sale de
71
modo sleep cuando van a trabajar, excepto en el coordinador que no puede poner el Xbee
en modo ahorro.
Arduino, posee distintos modos de ahorro, en función de los distintos elementos
hardware que va desactivando, se muestra en la siguiente figura la relación entre elementos
activos y modos de trabajo, véase [66].
Tabla 5.2 Tabla de modos sleep de Arduino
Destacar que el modo que menor consumo tiene es el Power-Down, por el
contrario, el que mayor tiene es el Idle.
El problema que se ha encontrado por utilizar el Power-Down es que desactiva el
reloj interno, CLKIO en la figura, por lo que al tomar las muestras de las medidas, la fecha
no coincide con la real, ya que se mantiene intacta desde el momento en el que se activó el
modo sleep. Por lo que nuestra única opción es el modo IDLE, que es menor ahorro nos
ofrece.
Indicar que debido a la arquitectura del procesador del Arduino Due, éste no se
puede introducir en modo ahorro.
En el Arduino Uno, que se utiliza en los dispositivos finales, si se puede, por lo que
desde el servidor, mediante la variable modo_trabajo, se puede indicar el modo de
funcionamiento, el normal, el cual entra en bucle esperando hasta que ha pasado el tiempo
indicado para realizar una acción, o el modo ahorro, que activa el modo IDLE durante ese
intervalo temporal.
72
Para su implementación, se ha utilizado la librería N0M1,véase [67], que al
contrario de otras librerías como Low-Power, podemos entrar en modo sleep hasta un
periodo máximo de 47 días, mientras que Low-Power solo nos permite intervalos de 8
segundos, por lo que para conseguir un tiempo determinado, debe entrar y salir del modo
sleep de forma cíclica.
5.1.5 Algoritmo de decisión de riego.
Como se indicó en el apartado 4.8, el algoritmo de riego se va a basar en un sistema
"fuzzy" o borroso basado en reglas.
Las variables de entradas van a consistir en los parámetros físicos obtenidos a
través de los sensores, temperatura, luminosidad, humedad ambiente y humedad del suelo,
y como salida la cantidad de agua necesaria para regar.
5.1.5.1 Conjuntos borrosos
Se va a definir los conjuntos borrosos, tanto para las entradas como para la salida,
el modelo geométrico que se va a utilizar es el trapezoidal, para indicar el grado de
pertenencia de los valores, previamente normalizados entre 0 y 1.
El trapezoide se define por cuatros puntos, A, B, C y D. Siendo A y D los puntos
donde la pertenencia vale 0, y B y C donde vale 1. Se procede a realizar un ejemplo
gráfico:
Figura 5.51 Conjunto borroso trapezoidal
73
5.1.5.1.1 Temperatura
Dada la meteorología típica de Jaén, se ha considerado el rango de valores entre
-10ºC y 50 ºC.
Para normalizar se realiza una interpolación lineal (5), siendo el valor cero, -10 ºC
(6), y el valor 1, 50ºC (7).
𝑦 = 𝑎𝑥 + 𝑏(5)
0 = 𝑎(−10) + 𝑏(6)
1 = 𝑎(50) + 𝑏(7)
Al resolver el sistemas de ecuaciones, se obtiene que a=1/60 y b=16.
Una vez hemos normalizado, se clasifica la temperatura en tres posible etiquetas,
baja, media y alta, y se procede a definir los valores que pertenecen a cada uno.
El conjunto borroso para temperatura baja queda definido por los siguientes puntos:
A= -10, B =-10, C=10, D=20, que normalizados por la ecuación (5), pasan a ser,
A=0, B=0, C=0.33, D=0.5.
Siguiendo el mismo proceso se obtienen para temperatura media y alta:
Temperatura media: A= 10, B=20, C=25, D=30, que normalizados son, A=0.33,
B=0.5, C=0.58, D=0.66.
74
Temperatura alta: A=25, B=30, C=50, D=50, que tras la normalización pasan ser,
A=0.58, B=0.66, C=1, D=1.
5.1.5.1.2 Humedad ambiente
La humedad ambiente viene dada en humedad relativa respecto a la cantidad de
vapor de agua máxima posible. Por lo tanto, sus valores van de 0% a 100%, por lo que el
proceso de normalización es trivial, solo hay que dividir el valor entre 100.
Se procede a determinar los conjuntos borrosos por sus puntos A, B, C y D como
en el apartado anterior.
En el conjunto de humedad baja, A=0, B=0, C=30, D=40, que siendo normalizados
son A=0, B=0, C=0.3 y D=0.4.
En el conjunto de humedad media, A=30, B=40, C=50, D=60, que siendo
normalizados son A=0.3, B=00.4, C=0.5 y D=0.6.
En el conjunto de humedad alta, A=50, B=60, C=100, D=100, que siendo
normalizados son A=0.5, B=0.6, C=1 y D=1.
5.1.5.1.3 Humedad Suelo
En este caso, los valores van entre 0 y 1023, que son los valores obtenidos en el pin
analógico según la conductividad del suelo. Dado que el sensor no nos ofrece ninguna hoja
de características, se ha considerado válido los valores que nos proponen en [23].
La normalización es sencilla, solo hay que dividir el valor entre su máximo, que es
1023.
Se repite el proceso de los apartados anteriores para definir los conjuntos:
En el conjunto de humedad baja, A=700, B=800, C=1023, D=1023, que siendo
normalizados son A=0.68, B=0.78, C=1 y D=1.
En el conjunto de humedad media, A=400, B=500, C=700, D=800, que siendo
normalizados son A=0.39, B=0.48, C=0.68 y D=0.78.
75
En el conjunto de humedad alta, A=0, B=0, C=400, D=500, que siendo
normalizados son A=0, B=0, C=0.39 y D=0.48.
5.1.5.1.4 Luminosidad
El rango de valores típico en el campo viene dado en [68], siendo entre 0 y 100.000
lux. Por lo que el proceso de normalización es simplemente dividir entre 100.000.
Se repite el proceso de los apartados anteriores para definir los conjuntos:
En el conjunto de luminosidad baja, A=0, B=0, C=20.000, D=25.000, que siendo
normalizados son A=0, B=0, C=0.2 y D=0.25.
En el conjunto de luminosidad media, A=20.000, B=25.000, C=45.000, D=50.000,
que siendo normalizados son A=0.2, B=0.25, C=0.45 y D=0.5.
En el conjunto de luminosidad alta, A=45.000, B=50.000, C=100.000, D=100.000,
que siendo normalizados son A=0.45, B=0.5, C=1 y D=1.
5.1.5.1.5 Salida
La salida será la cantidad de agua que se va a regar, se dividirá los posibles valores
en cinco, desde no regar, hasta regar al máximo. La salida al final sufrirá un proceso de
desnormalización para poder ser usado por nuestro sistema. Se procederá al mismo
elemento geométrico, al trapezoide, para definir los conjuntos borrosos.
En el conjunto de no regar, A=0, B=0, C=0.2, D=0.3.
En el conjunto de regar poco, A=0.2, B=0.3, C=0.4, D=0.5.
En el conjunto de regar medio, A=0.4, B=0.5, C=0.6, D=0.7.
En el conjunto de regar alto, A=0.6, B=0.7, C=0.8, D=0.9.
En el conjunto de regar muy alto, A=0.8, B=0.9, C=1, D=1.
La salida será un valor comprendido entre cero y uno. Para desnormalizar, se hará una
conversión de este valor, siendo su valor máximo, un litro.
76
5.1.5.2 Conjunto de reglas
Para completar nuestra base de conocimientos, debemos realizar las reglas que
definan el funcionamiento de nuestro sistema. Estas reglas se basan en la experiencia
propia.
Estas reglas deben definir para todas las posibles combinaciones de entradas, su
salida. Para economizar tiempo de computación y consumo energético, se ha decidido
agrupar algunas reglas que tenían la misma salida, esto produce pequeñas desviaciones en
los valores de salida, pero son aceptables.
Un ejemplo es la primera regla, dado que siempre que la temperatura sea baja no se
va a regar, entonces se indica como una única regla, más adelante se indicará como se
plasma esto en el código.
Conjunto de reglas:
1. Si la temperatura es baja entonces no regar. Esto se debe a que si la temperatura es
baja no hace falta regar, e incluso en algunos casos en contraproducente, ya que por
ejemplo se pueden estropear tuberías al congelarse el agua.
2. Si la temperatura es alta entonces no regar. Esto se debe a que si la temperatura es
demasiado alta, se evapora el agua, no siendo absorbida por la planta y por tanto se
desperdicia.
3. Si la temperatura es media y la humedad del suelo alta entonces no regar. El suelo
está húmedo, por tanto no hace falta regar.
4. Si la temperatura es media, la humedad suelo media y la luminosidad baja
entonces regar poco. El suelo tiene suficiente humedad y al tener poca luminosidad
(por la noche) no hace falta regar.
5. Si la temperatura es media, la humedad del suelo media y la luminosidad alta
entonces regar medio. Igual que el caso anterior pero a plena luz del día, no hace
falta regar mucho.
6. Si la temperatura es media, la humedad del suelo media, la luminosidad media y la
humedad ambiente baja entonces regar poco, hay un grado medio de luz pero hay
poca humedad en el ambiente.
77
7. Si la temperatura es media, la humedad del suelo media, la luminosidad media, y la
humedad ambiente media entonces regar poco. Hay bastante humedad en el suelo
y en el ambiente.
8. Si la temperatura es media, la humedad del suelo media, la luminosidad media, y
la humedad ambiente alta entonces no regar. Hay mucha humedad en el ambiente y
bastante en el suelo.
9. Si la temperatura es media, la humedad del suelo baja, la luminosidad alta y la
humedad ambiente baja entonces regar muy alto. Es el peor caso posible, ya que
hay poca humedad y está dando mucho el sol.
10. Si la temperatura es media, la humedad del suelo baja, la luminosidad media y la
humedad ambiente baja entonces regar alto, ya que todavía hay bastante
luminosidad.
11. Si la temperatura es media, la humedad del suelo baja, la luminosidad media y la
humedad ambiente media entonces regar medio, hay más humedad en el ambiente,
así que no hace falta regar demasiado.
12. Si la temperatura es media, la humedad del suelo baja, la luminosidad media y
humedad ambiente alta entonces regar poco, ya que la humedad ambiente es alta.
13. Si la temperatura es media, la humedad suelo baja y la luminosidad baja entonces
regar poco, no se va a evaporar mucha agua, así que aunque haya poca humedad,
mejor regar poco.
5.1.5.3 Librería motorv2
Para facilitar el uso de motor borroso, se ha implementado una librería que efectúa
todas las operaciones, y devuelve el valor de salida.
Esta librería está formada por dos archivos: motov2.h y motorv2.cpp. En el
primero, la cabecera, se definen los objetos y métodos a utilizar.
Existen dos objetos, el principal, motorv2, que realiza los cálculos, y peso, que es
un objeto auxiliar que almacena los datos parciales, y también el total, de los cálculos.
78
Figura 5.52 motorv2.h
En el archivo motorv2.ccp se implementan los métodos, el principal es
MotorInfiere (), que a partir de los datos de los sensores y de las reglas, calcula la salida.
Esta función lo que hace, es primero, extraer la regla de la base de datos, para cada
entrada, ver su pertenencia al conjunto borroso definido en la regla, y quedarse con el
menor.
Figura 5.53 motorInfiere () -1
79
Una vez obtenido el mínimo, se calcula la aportación de esa regla al total, y se
almacena. Los valores que se guardan son el área de la aportación al total, y su centro de
gravedad multiplicado por el área. El valor final será la división entre estos valores.
Figura 5.54 motorInfiere () -2
Para calcular la pertenencia de un valor a un conjunto borrosos se utiliza a función
pertenencia (), que usando la entrada y los puntos que definen el conjunto borroso, definen
su valor de pertenencia, resolviendo la ecuación del trapezoide. Siendo fuera de A y D,
pertenencia nula, entre B y C, pertenencia completa, y para el resto, se calcula su posición
resolviendo la ecuación de la recta (5).
Figura 5.55 pertenencia ()
Para obtener la aportación de cada regla al total, se emplea el método CalculaPeso
(), que basándose en el conjunto borroso de salida y el valor mínimo de pertenencia de
entrada, calcula el área y centro correspondiente.
80
Para ello calcula el área y centro de cada parte del trapecio por separado, por un
lado los triángulos que forman AB y CD, y el rectángulo BC, para finalmente, sumar las
áreas, y ponderar los centros con sus áreas para obtener el centro de gravedad total.
Figura 5.56 CalculaPeso ()
Para terminar este capítulo, indicar que la base de reglas se implementa como una
matriz multidimensional cuyas componentes son vectores que contiene los valores de los
conjuntos borrosos de entrada y salida para cada regla.
En los casos que se han comprimido reglas, para facilitar el código, lo que se ha
hecho es definir un conjunto borroso nuevo, cuyo grado de pertenencia es máximo para
todos los valores, para que así, no afecte a la hora de calcular el mínimo grado de
pertenencia de las entradas. Este conjunto está definido por los puntos A=0, B=0, C=1 y
D=1.
81
Figura 5.57 Base reglas
5.1.6 Esquema global
En estos últimos apartados se ha visto el funcionamiento de distintos elementos,
tanto del coordinador como de los dispositivos finales. Ahora se procede a presentar una
visión de funcionamiento del conjunto mediante diagramas de flujo.
Primero se expone el diagrama del dispositivo final por ser más sencillo, y después
el coordinador, que debido a su extensión se ha dividido en dos partes.
82
Figura 5.58 Diagrama de flujo del dispositivo final
83
Figura 5.59 Diagrama de flujo del coordinador -1
84
Figura 5.60 Diagrama de flujo del coordinador -2
85
5.2 Servidor
En este apartado se va a tratar sobre la programación de los distintos servlets, así
como de las páginas web y la base de datos que implementa el servidor. Siguiendo el
paradigma Modelo Vista Controlador, MVC.
5.2.1 Modelo
Aquí se va a presentar la base de datos que se ha realizado, denominada
sistemariego, la cual contiene tres tablas: arduino, deposito y medida.
La primera establece una relación entre la ID asociada al Arduino, con el
emplazamiento físico en el que se encuentra. Siendo la ID la key primaria de la tabla.
Figura 5.61 Tabla arduino
La segunda, almacena para los distintos depósitos, diferenciados por la ID que se
relaciona con el lugar y el Sub-ID que identifica al equipo, el porcentaje de agua que
queda, y los litros consumidos, lo cual está relacionado con la maqueta. La key primaria de
esta tabla es una variable adicional que va incrementándose cada vez que se añade un
depósito, llamada id_deposito.
Figura 5.62 Tabla deposito
La última guarda las medidas realizadas por los equipos, siendo los parámetros
almacenados, la fecha, la ID y Sub-ID del equipo que la ha realizado, los valores de
temperatura, luminosidad, humedad ambiente y del suelo, y finalmente el valor de salida
86
del sistema borroso. Para cumplir con la normalización de la tabla, se ha usado como key
primaria una variable adicional llamada medida_id, para evitar duplicidades.
Figura 5.63 Tabla medida
5.2.2 Controlador
En esta sección se presenta el encargado de interactuar entre la base de datos y las
páginas webs, que serán los Servlets y la clase Java que permite extraer, insertar y
modificar la base de datos.
5.2.2.1 Controlador de base de datos
La clase Java que implementa las interacciones con la base de datos se llama
Database.java, que incluye una serie de funciones que permiten introducir medidas, nuevas
localizaciones y depósitos, así como extraer información necesaria para las
representaciones gráficas y las tablas de datos. La librería que permite esto se llama:
mysql-connector-java.bin.jar. Véase [69].
87
Figura 5.64 Database.java
La función introducirMedida() permite añadir a la tabla "medida" los datos
obtenidos, para ello se establece una conexión con la base de datos, se realiza una petición
para añadir los valores y se cierra la conexión.
Figura 5.65 IntroducirMedida()
Se muestra en la figura la parte principal de la función, se establece la conexión
con el DriverManager, accediendo con las credenciales de administrador, y se ejecuta el
comando correspondiente para introducirlos datos con el objeto Statement y su método
executeUpdate. Finalmente hay que cerrar la conexión.
De forma similar se ejecutan las funciones IntroducirArduino() y
ActualizarDeposito(), el primero para añadir nuevas localizaciones a la base de datos, y el
88
segundo, actualiza el estado de los depósitos, y si se detecta que no está en la base de
datos, se añade, para ver el código completo ver el anexo correspondiente.
Por otro lado, Representar(), nos permite extraer todos los datos relativos a una
medida comprendidos entre dos fechas, sigue el mismo proceso que el anterior, cambiando
únicamente el comando a ejecutar.
Figura 5.66 Representar()
Se observa que el objeto Statement para realizar consultas ejecuta la función
executeQuery, y el comando de MySQL es del tipo SELECT, seguido de los parámetros a
extraer, la tabla en donde están y los filtros a utilizar.
Las funciones extraerLocalizacion(), extrae todos los emplazamientos para después
poder elegir uno en el formulario correspondiente, extraerUltimoRiego(), extrae el último
valor del sistema borroso para decidir al riego, extraerDeposito(), permite obtener los
porcentajes de agua de los depósitos y el agua consumida desde la última recarga. El
método devolverNum_id(), a partir del nombre de la localización del Arduino, obtiene su
ID. Para ver el código completo ver el anexo correspondiente .Finalmente,
devolverLocal(), a partir del ID, extrae la localización.
El último método, DividirFechas(), es una función auxiliar utilizada dentro de la
clase, para extraer de una fecha, el año, día, mes, hora, minuto y segundo.
5.2.2.2 Servlets
Se presenta Senalizacion.java, este Servlet tiene como objetivo procesar los
mensajes de petición de configuración del coordinador, por una parte, extrae de un archivo
CSV los parámetros de configuración definidos por el usuario, y por otro lado, procesa los
89
datos sobre el estado del depósito, lo guarda en un archivo CSV y actualiza la tabla
correspondiente.
Figura 5.67 Senalizacion.java -1
Mediante el objeto HttpRequest extrae la petición, y con el objeto BufferedReader
leo el archivo CSV, y lo almaceno en un String, [70].
Figura 5.68 Senalizacion.java -2
Seguidamente, se define con el objeto Path, el directo donde se va a guardar o
sobreescribir los datos, y se escribe con los objetos FileWriter y BufferedWriter, y se cierra
el archivo, [71].
Figura 5.69 Senalizacion.java -3
90
A continuación, se crea un objeto de la clase CsvParser, encargado de extraer la
información del archivo CSV e introducirla en la base datos, así como extraer el ID del
Arduino para leer el archivo de configuración correspondiente, que se explicará después.
Finalmente, se extraen los datos almacenados en el archivo de configuración, y se envía al
coordinador. Para ver el código completo ver el anexo correspondiente.
Figura 5.70 Senalizacion.java -4
El próximo Servlet a introducir es el RecibirCsv.java, que permite extraer las
medidas enviada por el coordinador al servidor.
Al igual que en Senalizacion.java, lee los datos recibidos, los almacena en un
archivo CSV, y llama a la clase CsvParser, utilizando un método distinto, para almacenar
los datos en la tabla medida. Para ver su implementación ver el anexo correspondiente.
Se presenta la implementación del parser en la clase CsvParser.java, [72]:
Figura 5.71 CsvParser.java
Esta clase presenta dos métodos, Parsear (), que permite almacenar las medidas
enviadas por el coordinador, y ParsearDepos (), de similar funcionamiento para guardar el
estado de los depósitos.
Conociendo a priori la estructura del archivo, se extraen los datos, y se procede a
introducirlos en la base de datos como se muestra en la siguiente figura:
91
Figura 5.72 Parsear ()
Siguiendo el mismo procedimiento que en la función anterior se implementa
ParsearDepos ():
Figura 5.73 ParsearDepos ()
Se puede observar el uso de dos objetos auxiliares en las funciones, ListaMedidas ()
y Deposito (). Estas clases sirven para almacenar los datos de una medida, o de un
depósito, respectivamente. Incluyen sus constructor, su función para asignar valores y sus
métodos para extraer sus atributos. Su implementación se puede observar en el anexo
correspondiente.
Figura 5.74 ListaMedidas.java
92
Figura 5.75 Deposito.java
El siguiente Servlet es Config.java, encargado de extraer la configuración de la
página web del servidor, y almacenarla en un archivo CVS, que posteriormente será
utilizado para retransmitirlo al coordinador, como ya se ha visto.
Permite obtener los datos recibidos por el formulario correspondiente mediante el
objeto HttpRequest y su función getParameter(), y los guarda en un fichero CSV,
siguiendo el procedimiento visto anteriormente. Para ver su implementación ver el anexo
correspondiente.
El penúltimo Servlet es Middle.java, cuya función es a partir del nombre de la
localización, extraer la ID correspondiente, y redireccionar a la página del formulario de
configuración, pasando como parámetro la ID.
Figura 5.76 Middle.java
El último Servlet de la aplicación web es MostrarDatos.java, permite, a través de la
fecha inicial y final, y de la localización y el Arduino en concreto (mediante su Sub-ID),
obtener los datos que cumplen esa serie de condiciones, y se los envía a un archivo JSP
para su posterior visualización.
93
Primero se comprueba que ambas fechas son correctas, y que la fecha final es
posterior a la inicial, para finalmente extraer los datos y pasarlos como parámetros al
siguiente JSP.
Figura 5.77 MostrarDatos.java
Finalmente, hay que añadir el Servlet al archivo web.xml para que se pueda utilizar,
como se muestra en la siguiente imagen:
Figura 5.78 Añadir Servlet al archivo web.xml
Hay que indicar tanto el nombre del Servlet , <servlet-name>, como la clase que lo
contiene, <servlet-class>, así como su URL para llamarlo en una petición, <url-pattern>.
94
5.2.3 Vista
En este apartado se va a tratar de las páginas web que permiten visualizar e
interaccionar directamente con el usuario, que están desarrolladas en lenguaje HTML, JSP
y JavaScript.
Para facilitar la estética de la aplicación se ha utilizado una hoja de estilos, CSS,
gratuita disponible en [73].
Primero se van a tomar unas consideraciones generales para todas las páginas webs
implementadas en la aplicación.
Se utiliza el conjunto de caracteres UTF-8, para poder utilizar tíldes y la letra "ñ"
sin sus comandos específicos.
Así mismo, se ha de cargar las librerías que conforman la hoja de estilos.
Figura 5.79 Charset y CSS
No se va a entrar en detalle de como se ha codificado cada elemento, sino que se
van a presentar las partes más importantes.
El archivo inicio.html, simplemente muestra una introducción y da la opción de
moverse a otras páginas.
En fechatablav2.jsp, que contiene un formulario para poder mostrar la información,
hay que destacar la utilización de la clase DataBase para poder mostrar las localizaciones
existentes, y como se mostró en el apartado 5.2.2, con el Servlet MostrarDatos, traducir la
elegida a una ID.
Figura 5.80 Extraer Localizaciones
95
Una vez rellenado el formulario y extraída la información por MostrarDatos, se
ejecuta Intermedio.jsp, que actúa como selector de opciones, pudiendo elegir entre mostrar
los datos en un tabla, o en una gráfica de evolución temporal, cada una con un archivo JSP
distinto, usando la librería Google Charts, como se explicará más adelante en esta misma
sección.
El archivo IntroducirArduino.html, es un simple formulario con una caja de texto,
para añadir nuevas localizaciones, que utilizando GuardarArduino.jsp, lo introduce en la
tabla correspondiente de la base de datos, y devuelve una página web u otra según se haya
realizado la operación con éxito o no.
Cuando seleccionamos la opción para configurar, primero hemos de elegir la
localización en eligeLocal.jsp, que a través del Servlet Middle, extraerá la ID
correspondiente y la pasará a configurate.jsp, dónde se eligen las opciones.
Además, se muestra la última recomendación del sistema borroso para cada nodo, o
al menos desde la última vez que el coordinador ejecutó una petición de configuración,
para ello hay que extraerlo de la base de datos con un objeto DataBase y su función
extraerUltimoRiego( ). Indicando el ID que identifica al conjunto.
Figura 5.81 Extraer recomendaciones
La última opción es mostrar el estado de los depósitos, con deposito.jsp, para lo que
se utiliza el método extraerDeposito( ).
Figura 5.82 Extraer estado depósitos
96
Para ver el código completo de estos ficheros ver el anexo correspondiente.
Para la implementación de las tablas y gráficos se ha utilizado la ya citada librería
Google Charts, se procede a explicar su uso, usando como ejemplo el archivo
luminosidad.jsp, que nos muestra la evolución de la luminancia a lo largo del tiempo:
Primero se carga el script, indicando el tipo de gráfico, y las columnas que va a
contener y su nombre, en este caso Annotation Chart, y las columnas la fecha y la
luminosidad, y su identificador, dibujarLumi:
Figura 5.83 Ejemplo Google Charts-1
Seguidamente se añade los valores de las filas, entre corchetes y separado por
comas, y para finalizar se configurar algunas opciones, y se dibuja:
Figura 5.84 Ejemplo Google Charts -2
5.3 Montaje de la maqueta
Para la demostración del funcionamiento global del sistema, se va a realizar una
maqueta, se ha creído conveniente añadir algunas funcionalidades adicionales para mejor
monitorización del sistema, tales como el control sobre el nivel del depósito, además se va
a usar un motor para propulsar el agua a través de un tubo de plástico, para simular el
97
bombeo de agua, dado que para utilizar goteros se necesita un motor con una presión de
entre una y dos atmósferas, el cual tiene un precio elevado.
5.3.1 Sensor de ultrasonidos HC-SR04
El sensor de ultrasonidos HC-SR04 permite estimar la distancia a la que se
encuentra un sonido utilizando técnicas sonar, basadas en detectar el tiempo transcurrido
entre la onda incidente y reflejada
Se ha aplicado el código disponible en [74], que consiste en emitir un pulso de diez
microsegundos, y leer el tiempo que tarda en volver.
Una vez se obtiene este valor, se calcula la distancia, conociendo que la velocidad
del sonido en el aire es del orden de 343 metros por segundo, aunque varía ligeramente
con la temperatura. En la siguiente ecuación se obtiene la separación del sensor al objeto:
𝑡 =2 ∗ 𝑑
𝑣(8)
En (8) "t" es el tiempo de propagación, "d" es la distancia al objeto, siendo el
camino que recorre la onda el doble, y "c" la velocidad en el aire. Despejando se obtiene:
𝑑 =𝑣 ∗ 𝑡
2(9)
En la siguiente figura se muestra el código, se manda el pulso de diez
microsegundos a través del pinTrigger, y se detecta la onda reflejada en el pinEco,
98
posteriormente se utiliza la fórmula (9), normalizada para que nos dé el valor en
centímetros.
Figura 5.85 Funcionamiento HC-SR04
Figura 5.86 Conexión HC-SR04
99
5.3.2 Caudalímetro YF-S201
El sensor YF-S201 nos permite conocer la cantidad de agua que extrae la bomba de
agua del depósito. La sensibilidad del sensor aumenta con la velocidad con la que atraviesa
el agua el sensor, como nos muestra el fabricante, aunque de forma muy ligera, [75].
Figura 5.87 Flujo de agua según la frecuencia de pulsos
Dado que nuestro motor, como se indicará más adelante, no tiene ejerce mucha
presión, es una buena aproximación utilizar que la relación entre flujo y frecuencia de
pulsos es constante. Se procede a extraer el volumen de agua por pulso:
Sabiendo que el flujo es de 120 L/H, a una frecuencia de 16 Hz por pulso,
extraemos el número de pulsos:
𝑁 = 𝑇 ∗ 𝑓(10)
Siendo "N" el número de pulsos, "T" el tiempo, y "f" la frecuencia de pulsos, si
sustituimos los datos expuestos en (10), se obtiene que el número de pulsos, "N" es de
57600 pulsos.
100
Sabiendo que 120 litros son 120.000 mililitros, extraemos el volumen de agua
extraído en cada pulso.
𝑀𝑃 =𝑉
𝑁(11)
"MP" son los mililitros por pulso, "V" el volumen en mililitros, y "N" el número de
pulsos, sustituyendo en (11), se consigue 2.08 mililitros por pulso aproximadamente.
El código para implementarlo se puede observar en [76], usa las interrupciones de
Arduino, esto permite parar el código que se está ejecutando, para activar otro, y tras su
finalización, volver al anterior.
Esto se debe a que el sensor, al detectar paso de agua, envía un pulso por el pin
digital que se ha configurado para tal efecto.
Se activan las interrupciones con la opción RISING, para que solo se activen
cuando llega un pulso, e indicando la función que se va a activar, en este caso flujo (), y al
inicio se pone la interfaz digital, en este caso INT0, correspondiente el pin digital 2, que va
a estar atento a los pulsos.
Figura 5.88 Activación de las interrupciones
La función flujo (), tendrá la utilidad de aumentar el contador de los pulsos.
101
Figura 5.89 flujo ()
Figura 5.90 Conexión YF-S201
5.3.3 Motor
Hace falta un motor que bombee el agua, para ello se va a utilizar el motor JT-500,
que tiene un consumo de 15W a una tensión de 12V, por lo que va a hacer falta una fuente
de alimentación externa.
Dado los recursos disponibles, se va a utilizar una fuente que ofrece 9W con una
tensión de 9V, el único problema es que el bombeo es débil ante la falta de potencia, pero
es funcional.
Para controlar la activación y desactivando del motor, hace falta un elemento
conmutador, ya que un pin del Arduino nos ofrece únicamente una corriente máxima de
50mA, insuficiente en este caso.
Para implementar el interruptor se va a utilizar un mosfet, el modelo IRF-520N, que
aplicando una tensión de 5V en su patilla de puerta o "gate", permite el paso de corriente
con bajas pérdidas, por lo tanto, se va a conectar la fuente por la patilla de fuente o
"source", y el motor en el drenador o "drain".
Se ha encontrado una limitación, y es que el Arduino Due solo permite salidas de
3.3V como máximo, no siendo suficiente para permitir el flujo de corriente entre fuente y
102
drenador, por lo que se utilizará el Arduino Uno, lo que es lo mismo, en el dispositivo
final.
El código es trivial, al tratarse de poner en alto o bajo la señal de un pin, la
conexión se puede ver en [77].
Figura 5.91 Conexión Mosfet IRF520N
5.3.4 Implementación del sistema de riego
Para conocer el estado del depósito mediante el sensor de ultrasonidos, usaremos la
función comprobarAgua ().
Mide la distancia desde el sensor hasta el agua en el depósito, y conociendo a priori
la distancia en el momento en el que depósito está vacío y cuando está lleno, se puede
obtener el porcentaje del depósito.
103
Figura 5.92 Medida depósito
Debemos ignorar el espacio que existe entre el sensor, que estará encima, y el
depósito, por lo tanto:
𝐷𝑟𝑒𝑎𝑙 = 𝐷𝑚𝑎𝑥 − 𝐷𝑚𝑖𝑛(12)
Por otro lado, cuando hacemos una medida, lo que realmente medimos es la
distancia que existe entre el sensor con el nivel de agua, pudiéndose obtener el nivel de
agua, "Dagua":
𝐷𝑎𝑔𝑢𝑎 = 𝐷𝑚𝑎𝑥 − 𝐷𝑚𝑒𝑑𝑖𝑑𝑎(13)
104
Finalmente, para saber el porcentaje de agua, Pagua, se divide el nivel de agua entre
el máximo posible:
𝑃𝑎𝑔𝑢𝑎 =𝐷𝑎𝑔𝑢𝑎
𝐷𝑟𝑒𝑎𝑙(14)
Además, se compara el valor actual con el anterior, si se detecta que ha aumentado
el nivel del agua más de un veinte por ciento, se considerará que se ha rellenado el
depósito, y se pondrá a cero el número de litros consumido. Se tiene en cuenta este
porcentaje tan alto debido a que el sensor tiene un margen de error entorno a un
centímetro, que según la geometría del tanque de agua, puede ser mucho.
Asimismo, si detecta que el depósito está a un veinte por ciento o menor de su
porcentaje máximo, no se regará, para evitar dañar el motor.
Se muestra la implementación, usando el valor obtenido por el sensor de
ultrasonidos:
Figura 5.93 comprobarAgua ()
105
Para activar y desactivar el motor, como se indicó en el apartado 5.3.3, únicamente
hay que enviar un voltaje de 5V o de 0V, lo cual se implementa en las siguientes
funciones:
Figura 5.94 Control del motor
La función comprobarDeposito (), se encarga de controlar si existe agua suficiente
para regar, para ello extrae el valor del método comprobarAgua (), y según el valor,
desactiva el riego, o lo activa y llama a la función decidirRiego (), que se explicará más
adelante.
Figura 5.95 comprobarDeposito ()
El método decidirRiego (), discrimina entre utilizar el valor de riego ofrecido por el
sistema borroso o por el indicado por el usuario, según el modo de trabajo elegido en la
aplicación web.
Figura 5.96 decidirRiego ()
106
Mientras se está regando, mediante interrupciones se irán contando los pulsos
transmitidos por el caudalímetro, mediante la función contador_pulsos(), que es una
expansión del método flujo() introducida en el apartado 5.3.2, aunque ahora también
calcula el volumen de agua consumido y , debido a que se retorna agua por la inercia del
motor, cuando este está desactivado no cuenta los pulsos del agua que retrocede.
Asimismo, puede dar lugar a errores lo anterior, a la hora de activar y desactivar el motor,
por lo que si se encuentra que está circulando agua sin tener la orden de activar el motor, se
apaga.
Figura 5.97 contador_pulsos () final
Finalmente, cada vez que se detecta un pulso, se ejecuta el método procesoRiego (),
el cual comprueba si se ha superado la cantidad de agua indicada, en ese caso, desactiva el
motor y poner el contador a 0. Además se acumula la cantidad de litros de agua regada en
total desde la última vez que se rellenó el tanque de agua.
Se ha encontrado el problema, que por inercia del motor, sigue cayendo un poco de
agua tras desactivar su alimentación, pero es despreciable, del orden de 50 mililitros, si la
cantidad que se riega es elevada.
107
Figura 5.98 procesoRiego ()
Para dar una visión completa del proceso, se presenta un diagrama de flujos del
mismo:
108
Figura 5.99 Algoritmo de riego
109
CAPÍTULO 6. CONCLUSIONES Y LÍNEAS DE
FUTURO
6.1 Conclusiones
Durante la realización del proyecto se ha llegado a una serie de conclusiones:
Las redes de sensores es una tecnología con multitud de aplicaciones, desde
la domótica hasta la agricultura de precisión, pasando por las smart cities.
Siendo en nuestro ámbito, la agricultura de precisión, muy útil para poder
monitorizar el estado de los cultivos de forma precisa, y sin necesidad
acudir a los mismos.
Utilizar Arduino como nodo de las redes de sensores nos permite, por un
lado, ofrecer una propuesta económica, y por otro lado, la posibilidad de
integrar distintas tecnologías, siendo así una opción amoldable a las
necesidades y presupuestos de los potenciales clientes.
Se puede realizar un sistema completo y funcional usando componentes de
bajo costo, siendo útil para pequeños agricultores que no puedan permitirse
algunas de las opciones presentadas en el estado del arte.
La utilización de hardware libre permite acceder a documentación
desarrollada por otros usuarios pudiéndose reutilizar código libre así como
encontrar soluciones a problemas en distintos foros.
6.2 Líneas de futuro
En esta sección se van a presentar mejoras o nuevas funcionalidades que se podrían
añadir al proyecto en una serie de trabajos futuros:
Aplicar otras tecnologías para la comunicación del coordinador con el
servidor, como podría ser Wi-Fi o WiMax.
Diseñar un sistema fotovoltaico autónomo para alimentar los equipos.
110
Dar la posibilidad de transmitir imágenes del estado actual de la plantación
para dar información adicional.
Mejorar el sistema borroso de decisión de riego, basándose en un estudio
técnico profundo.
Realizar una aplicación móvil que nos ofrezca los mismos servicios que la
aplicación web desarrollada.
Cambiar la tecnología Xbee Serie 1 por la Serie 2 para implementar una red
mallada.
CAPÍTULO 7. BIBLIOGRAFÍA
[1] PORTAL JAEN.ES. Olivar .Consulta: 16 de mayo de 2017] Disponible en:
http://www.jaen.es/economia/actualidad-economica/olivar/
[2] PASTOR, M, VEGA, V y HIGALDO, J. "Riego deficitario en el olivar" en IFAPA-
CIFA Alameda del Obispo. Córdoba. Consejería de innovación, Ciencia y Empresa. Junta
de Andalucía. [Consulta: 16 de mayo de 2017] Disponible en:
https://www.google.es/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8
&ved=0ahUKEwiOoZeyrfbTAhUH6RQKHVc8Ak8QFggnMAA&url=http%3A%2F%2F
www.juntadeandalucia.es%2Fagriculturaypesca%2Fifapa%2F-%2Faction%2F90004fc0-
93fe-11df-8d8b-f26108bf46ad%2Fe5747030-1bb8-11df-b7e2-
35c8dbbe5a83%2Fes%2F02f9e190-faff-11e0-929f-
f77205134944%2FalfrescoDocument%3Fi3pn%3DcontenidoAlf%26i3pt%3DS%26i3l%3
Des%26i3d%3De5747030-1bb8-11df-b7e2-35c8dbbe5a83%26contentId%3D04a7f925-
49c0-4372-9dfb-331ac33511fa&usg=AFQjCNH-
6N9LAx_UIvS8ET_Sx7L30KVLoA&sig2=AlnyHa5kyjE1IJAic7UB1g
[3] TELEFÓNICA S.A. Internet de Todo el futuro de IoT. [Consulta: 16 de mayo de
2017]. Disponible en:
https://www.openfuture.org/es/new/internet-de-todo-el-futuro-del-iot
[4] Comisión Europea. Es Horizonte 2020. [Consulta: 17 de mayo de 2017]. Disponible
en: http://www.eshorizonte2020.es
[5] Comisión Europea. Apollo. [Consulta: 17 de mayo de 2017]. Disponible en:
http://apollo-h2020.eu/es/
[6] VALERO UBIERNA. C. (2001). "Agricultura de precisión: conceptos y situación
actual." en Vida Rural, nº 136, p. 58-62. <http://oa.upm.es/6291/1/Valero_36.pdf>
111
[Consulta: 17 de mayo de 2017]. Disponible en:
http://www.revistaambienta.es/WebAmbienta/marm/Dinamicas/secciones/articulos/AP.ht
m
[7] KRANNICH SOLAR. Fotovoltaica Aislada. [Consulta: 17 de mayo de 2017].
Disponible en: http://es.krannich-solar.com/es/autoconsumo/fotovoltaica-aislada.html
[8] RIEGO SOLAR. Bombeo solar directo.[Consulta: 17 de mayo de 2017]. Disponible
en: http://www.riegosolar.net/es/bombeo-solar-directo/
[9] NOVEDADES AGRÍCOLAS S.A. Riego automático. [Consulta: 15 de mayo de 2017].
Disponible en: http://www.novedades-agricolas.com/es/riego/sistemas-de-riego/riego-
automatico
[10] ELECTRONOBO S.L. Fincas particulares. [Consulta: 15 de mayo de 2017].
Disponible en: http://www.electronobo.com/es/telecontrol/fincas-particulares.php
[11] LORENZT. Productos y tecnologías. [Consulta: 15 de mayo de 2017]. Disponible en:
https://www.lorentz.de/es/productos-y-tecnologia/
[12] NATIONAL INSTRUMENT. ¿Qué es una red inalámbrica de sensores?. [Consulta:
26 de mayo de 2017]. Disponible en: http://www.ni.com/wsn/whatis/esa/
[13] LIBELIUM. Waspmote.[Consulta: 26 de mayo de 2017]. Disponible en:
http://www.libelium.com/products/waspmote/
[14] ARDUINO. Introduction.[Consulta: 16 de mayo de 2017]. Disponible en:
https://www.arduino.cc/en/Guide/Introduction
[15] NATIONAL INSTRUMENT. Bluetooth. [Consulta: 19 de mayo de 2017]. Disponible
en: http://www.ni.com/white-paper/7104/en/
[16] OLIMEX. Bluetooth Serial HC-06.[Consulta: 26 de mayo de 2017]. Disponible en:
<https://www.olimex.com/Products/Components/RF/BLUETOOTH-SERIAL-HC-
06/resources/hc06.pdf>
[17] ARDUINO.ORG. ESP8266 Datasheet. [Consulta: 26 de mayo de 2017]. Disponible
en: http://download.arduino.org/products/UNOWIFI/0A-ESP8266-Datasheet-EN-v4.3.pdf
[18] DIGI. Digi Xbee Zigbee Specifications.[Consulta: 26 de mayo de 2017]. Disponible
en:
https://www.digi.com/products/digi-xbee-rf-solutions/embedded-rf-modules-
modems/digi-xbee-zigbee#specifications
[19] OYARCE, A., AGUAYO, P. Guía de Usuario. Ingeniería MCI LTDA. 2008. [Consulta:
19 de mayo de 2017]. Disponible en:
<http://olimex.cl/website_MCI/static/documents/XBee_Guia_Usuario.pdf>
112
[20] ARDUINO. Boards. [Consulta: 16 de mayo de 2017]. Disponible en:
https://www.arduino.cc/en/Products/Compare
[21] HISPATEC. Ceres, monitorización automática de cultivos. [Consulta: 17 de mayo de
2017]. Disponible en: http://www.hispatec.es/ceres-monitorizacion-automatica-de-cultivos/
[22] D-ROBOTICS.DHT11 Humidity & Temperature Sensor. D-Robotics UK, 2010.
[Consulta: 17 de mayo de 2017]. Disponible en: http://www.micropik.com/PDF/dht11.pdf
[23] LUISLLAMAS. Medir la humedad del suelo con Arduino e hidrómetro FC-28.
[Consulta: 17 de mayo de 2017]. Disponible en: https://www.luisllamas.es/arduino-
humedad-suelo-fc-28/
[24] SHENZEN SENBA OPTICAL & ELECTRONIC CO., LTD. LG55 Series
Photoresistor.[Consulta: 17 de mayo de 2017]. Disponible en:
http://akizukidenshi.com/download/ds/senba/GL55%20Series%20Photoresistor.pdf
[25] GARCÍA, J.M., molina GARCÍA-PARDO, J.M., LEANDRO, J. Sistemas de comunicaciones
móviles: segunda, tercera y cuarta generación. Cartagena: Universidad Politécnica de
Cartagena. 2014. [Consulta: 17 de mayo de 2017]. Disponible en:
https://libroselectronicos.ujaen.es/Record/Xebook1-2713
[26] AJAY R., M. "2.5-Generation Networking Planning and Optimisation (GPRS and
EDGE)" en Fundamentals of Cellular Network Planning and Optimisation:
2G/2.5G/3G…Evolution to 4G. John Wiley & Sons Ltd. 2004. [Consulta: 17 de mayo de
2017]. Disponible en:
http://sd6tr7ck8b.search.serialssolutions.com/?ctx_ver=Z39.88-
2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-
8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffm
t%3Akev%3Amtx%3Abook&rft.genre=book&rft.title=Fundamentals+of+Cellular+Netwo
rk+Planning+and+Optimisation%3A+2G%2F2.5G%2F3G...+Evolution+to+4G&rft.au=A
uthor&rft.au=Ajay+R.+Mishra&rft.date=2004-01-
01&rft.pub=John+Wiley+%26+Sons+Ltd&rft.isbn=9780470862674&rft.externalDocID=9
780470862681¶mdict=es-ES
[27] GEEETECH. Arduino GPRS Shield. [Consulta: 19 de mayo de 2017]. Disponible en:
http://www.geeetech.com/wiki/index.php/Arduino_GPRS_Shield
[28] SANTOS GONZÁLEZ, M. "Módems" en Sistemas Telemáticos. RA-MA Editorial. 2014.
[Consulta: 17 de mayo de 2017]. Disponible en:
http://0-site.ebrary.com.avalos.ujaen.es/lib/bibujaen/detail.action?docID=11038861
[29] OVH. Web hosting, cloud y servidores dedicados. [Consulta: 18 de mayo de 2017].
Disponible: https://www.ovh.es
113
[30] 000WEBHOSTING. Free Web Hosting.[Consulta: 18 de mayo de 2017]. Disponible
en: https://www.000webhost.com
[31] RFC (1982). The Domain Naming Convention for Internet User Applications. RFC:
819. [Consulta: 18 de mayo de 2017]. Disponible en: https://tools.ietf.org/rfc/rfc819.txt
[32] DNYDNS. Pursache & Pricing. [Consulta: 18 de mayo de 2017]. Disponible en:
https://dyn.com/dns/pricing/
[33] NO-IP. Dynamic DNS. [Consulta: 18 de mayo de 2017]. Disponible en:
<https://www.noip.com/remote-access>
[34] NO-IP. Download. [Consulta: 18 de mayo de 2017]. Disponible en:
https://www.noip.com/download?page=win
[35] LÓPEZ MONTALBÁN, I., CASTELLANO PÉREZ, M.J.Gestión de Bases de Datos. Madrid.
Garceta. 2011.
[36] IBM. IBM DB2.[Consulta: 18 de mayo de 2017]. Disponible en:
https://www.ibm.com/analytics/us/en/technology/db2/
[37] MICROSOFT. Microsoft Access. [Consulta: 18 de mayo de 2017]. Disponible en:
https://products.office.com/es-es/access
[38] MYSQL. Why MySQL. [Consulta: 18 de mayo de 2017]. Disponible en:
https://www.mysql.com/why-mysql/
[39] ECLIPSE. Downloads. [Consulta: 18 de mayo de 2017]. Disponible en:
https://www.eclipse.org/downloads/
[40] APACHEFRIENDA. Xampp. [Consulta: 18 de mayo de 2017]. Disponible en:
https://www.apachefriends.org/es/index.html
[41] TOMCAT APACHE. Index.[Consulta: 18 de mayo de 2017]. Disponible en:
http://tomcat.apache.org
[42] Ministerio de Educación Nacional República de Colombia. Manual de cambio de
puerto Apache Tomcat. [Consulta: 18 de mayo de 2017]. Disponible en:
http://snies.mineducacion.gov.co/descargas/manuales/ManualCambioPuertoTomcat.pdf
[43] WALTER.WEB. 2012. "Como cambiar puerto 80 de Apache Server por el puerto
8080". [Consulta: 18 de mayo de 2017]. Disponible en:
http://snies.mineducacion.gov.co/descargas/manuales/ManualCambioPuertoTomcat.pdf
[44] BLANK, A.G. TCP/IP JumpStart: Internet Protocol Basics. Sybex. 2006. [Consulta: 18
de mayo de 2017]. Disponible en:
http://0-site.ebrary.com.avalos.ujaen.es/lib/bibujaen/detail.action?docID=10152540
114
[45] GOURYLE, D. HTTP: The Definitive Guide. Beijing; Sebastopol, CA: O'Relly, 2002.
[Consulta: 19 de mayo de 2017]. Disponible en:
HTTP://0-proquestcombo.SAFARIBOOKSONLINE.COM.AVALOS.UJAEN.ES/BOOK/WEB-
DEVELOPMENT/HTTP/1565925092
[46] WARIN, G. Mastering Spring MVC 4: gain expertise in designing real-word web
application using the Spring MVC framework. Birmingham, UK .Pack Publishing Ltd.
2015. [Consulta: 19 de mayo de 2017]. Disponible en:
http://0-proquestcombo.safaribooksonline.com.avalos.ujaen.es/book/web-
development/9781783982387
[47] SCHILD, H. Java: manual de referencia. McGraw-Hill Interamericana. 2009.
[Consulta19 de mayo de 2017]. Disponible en:
http://0-site.ebrary.com.avalos.ujaen.es/lib/bibujaen/detail.action?docID=10433817
[48] HANNA, P. JSP: Manual de referencia. Madrid: McGraw-Hill, D.L. 2002.
[49] MOZILLA FOUNDATION. Acerca de JavaScript. [Consulta: 26 de mayo de 2017].
Disponible en:
https://developer.mozilla.org/es/docs/Web/JavaScript/Acerca_de_JavaScript
[50] PHP.NET. Conceptos básicos. [Consulta: 26 de mayo de 2017]. Disponible en:
http://php.net/manual/es/getting-started.php
[51] JFREE. Index. [Consulta: 19 de mayo de 2017]. Disponible en:
http://www.jfree.org/jfreechart/
[52] HIGH CHARTS. Index. [Consulta: 19 de mayo de 2017]. Disponible en:
https://www.highcharts.com
[53] CHART.JS. Index.[Consulta: 19 de mayo de 2017]. Disponible en:
http://www.chartjs.org
[54]GOOGLE. Annotation Chart. [Consulta: 19 de mayo de 2017]. Disponible en:
https://developers.google.com/chart/interactive/docs/gallery/annotationchart
[55] W3SCHOOLS. XML Tutorial.[Consulta: 19 de mayo de 2017]. Disponible en:
https://www.w3schools.com/xml/default.asp
[56] W3SCHOOLS. JSON Tutorial.[Consulta: 19 de mayo de 2017]. Disponible en:
https://www.w3schools.com/js/js_json_intro.asp
[57] RFC (2005). Common Format and MIME Type for CSV Files. RFC: 4180. [Consulta:
19 de mayo de 2017]. Disponible en: https://www.ietf.org/rfc/rfc4180.txt
[58] CORDÓN, O., HERRERA, F., HOFFMAN, F., MAGDALENA, L. Genetic Fuzzy Systems:
Evolutionary Tuning and Learning of Fuzzy Knowledge Bases. Singapore [etc.]: World
115
Scientific, cop. 2001. [Consulta: 20 de mayo de 2017]. Disponible en:
https://books.google.es/books?id=BWmSV38fKAC&printsec=frontcover&dq=genetic+fuz
zy++systems&hl=es&sa=X&redir_esc=y#v=onepage&q&f=false
[59] PROMETEC. Sensores de Temperatura DHT11. [Consulta: 20 de mayo de 2017].
Disponible en: http://www.prometec.net/sensores-dht11/
[60] PROMETEC. Conectarse a Internet mediante GPRS. [Consulta: 20 de mayo de
2017]. Disponible en: http://www.prometec.net/gprs-internet/
[61] ARDUINO.CC. Due Software Reset. [Consulta: 27 de mayo de 2017]. Disponible en:
https://forum.arduino.cc/index.php?topic=345209.0
[62] ADAFRUIT. SIM800 Series NTP Application Note.[Consulta: 20 de mayo de 2017].
Disponible en:
https://cdn-shop.adafruit.com/product-
files/2637/SIM800+Series_NTP_Application+Note_V1.01.pdf
[63] DIGI. XCTU. [Consulta: 22 de mayo de 2017]. Disponible en:
https://www.digi.com/products/xbee-rf-solutions/xctu-software/xctu
[64] DIGI. Xbee / Arduino Compatible Coding Platform. [Consulta: 22 de mayo de 2017].
Disponible en:
http://docs.digi.com/display/XBeeArduinoCodingPlatform/XBee+Arduino+Compatible+C
oding+Platform
[65] GITHUB. Xbee-Arduino Download. [Consulta: 22 de mayo de 2017]. Disponible en:
https://github.com/andrewrapp/xbee-arduino#Download
[66] MARTÍNEZ FERNÁNDEZ, R. (2014). Evaluación del consumo de energía de
Arduino. Proyecto fin de carrera. Casteldefels: Universidad Politécnica de Cataluña.
[67] GITHUB. Sleep_n0m1.[Consulta: 22 de mayo de 2017]. Disponible en:
https://github.com/n0m1/Sleep_n0m1
[68] KOBAN. Medición de iluminación (lux). [Consulta: 23 de mayo de 2017]. Disponible
en:
http://www.escuelassj.com/pluginfile.php/37028/mod_folder/content/0/MEDICIONES/Me
dicionDeIluminacion.pdf?forcedownload=1
[69] ULLMAN, L. MYSQL, Second Edition: Visual Quickstart Guide. Peachpit Press. 2006.
[Consulta: 24 de mayo de 2017]. Disponible en:
http://0-proquestcombo.safaribooksonline.com.avalos.ujaen.es/0321375734
[70] STACKOVERFLOW. How to retrieve raw post data from HttpServletRequest in
java. [Consulta: 24 de mayo de 2017]. Disponible en:
116
https://stackoverflow.com/questions/5023718/how-to-retrieve-raw-post-data-from-
httpservletrequest-in-java
[71] MKYONG. How to write to file in Java – BufferedWriter. [Consulta: 24 de mayo de
2017]. Disponible en:
https://www.mkyong.com/java/how-to-write-to-file-in-java-bufferedwriter-example/
[72] MKYONG. How to read and parse CSV File in Java. [Consulta: 24 de mayo de
2017]. Disponible en: https://www.mkyong.com/java/how-to-write-to-file-in-java-
bufferedwriter-example/
[73] JUSTFREETEMPLATES. Ripped Blue – Premium HTML web template – Free web
template.[Consulta: 24 de mayo de 2017]. Disponible en:
http://www.justfreetemplates.com/web-templates/view/3770-Rippedblue-Premium-
HTML-web-template.html
[74] LUISLLAMAS. Medir distancias con Arduino y Sensor de ultrasonidos HC-SR04.
[Consulta: 25 de mayo de 2017]. Disponible en:
https://www.luisllamas.es/medir-distancia-con-arduino-y-sensor-de-ultrasonidos-hc-sr04/
[75] HOBBYTRONICS. YF-S201. [Consulta: 25 de mayo de 2017]. Disponible en:
http://www.hobbytronics.co.uk/datasheets/sensors/YF-S201.pdf
[76] MECATRONIUM CHIPS. Tutorial Sensor de flujo YS-S201. [Consulta: 25 de mayo
de 2017]. Disponible en: http://chips.mecatronium.com/tutorial-sensor-de-flujo-yf-s201/
[77] LUISLLAMAS. Usar Mosfet como interuptor digital con Arduino y IRF520N.
[Consulta: 25 de mayo de 2017]. Disponible en:
https://www.luisllamas.es/arduino-mosfet-irf520n/
[78] ORACLE. Java SE Development Kit 8 Downloads. [Consulta: 1 de junio de 2017]
Disponible en:
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
[79] ARDUINO.CC. Download IDE. [Consulta: 1 de junio de 2017]. Disponible en:
https://www.arduino.cc/en/main/software
117
CAPÍTULO 8. ANEXOS
8.1 Manuales
En esta sección se van a incluir dos manuales, el primero, de usuario, para enseñar a
utilizar la aplicación, y el segundo, de instalación y mantenimiento, para poner en marcha
el sistema y poder realizar las modificaciones necesarias.
8.1.1 Manual de usuario
En este apartado se va explicar la utilización de la aplicación web.
Primero hay que conectarse al servidor, para ello poner en el navegador web la
dirección correspondiente, en nuestro caso: sistemariego.ddns.net:8084/prueba1.
Como página de inicio se ha desarrollado inicio.html, que nos hace una
introducción sobre las funcionalidades de la aplicación y un acceso directo a ellas:
Visualizar valores: nos lleva a un formulario, que nos permitirá
posteriormente ver los gráficos.
Añadir Arduino: a través de un formulario nos ofrece la posibilidad
de añadir una nueva localización en la base de datos.
Configuración del sistema: podemos cambiar los parámetros del
sistema.
Depósitos: permite conocer el estado de los depósitos.
118
Figura 8.1 Inicio
Al pulsar "Visualizar valores" se muestras los distintos campos a rellenar, tanto la
localización y el Sub-ID que identifica a cada Arduino del cual queremos saber las
mediciones, así como el intervalo de tiempo que queremos ver.
Figura 8.2 Formulario selección de equipo
Tras rellenar estos datos y darle al botón enviar, se abre en la pantalla otra página
web, que nos permite elegir qué datos queremos visualizar:
Tabla: nos muestra en una tabla la fecha de las medidas, así como sus
parámetros asociados y el valor de decisión de riego.
119
Evolución: las otras posibilidades nos muestran la evolución de una
magnitud física en el tiempo.
Los parámetros cuya evolución podemos ver son: temperatura, luminosidad,
humedad ambiente, y humedad del suelo.
Se va a mostrar un ejemplo de la tabla y de la evolución de la temperatura.
Figura 8.3 Selección de gráfico a representar
120
Fig
ura
8.4
E
volu
ción T
emper
atura
121
Fig
ura
8.5
Tab
la d
e m
edid
as
122
Ahora se muestra la opción de "Añadir Arduino", que a través de cuadro de texto,
nos permite añadir nuevas zonas a nuestra base de datos.
Figura 8.6 Añadir nueva localización
Previamente a rellenar el formulario de configuración, hay que elegir la
localización a configurar, al rellenarlo nos reenviará al formulario final.
Figura 8.7 Elección de equipos a configurar
En esta parte nos permite elegir una serie de características, como el tiempo de
muestreo y configuración, si se ha de tomar una medida con urgencia, el de modo de
trabajo, y si el sistema de riego es manual, regando la cantidad que nosotros indicamos, o
siguiendo las recomendaciones del sistema borroso de decisión. Asimismo, se muestra las
últimas recomendaciones de riego recibidas y la posibilidad de elegir manualmente la
cantidad. Se muestra en la siguiente figura:
123
Finalmente, en "Depósitos" se muestra en una tabla, el Arduino identificado por su
localización y el Sub-ID, su porcentaje de agua, y los litros consumidos.
Fig
ura
8.8
Form
ula
rio c
onfi
gura
ción
124
Figura 8.9 Tabla estado de los depósitos
8.1.2 Manual de instalación y mantenimiento
Para empezar, se va a presentar el equipo utilizado, es un portátil VAIO con las
siguientes características:
Sistema operativo Windows 10 Home de 64 bits.
Procesador Intel Core M480 a 2.67GHz.
Memoria RAM de 4 GB.
Tarjeta gráfica Radeon HD 5000.
Una vez tenemos el equipo, se ha de instalar una máquina virtual Java, JRE, y su
entorno de desarrollo, JDK, del siguiente enlace [78]. Seleccionamos nuestro sistema
operativo y ejecutamos el instalador. Para ser compatible con el servidor Apache y el
contenedor de Servlets Tomcat utilizados, se ha instalado el kit versión 8, update 111.
Posteriormente, es necesario indicar su path a las variables de entorno del sistema,
para ello, accedemos al panel de control, en la opción sistemas, y le damos al enlace de
Configuración avanzada del sistema, y nos saldrá una pantalla como esta:
125
Figura 8.10 Variables de entorno
Pulsamos sobre el botón resaltado en azul, Variables de entorno, y buscamos la
variable Path, le damos a editar y añadimos los directorios del JDK y JRE.
Figura 8.11 Modificando Path
El siguiente programa será Xampp, disponible en [40], hay que elegir el sistema
operativo correcto, nos dará la opción de instalar diversos elementos, los mínimos son:
Apache, MySQL, Tomcat y phpMyAdmin.
Se ha instalado la versión 5.6.28, que incluye Apache 2.4.23, el motor de MySQL:
MariaDB 10.1.19, phpMyAdmin versión 4.5.1 y Tomcat 7.0.56.
126
Figura 8.12 Instalando Xampp
A continuación se instalará Eclipse, en [39], y se elegirá la opción, Eclipse IDE for
Java EE Developers. Se ha usado la versión 4.6.0.
Figura 8.13 Instalando Eclipse
Para la configuración de los Xbee, hay que usar el programa XCTU, disponible en
[63], para el sistema operativo correspondiente.
Seguidamente, hay que descargar el IDE de Arduino, disponible en [79], en mi caso
la versión 1.8.3. Una vez instalada, hay que descargar el compilador del Arduino Uno y
Due por separado, dándole al botón herramientas, y dentro a la opción gestor de tarjetas,
buscar las tarjetas Arduino AVR Boards y Arduino SAM (32-bits ARM Cortex-M3), como
se muestra en la figura:
127
Figura 8.14 Compiladores de Arduino
Por último, hay que importar las librerías que se utilizan, en formato zip, usando la
opción disponible en Programa/Incluir librería/ Añadir Librería .ZIP.
Estas librerías son: DTH11, Datos, Sensores, Sleep_n0m1, xbee-arduino y
motorv2, ya presentadas a lo largo de la memoria.
Ahora se va indicar cómo configurar la parte del servidor. Una vez tengamos
configurado el equipo como servidor tal se mostró en el apartado 4.4.2 y se haya
configurado los puertos e inicializado Xampp, como se muestra en el apartado 4.6.1.1. Se
procede a arrancar el servidor en Eclipse. Este mismo se puede importar de un archivo war.
Primero, en Java Resources, hay que incluir todas las clases Java y Servlet que
utiliza la aplicación, así como la librería mysql-connector en la zona de librerías, para que
se puedan ejecutar los códigos.
128
Figura 8.15 Servidor Eclipse -1
Previamente hay que incluir los Servlets en el archivo web.xml como se mostró en
la figura 5.77.
En la carpeta WebContent hay que incluir todos los archivos HTML y JSP que se
van a utilizar, así como las imágenes y archivos relacionados con la hoja de estilos CSS.
129
Figura 8.16 Servidor Eclipse -2
Seguidamente, le damos al botón de inicializar el servidor, y una vez termine, nos
aparecerá un mensaje como este:
Figura 8.17 Arranque del Servidor
130
Seguidamente llevar a cabo una configuración para cada red de sensores
identificada por una localización, si no se ha hecho antes, para crear el archivo de
configuración específico para cada uno y así evitar errores.
A continuación se explica las consideraciones que hay que tener con cada
coordinador. Primero hay que asignar su valor de ID correspondiente.
En el código hay que modificar una serie de aspectos según el número de
dispositivos finales que vayan a asociarse a un coordinador.
Hay que declarar una variable por cada dispositivo final para almacenar el número
de litros consumidos, o en su defecto, declarar un vector de tamaño igual a la cantidad de
nodos.
Figura 8.18 Configuración Coordinador -1
A su vez, hay que modificar la función configurar(), para que en el archivo CSV se
añadan todos los dispositivos en la red, mediante un bucle o manualmente.
131
Figura 8.19 Configuración Coordinador -2
En la misma función, al recibir el archivo CSV, hay que conocer también el número
de dispositivos finales para extraer su información y añadirla a su variable o vector
correspondiente.
Si se quiere modificar el tamaño de los paquetes a enviar, modificar la variable
"cont", para las medidas del coordinador, y "cont2", para los datos recibidos de los
dispositivos finales.
Después, tras la conexión del módulo SIM900 GPRS, el Xbee y los sensores, como
se ha mostrado a lo largo de la memoria, pudiéndose cambiar los pines que se utilizan en el
código, hay que realizar los siguientes pasos:
Introducir la tarjeta SIM en el módulo SIM900.
Poner el interruptor, Power Select, que se puede visualizar en la figura 4.15,
en la posición correcta, que se identificará con una luz verde.
Presionar durante varios segundos el botón para encender el dispositivo, el
botón Power Key, figura 4.15, y si se ha realizado correctamente se
encenderá una luz roja, y a su lado, parpadeará otra luz verde.
132
Seguidamente conectar el Arduino Due a su fuente de alimentación.
Posteriormente, se conectan a la alimentación los dispositivos finales, dando un
margen para al coordinador en torno a un minuto, para que tenga tiempo de arrancar y
configurarse.
Para los dispositivos finales, hay que indicar la ID a la que pertenece el dispositivo,
y su Sub-ID. Asimismo, en los paquetes Xbee, hay que poner como destinatario la
dirección de 16 bits del coordinador. En el coordinador no hace falta, ya que
automáticamente extrae la dirección del paquete entrante y se lo pone al paquete de salida.
Al configurar los Xbee, se ha de realizar el procedimiento visto en 5.3.1.2, teniendo
en cuenta que, todos los Xbee deben estar en el mismo radiocanal y misma red, y que todos
deben tener una dirección de 16 bits distinta, y en los dispositivos finales, poner la
dirección de destino, la primera parte, DH a 0, y la segunda, DL la dirección del
coordinador.
8.2 Presupuesto
En este apartado se va a mostrar el coste del equipamiento utilizado.
Equipo Unidades Precio Unitario (€) Precio Total (€)
Arduino Uno 1 21.26 21,26
Arduino Due 1 38.4 38,4
Módulo Xbee 2 30.13 60,26
Shield Xbee 2 9.57 19,14
USB Xbee 1 26.4 26,4
Módulo GPRS 1 24.97 24,97
Sensor LDR 10 0.264 2,64
Sensor DTH11 2 4.69 9,38
Sensor FC-28 1 9.4 9,4
Sensor HC-SR04 1 1.8 1,8
Sensor YF-S201 1 7.91 7,91
Mosfet IRF520N 1 2.5 2,5
133
Resistencias 4 0.015 0,06
Motor JT-500 1 11.01 11,01
Fuentes externas 4 12.89 51,56
Módulo
alimentación
1 1.83 1,83
Tarjeta SIM 1 0 0
Servidor 1 405 405
El coste del material es: 693.52 euros.
A esto añadirle el precio de los recursos humanos:
Actividad Horas Precio unitario (€) Precio total (€)
Diseño 400 30 12000
Configuración 5 30 150
Instalación 10 30 300
Esto nos da un importe de 12450 euros.
Se procede a calcular el total, incluyendo el IVA:
Ítem Precio (€)
Gastos en equipamiento 693.52
Gasto en recursos humanos 12450
Base imponible 13.143,52
IVA (21%) 2.760,14
Total 15.903,66
Por lo tanto, el precio total es de QUINCEMIL NOVECIENTOS TRES EUROS
CON SESENTA Y SEIS CÉNTIMOS.
Hay unos costes recurrentes a pagar cada mes, para la conexión GPRS y el acceso a
Internet del servidor.
134
Ítem Precio mensual (€)
Conexión GPRS 1
Conexión Internet 19,30
Total 20,30
Los costes recurrentes son de VEINTE EUROS CON VEINTE CÉNTIMOS.
8.3 Código
En este apartado se va a colocar el código de los distintos elementos de la red, tanto
de los dispositivos finales, como del coordinador, como del servidor web.
Dentro de la carpeta "ANEXOS CÓDIGOS" se encuentran varios archivos
comprimidos en formato zip:
"ENDDEVICE" contiene el archivo "ENDDEVICE.cpp", correspondiente
al dispositivo final utilizado.
"COORDINATOR" contiene el archivo "COORDINATOR.cpp" que se
ejecuta en el coordinador.
"Sensores", incluye la librería encargada de obtener los datos de los
sensores, con los ficheros "sensores.cpp" y"sensores.h".
"Datos", tiene la clase en la que se guardan la información obtenida por los
sensores, con los ficheros "datos.cpp" y "datos.h".
"motov2", es la librería del motor borroso, contiene los archivos
"motorv2.cpp" y "motorvv2.h".
"xbee-arduino-master" contiene al librería que facilita el uso de Xbee en
Arduino.
"Time-master", librería encargada de controlar el reloj interno de Arduino.
"Sleep_n0m1-master", clase que administra el modo sleep de Arduino.
Finalmente, está el archivo "prueba1.war", que contiene el servidor Apache con
todos los ficheros utilizados, que se puede importar directamente para su posterior uso.
135
8.4 Pliego de condiciones
Para poder desarrollar este proyecto hay que tener las siguientes consideraciones:
El dispositivo final debe estar implementado sobre un Arduino modelo Uno,
o compatible, debido a que según el dispositivo, puede ser o no compatible
el código.
El coordinador, por el mismo motivo que en el punto anterior, debe ser un
Arduino modelo Due o compatible.
Debe existir cobertura de la red GSM/GPRS en la localización donde se
vaya a implementar el sistema, para poder enviar los datos al servidor.
Los distintos sensores que utilizan los microcontroladores para monitorizar
deben ser los mostrados a lo largo de la memoria, el sensor DHT11, FC28 y
LDR GL5516, para realizar mediciones conforme a lo contemplado.
El módulo GPRS utilizado, en este caso el SIM900, debe ser compatible
con los comandos Hayes introducidos anteriormente.
El servidor debe de disponer de conexión a Internet permanente, así como
los programas introducidos en la memoria, para su correcta instalación y
ejecución, como son la base de datos MySQL, el servidor Apache, una
máquina virtual Java, y el contenedor de Servlet Apache Tomcat.
Para configurar los dispositivos Xbee hay que disponer en un ordenador del
programa XCTU, para su configuración, a través de un adaptador USB
compatible.
8.5 Catálogo de compras
Se procede a presentar la procedencia de cada elemento del presupuesto:
Arduino Uno, Amazon, ASIN: B008GRTSV6
Arduino Due, Amazon, ASIN: B00A6C3JN2
Módulos Xbee , Digi Key, Digi Key Part Number: XBP24-ASI-001-ND
Shield Xbee, DFROBOT, SKU: DFR0015
USB XBEE, Mousers, Nº Ref: 992-XBEE-USB
Módulo GPRS, Amazon, ASIN: B00A8DDYB6
Sensor LDR, Amazon, EAN: 5054648017444
136
Sensor DTH11, Amazon, ASIN: B00HI7LUKW
Sensor FC-28, Amazon, ASIN: B00NPRXYY4
Sensor HC-SR04, Amazon, ASIN: B00GGPYTSW
Sensor YF-S201, Amazon, ASIN: B01F04T1KU
Mosfet IRF520N, Amazon, ASIN: B01N2V0RVT
Resistencias, RS, Código RS: 707-7745
Motor JT-500, Amazon, ASIN: B017QTHXV6
Fuentes externas, Farnell, Order Code: 1848973
Módulo de alimentación, Amazon, ASIN: B015CJJVO4
Tarjeta SIM, República Móvil
Servidor, PC componentes, Cod. Artículo: 126687
Conexión GPRS, República Móvil
Conexión Internet, Jazztel