trabajo fin de gradotauja.ujaen.es/bitstream/10953.1/5144/1/memoria cristóbal lópez.pdf · 2...

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


______

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


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.38 Configuración dispositivo final -1 ..................................................................... 62

Figura 5.39 Configuración dispositivo final -2 .................................................................... 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.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.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.


AP: modo de funcionamiento, para el modo de conmutación de

paquetes, modo API.


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


Se configura para que funcione como dispositivo final.


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.


Las velocidades de ambos elementos deben ser iguales.


El modo de funcionamiento debe ser el mismo.


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


Por otra parte, si el byte indica que hay que enviar directamente al servidor:


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].


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].


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.


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>

http://es.krannich-solar.com/es/autoconsumo/fotovoltaica-aislada.html

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


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&paramdict=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.


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:


114

[45] GOURYLE, D. HTTP: The Definitive Guide. Beijing; Sebastopol, CA: O'Relly, 2002.


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:


[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.


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


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.


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.


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

trabajo fin de gradotauja.ujaen.es/bitstream/10953.1/5144/1/memoria cristóbal lópez.pdf · 2...

Documents