Monitoreo Remoto para Lora
Monitoreo Remoto para Lora
Monitoreo Remoto para Lora
monitorización remota de un
depósito de agua mediante
LoRa.
MEMORIA TFM.
I
Esta obra está sujeta a una licencia de
Reconocimiento-NoComercial-SinObraDerivada 3.0
España de Creative Commons
ii
Ficha del trabajo final
Por un lado, se pretende poder conocer con mayor frecuencia parámetros como el
nivel del depósito y el pH del agua, sin necesidad de estar en las instalaciones. De
este modo se logra una monitorización remota que facilita en gran medida el acceso a
la información.
iii
de forma remota. Para ello, se recurre a una metodología en cascada, donde
partiendo de la contextualización del proyecto y del estudio de las tecnologías
necesarias, se diseña el sistema, se construye el prototipo y se verifica su
funcionamiento.
In this work, we propose the design of a system that allows monitoring, automate
processing and transmiting data from a water tank for human consumption, typical of
small populations. The purpose is to be able to have greater control over the water
consumed in a municipality, where normally only recurrent quality controls are used,
which can be semi-annual or even annual.
On the one hand, it is intended to be able to know more frequently parameters such as
the level of the tank and the pH of the water, without needing to be in the facilities. In
this way, remote monitoring is achieved, which greatly facilitates access to information.
On the other hand, the Arduino environment is used as a monitoring and automation
system and the LoRa technology is used to access the data remotely. Then, a cascade
methodology is used, that is, starting from the contextualization of the project and the
study of the necessary technologies, the system is designed, the prototype is built and
its operation verified.
Finally, once the initial objectives have been achieved, some improvements are
implemented, such as using LoRaWAN to upload the data to TTN and add GSM /
GPRS communications that allow sending alarm messages, giving rise to a more
complete system than initially proposed.
iv
Índice
Índice de figuras ..........................................................................................................vii
Índice de tablas............................................................................................................. x
1. Introducción .............................................................................................................. 1
1.1 Contexto y justificación del Trabajo...................................................................... 1
1.1.1 Ejemplo de caso de aplicación. ................................................................... 2
1.2 Objetivos del Trabajo. .......................................................................................... 4
1.3 Enfoque y método seguido. ................................................................................. 4
1.4 Planificación del Trabajo ...................................................................................... 5
1.4.1 Alcance. ...................................................................................................... 6
1.4.2 Hitos. .......................................................................................................... 6
1.4.3 Calendario de trabajo. ................................................................................. 7
1.4.4 Tareas y Diagrama de Gantt. ...................................................................... 8
1.4.5 Riesgos e incidencias. .............................................................................. 11
1.4.6 Recursos. .................................................................................................. 11
1.5 Breve sumario de productos obtenidos .............................................................. 12
1.6 Breve descripción de los otros capítulos de la memoria..................................... 13
2. Estado del arte........................................................................................................ 14
2.1 Contexto actual. ................................................................................................. 14
2.1.1 Parámetros de control de calidad del agua potable................................... 14
2.1.2 Sensores y sistemas de control del agua. ................................................. 17
2.2 Trabajos relacionados........................................................................................ 19
2.3 Resumen del capitulo ........................................................................................ 24
3. Diseño del sistema.................................................................................................. 25
3.1 Tecnologías necesarias ..................................................................................... 25
3.1.1 Entorno Arduino ........................................................................................ 25
3.1.2 LoRa ......................................................................................................... 28
3.2 Monitorización y automatización. ....................................................................... 32
3.2.1 Sensores. ................................................................................................. 33
3.2.2 Módulo Arduino. ........................................................................................ 38
3.2.3 Sistema de monitorización y posible automatización. ............................... 40
3.3 Comunicaciones LoRa. ...................................................................................... 41
3.3.1. Módulos LoRa .......................................................................................... 42
3.3.2 Configuración y pruebas de enlace punto a punto. .................................. 47
3.3.3 Pruebas con sensor DHT11 y TTGO. ....................................................... 50
3.4. LoRaWAN y TTN .............................................................................................. 51
v
3.4.1 The Things Network. ................................................................................. 51
3.4.2 TTN en este proyecto. .............................................................................. 53
3.4.3 Pruebas con TTN. ..................................................................................... 54
3.5 Resumen del capítulo ........................................................................................ 60
4. Prototipo y pruebas ................................................................................................. 61
4.1 Ubicación. .......................................................................................................... 61
4.2 Prototipo inicial. ................................................................................................. 62
4.3 Prototipo definitivo ............................................................................................. 66
4.4 Pruebas. ............................................................................................................ 68
4.5 Comentarios sobre los resultados de las pruebas.............................................. 70
4.6 Presupuesto. ..................................................................................................... 71
4.7 Resumen del capítulo. ....................................................................................... 72
5. Mejora del sistema: alarmas SMS ........................................................................... 73
5.1 Contexto y requisitos ......................................................................................... 73
5.2 Implementación en el sistema y pruebas ........................................................... 74
5.3 Pruebas con el prototipo en el depósito ............................................................. 76
5.4 Resumen del capítulo. ....................................................................................... 78
6. Conclusiones y líneas futuras ................................................................................. 79
Glosario ...................................................................................................................... 83
Bibliografía .................................................................................................................. 84
Anexos ....................................................................................................................... 90
vi
Índice de figuras
vii
FIGURA 26. MÓDULO DRAGINO LORA SHIELD [46] .......................................................... 44
FIGURA 28. PINOUT DEL MÓDULO TTGO LORA32 V2.1_1.6 [47] .................................... 46
FIGURA 75. PRUEBAS CON SENSOR DHT11 Y ENVÍO DE SMS ...................................... 137
ix
Índice de tablas.
x
1. Introducción
Sin duda, la calidad del agua para el consumo humano es un factor determinante en la
salud, al igual que contar con los suficientes recursos o, al menos, conocer su
disponibilidad. Por ello, en este trabajo se plantean una serie de iniciativas que
permitan tener un mayor control sobre algunos de los parámetros de la calidad y sobre
la disponibilidad que hay en un depósito de agua potable para el suministro municipal.
En primer lugar, conocer el nivel del depósito de agua que abaste un municipio puede
parecer que no es crítico, pero hay que darse cuenta de que cualquier incidencia que
se descubre tarde puede dar lugar a una suspensión del abastecimiento, con lo que
esto conlleva. El ejemplo más contundente es una fuga en las tuberías de
abastecimiento que se descubre tarde, donde se produce una disminución drástica del
agua almacenada en el depósito de forma repentina. En este caso, si se dispone de un
mecanismo de alarma, se puede recurrir a revisar la red de suministro con mayor
1
antelación para localizar la fuga y evitar males mayores. Además, donde ahora se
emplea una simple boya que activa y desactiva el mecanismo de bombeo que trae el
agua al depósito en función del nivel, se puede evolucionar a un sistema de
monitorización del nivel que además de automatizar la puesta en marcha del bombeo
permita transmitir la información a un servidor y emplear los datos para su análisis y
procesado.
En segundo lugar, los parámetros de calidad del agua son bastantes y difíciles de
medir, donde normalmente se requieren laboratorios para poder realizarlos. Como se
puede ver en [1] la legislación es bastante clara y precisa, pero no es exigente en
cuanto a la frecuencia de toma de muestras. A modo de ejemplo en [2] se puede tener
acceso a casi la totalidad de los abastecimientos de agua en España, donde pueden
verse los análisis, tratamientos y periodicidad de los mismos. En este proyecto no se
trata de entrar en detalle en los distintos parámetros, sino simplemente aplicar alguno
de ellos como es el potencial de Hidrógeno (pH) del agua. Por tanto, se trata de poder
medir este parámetro con mayor regularidad que la que se propone desde la
administración y, en su caso, actuar sobre mecanismos que permitan su corrección.
2
Sin embargo, en determinados periodos esta población se triplica, siendo esto un
pequeño hándicap para el suministro de agua, sobre todo en verano.
Por otro lado, la aplicación del proyecto a este caso concreto consiste en la
construcción del prototipo que permita medir el nivel de agua almacenada con una
periodicidad determinada, actuar sobre el equipo de bombeo si es necesario, transmitir
datos de nivel y pH empleando LoRa y poder enviar alarmas sobre eventos
programados.
En resumen, se propone que una vez diseñado el sistema sea posible emplearlo en un
entorno real como el propuesto y comprobar su funcionalidad. Se considera que es
una buena forma de prevenir sucesos no deseados como son interrupciones del
suministro por desconocer la existencia de grandes fugas o tener un mayor control
3
sobre el pH. En ambos casos, las alertas pueden ser muy importantes, pero también
tener un perfil estadístico de ambos parámetros.
Por un lado, una vez planteado el diagrama de bloques que se presentan en la figura
2, se procederá con la resolución de cada bloque siguiendo lo explicado
anteriormente. De este modo, en cada bloque se buscará la información necesaria, se
realizará el diseño y simulaciones pertinentes, bien sea mediante software o mediante
prototipo, con la finalidad de poder comprobar la funcionalidad del bloque diseñado.
4
Por otro lado, se afronta el trabajo empleando una metodología en cascada donde
resolviendo los bloques debe lograrse un prototipo funcional disponible para pruebas.
Por tanto, a lo largo del trabajo se profundiza en cada uno de los bloques mediante el
estudio de las tecnologías, el análisis de requisitos y la búsqueda de soluciones que
permitan resolver cada bloque y la interconexión entre ellos.
Todo esto puede variar ligeramente respecto a lo inicialmente aquí expuesto, según se
profundice en cada bloque y se adquieran mayores conocimientos. Aparte, no se
incluye un bloque de alimentación, dado que se plantea la posibilidad de alimentar el
sistema con una pequeña batería. Aun así, si durante el trabajo se acaba
considerando imprescindible se puede diseñar una pequeña fuente de alimentación
para el sistema, partiendo de la existencia de una tensión de red de 220 V en la
ubicación del depósito.
5
formación como a nivel de construcción del prototipo, todo ello desglosado en las
tareas e hitos necesarios dentro de una planificación temporal coherente con los
conocimientos actuales y con la disponibilidad temporal.
1.4.1 Alcance.
Se enumeran a continuación los objetos que forman parte del alcance del proyecto:
1.4.2 Hitos.
Los hitos del proyecto corresponden a las entregas parciales (PECs) y a la entrega
final de la memoria y de la presentación. Así mismo, se considerarán también como
hitos los diferentes borradores correspondientes a cada entregable. También, se
añade como hito la fecha de defensa del proyecto, tabla 1.Por otro lado, estos hitos
son la visión global de todo el trabajo, los cuales se desglosan en las diferentes
tareas que se presentan en el diagrama de Gantt del siguiente apartado, que
permite ver la EDT del proyecto.
6
TABLA 1. HITOS
El TFM tiene una carga de 12 créditos, de modo que se trata de repartir 300 horas
(12 créditos x 25 horas/crédito) entre 15 semanas que hay desde el comienzo del
proyecto hasta su entrega definitiva. Así, se puede considerar una carga semanal
de 20 horas, por lo que si se establece una dedicación de dos horas diarias de
lunes viernes y diez horas a lo largo del fin de semana, se estaría cumpliendo con
la distribución temporal necesaria. En la tabla 2 se muestra la distribución de horas
disponibles en función del número de días laborables y de fines de semana con la
distribución planteada, donde se aprecia que se dispone de más tiempo que el
supuestamente requerido.
7
1.4.4 Tareas y Diagrama de Gantt.
En este punto se procede a definir las tareas que formaran parte del trabajo
necesario para alcanzar cada uno de los hitos. De este modo, se puede desglosar
el proyecto en las siguentes tareas:
8
4. PEC 4. Finalización del proyecto. (20/05/2017- 13/06/2017).
Revisión feedback y modificaciones.
Mejoras.
Conclusiones y lieneas futuras de trabajo.
Colchon temporal: imprevistos, mejoras y cambios.
Documento PEC4.
Revisión e imprevistos.
Entrega PEC4.
9
Rubén Adrián de la Cámara
Master Universitario en Ingeniería de Telecomunicaciones.
UOC, Curso 2018/19
10
Rubén Adrián de la Cámara
Master Universitario en Ingeniería de Telecomunicaciones.
UOC, Curso 2018/19
En este punto es importante tratar de advertir sobre una serie de riesgos que
pueden acontecer durante la elaboración del proyecto, con la finalidad de poder
mitigar sus efectos en caso de que se materialicen. De este modo se exponen los
que a priori pueden presentarse:
1.4.6 Recursos.
11
Módulos de comunicaciones LoRa.
Fuente de alimentación regulable y/o pilas y baterías.
Resistencias, condensadores, diodos y pequeños cables.
Partiendo de estos elementos y una vez conocido y estudiado tanto el entorno Arduino
como LoRa, se puede definir con precisión el tipo de tarjetas o módulos que serán
necesarios para elaborar el prototipo. Lo mismo sucede con los sensores específicos
del sistema, ya que para simulaciones se pueden sustituir por cualquier otro tipo de
entrada y una vez se tenga clara su disponibilidad se pueden adquirir y realizar el
prototipo.
Por otro lado, debido la extensión de los anexos, se incluyen todos ellos en un
documento complementario a esta memoria, con la finalidad de incluir todo lo
necesario para comprender que se ha hecho y como, pero fuera del documento
principal.
12
1.6 Breve descripción de los otros capítulos de la memoria
Capítulo 2: se realiza una aproximación al estado actual del ámbito del tema del
proyecto: el agua potable y su control. También, se presentan ejemplos de elementos
de control dentro de este ámbito así como trabajos académicos que abordan este
campo.
Capítulo 3: se trata del capítulo principal del proyecto, donde se expone todo el
proceso de diseño del sistema. Se parte de la exposición de las tecnologías que se
emplean en el diseño de la solución (Arduino y LoRa), continuando con un pequeño
análisis de los distintos tipos de componentes hardware empleados. Se proponen los
dispositivos que se emplean y las pruebas necesarias para verificar su funcionamiento,
tanto en monitorización como en comunicaciones. Finalmente, se aborda la aplicación
de LoRaWAN en el proyecto empleando un gateway y The Things Network (TTN).
Capítulo 5: se expone una mejora del sistema que consiste en enviar mensajes SMS
de alarma empleando la red GSM/GPRS. Para ello, se explica todo el proceso
seguido en el diseño, la adaptación al prototipo construido en el capítulo 4 y las
pruebas necesarias para validar su operatividad.
13
2. Estado del arte
En primer lugar, como ya se comentó, en [1] y [2] se pueden ver tanto la legislación
que el agua potable debe cumplir como el estado de las distintas captaciones de
agua en la mayoría de España. Por tanto, ahora se trata de conocer con mayor
precisión como está este ámbito. Así, haciendo referencia a [1], en [4] se expone
que la vigilancia de la calidad del agua para el abastecimiento a la población
comienza en embalses, ríos y pozos, continúa durante su tratamiento en las
estaciones de tratamiento de agua potable (ETAP) y a través de su paso por la red
de distribución hasta que llega al consumidor. En todos estos puntos se recoge
muestras de agua que, posteriormente, se analizarán en laboratorio. Con las
técnicas adecuadas, los técnicos analizarán aquellos parámetros necesarios para
conocer si el agua es apta para consumo humano. Por ejemplo, los parámetros a
controlar para el grifo del consumidor son, al menos: olor, sabor, color, turbidez,
conductividad, pH, amonio, bacterias coliformes, E. Coli, cobre, cromo, níquel,
hierro, plomo, cloro libre residual y cloro combinado residual. La calidad del agua se
determina comparando las características físicas y químicas de una muestra de
14
agua con unas directrices de calidad del agua o estándares. En el caso del agua
potable, estas normas se establecen para asegurar el suministro de agua saludable
para el consumo humano y, de este modo, proteger la salud de las personas. Estas
normas se basan en unos niveles de toxicidad aceptables tanto para los personas
como para los organismos acuáticos.
Por otro lado, los controles de calidad pueden realizarse in situ o bien tomando
muestras que se llevan a un laboratorio para su estudio. En la figura 3 se muestran
2 kits para realizar mediciones en el lugar de la toma de muestras, que permiten
medir parámetros como:
15
disponibles y se presentan en la tabla 3 los estándares de la Organización Mundial de
la Salud (OMS).
Finalmente y a modo de tema de estudio y controversia, hay que comentar que existe
cierta polémica en cuanto al tratamiento de agua potable con lejía (hipoclorito sódico).
Tradicionalmente, se ha empleado la lejía como desinfectante del agua y está
perfectamente definida su dosificación [6] como se muestra en la tabla 4, pero hay
estudios que demuestran que al emplear este producto se están generando
compuestos potencialmente cancerígenos como los trihalometanos [7]. Por ello, en
algunas provincias ya se está empezando a emplear como agente desinfectante el
dióxido de cloro [8], que prácticamente elimina la presencia de los temidos
trihalometanos.
16
2.1.2 Sensores y sistemas de control del agua.
17
También, se encuentran en el mercado sensores y sondas que deben conectarse a
otros equipos electrónicos para poder mostrar los datos o procesarlos. Estos son los
que se emplean cuando se realizan diseños de
sistemas más complejos, donde se persigue
monitorizar mayor cantidad de parámetros y,
posteriormente, emplear los datos para actuar sobre
los mecanismos de corrección en caso necesario. Así,
en la figura 7 se muestra un ejemplo que corresponde
a un sensor para medir la turbidez del agua.
18
2.2 Trabajos relacionados.
Con todo, una vez comprobado que el sistema funciona parecería lógico recurrir a más
sensores para poder medir otros parámetros del agua y esto es lo que empresas
especializadas suelen realizar. Sin embargo, hay que tener presente que existen
muchos tipos de sensores siendo necesario validar su fiabilidad y es aquí donde se
puede ver como entran en juego iniciativas como el diseño de plataformas de
validación de este tipo de sensores [13]. Aparte, conocer los parámetros de calidad del
agua solo es útil para técnicos cualificados que sepan interpretar y tomar decisiones
en base a estos datos. Por ello, para automatizar procesos de tratamiento de aguas se
requiere que estos técnicos determinen los límites de dichos parámetros, de forma que
19
los automatismos entren en acción cuando la programación del sistema así lo
requiera.
20
destacan RIFFLE y Water Quality Sensor [17]. Es importante destacar que
RIFFLE no se centra en el diseño de los distintos sensores, sino en que su
dispositivo sea compatible con una gran variedad de estos. Entre las ventajas
de RIFFLE frente a otros proyectos destacan el precio, su fácil uso y la idea de
hágalo usted mismo, que permite a los usuarios replicar y adaptar el sistema a
sus necesidades. Almacena las distintas medidas en un archivo de texto de una
tarjeta SD, que el usuario a posteriori debe inspeccionar. Esto impide que la
monitorización se realice en tiempo real e involucra demasiado al usuario en
las tareas de monitoreo, aunque es viable la implementación de
comunicaciones. El precio del RIFFLE es de aproximadamente 60€ sin
contar el precio de los sensores o distintos módulos que se le quieran
añadir.
D. Mãe d’água -Water’s mother, un proyecto de Rede InfoAmazoniay de la
iniciativa Open Water [18]. El dispositivo desarrollado está formado por un
Arduino y sensores de pH, conductividad, potencial de oxidación/reducción y
temperatura. Los datos recogidos por estos sensores se almacenan en una
tarjeta SD. Además, el dispositivo está conectado a un módulo de
comunicación 2G GSM que permite el envío de datos y alarmas por
SMS y la transmisión de datos por GPRS a una página web para su
visualización. Su precio, dependiendo del modelo, varía desde los 40$ a los
80$. A este precio, además de los gastos de envío, hay que sumarle el precio
de una batería de litio y una antena, imprescindibles para su funcionamiento.
21
pasarelas, subir estos datos a servidores en Internet. También, en [20] se propone el
diseño de un sistema de monitorización ciudadana empleando LoRa junto con wifi.
Además, en [28] se presenta un diseño de la arquitectura para la monitorización
remota de sensores (ambiental, posicionamiento GPS y contadores eléctricos) basado
en LoRa y su volcado a servidores para el análisis de los datos. En [29] se propone
evaluar y documentar las características de los módulos LoRa como dispositivo
de comunicación de largo alcance y bajo consumo energético para aplicaciones
del ámbito del desarrollo, proponiéndose además posibles aplicaciones.
Finalmente, se propone en la tabla 5 una visión comparativa donde se pueden ver los
distintos atributos presentes en algunos de los ejemplos dentro el ámbito del control de
calidad de agua que se han propuesto. Esto debe permitir tener una visión global de lo
que existe y de lo que se pretende conseguir en el presente proyecto. Por otro lado,
mientras que en [10] y [11] solo se mide el nivel de los depósitos y se transmite la
información al centro de control, en [12] se miden una cantidad considerable de
parámetros y se actúa sobre los mismos mediante las técnicas necesarias. En cambio,
en [14] se miden algunos parámetros y se transmite la información sin automatizar
ningún proceso. Como puede verse, se trata de sistemas que tienen diferentes
objetivos, por lo que emplean diferentes tecnologías y aunque pueden parecer
similares, son diferentes y distintos de lo que se persigue en el sistema que se plantea
en este proyecto.
22
Sistema Monitorización Automatización Comunicaciones Coste
1Los títulos de los trabajos son demasiado largos para incluirlos en la tabla, por lo que se referencian con su orden de
aparición en la bibliografía.
2
El precio puede parecer desconcertante, dado que se trata de un proyecto completo para la modernización de una
planta potabilizadora de agua, por lo que incluye bombas, tuberías y todo tipo de mecanismos eléctricos y electrónicos
para su control, incluso diseño e instalación.
23
2.3 Resumen del capitulo
Hasta aquí han quedado expuestos los aspectos necesarios para entender el contexto
del proyecto. Por un lado, se han presentado conceptos relacionados con los
estándares de calidad del agua potable y la existencia de un amplio abanico de
sensores y sistemas diseñados para su medición. Por otro lado, se han expuesto
trabajos con un contexto similar al que se propone en este proyecto, de forma que
pueda comprobarse la posibilidad de implementar mejoras que ayuden a optimizar
procesos de esos sistemas. Aun así, se ha podido comprobar que en muchos casos
los sistemas solo monitorizan y transmiten datos a un sistema de control ubicado en
otro lugar, por ser proyectos mucho más complejos los que incluyen la automatización
del tratamiento del agua. Además, en la tabla 5 se han resumido las características
más interesantes de los trabajos similares que se han tomado como ejemplos de
proyectos ya existentes, con la finalidad de comparar proyectos existentes con el que
se plantea en este trabajo. Entonces, el presente trabajo persigue obtener un sistema
totalmente escalable que permita la monitorización y transmisión de datos
empleando LoRa, todo ello a un coste lo más bajo posible. Sin duda, existen
soluciones muy complejas que ya se comercializan, al igual que existen proyectos o
soluciones más sencillas y es a este último tipo a lo que se pretende llegar a la
finalización del diseño del sistema. La parte de automatización, si bien es
perfectamente realizable, puede que no se implemente en este trabajo por ser
necesario el asesoramiento de técnicos en materia de calidad del agua, además de
necesitar los permisos pertinentes.
24
3. Diseño del sistema
25
FIGURA 9. ENTORNO ARDUINO [39]
Hardware Arduino.
26
IDE Arduino.
Por otro lado, en [24] se puede ver que existen otras interfaces de programación que
pueden ser empleadas, ya que el único requisito es que permitan la transmisión por
puerto serie. De este modo, se pueden emplear otros lenguajes de programación para
programar una placa Arduino. Una alternativa muy interesante es emplear Sublime
Text que, con las adaptaciones necesarias, permite trabajar con Arduino al igual que el
27
IDE propio de Arduino, pero con ciertas ventajas que facilitan todo el proceso de
codificación.
Aparte, es importante destacar que existen gran cantidad de librerías creadas por
usuarios y que son de código abierto. Así, se pueden emplear en cualquier proyecto
con la finalidad de reutilizar código y poder simplificar el trabajo de programación. De
esta forma, se consigue reducir el número de líneas de código, ya que simplemente se
requiere importar una librería y definir variables de este tipo (similar a la programación
orientada a objetos), facilitando en gran medida las tareas de programación [22].
Comunidad Arduino.
Un factor del éxito de Arduino ha sido la comunidad que está apoyando este proyecto
y que día a día publica nuevo contenido, divulga y responde a las dudas. En Internet
hay disponible todo tipo de cursos, tutoriales, herramientas de consulta y proyectos
que ayudan a que se pueda usar Arduino con facilidad. Además, en [25] se ve que
Arduino playground es un wiki donde todos los usuarios de Arduino pueden contribuir,
siendo el lugar donde publicar y compartir código, diagramas de circuitos, tutoriales,
trucos, cursos y, sobre todo, el lugar donde buscar cuando existen dudas sobre un
problema, una librería adecuada para un proyecto, siendo la base de datos de
conocimiento por excelencia de Arduino.
3.1.2 LoRa
LoRa y LoRaWAN
28
capa física porque es una modulación muy eficiente para reducir la potencia de
transmisión. LoRa se basa en la modulación CSS (modulación de espectro de
chirrido), que mantiene las mismas características de baja potencia que la modulación
FSK pero aumenta significativamente el alcance de comunicación. Es una técnica de
modulación de espectro expandido derivada de la tecnología de espectro expandido
de chirp (CSS). Los dispositivos LoRa de Semtech y la tecnología de radiofrecuencia
inalámbrica (LoRa Technology) permiten crear una plataforma inalámbrica de largo
alcance y bajo consumo que se ha convertido en la tecnología de facto para las redes
de Internet de las cosas (IoT) en todo el mundo [26].
Por otro lado, también en [26], se puede ver que LoRaWAN es un protocolo de red de
área amplia y de baja potencia (LPWAN), basado en la tecnología LoRa, que está
diseñado para conectar a Internet de manera inalámbrica dispositivos con baterías en
redes regionales, nacionales o globales. Por ello, el protocolo LoRaWAN aprovecha el
espectro de radio sin licencia en la banda Industrial, Científica y Médica (ISM). La
especificación define los parámetros de la capa física LoRa y el protocolo LoRaWAN y
proporciona una interoperabilidad perfecta entre los dispositivos. Por tanto, se
entiende que LoRa es la tecnología radio que opera en la capa física de la pila de
protocolos, mientras que LoRaWAN se corresponde con los protocolos y la
especificación del sistema de comunicaciones, como se muestra en la figura 12.
Además, también se puede ver que existen cuatro frecuencias de transmisión
(dependiendo de la zona geográfica) y tres clases de dispositivos con distintas
características, que se comentarán posteriormente.
29
En resumen, para entender la arquitectura LoRaWAN y su relación con LoRa, basta
con ver la figura 13, donde se presenta el esquema general de despliegue de una red
de sensores que empleen esta tecnología y protocolos para su conexión a Internet.
Finalmente, hay que comentar que además de LoRa existen otras tecnologías LPWAN
como son Sigfox e Ingenu, que presentan como mayor diferencia que son modelos
de negocio propietarios, es decir estas empresas ofrecen todo lo necesario: venta de
dispositivos, red de conexión y servicios [27]. En cambio, en LoRA es de Semtech, la
empresa propietaria de la capa física (patente sobre los módulos de radio), mientras
que la capa de acceso al medio está abierta y es desarrollada por LoRa Alliance, que
es una agrupación de entidades que colaboran en el desarrollo de esta tecnología.
Así, cualquier empresa interesada puede desarrollar soluciones LPWAN para que sus
clientes tengan una infraestructura de red y servicios, por lo que es mucho más
atractivo que Sigfox o Ingenu, donde todo está más encapsulado.
Especificaciones LoRa.
30
TABLA 6. PARÁMETROS LORA EUROPA Y USA [27]
Clase A: este tipo de clase ofrece el mayor ahorro de energía debido a que
solo entra en modo escucha después de enviar datos hacia el Gateway,
siendo la más eficiente cuando solo se quieren enviar datos.
Clase B: permite la creación de ventanas de recepción sin transmisión previa,
por ello consume más energía que la anterior, pero permite mejorar el envío de
datos.
Clase C: es la menos eficiente desde el punto de vista energético, debido a
que está permanentemente en modo escucha y solo cambia a modo
transmisión cuando tiene que transmitir. Es ideal para dispositivos que
31
necesitan recibir datos con mucha frecuencia (actuadores) presentando muy
baja latencia.
Las tres clases pueden coexistir en la misma red y, además, todos los dispositivos
deben cumplir con las funcionalidades de Clase A y opcionalmente cumplir las de
Clase B y/o Clase C.
Para concluir, aunque la conexión punto a punto entre dos dispositivos LoRa es
totalmente posible, dado el interés de esta tecnología en el ámbito IoT, en [26] se
puede ver que una red LoRa está formada por tres tipos de dispositivos:
Dispositivos finales: son los que se conectan los objetos (sensores) a la red
LoRa, transmitiendo la información a las pasarelas.
Pasarelas (Gateway): son las estaciones base LoRa que permiten pasar la
información a la red de Internet, recibiendo los datos de múltiples dispositivos
finales.
Servidores: reciben la información de las pasarelas y gestionan y procesan esta
información así como la red.
La red LoRa presenta una configuración en estrella, donde cada pasarela recibe de
datos de múltiples dispositivos finales en un solo salto y estos datos son enviados a
los servidores mediante Ethernet, telefonía móvil, fibra óptica o cualquier otro medio
que soporte la pasarela. También, hay que hay que destacar una gran ventaja que
consiste en que varias pasarelas pueden recibir datos del mismo dispositivo final, de
forma que se puede proporcionar un servicio de posicionamiento basado en LoRa.
En este apartado se detallarán todas las fases del diseño del sistema de
monitorización y automatización tanto a nivel hardware como software. Así, se parte
de la selección de los sensores adecuados y del módulo Arduino necesario,
continuando con la descripción de la conexión de entradas y salidas en la placa
Arduino (módulo de automatización) y la codificación necesaria del software, de modo
que el sistema realice los procesos para los que está diseñado.
32
3.2.1 Sensores.
En este punto se describen los sensores que requiere el sistema para captar los
datos que el proyecto necesita. Así, se proponen los sensores nivel y pH a emplear
y que son compatibles con Arduino, de forma que las adaptaciones a realizar son
inexistentes o mínimas.
33
Por tanto, se puede conocer la distancia a un objeto simplemente teniendo en cuenta
el valor anterior, de forma que la distancia viene dada por la mitad del tiempo que ha
tardado la señal en regresar al sensor. Es decir, si se ha medido 292 microsegundos,
entonces la distancia es 5 cm. Para mejor comprensión se muestra esquema en la
figura 15. Si las condiciones de presion temperatura y humedad ambiental son
diferentes las medidas no son tan exactas, aunque el error puede despreciarse.
Con todo, hay que aclarar que la precisión del sensor no es del todo óptima (0.3cm),
pero dada la aplicación donde se va a emplear es una precisión más que suficiente.
Se puede considerar que un margen de error de 3 mm en este contexto no supone
ningún inconveniente, pero quede claro que hay sensores más precisos a costa de
presentar un precio más elevado.
34
En los anexos se incluye el código Arduino empleado para comprobar el correcto
funcionamiento del sensor. Una vez montado el circuito y cargado el código en el
microcontrolador, las mediciones se pueden ver en el monitor serie del IDE de
Arduino, mostrándose las distancias en cms y sin decimales. Aun así, este código no
es el adecuado para poder conseguir conocer el nivel de agua en el depósito, por lo
que en la parte de diseño del prototipo se realizarán las modificaciones oportunas.
Sensor de pH.
En este caso, el sensor elegido es el que se puede ver en la figura 17. Se trata de un
conjunto formado por una sonda y un circuito de adaptación, perfectamente diseñado
para poder emplearse en el entorno Arduino. Además, su precio es muy bajo, por lo
que para un proyecto académico como el actual es más que suficiente. Es obvio que
existen sensores de mayor calidad (profesionales), pero no se considera oportuno
adquirir alguno de ellos dados los precios excesivos. El precio de este conjunto de
elementos es inferior a 25 euros, dependiendo del vendedor.
35
Tensión de operación 5 ± 0,2 V
Corriente de operación 5-10 mA
Rango de medición 0 - 14
Temperatura de operación -10 a 50 ºC
Tiempo de respuesta <= 5 s
Potencia <= 0.5 w
En cuanto a su conexión con la placa Arduino, tal y como puede verse en la figura 18,
es muy sencilla, dado que solo se requiere alimentar el sensor con 5 Vcc y GND y
emplear un pin de entrada analógico para que Arduino reciba el valor de tensión que
envía la sonda.
Por otro lado, hay que tener en cuenta que las tensiones a la salida de la sonda, según
lo especificado en el datasheet y que se muestran en la tabla 8, son simétricas. Es
decir, las tensiones en la entrada del módulo Arduino deben ser adaptadas al rango 0-
5V, por ello es necesario emplear el circuito de adaptación, que proporcionará ese
rango de tensiones y no el rango simétrico que se ve en la tabla.
36
TABLA 8. TENSIONES EN LA SALIDA DE LA SONDA DE PH
Como puede verse se pone de manifiesto que el sensor de pH detecta este parámetro
de forma correcta, dependiendo de la disolución en la que se introduzca.
37
FIGURA 19. PUEBAS SENSOR DE PH
La placa escogida para realizar este proyecto es la versión UNO R3, la cual puede
verse en la figura 20 junto con sus principales características. Esto es así,
simplemente, por el hecho de que es la placa que se recomienda para principiantes
38
en el mundo de Arduino, siendo una placa muy versátil y económica (menos de 20
euros).
El cerebro de la placa es el microcontrolador ATmega 328, que es el encargado de
ejecutar las instrucciones del sketch en función de las entradas, activando o
desactivando las salidas de la placa, incluso enviando información a través del
puerto serie.
Microcontrolador ATmega328.
Voltaje de entrada 7-12V.
14 pines digitales de I/O (6 salidas PWM).
6 entradas análogas.
32k de memoria Flash.
Reloj de 16MHz de velocidad.
Además, la placa cuenta con un puerto USB que permite la conexión con un PC, para
realizar la carga del programa y el intercambio de información. De igual modo, se ve
que existen pines que permiten la transmisión serial con cualquier dispositivo que
admita este sistema de comunicación. También, se puede apreciar la existencia de un
conector de alimentación que permite alimentar la placa desde cualquier fuente con
tensión en el rango 7-12 Vcc, ya que la placa contiene un regulador de tensión a 5
Vcc, para su funcionamiento. Esto permite operar con la placa mediante una batería o
fuente de alimentación independiente, posteriormente a la carga del programa y
simulaciones.
39
FIGURA 21. PROTOTIPO CON ATMEGA328 [39]
Por tanto, como puede verse en la figura 23, para la monitorización y automatización
de procesos en el depósito de agua, el circuito es bastante sencillo. Solo es necesario
40
respetar las conexiones indicadas en los datasheets de los distintos periféricos y tener
en cuenta las tensiones de alimentación y las tierras, que deben ser comunes a todos
los elementos. Solo comentar, que dado que no hay un sensor de pH en el software
con que se ha realizado el esquema, éste se ha sustituido por una fuente que
proporciona una tensión variable en el rango previsto y que varía con una frecuencia
determinada de antemano. También, se podría emplear una fuente de tensión fija y
modificarla manualmente en cada simulación, pero sería más entretenido. Aun así, no
se realiza ninguna simulación, porque esto solo pretende dar una idea del diseño
(incluyendo posible actuación sobre bombas u otros mecanismos), el cual, en su
momento, se materializará en un prototipo.
41
3.3.1. Módulos LoRa
A continuación, se enumeran una serie de módulos que incluyen una radio LoRa y
que pueden ser usados como medio de comunicación del sistema. Entre ellos
existen bastantes diferencias, debido a que el grado de complejidad es diferente y
por tanto su funcionalidad así como su precio.
42
Módulo E32-868T20D de EBYTE.
Se trata de un módulo bastante sencillo, pero un poco más completo que el anterior.
Según su datasheet, dentro de la gama E32 de este fabricante, este módulo en
concreto presenta una potencia de transmisión de 20 dBm (100mw) con un alcance
aproximado de 3 Kms, en la banda de 868 MHz. Está un poco limitado comparado con
el E32-868T30D, que presenta una potencia de 30 dBm (1000 mW) con alcance de
hasta 8 Kms. Aun así, su precio es bastante inferior (aproximadamente 10 euros). En
la figura 25 pueden verse vistas superior e inferior donde se aprecia el SoC y los pines
de conexión. Además, en la tabla 10 se presenten sus características más
importantes. Básicamente, está basado en el SX1276 de SEMTECH, al igual que la
mayoría de módulos LoRa, y en este caso posee varios modos de funcionamiento en
función del estado de los pines M0 y M1. Estos modos de operación son: normal,
despertar, dormido, y ahorro energético, y el microcontrolador al que se conecta el
módulo es el que decide en qué modo opera el módulo, mediante los pines de salida
del micro.
43
Módulo Dragino Lora Shield.
Se trata de un escudo para Arduino con un factor de forma que permite encastrar
directamente la tarjeta sobre una placa Arduino compatible, como puede verse en la
figura 5. Es una tarjeta que cuenta con todo lo necesario para que la conexión con la
placa Arduino sea muy simple y eficiente, permitiendo incluso que algunos de sus
pines sean transparentes y permitan acceso al exterior a la tarjeta Arduino. Al igual
que los anteriores, está basado en el chip SX1276 de SEMTECH, que es lo que
proporciona la radio Lora, siendo sus características principales las siguientes:
44
que facilita tener acceso a datos sin necesidad de emplear el monitor serie del IDE de
Arduino. También, cuenta con un zócalo para tarjetas de memoria SD, así se puede
almacenar información en esta o leer desde la misma.
Además, este módulo también presenta conectividad WiFi y Bluetooth, por lo que su
incorporación a otras redes es viable, permitiendo escalar hacia sistemas más
complejos. Sin duda, es un módulo muy adecuado para el ámbito IoT gracias a la radio
LoRa que trabaja en las bandas 433/868/915 MHz, dependiendo de la región. El
alcance viene determinado por el entorno (urbano o rural), de forma que al ajustar el
spreading factor (SF) varía la sensibilidad. Sus características principales se presentan
el al tabla 11 y el pinout en la figura 28.
Tª de trabajo -40 ºC a 85 ºC
45
FIGURA 28. PINOUT DEL MÓDULO TTGO LORA32 V2.1_1.6 [47]
46
3.3.2 Configuración y pruebas de enlace punto a punto.
En primer lugar, para poder realizar una serie de pruebas se recurre a los módulos
TTGO LORA32 V2.1_1.6, ya que presentan la ventaja de la pantalla OLED, que
permite la visualización de la información sin recurrir a elementos externos. Una vez
adquiridas las tarjetas LoRa se requiere comprender su funcionamiento y probar su
operatividad. Para ello, hay que recurrir al pinout de las placas entendiendo que
función tiene cada pin y buscar las librerías necesarias para que el IDE Arduino
pueda trabajar con este tipo de módulo. De este, modo es posible configurar el
código necesario para probar que los módulos establecen un enlace punto a punto.
Así, cargando en el módulo que hace de emisor el código necesario y en el que
actúa como receptor el correspondiente, es posible establecer el enlace y enviar
datos. Esta tarea no está carente de dificultad y tiempo, debido a la variedad de
módulos LoRa existentes (diferencias en el pinout) así como a la diversidad de
librerías. En los anexos se presentan ambos códigos.
Por otro lado, una vez realizados los sketchs de transmisión y recepción y cargados
en los correspondiente módulos, se puede verificar su funcionamiento. Así, en la
figura 29 se muestra que la prueba de enlace punto a punto es correcta. En esta
figura pueden verse ambos módulos LoRa (433 MHz), el que se encuentra a la
derecha actúa como emisor y el de lado izquierdo actúa como receptor. Como
puede verse en las pantallas OLED, el emisor (está identificado como LoRaSender)
envía un mensaje con una periodicidad que este caso ha sido fijada en cinco
segundos y al final se ve el número de mensajes enviados. En cambio, el receptor
(LoRa Receiver) informa sobre el mensaje recibido, el número de mensajes actual y
sobre la potencia de la señal recibida expresada en dBm. También, se aprecia que
ambas tarjetas están alimentadas con sendas baterías, de forma que no interviene
para nada un PC. En esta simulación no se ha recurrido a ningún sensor,
simplemente se trataba de ver si se establecía el enlace de comunicaciones, por
ello solo se ha subido el código a cada tarjeta y se las ha alimentado mediante las
baterías que se ven en la imagen.
47
FIGURA 29. PRUEBAS ENLACE PUNTO A PUNTO
A continuación, una vez claro todo lo anterior se requiere comprobar el alcance del
enlace y si es necesario realizar las modificaciones oportunas para lograr que el
enlace de comunicaciones sea operativo. Así, en la tabla 10 se muestran los valores
48
obtenidos (son aproximados) en una prueba real en un entorno al aire libre y sin
obstáculos.
49
seguridad que impida el acceso a los datos. En todo caso, podría tenerse en cuanta de
cara a mejoras futuras a implementar en el sistema.
50
3.4. LoRaWAN y TTN
En este punto, parece interesante ir un poco más allá y añadir nuevas características
al diseño planteado. Por ello, se propone incluir LoRaWAN en sistema, de forma que
se posible enviar los datos a un servidor en Internet. Para ello, se realiza a
continuación la exposición de todo lo necesario para su consecución, empleando The
Things Network (TTN).
The Things Network (TTN) es una iniciativa basada en la comunidad para establecer
una red global de IoT dentro del contexto LoRaWAN. Actualmente cuenta con 7139
pasarelas LoRaWAN instaladas en más de 137 países con 68132 miembros [37]. Por
tanto, se trata de un entorno muy adecuado para poder monitorizar el estado de
sensores que emplean LoRaWAN desde la red de Internet, incluso proporcionando
múltiples aplicaciones. Así es posible subir los datos de los sensores al servidor TTN y
emplear servidores de aplicaciones para poder tratar estos datos como mejor
convenga. Como puede verse en la figura 31, la cobertura de la red no es óptima, pero
es indudable el continuo crecimiento de la misma, gracias a voluntarios que despliegan
sus propios gateways y dan cobertura LoRaWAN.
51
Arquitectura de red.
Como puede verse en la figura 32, la arquitectura necesaria para poder gestionar la
información de los sensores desde Internet es la correspondiente a LoRaWAN. En
esta arquitectura, las partes esenciales son:
52
3.4.2 TTN en este proyecto.
Por un lado, como ya se ha comentado, se requiere de una pasarela para poder subir
los datos de los sensores a Internet. En el caso del presente proyecto no hay ninguna
disponible dentro del radio de alcance, de modo que es necesario adquirir y configurar
una. Una pasarela es un router que incluye un concentrador LoRa que permite recibir
paquetes LoRa. Estos paquetes serán convertidos a TCP/IP y enviados al servidor de
red mediante una conexión del tipo que sea (Ethernet, WiFi, 3G/4G). Por ello,
pensando en una alternativa sencilla, se puede emplear una gateway como el de la
figura 33, siendo un dispositivo de un solo canal por lo que es bastante asequible
(aproximadamente 60 euros). Existen pasarelas de 8 canales que permiten el acceso
de un número muy superior de nodos finales, pero su precio es bastante elevado.
53
Por otro lado, se requiere registrar la pasarela dentro de TTN para poder emplearla.
Primero es necesario configurar el gateway siguiendo las instrucciones de su
datasheet y, después, siguiendo los pasos que se muestran en los anexos es sencillo
de realizar el registro del dispositivo en TTN. Una vez registrado el dispositivo ya es
posible enviar datos provenientes de cualquier dispositivo LoRa dentro de su radio de
acción, pero es necesario que los nodos finales tengan el software adecuado y se
registren en TTN. En este caso, además, se requiere registrar en TTN el nodo final
que se emplea en este proyecto para que pueda enviar la información a través del
gateway. En los anexos se incluye una pequeña explicación del proceso de registro y
configuración de ambos dispositivos: gateway y nodo final así como la creación de la
aplicación, dentro de la que se registra el nodo.
Finalmente, sería interesante estudiar las aplicaciones que se pueden emplear para
manejar los datos, pero esto queda fuera del alcance del presente proyecto, pudiendo
ser incluido como mejora futura del sistema. Además, la finalidad principal es la
capacidad de trasmisión de la información y su visualización, no la gestión.
1. Una vez se tiene cuenta de usuario en TTN, siguiendo los pasos necesarios
se crea la aplicación en la consola de TTN, que como puede verse en la figura
34, en el caso del presente proyecto se identifica como “depositoaguagdi”.
54
FIGURA 34. APLICACIÓN EN TTN
55
3. Se registra el gateway en TTN tal como se explica en los anexos, que
previamente se ha debido configurar y el resultado puede verse en la figura 36.
En la imagen se ven los aspectos clave del registro del gateway, incluso puede
verse como el nodo final ha estado enviando mensajes y éste los ha
retransmitido a TTN (109 mensajes).
56
FIGURA 37. EJEMPLO DE PAQUETE RECIBIDO
57
configuración de todos los elementos es correcta y las simulaciones realizadas
muestran que es viable implementar esta mejora en el diseño del sistema.
Finalmente, hay que decir que se ha podido comprobar que TTN sólo muestra datos
cuando se abre la web de la aplicación, de forma que los datos que va recibiendo son
los que se pueden visualizar, siendo imposible tener acceso a datos anteriores. Por lo
que se ha podido averiguar, en [38] se expone que se requiere una integración de
almacenaje, de forma que TTN presta un servicio de almacenamiento de datos gratuito
durante 7 días. Así, mediante consultas SQL se puede acceder a los datos
58
almacenados, como puede verse en las figuras 40 y 41, donde se presentan tanto la
integración de almacenaje como una consulta.
59
3.5 Resumen del capítulo
60
4. Prototipo y pruebas
4.1 Ubicación.
61
Por otro lado, la capacidad del depósito es de aproximadamente 62 metros cúbicos,
con una dimensiones de 6x4x3 (largo x ancho x alto). Actualmente, el sistema que
regula la cantidad de agua que hay en el mismo consiste en sendas válvulas que se
abren o cierran el paso de agua al depósito en función de una boya. Es decir, cuando
la boya indica que el nivel ha disminuido aproximadamente un 20% ordena a las
válvulas que deben abrirse y cuando alcanza el nivel de llenado se cierran. Además,
existe un rebosadero para evitar que el depósito se desborde, en caso de
malfuncionamiento del sistema. Todo ello puede verse en la figura 43.
Por un lado, una vez realizado el montaje del prototipo, cada uno de los dispositivos
requiere su propio sketch de funcionamiento, los cuales se incluyen en los anexos, de
forma que sea posible realizar las funciones correspondientes a cada subsistema. En
62
estas condiciones, el montaje queda como se muestra en la figura 44, donde se
muestran todos los elementos del prototipo diseñado. Para mejor comprensión se
enumeran los componentes:
63
Por otro lado, para verificar el funcionamiento del prototipo y poder validar que los
sketchs programados funcionan bien, se han realizado algunas pruebas simulando
variaciones del nivel del depósito y del pH del agua. Para ello, simplemente se recurre
a modificar la distancia que mide el sensor correspondiente y modificar el contenido de
un recipiente (en este caso un vaso). Pese a que ya se demostró en el capítulo
anterior que el sistema de monitorización funcionaba, ahora lo interesante es
comprobar que la información se trasmite por LoRa entre los nodos que forman el
enlace. De este modo en las figuras 45, 46 y 47 pueden verse estas simulaciones.
Entonces, en la figura 45 se muestra la información que el TTGO ha recibido del
sistema de monitorización y que es enviada al TTGO Receptor. En este caso, se ve
que el nivel medido del depósito es del 59% y que el pH tiene un valor de tres (el
sensor estaba en un vaso de agua con una gotas de vinagre). En la figura 46 se
presenta un ejemplo de información recibida por el TTGO Receptor, al igual que en la
figura 47. La diferencia es que en las simulaciones se han empleado distintos niveles y
soluciones con distinto pH, donde lo importante era demostrar que los parámetros
medidos eran transmitidos desde el subsistema de monitorización al receptor.
64
FIGURA 46. PRUEBA_UNO TTGO RECEPTOR
Por tanto, mediante las pruebas realizadas se ha podido comprobar que el prototipo
inicial que se ha construido cumple con sus objetivos: medir los parámetros que se
plantearon inicialmente y transmitir esta información a distancia empleando
radio LoRa. Aunque no se han incluido aquí mas imágenes por no extender este
apartado, se puede decir es es bastante obvio que las pruebas han sido satisfactorias,
a falta de realizar pruebas de largo alcance (centenas de metros a kilómetros).
Finalmente, hay que aclarar que en este diseño las comunicaciones LoRa se
establecen en la frecuencia central de 433 MHz, que no es lo ideal siendo más
interesante emplear 868 MHz, porque las pasarelas en Europa suelen emplear esta
frecuencia. Es decir, si se pretende enviar información a Internet a través de una
pasarela, en este diseño se debería construir o adquirir una que opere a 433 MHz.
65
4.3 Prototipo definitivo
66
Por otra parte, se incluye un receptor TTGO 433 MHz para recibir los datos del enlace
punto a punto, que se ubica en dependencias municipales, al alcance del responsable
de gestión de aguas del municipio. De este modo es inmediato conocer la última
lectura de niveles que se ha realizado.
Finalmente, para subir los datos a TTN, se emplea el gateway que se ha adquirido
para este proyecto y que está configurado a la frecuencia de 868,1 MHz, al igual que
el TTGO emisor que hay en el depósito. En ambos casos se han cargado los sketchs
oportunos para permitir la transmisión de información del TTGO emisor al gateway y
desde este al servidor TTN. Todo esto se incluye en los anexos, siendo los más
importantes la correcta configuración del gateway así como las claves necesarias en el
sketch del TTGO emisor. Es imprescindible que TTN sea capaz de identificar la
aplicación y el nodo final que está enviando datos y, para ello, al tratarse de una
conexión ABP se requieren estos tres parámetros:
Device Address
Para mayor claridad, en la figura 49 se presenta la arquitectura que permite ver todos
los componentes que forman parte del diseño y del prototipo construido.
67
4.4 Pruebas.
Por otro lado, para verificar que TTN recibe los datos, se inicia sesión en el servidor y
en la aplicación que se ha creado y se puede comprobar si se reciben los datos. Así,
en las figuras 50 y 51 se muestran los datos que recibe el gateway y los datos que
recibe la aplicación que se ha creado, provenientes del emisor TTGO a 868.1 MHz.
68
FIGURA 51. TTN - DATOS RECIBIDOS POR LA APLICACIÓN
69
4.5 Comentarios sobre los resultados de las pruebas
A continuación, pese a que las pruebas realizadas con el prototipo muestran que se
han logrado los objetivos que se plantearon, se exponen algunos resultados y
conclusiones que se han observado:
2. Se ha podido comprobar que TTN no recibe todos los paquetes que envía el
emisor. Esto parece deberse a que el emisor en la configuración de las librerías
que se incluyen tiene configurado que se transmite en tres frecuencias: 868.1,
868.3 y 868.5 MHz, iterativamente, mientras que el gateway al ser de un canal
y estar configurado a 868.1 MHz, solo recibe la trasmisión a esta frecuencia,
por ello, solo es visible un paquete de cada tres en TTN. Esto se ha podido
comprobar empleando el monitor serie del IDE de Arduino, donde observando
todo el proceso del sketch y mediante la instrucción ”Serial.println(LMIC.freq);”
es posible conocer la frecuencia de transmisión de cada paquete en LoRa.
70
al refrescar la página se pierden los datos que hasta ese momento se habían
recibido.
4.6 Presupuesto.
Arduino UNO 8 1 8
Sensor nivel 7 1 7
Sensor pH 15 1 15
Dragino LG01 65 1 65
71
4.7 Resumen del capítulo.
72
5. Mejora del sistema: alarmas SMS
Para empezar, el hecho de poder conocer de forma instantánea que se producido una
situación anormal es muy interesante de cara a poder realizar las medidas correctoras
con la mayor prontitud. En este caso, independientemente de la causa, si se detecta
un descenso del nivel del agua por debajo de un límite prefijado o una desviación del
pH fuera de los límites establecidos, es muy importante conocerlo con la mayor
prontitud. Por tanto, dotar al sistema de la posibilidad de enviar una alarma en una
situación de este tipo parece ser algo muy necesario. Para ello, partiendo de lo
realizado en el TFG [39] y adaptándolo al caso actual, es factible implementar esta
mejora, permitiendo al responsable del agua municipal estar informado
inmediatamente de que algo no marcha bien, reduciendo los tiempos de intervención
enormemente.
Por un lado, para implementar esta idea en el sistema se requiere la Tarjeta SIM900
GSM/GPRS compatible con Arduino, que puede verse en la figura 53 y que será la
encargada de permitir al sistema enviar un SMS de alarma. Se trata de una tarjeta o
módulo de expansión perfectamente compatible con cualquier tarjeta del universo
Arduino, que emplea la red de telefonía móvil GSM/GPRS, por lo que requiere una
tarjeta SIM de cualquiera de las operadoras con cobertura en la zona de aplicación del
sistema.
73
FIGURA 53. TARJETA SIM900 GSM/GPRS [39]
Finalmente, hay que decir que las pruebas realizadas para comprobar su
funcionamiento también se incluyen en el anexo correspondiente, donde se realiza una
explicación detallada de todo el proceso.
En primer lugar, una vez que se ha comprobado que la tarjeta funciona y es capaz de
enviar y recibir mensajes SMS, el siguiente paso es implementar esta mejora en el
sistema. En la figura 54 se presenta el esquema hardware actualizado del prototipo.
Entonces, en la figura 55 se puede ver que se ha conectado Arduino al módulo GSM
empleando un puerto serie definido por software utilizando los pines dos y tres de
Arduino. Así, es posible mantener los pines siete y ocho como puerto serie definido por
software para comunicar Arduino con los dos transmisores LoRa que se ven en la
74
imagen. Tanto Arduino como la tarjeta GSM se alimentan a través de la fuente de
tensión regulable que se aprecia en la imagen, siendo un sistema totalmente operativo
sin necesidad de conectarlo a un ordenador. Solo se conecta para cargar el software
o para monitorizar que ocurre mediante un emulador de puerto serie.
75
Después, tras definir todos los parámetros necesarios en el
sketch, como por ejemplo el número de móvil que recibirá los
mensajes de alarma, si se realizan algunas simulaciones
básicas forzando la trasmisión, se obtiene lo que se muestra
en la figura 54. De este modo, puede verse que el teléfono
móvil destinatario de los mensajes de alarma recibe este tipo
de mensajes cuando se da la situación que dispara la alarma.
En este caso, se ha condicionado el envío del mensaje a que
el sensor de nivel presentara una lectura inferior al 80%. Con
todo, los parámetros límite que disparan las alarmas deben
configurarse en el sketch de acuerdo a lo sugerido por los
técnicos de aguas.
Para terminar, hay que decir que no se han incluido los sensores en la figura 55, para
mayor claridad; pero partiendo de lo que se presenta en la figura 44 solo se requiere
conectar la tarjeta GSM como se ha comentado y cargar el nuevo sketch, que es una
actualización del que se propuso en el capítulo de prototipo y pruebas. Además, es de
destacar que esta mejora no supone un sobrecoste elevado, dado que el precio actual
de este tipo de tarjetas es inferior a 20 euros, como puede verse en [40], por lo que
presenta un balance coste/solución muy bueno.
76
FIGURA 56. TTN - VACIADO DEL DEPÓSITO
77
FIGURA 58. TTN - LLENADO DEL DEPÓSITO
En este capítulo se ha propuesto y desarrollado una mejora del sistema que puede
aportar una solución ante situaciones inesperadas que alteren los parámetros que este
sistema monitoriza. Así, empleando la red GSM, se ha diseñado y probado que sea
posible enviar un mensaje SMS de alarma para estar informado a la mayor brevedad,
permitiendo una rápida intervención. Para ello, se ha presentado el módulo de
comunicaciones y se ha explicado su integración el prototipo del capítulo cuatro,
realizando las pruebas oportunas para verificar que realmente se envían y reciben los
SMS de alarma, junto con las demostraciones de que TTN muestra los datos del
proceso de vaciado y llenado (medidas del nivel de agua) Con todo, la mayor parte de
los detalles no se han incluido en el capítulo, sino en los anexos, para evitar alargar la
extensión de este documento. Por ello, para mayor información acerca de la tarjeta y
diversas pruebas, es preferible recurrir al documento de anexos.
78
6. Conclusiones y líneas futuras
Una vez finalizado el presente trabajo, es momento de realizar una reflexión y poder
obtener una serie de conclusiones que permitan asentar conocimientos y
procedimientos. De este modo, se puede exponer lo siguiente:
79
5. Se ha conseguido poner en práctica competencias comunicativas y la
redacción de textos técnicos, sin duda componentes muy importantes en el ámbito
de la Ingeniería. Además, se ha experimentado con la elaboración de presentaciones y
la edición de video.
80
realizar las simulaciones es lo que hace que todo este proceso haya sido ameno; pero
también hay que decir que la búsqueda de información y aprendizaje es muy exigente.
Con todo, considero que realizar este proyecto ha sido una experiencia muy
gratificante.
3. Mejorar todo el contexto LoRaWAN, de forma que sea posible tener un servidor
que presente más funcionalidades que las que se han conseguido, como por ejemplo
elaborar estadísticas, gráficas, informes, etc.
81
82
Glosario
pH Potencial de Hidrógeno.
83
Bibliografía
[1]. Real Decreto 140/2003, de 7 de febrero, por el que se establecen los criterios
sanitarios de la calidad del agua de consumo humano. [Sede web]. [Acceso:
25/02/2019]. Disponible en: https://www.boe.es/eli/es/rd/2003/02/07/140/con
[3]. Web del ayuntamiento de Gumiel de Izan. [Acceso: 01/03/2019]. Disponible en:
http://www.gumieldeizan.es/
[4]. Parámetros de control del agua potable. [Sede web]. [Acceso: 05/03/19].
Disponible en: https://www.iagua.es/blogs/beatriz-pradillo/parametros-control-agua-
potable
[7]. Los trihalometanos y la cloración del agua. [Sede web]. [Acceso: 05/03/19].
Disponible en: http://hispagua.cedex.es/node/61343
[9]. Monitorización del Agua Potable. [Sede web]. [Acceso: 07/03/19]. Disponible
en: https://www.s-can.at/es/aplicaciones/agua-potable
84
[10]. Salazar Vilañez M.D. (2018). Unidad de adquisición y transferencia de
variables remotas para el monitoreo en tanques de agua potable. (Grado).
Disponible en:
http://repositorio.utn.edu.ec/bitstream/123456789/8044/1/04%20MEC%20221%20TRABAJ
O%20DE%20GRADO.pdf
[15]. HYDROPORT Acceso al Internet del agua. [Sede web]. [Acceso: 08/03/19].
Disponible en: https://www.vonroll-hydro.ch/es/hydroport.html
[16]. Design of low-cost autonomous water quality monitoring system. [Sede web].
[Acceso: 08/03/19]. Disponible en:
https://ieeexplore.ieee.org/abstract/document/6637139/authors#authors
[17]. The Open Water Project. [Sede web]. [Acceso: 08/03/2019]. Disponible en:
https://publiclab.org/wiki/open-water#The+Open+Water+Project
85
[19]. Córdoba Peñalver, E.J. (2017). Análisis y diseño de una red de sensores en
un parque natural (Grado). Disponible en: http://hdl.handle.net/10609/59925
86
[31]. APLICACIONES SENSORES LORAWAN. [Sede web]. [Acceso: 12/03/19].
Disponible en: https://www.catsensors.com/es/lorawan/aplicaciones-sensores-lorawan
[32]. IOT STARTER KIT CON TECNOLOGÍA LORA. [Sede web]. [Acceso:
12/03/19]. Disponible en: https://www.matrix.es/product/wireless-iot/multiconnect-conduit-
iot-starter-kit
[36]. ESP32 LoRa: You Can Reach Up to 6.5 Km! [Sede web]. [Acceso: 25/03/19].
Disponible en: https://www.instructables.com/id/ESP32-LoRa-You-Can-Reach-Up-
to-65-Km/
87
[42]. SENSOR PARA MEDIR LA TURBIDEZ DEL AGUA. [Acceso: 28/05/2019].
Disponible en: https://lualtec.es/sensor-para-medir-la-turbidez-del-
agua.html?gclid=EAIaIQobChMIh8etldXI4gIVggvTCh3Zcw8pEAQYAiABEgKsPPD
_BwE
[44]. REYAX RYLR896 Lora module SX1276 UART 868MHz 915MHz Antenna AT
command FCC NCC. [Acceso: 28/05/2019]. Disponible en:
https://www.ebay.com/itm/REYAX-RYLR896-Lora-module-SX1276-UART-868MHz-
915MHz-Antenna-AT-command-FCC-NCC-/181562403752
[47]. TTGO LoRa32 V2.1_1.6 Version 433/868/915Mhz ESP32 LoRa OLED 0.96 Inch
SD Card Bluetooth WIFI Wireless Module ESP-32 SMA. [Acceso: 28/05/2019].
Disponible en:
https://es.aliexpress.com/item/32872078587.html?spm=a2g0o.detail.1000016.1.6e
406ee1zwaQwP&isOrigTitle=true
[48]. Módulo de sensor de detección del valor del pH en líquidos y sonda del
electrodo del PH para Arduino. [Acceso: 28/05/2019]. Disponible en:
https://es.aliexpress.com/item/32803578131.html?src=google&albslr=227527957&
albch=shopping&acnt=494-037-
6276&isdl=y&slnk=&plac=&mtctp=&albbt=Google_7_shopping&aff_platform=googl
e&aff_short_key=UneMJZVf&albagn=888888&albcp=1633820309&albag=6389029
4393&trgt=743612850714&crea=es32803578131&netw=u&device=c&gclid=EAIaI
QobChMIkZy4iO_I4gIViTLTCh0h8AHzEAYYAiABEgLnU_D_BwE&gclsrc=aw.ds
88
[50]. Network Architecture. [Acceso: 28/05/2019]. Disponible en:
https://www.thethingsnetwork.org/docs/network/architecture.html
89
Anexos
void setup() {
Serial.begin(9600);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
}
void loop() {
digitalWrite(TriggerPin, LOW);
delayMicroseconds(4);
digitalWrite(TriggerPin, HIGH);
delayMicroseconds(10);
digitalWrite(TriggerPin, LOW);
duration = pulseIn(EchoPin, HIGH); //tiempo entre pulsos, en
microsegundos
distanceCm = duration * 10 / 292/ 2; // obtener distancia en cm
return distanceCm;
}
90
2. Código Arduino para comprobar el funcionamiento del
sensor de pH.
void setup()
{
pinMode(13,OUTPUT);
Serial.begin(9600);
Serial.println(“Ready”); //Test the serial monitor
}
void loop()
{
for(int i=0;i<10;i++) //Get 10 sample value from the sensor for
smooth the value
{
buf[i]=analogRead(SensorPin);
delay(10);
}
for(int i=0;i<9;i++) //sort the analog from small to large
{
for(int j=i+1;j<10;j++)
{
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
91
}
avgValue=0;
avgValue+=buf[i];
Como se puede observar, en el circuito hay dos potenciómetros: el que está más
cerca al conector BNC de la sonda es el que regula el offset y el otro es el del límite
de pH.
Offset: el rango de media de la sonda oscila entre valores negativos y
positivos. El 0 representa un pH de 7.0. Para poder utilizarlo con Arduino este
circuito añade un valor de offset al valor medido por la sonda, de esta forma el
ADC solo tendrá que tomar muestras de valores positivos de tensión. Por lo
tanto forzaremos un pH de 7.0 desconectando la sonda del circuito y
cortocircuitando la parte interna del conector BNC con la exterior. Con un
multímetro medimos el valor del pin Po y ajustamos el potenciómetro para que
sea 2.5V.
Límite de pH: Este potenciómetro es para establecer una valor del límite del
circuito sensor de pH que hace que el LED rojo se encienda y la señal de pin
Do se ponga en ON.
92
Además hay que calcular la conversión del voltaje que dará el sensor de pH, para lo
que se necesitan dos valores de referencia de pH y medir el voltaje que devuelve el
sensor en el pin Po. Lo más recomendable es utilizar una solución de calibración en
sobre, también las hay en líquido pero es más fácil conservar las de sobre. Estas
soluciones se venden en diferentes valores aunque los más comunes son pH 4.01, pH
6.86 y pH 9.18.
Utilizando los sobres con pH 4.01 y pH 6.86 obtenemos los voltajes en el pin Po 3.04V
y 2.54V respectivamente. El sensor es lineal por lo que tomando dos puntos podemos
deducir la ecuación para convertir el voltaje medido a pH. La fórmula general sería
y=mx+b, por lo que se tiene que calcular m y b, ya que x sería el voltaje e y el pH. El
resultado es y=-5.70x+21.34.
93
4. Código para comprobar el enlace LoRa punto a punto
(emisor).
#include <SPI.h>
#include <LoRa.h>
#include <U8g2lib.h>
#include <U8x8lib.h>
#define OFF 0
#define ON 1
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST 16
#include <SPI.h>
#include <LoRa.h>
#include <U8g2lib.h>
#define OFF 0
#define ON 1
94
// I2C OLED Display works with SSD1306 driver
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST 16
/* Pick One. Hardware I2C does NOT work! This article helped:
https://robotzero.one/heltec-wifi-kit-32/
void setup() {
Serial.begin(115200);
while (!Serial);
Serial.println(“LoRa Sender”);
Display.begin();
95
Display.setFont(u8g2_font_ncenB10_tr);
if (!LoRa.begin(433E6)) {
void loop() {
digitalWrite(25, ON);
// send packet
LoRa.beginPacket();
LoRa.print(“HeLoRa! “);
LoRa.print(counter);
LoRa.endPacket();
digitalWrite(25, OFF);
// Display Info
Display.clearBuffer();
Display.setCursor(0,12); Display.print(“LoRa Sender”);
Display.setCursor(0,30); Display.print(“Sent Packet:”);
Display.setCursor(0,48); Display.print(“ # “ + (String)counter);
Display.sendBuffer();
counter++;
delay(5000);
96
5. Código para comprobar el enlace LoRa punto a punto
(receptor).
#include <SPI.h>
#include <LoRa.h>
#include <U8g2lib.h>
#define OFF 0
#define ON 1
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST 16
void setup() {
Serial.begin(115200);
while (!Serial);
Serial.println(“LoRa Receiver”);
Display.begin();
Display.enableUTF8Print();
Display.setFont(u8g2_font_ncenB10_tr);
97
SPI.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
void loop() {
digitalWrite(25, ON);
packet = “”;
while (LoRa.available()) {
packet += (char)LoRa.read(); }
rssi = LoRa.packetRssi();
// Display Info
Display.clearBuffer();
Display.setCursor(0,12); Display.print(“LoRa Receiver”);
Display.setCursor(0,26); Display.print(“Received packet:”);
Display.setCursor(0,42); Display.print(“ ‘” + packet + “’”);
Display.setCursor(0,58); Display.print(“RSSI “ + rssi);
Display.sendBuffer();
digitalWrite(25, OFF); // Turn blue LED off
}
}
98
6. Sketch monitorización y automatización (tarjeta arduino).
Este sketch se emplea para comprobar que los sensores funcionan y se pueden tomar
mediadas de nivel y pH, asi como pasar la información a un emisor LoRa (TTGO) por
un puerto serie definido por software.
#include <SoftwareSerial.h>
SoftwareSerial TTGO(7, 8); // Comunicacion serie con el TTGO emisor
String mensaje=""; // para pasar parámetros al TTGO por puerto serie
// para el sensor de pH
const int analogInPin = A0; // pin A0
int sensorValue = 0;
unsigned long int avgValue;
float b;
int buf[10],temp;
void setup() {
TTGO.begin(19200);
delay(100);
Serial.begin(19200);
Serial.println(F("Configurando el sistema (setup)........"));
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
pinMode(pulso, OUTPUT); // pin 4, acitvacion modulo GSM
Serial.println("Iniciando...");
SIM900.begin(19200); //
Serial.println(F("Configuracion completada......"));
delay(1000);
}
99
// Función que calcula el nivel del depósito
int nivel(){
int distAgua = ping(TriggerPin, EchoPin);
long cotaCero = 400 + separacion; // deposito lleno + separacion al
sensor
int nivel = (cotaCero - distAgua)*100/cotaCero;
return nivel;
100
}
for(int i=0;i<9;i++)
{
for(int j=i+1;j<10;j++)
{
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}
avgValue=0;
for(int i=2;i<8;i++)
avgValue+=buf[i];
float pHVol=(float)avgValue*5.0/1024/6;
float phValue = -5.70 * pHVol + 21.76;
return phValue;
}
void loop() {
Serial.println("Sensores midiendo...");
int niv = nivel();
float pH = medirPH();
101
Serial.println(" %");
Serial.print("ph del agua: ");
Serial.println(pH);
#include <SPI.h>
#include <LoRa.h> // https://github.com/sandeepmistry/arduino-
LoRa
#include <U8g2lib.h> // https://github.com/olikraus/U8g2_Arduino
102
#define OLED_RST 16
void setup() {
pinMode(25, OUTPUT); // pin 25, datos seri recibidos
Serial.begin(19200);
Serial.println("Iniciando...");
delay(1000);
Display.begin();
Display.enableUTF8Print(); // enable UTF8 support for the Arduino
print() function
Display.setFont(u8g2_font_ncenB10_tr);
if (!LoRa.begin(433E6)) {
Serial.println("Starting LoRa failed!");
while (1);
}
LoRa.setSpreadingFactor(12);
LoRa.setTxPower(17,PA_OUTPUT_PA_BOOST_PIN );
}
void loop() {
103
digitalWrite(25, LOW);
delay(500);
texto= mensaje;
if (Serial.available() >0){
mensaje="";
digitalWrite(25, HIGH);
}
}
if(mensaje != " "){
texto= mensaje;
}
// para enviar el mensaje al receptor
LoRa.beginPacket();
LoRa.print(mensaje);
LoRa.endPacket();
Display.clearBuffer();
Display.setCursor(10,12); Display.print("Emisor LoRa ");
Display.setCursor(0,42); Display.print(texto);
Display.sendBuffer();
104
8. Sketch del TTGO receptor en enlace punto a punto.
#include <SPI.h>
#include <LoRa.h> // https://github.com/sandeepmistry/arduino-
LoRa
#include <U8g2lib.h> // https://github.com/olikraus/U8g2_Arduino
// #include <U8x8lib.h>
void setup() {
Serial.begin(115200);
while (!Serial);
Serial.println("LoRa Receiver");
105
Display.begin();
Display.enableUTF8Print(); // enable UTF8 support for the Arduino
print() function
Display.setFont(u8g2_font_ncenB10_tr);
void loop() {
// try to parse packet
int packetSize = LoRa.parsePacket();
if (packetSize) {
// received a packet
Serial.print("Received packet ");
digitalWrite(25, ON); // Turn blue LED on
// read packet
packet = ""; // Clear packet
while (LoRa.available()) {
packet += (char)LoRa.read(); // Assemble new packet
}
rssi = LoRa.packetRssi();
106
// Display Info
Display.clearBuffer();
Display.setCursor(0,12); Display.print("LoRa Receiver");
107
FIGURA 60. CONSOLA EN TTN
108
4. Una vez añadida la aplicación hay que registrar el dispositivo que se va a
emplear, de modo que se hace click sobre register device y se accede la
configuración del registro del nodo final.
109
FIGURA 63. REGISTRO DE UN DISPOSITIVO
6. En este punto ya está el proceso finalizado y es posible enviar datos a TTN que
serán visualizados mediante la aplicación. Ahora bien, para que el dispositivo
puede conectarse con la aplicación y enviar datos se requiere que en su
configuración incluya las claves de acceso: AppKey y AppEUI, para una
conexión OTAA o Device Address, Network Session Key y App Session Key
para una conexión ABP, que se deben incluir en el sketch de forma que el
dispositivo se identifique ante la red.
110
9.2 Registro de una pasarela.
1. Desde Gateways, se clica en register gateway.
2. Se rellenan los campos correspondientes, donde básicamente hay que indicar el
identificador del gatewa, una pequeña descripción, la frecuencia de trabajo (868
MHz), la localización aproximada, el router TTN correspondiente a la zona y si la
antena es de interior o exterior. Se hace click en Register gateway y ya está
finalizado el proceso.
3. Una vez finalizado el proceso se pueden ver las características del registro y
empezar a emplearlo como pasarela. Además, es posible editar ciertos
parámetros del dispositivo y que sean visibles o no.
111
FIGURA 66. VISTA PREVIA DEL GATEW AY
El gateway viene configurado de fábrica como WiFi AP, por lo que se puede acceder a
el mediante un pc, abriendo un navegador web a través de la dirección IP 10.130.1.1.
Una vez se ha accedido pide la contraseña que viene de fábrica por defecto: “dragino”.
A partir de esto ya se tiene acceso a todos los parámetros configurables del gateway.
Primero, se configura el método de conexión a Internet que empleará el gateway,
mediante el menú Network -> Internet Access.
112
Se rellenan los campos siguientes con la información que se empleó en el registro en
TTN, mediante el menú Sensor -> LoRa/LoraWAN.
También, hay que configurar los parámetros de radio del gateway, dentro del mismo
menú anterior.
113
Se selecciona el tipo de servidor IoT.
Existen varias versiones de sketchs que permiten el reenvío de los paquetes LoRa al
servidor, así que una vez que se ha escogido uno de ellos se puede cargar en el
gateway empleando el IDE de Arduino. Es decir, se abre el sketch en Arduino, se
selecciona la tarjeta (Dragino Yun + UNO or LG01) y el puerto correspondiente al
gateway y se sube el sketch. Así el gateway queda listo para reenviar los paquetes al
servidor.
Este es el sketch que se emplea en el prototipo del capítulo cuatro para realizar las
pruebas correspondientes en el depósito.
#include <SoftwareSerial.h>
SoftwareSerial TTGO(7, 8); // Comunicacion serie con el TTGO emisor
114
char inchar=0; // lee los caracteres que envia el modulo de
comunicaciones
String mensaje=""; // Para recibir datos del puerto serie
// para el sensor de pH
const int analogInPin = A0; // pin A0
int sensorValue = 0;
unsigned long int avgValue;
float b;
int buf[10],temp;
void setup() {
TTGO.begin(115200);
delay(100);
Serial.begin(115200);
Serial.println(F("Configurando el sistema (setup)........"));
pinMode(bombas, OUTPUT);
pinMode(sensores, OUTPUT);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
Serial.println("Iniciando...");
delay(1000);
}
115
return nivel;
Serial.print("Distancia: ");
Serial.println(distanceCm);
return distanceCm;
}
116
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}
avgValue=0;
for(int i=2;i<8;i++)
avgValue+=buf[i];
float pHVol=(float)avgValue*5.0/1024/6;
float phValue = -5.70 * pHVol + 21.76;
return phValue;
}
void loop() {
digitalWrite(sensores, HIGH); // tyestigo de sensores leyendo
Serial.println("Sensores midiendo...");
int niv = nivel();
float pH = medirPH();
117
Serial.println(pH);
Serial.println("Mensaje enviado........");
delay(300000); //5 minutos entre mediciones
13. Sketch en el TTGO emisor 868 MHz del prototipo (para TTN).
Este sketch corresponde al programa que se carga en el TTGO emisor del prototipo
que debe subir a TTN los datos de nivel y pH que recibe del módulo Arduino.
#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>
#include <U8x8lib.h>
#include <U8g2lib.h>
#define BUILTIN_LED 25
118
// LoRaWAN NwkSKey, network session key
// This is the default Semtech key, which is used by the early
prototype TTN
// network.
119
int cont=0;
// Pin mapping
const lmic_pinmap lmic_pins = {
.nss = 18,
.rxtx = LMIC_UNUSED_PIN,
.rst = 14,
.dio = {26, 33, 32},
};
120
mensaje= "EV_BEACON_TRACKED";
delay(1000);
break;
case EV_JOINING:
Serial.println(F("EV_JOINING"));
mensaje= "EV_JOINING";
delay(1000);
break;
case EV_JOINED:
Serial.println(F("EV_JOINED"));
mensaje= "EV_JOINED";
// Disable link check validation (automatically enabled
// during join, but not supported by TTN at this time).
LMIC_setLinkCheckMode(0);
delay(1000);
break;
case EV_RFU1:
Serial.println(F("EV_RFU1"));
mensaje= "EV_RFUI";
delay(1000);
break;
case EV_JOIN_FAILED:
Serial.println(F("EV_JOIN_FAILED"));
mensaje= "EV_JOIN_FAILED";
delay(1000);
break;
case EV_REJOIN_FAILED:
Serial.println(F("EV_REJOIN_FAILED"));
mensaje= "EV_REJOIN_FAILED";
delay(1000);
break;
case EV_TXCOMPLETE:
Serial.println(F("EV_TXCOMPLETE (includes waiting for RX
windows)"));
mensaje= "EV_TXCOMPLETE";
delay(1000);;
digitalWrite(BUILTIN_LED, LOW);
121
if (LMIC.txrxFlags & TXRX_ACK)
Serial.println(F("Received ack"));
mensaje= "Received ACK";
delay(1000);
if (LMIC.dataLen) {
Serial.println(F("Received "));
u8x8.drawString(0, 6, "RX ");
Serial.println(LMIC.dataLen);
}
// Schedule next transmission
os_setTimedCallback(&sendjob,
os_getTime()+sec2osticks(TX_INTERVAL), do_send);
break;
case EV_LOST_TSYNC:
Serial.println(F("EV_LOST_TSYNC"));
mensaje="EV_LOST_TSYNC";
delay(1000);
break;
case EV_RESET:
Serial.println(F("EV_RESET"));
mensaje= "EV_RESET";
delay(1000);
break;
case EV_RXCOMPLETE:
// data received in ping slot
Serial.println(F("EV_RXCOMPLETE"));
mensaje= "EV_RXCOMPLETE";
delay(1000);
break;
case EV_LINK_DEAD:
Serial.println(F("EV_LINK_DEAD"));
mensaje= "EV_LINK_DEAD";
delay(1000);
break;
122
case EV_LINK_ALIVE:
Serial.println(F("EV_LINK_ALIVE"));
mensaje= "EV_LINK_ALIVE";
delay(1000);
break;
default:
Serial.println(F("Unknown event"));
u8x8.setCursor(0, 7);
mensaje="UNKNOWN EVENT %d", ev;
delay(1000);
break;
}
}
void setup() {
Serial.begin(115200);
Serial.println(F("Starting"));
123
u8x8.begin();
u8x8.setFont(u8x8_font_chroma48medium8_r);
mensaje= "LoRaWAN LMiC TTN Node...";
//esto siguiente lo copio del sketch receptor para inicializar el
display OLED
Display.begin();
Display.enableUTF8Print(); // enable UTF8 support for the Arduino
print() function
Display.setFont(u8g2_font_ncenB10_tr);
// LMIC init
os_init();
// Reset the MAC state. Session and pending data transfers will be
discarded.
LMIC_reset();
124
#if defined(CFG_eu868)
// Set up the channels used by the Things Network, which
corresponds
// to the defaults of most gateways. Without this, only three base
// channels from the LoRaWAN specification are used, which
certainly
// works, so it is good for debugging, but can overload those
// frequencies, so be sure to configure the full frequency range
of
// your network here (unless your network autoconfigures them).
// Setting up channels should happen after LMIC_setSession, as
that
// configures the minimal channel set.
// NA-US channels 0-71 are configured automatically
125
// frequency and support for class B is spotty and untested, so
this
// frequency is not configured here.
#elif defined(CFG_us915)
// NA-US channels 0-71 are configured automatically
// but only one group of 8 should (a subband) should be active
// TTN recommends the second sub band, 1 in a zero based count.
// https://github.com/TheThingsNetwork/gateway-
conf/blob/master/US-global_conf.json
LMIC_selectSubBand(0);
#endif
// Set data rate and transmit power for uplink (note: txpow seems
to be ignored by the library)
LMIC_setDrTxpow(DR_SF7,14);
// Start job
do_send(&sendjob);
}
// funcion para leer los datos del puerto serie y menetrlos en mydata
void processIncomingByte (const byte inByte)
126
{
static unsigned int input_pos = 0;
switch (inByte)
{
case '\n': // end of text
input_line [input_pos] = 0; // terminating null byte
void loop() {
if (Serial.available() >0){
mensaje="";
digitalWrite(25, HIGH);
127
}
// Fin del sketch ************************************
14.1 Hardware
Los elementos principales que conforman esta tarjeta son:
a) Chip SIM900: en su datasheet se pueden encontrar todas las características y
funcionalidades. En la figura 29 se muestra el pin out del chip.
b) Antena: tiene un zócalo para conectar una antena mediante un terminal para cable
coaxial, directamente al chip.
c) Zócalo tarjeta SIM: en la parte inferior de la tarjeta se encuentra el zócalo donde se
debe insertar la tarjeta SIM desbloqueada. También en ese mismo lado se encuentra
el alojamiento para una pila de botón de 3 V, que permite mantener la información
cuando la tarjeta no tiene alimentación.
128
d) Conector de alimentación tipo Jack: para alimentar la tarjeta con 5 VDC.
Normalmente, la intensidad operativa es de 450 mA, pero pueden haber ráfagas en las
que se requiera hasta 2 A, por lo que la fuente de alimentación debe ser consecuente
con este hecho.
e) UART: comunicaciones serie asíncronas por hardware mediante los pines D0 y D8
o mediante software por los pines D7 y D8. Esta característica se configura mediante
unos jumpers a tal efecto.
f) Pines de entrada y salida: permiten la conexión con Arduino y presentan
características similares aunque no coinciden todos. Hay pines analógicos, digitales y
PWM.
g) Conectores para micrófono y auricular: conectores de tipo minijack para emplearlos
en llamadas telefónicas.
h) Leds indicadores: indican el estado de los elementos de la tarjeta. En la tabla 5 se
muestra la información que ofrecen.
Obviamente la tarjeta consta de toda una serie de componentes electrónicos
(condensadores, resistencias, reguladores...) para permitir la correcta interacción entre
los distintos elementos, pero no se entrará más en detalle en este aspecto.
14.2 Software.
Para programar las funcionalidades de la tarjeta se requiere emplear comandos AT y
pese a que la lista de estos comandos es bastante extensa, en este caso se emplean
solo unos pocos. Hay que aclarar que son los comandos AT y para ello, se puede
decir que son lo que se conoce como el conjunto de comandos Hayes: un lenguaje
desarrollado por la compañía Hayes Communications que prácticamente se convirtió
en estándar abierto de comandos para configurar y parametrizar módems. Los
caracteres «AT», que preceden a todos los comandos, significan «Atención», e
hicieron que se conociera también a este conjunto de comandos como comandos AT.
129
ATI: Ver la información del producto.
AT+IPR=?: el Baud Rate en el que puede operar el SIM.
AT+IPR?: para preguntar el Baud Rate actual.
AT+IPR=XXXX: configura la frecuencia deseada.
AT+COPS?: nombre de la compañía telefónica.
AT+CGSN: visualizar el IMEI del chip utilizado.
AT+CSCS?: tipo de texto.
AT+CSCS=”XXX”: Configurar a tipo de texto.
AT+CMGF?: Ver el formato de un mensaje, ya sea PDU(0) o SMS(1) .
AT+CMGF=1; // modo texto para SMS
AT+CMGS=04455XXXXXXXX: Enviar un SMS Se despliega el símbolo mayor que ‘>’
Escribir mensaje y al finalizar presiona Ctrl+Z retornará OK si el SMS se envió
correctamente.
AT+CMGL=ALL: Sirve para ver todos los mensajes que nos han llegado al SIM.
ATD04455XXXXXXXX: Sirve para hacer una llamada a cualquier teléfono móvil.
ATA: Sirve para contestar una llamada.
ATH: Sirve para colgar una llamada
Por otra parte, se pueden diferenciar dos operaciones software sobre la tarjeta:
a) Programación y verificación de la tarjeta, donde conectando la tarjeta SIM900
GSM/GPRS a un PC, ya sea mediante un conversor FTDI que convierta la señal del
puerto USB o bien empleando el conversor de la tarjeta Arduino, es posible verificar el
funcionamiento y características de la tarjeta. Para ello, se recurre a un emulador de
puerto serie como puede ser Hyperterminal o Teraterm o cualquier otro similar.
b) Programación del sketch en Arduino, donde los comandos AT son interpretados por
al ATMega 328 de la tarjeta Arduino y, mediante la comunicación serie, se transmiten
a la tarjeta de comunicaciones para que realice las operaciones correspondientes.
Esto es, el propio sketch cargado en el microcontrolador incluye los comandos AT, de
forma que dependiendo de qué programa este ejecutando, puede ordenar a la tarjeta
de comunicaciones enviar o recibir datos. Por el contrario, también puede ser que sea
la tarjeta de comunicaciones la que contenga alguna instrucción o datos que necesite
transmitir al microcontrolador, por lo que esto debe estar incluido en el sketch.
130
En primer lugar, se procede comprobando la operatividad de la tarjeta de
comunicaciones. Para ello, se realizan los siguientes pasos:
1. Se alimenta la tarjeta con 5 VDC por el conector jack y se coloca el selector de
alimentación en la posición de alimentación externa. La alimentación proviene de un
regulador conectado a una fuente de 12 VDC.
2. Se acopla la antena.
3. Se inserta la tarjeta SIM desbloqueada en su ranura.
4. Se seleccionan los pines D0 y D1 como puerto de comunicaciones serie, mediante
el jumper a tal efecto.
5. Se ejecuta Hyperterminal, introduciendo los parámetros necesarios y se verifica la
operatividad del módulo mediante los parámetros AT. Ver figuras 32 y 33.
La tarjeta SIM900se alimenta mediante un regulador que está conectado a una fuente
de alimentación de 10 VDC. Además, se ha empleado el conversor FTDI de modo
que se comunica directamente la tarjeta de comunicaciones con el PC, conectando en
los pines Rx y Tx de ambas tarjetas.
131
igual modo, informa del fabricante (AT+CGMI) y del IMEI del chip de comunicaciones
(AT+CGSN). Con todo, hay que mencionar que este proceso se puede realizar con
cualquier otro emulador de puerto serie, incluso con el monitor serie del IDE de
Arduino, sin necesidad de cargar ningún sketch, previamente.
En segundo lugar, el siguiente paso es introducir una tarjeta SIM, para verificar que
hay conectividad GSM, figura 33. Esto es necesario, debido a que puede ser que
puede haber algún problema como: IMEI de la tarjeta bloqueado, no exista cobertura
de servicio, fuente de alimentación sin la energía suficiente, etc. Así, pueden verse los
comandos empleados para verificar que hay comunicación mediante la red GSM: el
comando AT+COPS? permite conocer a que operadora está conectada la tarjeta, con
AT+CMGF? se informa del tipo de mensajes (PDU(0) o SMS(1)), con
AT+CMGS=”NUMERO DE TELÉFONO” se envía un SMS, para ello una vez
introducido el comando aparece el signo ’>’ donde se escribe el mensaje y se pulsa
CTRL+Z para enviarlo. Una enviado se informa sobre este hecho si no hay errores.
Finalmente, se pueden realizar llamadas telefónicas empleando el comando
132
ATDXXXXXXXXX(Nº de teléfono); y se puede aceptar una llamada entrante o
finalizarla mediante ATA y ATH, respectivamente.
Existen muchos más comandos AT, pero con verificar algunos que se han probado es
suficiente para tener la certeza de que el prototipo está preparado para comunicarse
de forma remota.
void sendSMS() {
SIM900.print("AT+CMGF=1\r"); // modo texto para SMS
delay(200);
SIM900.println("AT+CMGR=?");// se activa el código para recpción de
mensajes
133
delay(200);
SIM900.print("AT+CNMI=2,2,0,0\r");// comando para poder visualizar los
mensajes
delay(200);
SIM900.print("AT+CMGS="); // móvil del destinatario en formato
internacional
delay(100);
SIM900.print((char)34);//ponemos las comillas ("), para que lo tome
debe ser char de lo contrario el serial envia caracter por caracter
SIM900.print(numMovil);//colocamos número de teléfono preestablecido
SIM900.println((char)34);//volvemos a poner el caracter (")
delay(200);
SIM900.print(smstext); // mensaje a enviar
delay(100);
SIM900.print((char)26); // Codigo ASCI para CTRL+Z, codigo 26, se
envia el mensaje
delay(500);
Serial.println(F("!!!!!!!!!!!!!!!!!!!!!!!!!: "));
Serial.print(F("SMS enviado al numero: "));
Serial.println(numMovil);
escribirLCD("SMS enviado");
delay(4000); // margen de tiempo para el envío del mensaje
Serial.println(F("SMS procesado!!!"));
delay(1000);
}
#include <dht.h>
134
#include <SoftwareSerial.h>
dht DHT;
SoftwareSerial SIM900(7, 8); //pines para comunicacion serie con la
SIM900
#define DHT11_PIN 13// para arduino uno entrada de señal de DHT
int pulso=9; //activar el modulo GSM por sw, conectar al pin 9 del
modulo
int testigo=12;
////////variables para las comunicaciones////////////////
const char numMovil[]= "676978681" ; // El número de teléfono movil
char inchar=0; // lee los caracteres que envia el modulo de
comunicaciones
String mensaje=""; // Para recibir datos del puerto serie de la SIM900
String smstext; // Texto del mensaje que recibirá el destinatario de
la solicitud de Info.
void setup(){
pinMode(testigo,OUTPUT);// pin 12 para ver si se envia SMS
Serial.begin(19200);
SIM900.begin(19200);
SIM900power();
delay(10000); // tiempo para acceder a la red GSM
Serial.println("Sensor DHT11 midiendo...");
}
//Función de encendido por software de la tarjeta de
comunicaciones/////////////////////
void SIM900power() {
Serial.println(F("Activando módulo de comunicaciones.............."));
digitalWrite(pulso, HIGH);
delay(1500);
digitalWrite(pulso, LOW);
//digitalWrite(testigo, LOW);
delay(1000);
Serial.println(SIM900.print("AT+CPIN=2940\r"));// introducir PIN de la
SIM
delay(10000);
Serial.println(("Modulo de comunicaciones activado................"));
}
//Función para el envío de SMS////////////////////
135
void sendSMS() {
digitalWrite(testigo, HIGH);
SIM900.print("AT+CMGF=1\r"); // modo texto para SMS
delay(200);
SIM900.println("AT+CMGR=?");//ACTIVAMOS CODIGO PARA RECIBIR MENSAJES
delay(200);
SIM900.print("AT+CNMI=2,2,0,0\r");// comando para poder visualizar los
mensajes
delay(200);
SIM900.print("AT+CMGS="); // movil del destinatario en formato
internacional
delay(100);
SIM900.print((char)34);//ponemos las comillas ", para que lo tome debe
ser char de lo contrario el serial envia caracter por caracter
SIM900.print(numMovil);//colocamos numero de telefono
SIM900.println((char)34);//volvemos a poner el caracter "
delay(200);
SIM900.print(smstext); // mensaje a enviar
delay(100);
SIM900.print((char)26);// Codigo ASCI para CTRL+Z, se envia el mensaje
delay(500);
Serial.println(F("!!!!!!!!!!!!!!!!!!!!!!!!!: "));
Serial.print(F("SMS enviado al numero: "));
Serial.println(numMovil);
delay(4000); // margen de tiempo para el envío del mensaje
Serial.println(F("SMS procesado!!!"));
delay(1000);
digitalWrite(testigo, LOW);
}
void loop() {
int chk = DHT.read11(DHT11_PIN);
Serial.print("Temperature = ");
Serial.println(DHT.temperature);
Serial.print("Humidity = ");
Serial.println(DHT.humidity);
Serial.println("========= ");
if (DHT.temperature > 28){
136
smstext= "Alarma: temperatura superior a 28ºC"; // mensaje de
alrma que recibe el destinatario
sendSMS();
}
delay(10000); // tiempo de espera entre lecturas de temperatura
}
En las siguientes imágenes se pueden ver tanto el pequeño prototipo para probar el
sketch, como una serie de mensajes que el móvil destinatario recibe cuando se supera
la temperatura indicada.
137
dispositivos de corrección del pH. Se envia un SMS de alarma***
****por nivel bajo o ph peligroso. Se pasa información por puerto
serie al TTGO emisor para el*** ***enlace LoRa entre lo 2 TTGO y al
modulo GMS900 para enviar SMS de alarma.
*******************Rubén Adrián de la Cámara*************************
********************************29/05/2019************************ */
#include <SoftwareSerial.h>
SoftwareSerial TTGO(7, 8); // Comunicacion serie con el TTGO emisor
// para el sensor de pH
const int analogInPin = A0; // pin A0
int sensorValue = 0;
unsigned long int avgValue;
float b;
int buf[10];
138
void setup() {
SIM900.begin(19200);
Serial.begin(19200);
Serial.println(F("Configurando el sistema (setup)........"));
SIM900power();
TTGO.begin(115200);
delay(100);
pinMode(bombas, OUTPUT);
pinMode(sensores, OUTPUT);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
Serial.println("Iniciando...");
temp = 0;
delay(500);
}
139
delay(1000);
Serial.println(("Modulo de comunicaciones activado................"));
}
140
//Función que realiza el disparo del sensor de distancia
int ping(int TriggerPin, int EchoPin) {
long duration, distanceCm;
digitalWrite(TriggerPin, LOW); //para generar un pulso limpio
ponemos a LOW 4us
delayMicroseconds(4);
digitalWrite(TriggerPin, HIGH); //generamos Trigger de 10us
delayMicroseconds(10);
digitalWrite(TriggerPin, LOW);
duration = pulseIn(EchoPin, HIGH); //medimos el tiempo entre
pulsos, en microsegundos
distanceCm = duration * 10 / 292/ 2; //convertimos a distancia,
en cm
Serial.print("Distancia: ");
Serial.println(distanceCm);
return distanceCm;
}
141
smstext="Alarma: Nivel del deposito inferior al 50%";
sendSMS();
delay(1000);
}
else if (pH < 6 || pH > 8){
Serial.println("Alarma !!! pH fuera de rango aceptable");
smstext="Alarma: pH fuera de rango aceptable";
sendSMS();
delay(1000);
}
}
TTGO.print("Niv ");
TTGO.print(nivel);
TTGO.print("%");
TTGO.print(" pH ");
TTGO.println(ph);
}
void loop() {
digitalWrite(sensores, HIGH); // testigo de sensores leyendo
Serial.println("Sensores midiendo...");
niv = nivel();
pH = medirPH();
mensaje= (char)niv +(char)niv;
delay (5000);
digitalWrite(sensores, LOW);// testigo sensores apagado
Serial.print("Nivel del depósito: ");
Serial.print(niv);
Serial.println(" %");
Serial.print("ph del agua: ");
Serial.println(pH);
142
15. Instrucciones para montaje del prototipo.
143
16. Imágenes del prototipo experimental.
A continuación se muestran algunas imágenes de los elementos que forman parte del
prototipo construido para pruebas en el depósito, incluyendo algunos comentarios.
2. Sensor de pH: se ha colocado sobre una placa de polietileno para que flote
en el agua y pueda realizar las medidas según sube o baja el nivel de agua en
el depósito. Si estuviera fijo sería imposible realizar dichas medidas.
144
3. Monitorización, comunicaciones y alimentación: conjunto de elementos
que forman parte del prototipo y que permiten medir y enviar la información,
junto con la fuente de alimentación. La fuente de alimentación regulable
alimenta el módulo Arduino y el módulo SIM900, mientras que los TTGO se
alimentan a 3.3 Vdc desde una salida a dicho voltaje de la SIM900. De igual
modo los sensores se alimentan a 5 Vdc desde un pin de salida de Arduino con
esta tensión, siendo todas las tierras comunes.
145