Embed Size (px)
Citation preview
DISEÑO E IMPLEMENTACIÓN DE UN SISTEMA EMBEBIDO
BASADO EN IoT PARA LA GESTIÓN DEL TRANSPORTE PÚBLICO.
JENIFER ANDREA TORRES RODRÍGUEZ
LUIS FELIPE PATIÑO LÓPEZ
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD DE INGENIERÍA
INGENIERÍA ELECTRÓNICA
Bogotá
Julio de 2019
2
DISEÑO E IMPLEMENTACIÓN DE UN SISTEMA EMBEBIDO
BASADO EN IoT PARA LA GESTIÓN DEL TRANSPORTE PÚBLICO.
Jenifer Andrea Torres Rodríguez
Luis Felipe Patiño López
Trabajo de grado en modalidad de monografía
para optar al título de Ingeniero Electrónico
Director:
Ing. Julián Rolando Camargo López
UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS
FACULTAD DE INGENIERÍA
INGENIERÍA ELECTRÓNICA
Bogotá
Julio de 2019
3
- Tabla de contenido
1. Planteamiento del problema .......................................................................... ……10
2. Justificación ............................................................................................................. 12
2.1. Justificación técnica ................................................................................................. 12
2.2. Justificación social ................................................................................................... 12
2.3. Justificación económica ........................................................................................... 12
2.4. Justificación ambiental ............................................................................................ 13
2.5. Justificación académica .......................................................................................... 13
2.6. Justificación personal .............................................................................................. 13
3. Objetivos .................................................................................................................. 14
3.1. Objetivo general ...................................................................................................... 14
3.2. Objetivos específicos ............................................................................................... 14
4. Marco teórico .......................................................................................................... 15
4.1. Sistemas de transporte inteligente ........................................................................... 15
4.1.1. Introducción ........................................................................................................ 15
4.1.2. Comunicación de las ITS .................................................................................... 15
4.1.3. Gestión del tráfico .............................................................................................. 16
4.1.3.1. Aplicaciones a la gestión del tráfico ................................................................ 17
4.1.4. Arquitectura ITS ................................................................................................. 18
4.1.5. Nuevas tecnologías ............................................................................................. 19
4.2. Red de sensores inalámbricos ................................................................................. 19
4.2.1. Principales tecnologías de IoT ............................................................................ 20
4.2.2. Tecnología LoRa ................................................................................................ 21
4.2.2.1. Modulación LoRa ............................................................................................. 21
4.2.2.2. Arquitectura LoRa ............................................................................................ 21
4.2.2.3. Protocolo LoRaWAN ....................................................................................... 22
4.2.2.3.1. Canales y velocidades de transmisión .......................................................... 23
4.2.2.3.2. Clases LoRaWAN ........................................................................................ 24
4.2.2.3.3. Seguridad LoRaWAN................................................................................... 24
4.2.2.4.Activación de un nodo ........................................................................................ 25
4.2.3. Sistema embebido ............................................................................................... 25
4.2.3.1.Módulo Transceptor de RF RN2903 .................................................................. 26
4.2.3.2.Gateway LoRaWAN........................................................................................... 27
4.2.3.2.1. Raspberry Pi 3 B+......................................................................................... 28
4.2.3.3.Microcontrolador MC9S08AW60 ...................................................................... 30
4.2.3.4.Módulo GPS NEO 6M ...................................................................................... 31
4.2.4. Aplicación web ................................................................................................... 32
4.2.4.1.Servidor LORIOT ............................................................................................... 32
4.2.4.2.Amazon Web Services........................................................................................ 33
4.2.4.2.1. AWS IoT....................................................................................................... 33
4
4.2.4.2.2. Base de datos no relaciona DynamoDB ....................................................... 34
4.2.4.3.API REST HTTP ................................................................................................ 35
4.2.4.4.Express y Node js ............................................................................................... 36
4.2.4.5.Túneles a localhost ............................................................................................. 37
4.2.4.6.Leaflet ................................................................................................................. 38
5. Estado del arte ....................................................................................................... 40
5.1.Sistema de seguimiento de Bus basado en GPS/GSM ............................................ 40
5.2.Aplicación móvil para sistema de información de bus y seguimiento de ubicación
utilizando tecnología cliente – servidor ................................................................... 41
5.3.Servicio de información de transporte público en tiempo real basado en sensores
participativos ........................................................................................................... 42
5.4.Novedoso esquema de guía de ruta en tiempo real en sistema de transporte
inteligente ................................................................................................................. 43
5.5.¿Dónde está mi bus? ................................................................................................ 43
5.6.Sistema de seguimiento de vehículo en tiempo real utilizando GPS ...................... 44
5.7.Desarrollo y pruebas de campo de un sistema interactivo de información de estaciones
de tránsito (ITSIS) utilizando tecnologías de vehículos conectados ....................... 45
6. Metodología ............................................................................................................. 46
6.1.Investigación sobre las tecnologías existentes en gestión del transporte público ... 46
6.2.Analizar y estudiar la tecnología LoRa ................................................................... 46
6.3.Desarrollar una red LoRa ........................................................................................ 46
6.3.1. Configuración del Gateway ................................................................................ 46
6.3.1.1.Funcionamiento .................................................................................................. 47
6.3.1.2.Conexión al servidor ........................................................................................... 51
6.3.1.2.1. Configuración de la Raspberry ..................................................................... 51
6.3.1.2.2. Registro usuario en LORIOT ....................................................................... 52
6.3.1.2.3. Registro del Gateway en LORIOT ............................................................... 53
6.3.2. Desarrollo del nodo ............................................................................................ 55
6.3.2.1.Comandos utilizados para módulos LoRa .......................................................... 55
6.3.2.2.Conexión módulo RN2903 con el Gateway ....................................................... 57
6.3.2.3.Configuración de módulo RN2903 con MCU .................................................... 63
6.3.2.4.Conexión módulo LoRa con el microcontrolador y GPS ................................... 63
6.3.2.4.1. Programa desarrollado para microcontrolador NXP MC9S08AW60 con
conexión a GPS y módulo LoRa ................................................................. 65
6.3.2.4.2. Programa desarrollado para PSoC5LP con conexión a GPS y módulo LoRa
...................................................................................................................... 68
6.3.2.4.3. Diseño PCB para los elementos del nodo .................................................... 72
6.4.Aplicación Web ........................................................................................................ 73
6.4.1. Obtención de datos desde Loriot ....................................................................... 73
6.4.1.1.Salida por AWS ................................................................................................. 74
6.4.1.1.1. Registro usuario AWS ................................................................................. 74
6.4.1.1.2. Registro objeto en AWS IoT ........................................................................ 74
5
6.4.1.1.3. Configuración en Loriot para conexión con AWS ....................................... 77
6.4.1.1.4. Verificación de conexión a través de la sombra del objeto .......................... 82
6.4.1.1.5. Creación de regla para almacenar información en la base de datos DynamoDB
...................................................................................................................... 83
6.4.1.1.5.1.Sentencia SQL de AWS IoT. ........................................................................ 83
6.4.1.1.5.2.Definición de la acción a realizar. ................................................................ 85
6.4.1.1.5.3.Creación de base de datos no relacional DynamoDB................................... 86
6.4.1.1.5.4.Verificación almacenamiento de información en la base de datos. .............. 88
6.4.1.2.Salida por HTTP Push. ....................................................................................... 89
6.4.1.2.1. Creación de servidor en express. .................................................................. 90
6.4.1.2.2. Verificación del servidor usando postman. .................................................. 93
6.4.1.2.3. Túneles a localhost para publicar servidor en internet. ................................ 95
6.4.1.2.4. Conexión de Loriot a servidor express mediante url de ngrok. .................... 95
6.4.1.2.5. Implementación de funciones JS en el servidor para procesar datos
escuchados de LORIOT ............................................................................... 97
6.4.1.2.6. Creación de mapa usando Leaflet ................................................................. 99
6.5.Verificación del prototipo ...................................................................................... 100
6.5.1. Verificación de funcionamiento por medio de prototipos de prueba ............... 101
6.5.2. Verificación de funcionamiento utilizando prototipo final. ............................ 103
7. Análisis de resultados ........................................................................................... 107
8. Conclusiones .......................................................................................................... 109
9. Referencias ............................................................................................................ 111
10. Anexos .................................................................................................................... 116
6
Tabla de Figuras
Figura 1 Escenario de comunicación ITS según ETSI. ........................................................ 16
Figura 2 Información al usuario en vías [12]. ...................................................................... 17
Figura 3 Arquitectura ITS [13] ............................................................................................. 18
Figura 4 Componentes de WSN gateway y nodos distribuidos [17] .................................... 20
Figura 5 Arquitectura LoRa [25]. ......................................................................................... 22
Figura 6 Arquitectura LoRaWAN [18]. ............................................................................... 23
Figura 7 Canales de frecuencia [28] ..................................................................................... 23
Figura 8 Clases de LoRaWAN [26] ..................................................................................... 24
Figura 9 Arquitectura Sistema Embebido [31]. .................................................................... 26
Figura 10 Módulo RF RN2903 [32] ..................................................................................... 26
Figura 11 Diagrama de bloques RN2903 [32]...................................................................... 27
Figura 12 Gateway LoRa/LoRaWAN para Raspberry Pi 3 [34]. ......................................... 28
Figura 13 Raspberry Pi 3 Model B + [35]. ........................................................................... 29
Figura 14 Microcontrolador MC9S08AW60 [38]. ............................................................... 30
Figura 15 Módulo GPS NEO 6M [38] ................................................................................. 31
Figura 16 Comandos GPS NMEA para GPS [39] ................................................................ 32
Figura 17 Funcionamiento de AWS IoT [43]. ...................................................................... 34
Figura 18 Funcionamiento de túneles locales [47]. .............................................................. 38
Figura 19 Arquitectura del sistema [49]. .............................................................................. 40
Figura 20 Visualización de la aplicación. Izquierda: Ruta en el mapa. Derecha:
Información de paradas. [50] ................................................................................................ 41
Figura 21 Vista principal TrafficInfo. [51] ........................................................................... 42
Figura 22 Modelo de sistema de transporte
inteligente [52]. 43
Figura 23 Diagrama de bloques para el sistema [54]. .......................................................... 44
Figura 24 Vista de la aplicación ITSIS.[55] ......................................................................... 45
Figura 25 Conexión del Hardware........................................................................................ 47
Figura 26 Inicio de Raspberry Pi 3. ...................................................................................... 47
Figura 27 Configuración SPI en Raspberry Pi 3B+. ............................................................ 48
Figura 28 Descarga de paquete por medio de comandos en terminal. ................................. 48
Figura 29 Configuración de Gateway en la Raspberry......................................................... 49
Figura 30 Documento inicio para el script de arranque. ....................................................... 50
Figura 31 Comandos para que el ejecutable de gateway inicie automáticamente. ............... 51
Figura 32 Información de la Raspberry Pi 3 por medio del comando ifconfig .................... 51
Figura 33 Registro nuevo usuario LORIOT. ........................................................................ 52
Figura 34 Tablero inicial de trabajo. .................................................................................... 52
Figura 35 Selección de plataforma base. .............................................................................. 53
Figura 36 Selección del concentrador a utilizar. .................................................................. 53
Figura 37 Solicitud dirección MAC. .................................................................................... 54
7
Figura 38 Ubicación física del Gateway............................................................................... 54
Figura 39 Registro correcto del Gateway en LORIOT......................................................... 55
Figura 40 Especificación de comandos de sistema [32]. ...................................................... 56
Figura 41 Especificación de comandos de protocolo LoRaWAN [32]. ............................... 56
Figura 42 Controlador PROLIFIC PL2303. ......................................................................... 57
Figura 43 Actualización controlador de dispositivo. ............................................................ 58
Figura 44 EUI del módulo RN2903. .................................................................................... 58
Figura 45 Registro de dispositivo en LORIOT. ................................................................... 59
Figura 46 Generación de claves e identificadores únicos para el módulo RN2903. ............ 59
Figura 47 Configuración correcta de un módulo RN2903 al Gateway. ............................... 62
Figura 48 Conexión módulo LoRa con Hércules protocolo serial. ...................................... 62
Figura 49 Código para enviar información desde el microcontrolador por el módulo LoRa.
.............................................................................................................................................. 63
Figura 50 Descripción main para microcontrolador. ............................................................ 65
Figura 51 Librerías utilizadas. .............................................................................................. 66
Figura 52 Declaración de variables programa microcontrolador. ........................................ 66
Figura 53 Funciones para envío de información por el puerto serial. .................................. 66
Figura 54 Envío comandos de configuración módulo LoRa RN2903. ................................ 67
Figura 55 Interrupción para el módulo LoRa. ...................................................................... 67
Figura 56 Introducción para el módulo GPS. ...................................................................... 68
Figura 57 Diseño esquemático programa para PSoC. .......................................................... 69
Figura 58 Descripción main para PSoC. .............................................................................. 69
Figura 59 Interrupción de Rx proveniente de GPS............................................................... 70
Figura 60 Interrupción para recepción de datos desde GPS. ................................................ 71
Figura 61 Selección de pines para PSoC5LP. ...................................................................... 71
Figura 62 Esquema de conexión de componentes en Eagle. ................................................ 72
Figura 63 PCB de nodo. ....................................................................................................... 72
Figura 64 Aplicaciones de salida de información LORIOT. ................................................ 73
Figura 65 Registro usuario en AWS. .................................................................................... 74
Figura 66 AWS IoT registro de objeto. ................................................................................ 75
Figura 67 Creación de objetos AWS IoT. ............................................................................ 75
Figura 68 Adición del dispositivo al registro de objetos. ..................................................... 76
Figura 69 Certificado para el objeto nuevo. ......................................................................... 77
Figura 70 Objeto creado correctamente................................................................................ 77
Figura 71 Interacción para asociar AWS y LORIOT. .......................................................... 78
Figura 72 Cadena API REST................................................................................................ 78
Figura 73 Crear nuevo usuario AWS. .................................................................................. 79
Figura 74 Registro nuevo usuario IAM. ............................................................................... 79
Figura 75 Permisos para nuevo usuario IAM. ...................................................................... 80
Figura 76 Revisión información de nuevo usuario. .............................................................. 80
Figura 77 Generación de claves para asociación con LORIOT. .......................................... 81
Figura 78 Configuración el LORIOT para comunicación con AWS IoT. ........................... 81
8
Figura 79 Verificación Sombra del dispositivo. ................................................................... 82
Figura 80 Creación de nueva regla. ...................................................................................... 83
Figura 81 Temas MQTT. ...................................................................................................... 84
Figura 82 Sentencia SQL utilizada para creación de regla. .................................................. 84
Figura 83 Definir la acción a realizar. .................................................................................. 85
Figura 84 Servicios disponibles de AWS IoT para la nueva regla. ...................................... 85
Figura 85 Configuración acción. .......................................................................................... 86
Figura 86 Creación de tabla DynamoDB. ............................................................................ 87
Figura 87 Creación de tabla completado. ............................................................................. 87
Figura 88 Configuración de acción de DynamoDB completa. ............................................. 88
Figura 89 Base de datos DynamoDB en funcionamiento..................................................... 88
Figura 90 Información recibida en servidor LORIOT.......................................................... 89
Figura 91 Salida de información HTTP Push. ...................................................................... 89
Figura 92 Creación servidor web [60]. ................................................................................. 90
Figura 93 Datos solicitados por comando npm init [60]. ..................................................... 90
Figura 94 Instalación paquete express.js [60]. ..................................................................... 91
Figura 95 Archivo package.json con actualización de paquete instalado [60]. .................... 91
Figura 96 Creación servidor web con express.js [60]. ......................................................... 91
Figura 97 Archivo index.html [60]. ...................................................................................... 92
Figura 98 Mensaje obtenido por consola [60]. ..................................................................... 92
Figura 99 Vista en el navegador del servidor web local[60]. ............................................... 92
Figura 100 Servidor básico propio de inicio. ....................................................................... 92
Figura 101 Contenido archivo Postman.desktop [61]. ......................................................... 93
Figura 102 Verificación por medio de solicitud GET al servidor local. .............................. 94
Figura 103 Verificación por medio de solicitud POST al servidor local. ............................ 94
Figura 104 Comando para descomprimir archivo desde terminal. ....................................... 95
Figura 105 Token de autenticación. ..................................................................................... 95
Figura 106 Ejecución de ngrok en terminal.......................................................................... 95
Figura 107 Configuración salida de LORIOT por HTTP Push. ........................................... 96
Figura 108 Mensaje json recibido por solicitud POST......................................................... 96
Figura 109 Servidor web implementado parte 1. ................................................................. 97
Figura 110 Servidor web implementado parte 3 (conversión hexadecimal a ASCII). ......... 97
Figura 111 Servidor web implementado parte 3 (POST). .................................................... 98
Figura 112 Verificación funcionamiento del servidor sin mapa. ......................................... 98
Figura 113 Líneas html para funcionamiento de Leaflet [63]. ............................................. 99
Figura 114 Archivo html para visualización de datos en mapa de Leaflet. .......................... 99
Figura 115 Mapa con posición actual de nodo en estado estático. ..................................... 100
Figura 116 Implementación prototipo de pruebas con PSoC5LP. ..................................... 101
Figura 117 Implementación prototipo de pruebas con microcontrolador M9SC08AW60. 102
Figura 118 Gateway ubicado para pruebas......................................................................... 102
Figura 119 Nodo para pruebas en vehículo. ....................................................................... 102
Figura 120 Alcance inicial de comunicación. .................................................................... 103
9
Figura 121 Tarjeta final implementada para el nodo. ......................................................... 103
Figura 122 Configuración salida de LORIOT con url generada en ngrok. ........................ 104
Figura 123 Datos recibidos en el servidor de express. ....................................................... 104
Figura 124 Verificación de trama enviada a LORIOT. ...................................................... 105
Figura 125 Mapa de visualización con datos reales obtenidos desde el nodo. ................... 105
Figura 126 Prueba final de alcance de la red LoRa implementada. ................................... 106
10
1. PLANTEAMIENTO DEL PROBLEMA
La necesidad de movilidad ha obligado al desarrollo de diferentes alternativas de transporte,
haciendo de este un tema de vital importancia dentro de la planificación urbana y territorial
ya que influyen directamente en el funcionamiento general de la ciudad. Es por esto, que en
Bogotá se puso en marcha el Sistema Integrado de Transporte Público (SITP), que se
perfilaba como la solución innovadora a los problemas de transporte público y movilidad en
la ciudad, pero que actualmente presentan rezagos en sus condiciones de operación y niveles
de desbordamiento en la capacidad de atención de la demanda [1].
Este sistema de transporte no ha logrado satisfacer de manera óptima dichos problemas de
movilidad y ha sumado inconformismo dentro de los usuarios. Actualmente, el SITP
moviliza a diario a 1’520.000 pasajeros en las 269 rutas urbanas, complementarias y
especiales que cuentan con 5.970 paraderos distribuidos por toda la ciudad de Bogotá [2].
Uno de los principales problemas que afectan directamente a los usuarios es el tiempo de
espera en paraderos para poder acceder al servicio de transporte público, este oscila entre 10,
20 y 28 minutos, lo que coloca a la ciudad de Bogotá en la cuidad de Latinoamérica donde
las personas dedican más tiempo en su trayecto de viaje, con un promedio de 97 minutos en
el uso de transporte público, de acuerdo con el Informe de Uso Global de Transporte Público
[3].
Por esta razón, se plantea un sistema de recolección de datos en tiempo real, en una ruta
modelo sobre la cual se efectuarán las pruebas pertinentes en donde se buscará saber con
certeza la ubicación del autobús. Este sistema estará basado en la tecnología LoRa, donde el
dispositivo integrado al vehículo envía información a un gateway, encargado de subir la
información a internet y de esta manera los usuarios podrán consultar dicha información a
través de sus Smartphones o computadores.
La tecnología LoRa de comunicación permite el envío y recepción de información punto-a-
punto. Lo que caracteriza a un dispositivo LoRa es su largo alcance con un mínimo
dispositivo. Para ello emplea la técnica de espectro ensanchado, donde la señal a mandar
utiliza más ancho de banda que el necesario teóricamente pero que permite una recepción de
múltiples señales a la vez que tengan distinta velocidad.
Las frecuencias de comunicaciones que LoRa usan son principalmente las de la banda ISM,
aunque la tecnología puede operar en cualquier frecuencia por debajo del 1 GHz. El uso de
estas frecuencias se debe a que mientras se respete los valores de emisión, cualquier persona
o empresa puede hacer uso de ella sin necesidad de licencia. Así pues, LoRa suele operar en
11
las bandas 433 MHz, 868 MHz y 915 MHz. Según el país, estas bandas pueden estar
restringidas. Por ejemplo, en Europa no se puede usar la 915 Mhz [4].
Teniendo en cuenta esto, ¿es posible implementar un sistema de recolección de datos en
tiempo real flexible, económico y confiable?
12
2. JUSTIFICACIÓN
La implementación de un sistema que permita conocer en tiempo real información sobre el
servicio de transporte público en la ciudad de Bogotá, permitirá que los usuarios estén
informados del estado actual de la ruta a tomar evitando esperas largas e innecesarias para el
uso de este servicio. De esta forma, encontramos diferentes consecuencias de alto impacto
en el proyecto a realizar:
2.1. Justificación técnica:
Alrededor del mundo, los sistemas de transporte inteligente usan tecnologías que permiten y
facilitan la gestión de información mediante la recolección y análisis en tiempo real, muchos
de estos sistemas cuentan con un modem en cada nodo que se encarga de subir la información
recolectada a internet, pero este sistema presenta una alta demanda de recursos para su
implementación ya que su costo económico y su consumo energético es bastante alto.
Por esto se implementará una red con módulos LoRa los cuales presentan un bajo consumo
de energía y no requieren conexión a internet entre nodos, con lo que el uso de módems se
reduce solamente a 1 que se encontraría al final de la red, mientras que todos los nodos
estarían comunicados con el gateway a través de radiofrecuencia en banda libre de 433MHz
proporcionada por los módulos LoRa.
2.2. Justificación social:
Con la implementación de este sistema se propone disminuir inconformismos con el servicio
a partir de la reducción considerable del tiempo de espera en paraderos, con esto se busca
mejorar la calidad de vida de los usuarios con respecto a la seguridad [5]. Así mismo, el
aprovechamiento del tiempo destinado a esta espera puede emplearse por el usuario a su
gusto, evitando estrés, riesgos y malestar innecesario que perjudican de manera directa la
salud de cada uno de ellos.
2.3. Justificación económica:
Implementar un sistema de medición de datos en tiempo real utilizando tecnología LoRa
reduce considerablemente los costos de implementación: bajo consumo de potencia, alta
tolerancia a interferencias, de largo alcance y, como los módulos se comunican entre ellos,
solo uno de los módulos estará conectado a la red, reduciendo la cantidad de módems que
deben colocarse.
13
2.4. Justificación ambiental:
Reduciendo la cantidad de módems y otros dispositivos que deben colocarse para lograr la
comunicación necesaria en la red, se disminuye la cantidad de desechos electrónicos
contaminantes para el medio ambiente ya que se espera que la duración promedio de vida de
un módulo con tecnología LoRa es de aproximadamente 10 años [6], lo que da un amplio
rango de tecnología bien empleada, que adicional reduce emisiones de radiación
electromagnética.
2.5. Justificación académica:
En el ámbito académico este proyecto es bastante interesante, ya que a través de este se
pueden poner en práctica los conocimientos adquiridos en diferentes áreas de la ingeniera
electrónica, tales como:
Comunicaciones: En esta área se hace énfasis en el uso de la tecnología LoRa, en sus
propiedades y cualidades que posee como dispositivo de radiofrecuencia de bajo consumo
que opera en banda libre.
Sistemas Embebidos: En esta aérea el proyecto presenta la posibilidad de incorporar
diferentes plataformas de microcontroladores y microprocesadores los cuales se encargarán
de ser el corazón del proyecto y a su vez los gestores de periféricos encargados de hacer de
este un sistema más robusto, los cuales también se comunicarán mediante los módulos LoRa.
2.6. Justificación personal:
Es de gran importancia para nosotros como ingenieros electrónicos poner en práctica los
conocimientos adquiridos durante nuestra etapa educativa en la Universidad Distrital
Francisco José de Caldas para solucionar los problemas que demanda la sociedad en la
actualidad.
14
3. OBJETIVOS
3.1.Objetivo general:
Diseñar e implementar un prototipo de un sistema embebido para crear una red LoRa que
recoja datos en tiempo real de una ruta de transporte público.
3.2.Objetivos específicos:
1. Analizar, estudiar y evaluar las tecnologías relacionadas con la provisión de Sistemas
de Transporte Inteligentes.
2. Analizar, estudiar y evaluar el protocolo de comunicación LoRaWAN empleado
mediante módulos LoRa.
3. Implementar y diseñar el prototipo del sistema embebido de recolección de datos en
tiempo real utilizando tecnología LoRa.
4. Validar el prototipo implementado en una sección de ruta de servicio de transporte
público en la ciudad de Bogotá.
15
4. MARCO TEÓRICO
4.1. Sistemas de transporte inteligentes
4.1.1. Introducción
El crecimiento acelerado de las grandes ciudades alrededor del mundo trae consigo el
aumento de requerimientos en la implementación y adecuación de sistemas de transporte
masivos, reducción del impacto ambiental, mejorar la habitabilidad en centros urbanos
congestionados y aprovechamiento de la malla urbana, lo que ha impulsado a muchos países
alrededor del mundo a avanzar en nuevas tecnologías que permitan resolver este tipo de
problemas viales.
La aplicación de estas tecnologías en el manejo de grandes redes de transporte urbano se
conoce como ITS, sistemas de transporte inteligente, que son esencialmente la fusión del
desarrollo en la informática, información tecnológica y telecomunicaciones unidas al sector
automotriz experto y de transporte. Las tecnologías de comunicaciones son de gran
importancia y potencial en el desarrollo de las ITS: Comunicaciones y multimedias
personalizadas y portátiles, comunicaciones inalámbricas, sistemas detectores y de sensores
y rastreo de vehículos [7].
Países como China, Estados Unidos y Alemania son algunos de los líderes en la
implementación de estas tecnologías en las redes de transporte urbano, dando a otros países
bases suficientes y buenas perspectivas frente al diseño y utilización de estos sistemas
inteligentes con el objeto de mejorar el tráfico urbano [8], dentro de lo que se puede encontrar
redes inteligentes de semáforos, peajes automáticos canalizados, gestión integral de
autopistas y túneles, hasta dispositivos inteligentes incorporados a los vehículos comerciales
tanto de transporte de pasajeros como de carga. Debido a esto, se puede asumir que un gran
factor de competitividad mundial está relacionado con la reducción de costo de transporte y
la aplicación de tecnologías en el mismo.
4.1.2. Comunicación de las ITS.
Desde el surgimiento de los sistemas de transporte inteligentes se han propuesto varias
tecnologías inalámbricas de corto y largo alcance tales como los radio módems en frecuencias
VHF y UHF. Para las comunicaciones de corto alcance, donde se refiere a una distancia de
máximo 500 metros, se pueden lograr utilizando protocolos IEEE 802.11, empleado por
primera vez en 2003 por el tren de cercanías Altamont del área de San Francisco. Para
comunicaciones de largas distancias se han propuesto redes de infraestructuras WiMax IEEE
802.16, GSM o 3G, que han funcionado de manera correcta, pero requieren un despliegue de
una mayor infraestructura y, por lo tanto, un mayor costo [9].
16
Actualmente, los avances en la tecnología inalámbrica de comunicaciones intra-vehiculares,
inter-vehiculares (V2V) y entre vehículos e infraestructuras fijas (V2I) se han convertido en
eje fundamental de los ITS. Por esto, CEN (Comité Europeo de Normalización) y ETSI
(produce estándares aplicables para las TIC a nivel mundial) vieron necesario implementar
un estándar para los Sistemas de Transporte Colaborativo de Inteligencia (C-ITS) que
permitirá que todos los vehículos producidos por diferentes fabricantes se comuniquen entre
sí y con los sistemas de infraestructura vial, ayudando a prevenir accidentes y atascos de
tráfico, obras viales y otros riesgos potenciales a la seguridad vial [10].
Figura 1 Escenario de comunicación ITS según ETSI.
Los actores intervinientes en la comunicación ITS interactúan entre sí dependiendo del tipo
de red y la configuración necesaria, sin embargo, cada uno presta una función específica
dentro del sistema. Las estaciones fijas ofrecen la capacidad de comunicación y la
implementación requerida de infraestructura, compuesta por VMS o luces de tráfico.
Vehículos equipados con el hardware necesario, celulares y equipos de navegación personal
proporcionan y soportan diferentes aplicaciones ITS, poniendo todo el sistema en conexión.
En resumen, la arquitectura de comunicación de las ITS consta de cuatro entidades
principales: Vehículos, equipamiento de carretera, equipamientos centrales y dispositivos
personales; donde cada una de ellas presenta una estación y una puerta de enlace de conexión
ITS [10].
4.1.3. Gestión del tráfico.
Los sistemas de transporte urbano se consideran actualmente como un factor de
competitividad, sin embargo, un exceso de crecimiento puede llevar a congestiones crónicas
que promueven el uso de vehículos particulares y suponen una amenaza mayor para la
eficiencia y productividad del sistema. En el caso de América Latina y el Caribe se presentan
actualmente condiciones tales como crecimiento poblacional, disminución del tamaño
familiar y aumento de la proporción de habitantes en ciudades [11], que combinadas entre sí
17
traen consigo una consecuencia negativa en el excesivo crecimiento del transporte urbano,
creando un sistema de transporte congestionado, poco equilibrado e ineficiente.
Por esta razón, las administraciones públicas han visto necesario implementar un sistema de
gestión del tráfico, en el que no solamente se tenga en cuenta temas de construcción y
mantenimiento de carreteras, sino en lograr que los sistemas trabajen de manera colaborativa,
haciendo de esta una operación más efectiva, maximizando la eficiencia y minimizando las
inversiones adicionales en infraestructuras [12], por lo que se han desarrollado centros
encargados de la gestión de la información relacionada al tráfico TMC, que como su nombre
lo indica tienen la función de la gestión de carreteras, gestión de incidencias y la información
al viajero.
4.1.3.1. Aplicaciones a la gestión del tráfico [12].
Existen en el mercado muchas aplicaciones de la gestión del tráfico tales como información
al usuario tanto de la vía o la ruta de transporte como de las condiciones meteorológicas,
tiempo de llegada, límites de velocidad, tarifas, rutas alternativas, congestión vial, entre otros.
La primera, información al usuario de la vía, pretende proporcionar al viajero sobre posibles
accidentes, deslizamientos, y todo tipo avisos en carretera. Esta información se entrega a
través de dispositivos instalados a lo largo de las vías y utilizan señales dinámicas, fijas y
radio avisos en carretera.
Figura 2 Información al usuario en vías [12].
Actualmente, a este tipo de mensajes dinámicos se les suma la información proporcionada a
todo tipo de teléfonos móviles y tabletas con conexión a internet, que permiten conocer en
tiempo real que sucede en la vía. Sin embargo, no se puede olvidar que las aplicaciones
móviles que permiten al usuario obtener información en tiempo real del sistema de transporte
publico están en auge y son utilizadas por un gran porcentaje de la población que utiliza este
tipo de medio para movilizarse. Dichas aplicaciones permiten conocer el estado de las rutas,
próximas paradas, tiempo aproximado de llegada y afectaciones que puedan generar retrasos
18
en el bus, información que no solo se puede obtener mediante la aplicación, sino que también
en pantallas dinámicas dentro de los buses y estaciones.
El tráfico urbano es el que se encuentra con mayor afectación de las aplicaciones de estos
sistemas de gestión del tráfico por esta razón, el uso de una línea de semaforización
inteligente permite mejorar la movilidad ya que este se encuentra recogiendo información en
tiempo real del estado de la ruta, por lo que puede adaptar los parámetros del semáforo al
tráfico actual de la ciudad.
4.1.4. Arquitectura ITS.
Como los ITS constituyen herramientas para mejorar la movilidad, el medio ambiente, el
costo – beneficio, la seguridad vial, la productividad y la economía, se necesita establecer
una infraestructura regulada para guiar el despliegue [13]: las funciones a realizar en el
despliegue, los componentes físicos para llevar a cabo las funciones ya mencionadas, las
interfaces y comunicaciones necesarias para permitir el intercambio de datos e información
entre los componentes físicos, roles y responsabilidades de las partes involucradas en el
despliegue del ITS.
Figura 3 Arquitectura ITS [13]
Esta arquitectura proporciona los requisitos necesarios para la adquisición, instalación y
desarrollo de todo tipo de procedimientos de despliegue de los sistemas inteligentes de
transporte y permite mejorar la relación existente entre los usuarios y los proveedores del
servicio. Estas se basan en un análisis detallado de como los sistemas van a funcionar en
conjunto e interactuar entre sí, dando lugar a un conjunto de declaraciones de alto nivel sobre
los requisitos del sistema, que son independientes del diseño final y de la tecnología [13]. A
partir de esto, se puede describir los aspectos más necesarios e indispensables en la formación
de una arquitectura ITS [14]: Identificación y actualización de necesidades, visión de su uso,
tecnologías disponibles, trazabilidad de los servicios, desarrollo de programas, marco
19
regulatorio, proyectos estratégicos, programas de implementación y normalización,
metodología de evaluación de proyectos.
4.1.5. Nuevas Tecnologías.
Las tecnologías utilizadas en sistemas de transporte inteligentes están encargadas de
proporcionar información en tiempo real acerca de vehículos, tráfico, velocidad de
irculación, clima, entre otros que permiten el control y la administración confiable. Un claro
ejemplo del desarrollo de nuevas tecnologías para la implementación de sistemas inteligentes
alrededor del mundo lo tiene la empresa Siemens, con su dependencia denominada Siemens
Traffic Solutions que busca mejorar la movilidad, seguridad y rendimiento, disminuyendo la
contaminación ambiental y el impacto económico [8].
Teniendo en cuenta esto, la compañía divide el sistema de transporte en diferentes categorías
y propone para cada una de ellas soluciones alternativas para hacer más eficiente y dinámica
la prestación del servicio. Por ejemplo, el tráfico interurbano, más conocido como
intermunicipal, requiere de un tipo especial de centro de control de autopistas, sistemas de
llamadas de emergencia, adquisición de datos ambientales y meteorológicos, señales de
cierre de carriles, y detección de tráfico; con lo que la empresa Siemens pretende reducir
emisiones de gases contaminantes y congestiones que generan un alto costo económico, que
actualmente representa el 3% del PIB de España [15].
Para controlar el tráfico urbano, la empresa plantea sistemas de control y gestión, detectores
para la adquisición de información del tráfico, sistemas de priorización del tráfico para el
transporte público, control del medio ambiente y, como media importante, semáforos y
controladores accionados según el tránsito, para lo que se ha empleado tecnología LED que
posee menor consumo tanto de potencia, consumo económico y despliegue, poseen mayor
durabilidad y contribuyen a la seguridad vial [16].
4.2. Red de sensores inalámbricos.
Se conoce como red de sensores inalámbricos WSN a una red inalámbrica que consiste en
dispositivos distribuidos espaciados autónomos utilizando sensores para monitorear
condiciones físicas o ambientales, que incorporan un Gateway que provee conectividad
inalámbrica de regreso al mundo de cables y nodos distribuidos [17].
20
Figura 4 Componentes de WSN gateway y nodos distribuidos [17]
Existen tres tipos de disposición de arquitecturas: en estrella, en el que cada nodo se conecta
directamente al gateway; en topología de árbol, donde cada nodo se conecta a otro de mayor
jerarquía hasta llegar al gateway y, las redes tipo malla, que son las más utilizadas, donde los
nodos transmiten mensajes de unos a otros hasta llegar a la estación base (gateway) que está
conectada a través de algún retorno como Ethenet, 3G, GPRS o WiFi a internet, a través del
cual viajan hasta los que monitorizan la red [18].
Gracias al desarrollo tecnológico los nodos se hacen cada vez más pequeños tanto en
consumo energético (una batería puede durar hasta 10 años) como en tamaño, además del
tipo de comunicación por medio de RF, lo que ha favorecido el despliegue de los nodos en
entornos urbanos para medir indicadores de tráfico, humedad, contaminación, entre otros.
4.2.1. Principales tecnologías de IOT
Cuando se habla de Internet de las Cosas se pueden decir tres cosas fundamentales con
respecto a las capacidades de los objetos inteligentes: 1) ser identificables, 2) comunicarse y
3) interactuar con otros objetos o con los usuarios finales u otras entidades en la red [19].
Este concepto de basa a partir del paradigma de “objetos inteligentes” que complementan las
entidades existentes en Internet, tales como routers y servidores y se definen como entidades
que tienen las siguientes características [20]: Materialización física, conjunto mínimo de
funciones de comunicación, tiene asociada una dirección (legible por máquinas) y nombre
(legible por humanos) únicos, tiene capacidades básicas de comunicación: desde RFID hasta
cálculos bastante complejos, posee medios para detectar fenómenos físicos como
temperatura o luz, y para desencadenar acciones que tienen un efecto en la realidad.
Teniendo en cuenta esto, las tecnologías de IoT pueden clasificarse en función de sus
elementos propios y las interfaces entre ellos, por esto se tienen [21]:
1. Tecnología de objeto conectado: Los objetos conectados son dispositivos basados en
plataformas hardware y software que implican capacidad de proceso y programación.
2. Tecnologías de comunicaciones en objetos conectados: La comunicación es
fundamental para el desarrollo de IoT, por eso se cuenta con un tipo de conexión
directa con un cloud, como lo es el WiFi o la conectividad del celular, Sigfox, LoRa,
Weighless, ZigBee, Z- Wave, IEEE 802.15.4.
21
3. Tecnologías aplicativas de red: La conectividad de los objetos es de mucha
importancia en las plataformas de IoT, lo que requiere de protocolos de internet
(TCP/IP) para ir a la red.
4. Tecnologías de cloud y Big Data: El cloud se sustenta en una arquitectura de
servidores de red en donde los grandes como Amazon AWS, Microsoft Azure o IBM
llevan la dirección.
5. Tecnologías de aplicación: Se considera ya una red de objetos conectados en una
plataforma IoT de tal forma que el usuario final interactúe con una aplicación, de
valor añadido y utilidad, que proporcione información al sistema.
4.2.2. Tecnología LoRa
LoRa es un sistema de comunicaciones de largo alcance y baja potencia que pretende ser
utilizado en dispositivos alimentados con baterías de larga duración y bajo consumo de
energía. Este se refiere a dos capas distintas: la primera es una capa física que utiliza la
técnica de modulación de radio CSS que permite aplicaciones de largo alcance, baja potencia
y comunicaciones de bajo rendimiento, y la segunda hace referencia a un protocolo de capa
MAC (LoRaWAN), que proporciona un mecanismo de control de acceso al medio, que
permite a muchos dispositivos finales comunicarse con una puerta de enlace utilizando
modulación LoRa [22]. Adicional a esto, se define como un espectro de modulación
ensanchado propio de Semtech derivado de la modulación de espectro ensanchado con chirps
(CSS) [23], que tienen como finalidad mejorar la sensibilidad a costa de una reducción en la
tasa de datos para un ancho de banda (BW) dado, para lo que utiliza factores de
ensanchamiento (SF) ortogonales que optimiza el desempeño de la red con un ancho de banda
constante [24].
4.2.2.1. Modulación LoRa [23].
LoRa se puede ver como una implementación de la capa física y no depende de otras capas
superiores. En la modulación LoRa se logra obtener el espectro ensanchado generando una
señal chirp que varía continuamente en frecuencia, que tiene como ventaja que las
variaciones de temporización y frecuencia entre el transmisor y el receptor son equivalentes,
reduciendo la complejidad del receptor. La señal deseada es ensanchada y modulada sobre
un chirp, por lo que la relación entre la tasa de datos deseada, la tasa de símbolos y la tasa de
chips para LoRa, permiten tener a LoRa como el mejor candidato para IoT: Ancho de banda
escalable, bajo consumo energético, alta robustez, resistente a desvanecimiento, capacidad
de amplia cobertura, capacidad de red mejorada.
4.2.2.2. Arquitectura LoRa.
La configuración LoRa consta de cuatro parámetros fundamentales que permiten determinar
rango de transmisión, resiliencia al ruido y consumo de energía [23]: 1. Frecuencia de
22
portadora que se refiere a la frecuencia central para la banda de transmisión; 2. Factor de
propagación, que representa la relación entre la tasa de símbolos y la tasa de chips, de esta
forma, un factor de propagación alto aumenta la relación señal a ruido, la sensibilidad y el
rango, así como el tiempo del paquete; 3. Ancho de banda, es el rango de frecuencias de
transmisión banda, lo que implica que a mayor ancho de banda se produce una mayor tasa de
datos, pero una menor sensibilidad; 4. Tasa de codificación, es la tasa FEC utilizada por el
módem LoRa y ofrece protección contra ráfagas de interferencias.
De igual forma, la tecnología LoRa se basa principalmente en tres componentes [25] que son:
dispositivos terminales, que corresponden a sensores y actuadores que se conectan por
interfaz de radio LoRa con una o más puertas LoRa. Puertas LoRa o Gateways, encargados
de conectar los dispositivos terminales con el servidor de red LoRa, que es el elemento central
de la arquitectura de red y, servidor LoRa, que como su nombre lo indica, es el servidor que
controla toda la red (administración de recursos de radio, control de admisión, seguridad,
etc.)
Figura 5 Arquitectura LoRa [25].
4.2.2.3. Protocolo LoRaWAN,
Este es un protocolo MAC para usar en la capa física de LoRa que está diseñado
principalmente para redes de sensores, donde los sensores intercambian paquetes con el
servidor a una baja velocidad de datos e intervalos de tiempo relativamente largos [22]. En
esta, se presenta una topología de estrella donde los nodos transmiten directamente a la puerta
que está conectada y alimentada a una estructura principal. La conexión gateway - servidor
es mediante IP y la conexión gateway – nodo es mediante LoRa, donde los nodos no se hablan
entre ellos [18]. La comunicación se realiza de forma bidireccional entre nodos, gateways
y servidor a través de diferentes frecuencias y tasas de datos.
A continuación, se presenta la arquitectura detallada de LoRaWAN cuyos principales actores
son los dispositivos terminales, sensores de baja potencia que se comunican con los gateways
a través de LoRa; los gateways, que son dispositivos intermedios que envían paquetes
recibidos de los dispositivos finales a un servidor de red mediante una interfaz de red como
Ethenet o 3G que permite mayor rendimiento; y los servidores de red, encargados de
23
decodificar y de – duplicar los paquetes enviados por los dispositivos finales y generando las
respuestas que deben enviarse de vuelta [22].
Figura 6 Arquitectura LoRaWAN [18].
4.2.2.3.1. Canales y velocidades de transmisión.
Gracias a la utilización del espectro ensanchado se pueden enviar varias portadoras por un
mismo canal con diferentes velocidades de datos y no interfieren entre sí, creando un
conjunto de canales virtuales que amplían la velocidad del gateway [26]. De este modo, los
nodos pueden transmitir por cualquier canal disponible en cualquier momento y utilizando
cualquier tasa de datos disponible, teniendo en cuenta que [27]: Los nodos cambian de canal
de forma aleatoria en cada transmisión que se realiza, haciendo el sistema robusto a
interferencias y, los nodos respetan la máxima duración de transmisión permitida y el
máximo ciclo de trabajo.
En general, los módulos LoRaWAN cuentan con 16 canales en las bandas de 433 MHz y 868
MHz y 72 canales para 900 MHz. La distribución de frecuencias se detalla en la siguiente
tabla, donde: * hace referencia a que los canales restantes se pueden configurar dentro de los
rangos establecidos, con un ancho de banda de 125 KHz para de 868 MHz y para la banda
de 433 MHz [28]. Los canales del 3 al 15 se encuentran en estado OFF por defecto, por lo
que el administrador de la red debe adecuarlo a través del ciclo de trabajo.
Figura 7 Canales de frecuencia [28]
24
4.2.2.3.2. Clases LoRaWAN [24]
Se definen tres clases diseñadas para diferentes aplicaciones, en las que se exige que todos
los dispositivos con tecnología LoRaWAN implementen por lo menos la clase A y se
compatibles con ella misma.
Figura 8 Clases de LoRaWAN [26]
Teniendo en cuenta esto, se explican a continuación las clases diseñadas para LoRaWAN:
Clase A que permiten comunicación bidireccional, ya que luego de cada transmisión
uplink (nodo al servidor) existen dos ventanas downlink (servidor al nodo), de esta
forma consume menos energía,
Los dispositivos de Clase B permiten más ventanas de recepción, para lo que envía
Beacons desde el gateway para fijar el tiempo en el que el dispositivo final debe estar
en modo de escucha.
Clase C, en la que las ventanas de escucha son continuas, es decir, estas se cierran
únicamente cuando se encuentra transmitiendo. Este tipo de dispositivos ofrecen
menos latencia entre el servidor y el dispositivo final, por lo que consumen más
energía para su funcionamiento.
4.2.2.3.3. Seguridad LoRaWAN [27]
La seguridad en un sistema de información urbano es de gran importancia ya que puede
contener datos que necesitan ser protegidos. Por este motivo, el sistema LoRaWAN
incorpora varias capas de cifrado que hacen uso del algoritmo de cifrado AES128, en los que
se tienen 3 posibilidades con claves de 128 bits:
- Network Session Key que garantiza la seguridad a nivel de red y que permite verificar
la validez de los mensajes.
- Application Session Key que garantiza la seguridad de extremo a extremo en la capa
de aplicación. Es la clave de cifrado entre el nodo terminal y la aplicación de red, de
tal forma que el usuario solo pueda conocer el contenido del mensaje.
- Application Key que garantiza la seguridad de extremo a extremo en el nivel de
aplicación, utilizando únicamente OTAA. Esta clave se emplea para determinar la
clave de sesión.
25
4.2.2.4. Activación de un nodo.
El término nodo se refiere a un sistema con la capacidad de recolectar, almacenar y comunicar
información e interactuar con el entorno por medio de actuadores o con otros sistemas de la
red, tales como gateways, servidores y otros nodos [29]. Estos generalmente son sistemas
pequeños que tienen bajo consumo de potencia, lo que los hace de bajo costo y se componen
generalmente de controladores, que suelen ser una placa integrada que incluye CPU, buses y
memoria; transceptores, que permiten que el dispositivo pueda conectarse tanto a la red como
a otros dispositivos de manera inalámbrica; sensores, que tienen la función principal de
recolectar información a través de conexiones con los buses hacia la CPU y memoria; y
actuadores, encargados de generar los cambios en el entorno provenientes desde el
controlador.
Ahora, la activación de los nodos puede darse de dos formas: OTAA o ABB [30]. Cuando
se habla de OTAA se refiere a una activación por aire, que corresponde a la manera más
segura de conectarse a la red ya que como su nombre lo indica, la sesión se activa por aire y
se renueva cada vez que el dispositivo es apagado o reiniciado. Por otro lado, el modo de
activación de nodo ABP, activación por personalización, es aún mucho más sencillo, pero
disminuye considerablemente la seguridad de la red.
4.2.3. Sistema embebido.
Para poder hablar de un sistema embebido se debe primero entender su definición: Sistema
de computación diseñado para realizar una o algunas funciones dedicadas frecuentemente en
tiempo real, diseñados para cumplir funciones específicas, disminuir tamaño, costo y
consumo, mejorar el desempeño. Un sistema embebido en general está compuesto por un
microprocesador, un software que requiere que se disponga de cierta cantidad de memoria,
entradas y salidas que permiten conectarlo con el exterior [32].
Debido a la complejidad que se tiene con este tipo de sistemas y los amplios campos de
aplicación en los que se pueden implementar, se debe analizar cada aspecto de su
funcionamiento detenidamente, como se presenta a continuación.
- Microprocesador, encargado de realizar las operaciones de cálculo principales de
todo el sistema además de dirigir el funcionamiento de los demás elementos que lo
rodean.
- Memoria que almacena el código de los programas que pueden ser ejecutados por el
sistema. Esta debe tener un acceso a lectura y escritura lo más rápido posible para
que no se pierda tiempo en tareas rutinarias que no sean cálculos.
- Memoria caché que tiene la función principal de realizar las tareas repetitivas,
ahorrando tiempo ya que no será necesario acudir a la memoria principal si el dato o
la instrucción ya se encuentra en la caché.
26
- Disco duro que almacena toda la información que no es volátil, además de tener un
gran tamaño de almacenamiento.
- Puertos de entrada / salida (I/O), en los que se pueden conectar e intercambiar
información con la memoria y el procesador central que utilizan registros para el
almacenamiento temporal de varios tipos de datos. Pueden ser de varios tipos: puerto
serie en los que se transfiere información bit a bit de forma secuencial; puertos
paralelos en los que se transfieren en paralelo, es decir, por byte; y los puertos
universales USB.
Figura 9 Arquitectura Sistema Embebido [31].
4.2.3.1.Módulo Transceptor de RF RN2903
El módulo transceptor RN2903 cuenta con modulación RF de tecnología LoRa, que
proporciona comunicación de amplio espectro de amplio alcance con alta inmunidad a
interferencias. Usando la técnica de modulación de la tecnología LoRa, RN2903 puede
lograr una sensibilidad del receptor de -146 dBm. La alta sensibilidad combinada con el
amplificador de potencia de salida integrado de +18.5 dBm produce un presupuesto de enlace
líder en la industria, lo que lo hace óptimo para
aplicaciones que requieren rango y robustez
extendidos. [32].
RN2903 tiene la pila de protocolos completa de
LoRaWAN™ en el módem y es fácil de
configurar a través de simples comandos ASCII a
través del UART, lo cual reduce
considerablemente el tiempo de desarrollo.
RN2903 es certificado por FCC que ahorra
significativos costos de certificación. Además,
Figura 10 Módulo RF RN2903 [32]
27
combina un factor de forma pequeño, de 17.8 x 26.7 mm × 3 mm, con 14 GPIO,
proporcionando la flexibilidad para conectar y controlar un gran número de sensores y
actuadores teniendo muy poco espacio. El módem RN2903 resuelve el dilema inalámbrico
del programador de elegir entre una gama más extensa y un menor consumo de energía.
Mediante el empleo del RN2903, un desarrollador puede maximizar ahora ambos,
eliminando el costo de los repetidores adicionales y aumentando la duración de la batería.
Con su escalabilidad, comunicación robusta, movilidad y la capacidad para operar en
entornos hostiles al aire libre, el RN2903 es ideal para una amplia gama de diseños de control
y monitoreo inalámbrico de baja velocidad de datos [33].
Figura 11 Diagrama de bloques RN2903 [32].
Este módulo tiene un alcance superior a 15 km, un bajo consumo de energía permitiendo una
vida útil de la batería de 10 años, opera en una banda de 915 MHz, interfaz de comandos
ASCII sobre UART fácil de usar, excelente inmunidad a la interferencia lo que lo hace ideal
para aplicaciones de IoT, medición, M2M, ciudad inteligente, redes de sensores,
automatización industrial y casas inteligentes [33].
4.2.3.2.Gateway LoRaWAN
Un gateway o puerta de enlace es un dispositivo, con frecuencia un ordenador, que permite
interconectar redes con protocolos y arquitecturas diferentes a todos los niveles de
comunicación. Su propósito es traducir la información del protocolo utilizado en una red al
protocolo usado en la red de destino.
El gateway es normalmente un equipo informático configurado para dotar a las máquinas de
una red local (LAN) conectadas a él de un acceso hacia una red exterior, generalmente
realizando para ello operaciones de traducción de direcciones IP (NAT: Network Address
Translation). Esta capacidad de traducción de direcciones permite aplicar una técnica llamada
28
IP Masquerading (enmascaramiento de IP), usada muy a menudo para dar acceso a Internet
a los equipos de una red de área local compartiendo una única conexión a Internet y, por
tanto, una única dirección IP externa [34].
Debido a la aplicación a implementar se requiere de una puerta de enlace, al menos un nodo
y un servidor local en el que se puedan supervisar los dispositivos vinculados a la red. A
partir de esto, se hace necesario la obtención de un kit que proporciona una puerta de enlace
y un servidor local que permite almacenar y recopilar datos.
Este kit de Seeed, empresa dedicada
soluciones de IoT, está diseñado para
implementarse sobre un Raspberry Pi 3
utilizando un módulo de puerta de enlace
RHF0M301, que es un canal de puerta de
enlace LoRaWAN de 10 canales (8 x
Multi-SF + 1 x LoRa + 1 x FSK) con un
puerto DIP de 24 pines a bordo; y un
puente PRI 2 RHF4T002. Así mismo, el
kit descrito anteriormente tiene un bajo
consumo de energía, permite un
monitoreo de la aplicación en tiempo real
y presenta una solución económica para
construir una red LoRa/LoRaWAN.
4.2.3.2.1. Raspberry Pi 3 B+
Raspberry Pi es un tablero de computadora pequeño, poderoso, económico y con énfasis en
la educación, de tal forma, que funciona como un computador estándar: necesita un teclado
para digitar los comandos, una unidad de pantalla y una fuente de alimentación. Así mismo,
contiene los componentes básicos de un sistema computacional tales como unidad de
procesamiento y gráficos, hardware de audio y comunicaciones y un chip de memoria. La
Raspberry Pi 3 Modelo B + es el último producto de la gama Raspberry Pi 3, que ofrece un
procesador de cuatro núcleos de 64 bits que funciona a 1,4 GHz, LAN inalámbrica de banda
dual de 2,4 GHz y 5 GHz, Bluetooth 4.2 / BLE, Ethernet más rápida y PoE capacidad a través
de un PoE HAT independiente La LAN inalámbrica de banda dual viene con una
certificación de cumplimiento modular, lo que permite que la placa se diseñe para productos
finales con pruebas de cumplimiento de LAN inalámbrica significativamente reducidas, lo
que mejora el costo y el tiempo de comercialización. [35].
Figura 12 Gateway LoRa/LoRaWAN para Raspberry Pi 3 [34].
29
El componente central de una tarjeta Raspberry Pi es la CPU, encargada de llevar a cabo
todas las instrucciones de un ordenador, capaz de realizar operaciones aritmético lógicas
gracias a su procesador ARM de bajo costo, potencia y de gran capacidad.
Una de las principales ventajas que ofrece este dispositivo para el desarrollo de aplicaciones
de IoT es su bajo consumo de energía, por lo que la tarjeta tiene incorporada componentes
de hardware de baja potencia y ciclos de operación de trabajo bajo, adicionalmente debe
incluirse en el desarrollo de la aplicación soluciones que reduzcan considerablemente el flujo
de datos tanto de sensores como de protocolos específicos. Teniendo en cuenta esto, se sabe
a partir de la hoja de datos de la tarjeta, que esta requiere para su funcionamiento hasta
2000mA [35] que pueden ser proporcionados por medio de una fuente de 5V 2A, sin
embargo, debe tenerse presente que por sus puertos USB no debe excederse una corriente de
salida de 100mA.
Figura 13 Raspberry Pi 3 Model B + [35].
Así como lo hace cualquier otro computador, la Raspberry Pi requiere de un sistema
operativo. La opción de Linux denominada Raspbian, que se ejecuta principalmente en el
procesador ARM de la misma, es de código abierto y gratuito, lo que facilita el acceso y
mantiene el bajo costo de este dispositivo [36]. Raspbian posee un entorno amigable similar
al de Windows que, adicionalmente, trae preinstalado un software útil para escribir código
que agiliza la labor del programador.
La facilidad de acceso tanto a la tarjeta de desarrollo como al sistema operativo para su
programación hacen de este dispositivo una plataforma ideal para el desarrollo de
aplicaciones de IoT, que requieren de sensores, receptores, transmisores, entre otros
dispositivos de baja potencia y largo alcance, de tal forma de implementar una red de
recolección de datos eficiente y completa.
30
4.2.3.3. Microcontrolador MC9S08AW60 [37]
La utilización de un microcontrolador para el desarrollo de nuestra aplicación es necesario
para poder controlar y monitorear los módulos LoRa, tanto implementados en los paraderos
como en los vehículos, para esto se utilizarán microcontroladores de Freescale de referencia
MC9S08AW60 debido a su funcionalidad y su fácil acceso, además de su énfasis en
aplicaciones automotrices, industriales y de electrodomésticos.
El microcontrolador (MCU) MC9S08AW60 hace parte de la familia de unidades de
microcontroladores HCS08 de bajo costo y alto rendimiento que permite aplicaciones de 5
voltios. Es un MCU altamente integrado con múltiples características valiosas:
- 60K de memoria flash programable en circuito y en chip con protección de bloque y
opciones de seguridad.
- 2K de RAM en chip.
- Generador de reloj interno flexible que
elimina la necesidad de utilizar
componentes externos.
- Detector de bajo voltaje.
- Convertidores analógico digital ADC de
alto rendimiento de 16 canales, 10 bits.
- CPU HCS08 de 40MHz.
- Sistema interno de depuración de fondo.
- Dos comparadores.
- Módulos de activación (nueve).
- FIFO (ocho) profundos para almacenar
direcciones de cambio de flujo y datos de
solo eventos.
- Dos módulos de interfaz de
comunicación serie (SCI).
- Módulo de interfaz serial periférica (SPI).
- Monitor de voltaje externo que permite el monitoreo de nivel de entrada con un punto
de activación seleccionable.
- Generación de interrupciones.
- Fuentes de reloj: cristal, resonador, reloj externo, reloj generado internamente con
recorte de precisión.
- Módulo I2C para funcionar hasta 100Kbps.
- Modulador de ancho de pulso.
- Módulos de temporizadores configurables para PWM.
- Pines de alta corriente (ocho).
- Pines de entrada/salida de propósito general (52).
Figura 14 Microcontrolador MC9S08AW60 [38].
31
Este microcontrolador permite trabajar entradas y salidas de propósito general en paralelo,
distribuidos en 7 puertos para un total de 54 pines. Estos pines son controlados por software
y están destinados a diversas funciones tales como temporizadores, ADC, SCI, SPI, I2C,
relojes, y sensores externos que se necesiten para la realización de la aplicación final.
4.2.3.4. Módulo GPS NEO 6M [38].
La serie de módulos NEO-6 es una familia de receptores GPS autónomos con el motor de
posicionamiento u-blox 6 de alto rendimiento. Estos receptores flexibles y rentables ofrecen
numerosas opciones de conectividad en un paquete en miniatura de 16 x 12.2 x 2.4 mm. Su
arquitectura compacta y sus opciones de energía y memoria hacen que los módulos NEO-6
sean ideales para dispositivos móviles que funcionan con baterías con costos y restricciones
de espacio muy estrictos.
El motor de posicionamiento u-blox 6 de 50 canales cuenta con un tiempo de corrección
(TTFF) de menos de 1 segundo. El motor
de adquisición dedicado, con 2 millones
de correladores, es capaz de realizar
búsquedas masivas paralelas en el espacio
de tiempo / frecuencia, lo que le permite
encontrar satélites al instante. El diseño y
la tecnología innovadores suprimen las
fuentes de interferencias y mitigan los
efectos de múltiples rutas, brindando a los
receptores GPS NEO-6 un excelente
rendimiento de navegación incluso en los
entornos más difíciles.
La comunicación entre satélites y receptor se realiza comúnmente mediante el envío de
paquetes con sentencias conocidos como comandos NMEA (National Marine Electronic
Asociation). Asociación que se encarga de definir un protocolo estándar de comunicación de
datos, la última versión NMEA-0183 del año 2001.
Todos los datos son transmitidos en sentencias con caracteres ASCII, en cada sentencia
comienza con el símbolo ‘$’ y termina con ‘CR o LF’. Los siguientes 2 caracteres después
de ‘$’ son los que identifican al equipo, ‘GP’ (por ejemplo: se utiliza para identificar datos
GPS), los tres siguientes caracteres que le siguen son el identificador del tipo de sentencia
que se envía. Los tipos de sentencias NMEA que existen corresponden a envío, origen del
equipo y consulta.
Figura 15 Módulo GPS NEO 6M [38]
32
Los datos están delimitados por comas dentro de la sentencia. Dentro de estas sentencias de
abajo se encuentran los diferentes datos que se utilizan para obtener la localización y demás
datos [39].
Los comandos soportados por el GPS son:
Figura 16 Comandos GPS NMEA para GPS [39]
4.2.4. Aplicación Web [40]
Las aplicaciones web reciben este nombre porque se ejecutan en internet. Es decir que los
datos o los archivos en los que trabajas son procesados y almacenados dentro de la web. Estas
aplicaciones, por lo general, no necesitan ser instaladas en tu computador.
El concepto de aplicaciones web está relacionado con el almacenamiento en la nube. Toda la
información se guarda de forma permanente en grandes servidores de internet y nos envían
a nuestros dispositivos o equipos los datos que requerimos en ese momento, quedando una
copia temporal dentro de nuestro equipo.
En cualquier momento, lugar y desde cualquier dispositivo podemos acceder a este servicio,
sólo necesitamos una conexión a internet y nuestros datos de acceso, que por lo general son
el nombre de usuario y contraseña.
Estos grandes servidores de internet que prestan el servicio de alojamiento están ubicados
alrededor de todo el mundo, así hacen que el servicio prestado no sea tan costoso o gratuito
en la mayoría de los casos y extremadamente seguro.
4.2.4.1. Servidor LORIOT [41].
LORIOT es una empresa suiza en el campo de Internet de las cosas cuyo principal producto
hoy en día es el software para la operación escalable, distribuida y resistente de las redes de
LoRaWAN y las aplicaciones de extremo a extremo, que ofrece bajo una variedad de
modelos de negocios.
33
Los servidores de red públicos LoRaWAN de LORIOT.io están brindando acceso mundial
de baja latencia a los servicios (NaaS), lo que implica proyectos de prueba de concepto
convincentes y con buen desempeño, con un costo de desarrollo mínimo y un tiempo de
comercialización extremadamente corto.
Debido a que en el momento son el único en el ecosistema de LoRa como proveedor de
software y operador de red, tienen contacto directo con los productores de hardware de LoRa
e integran muchas de sus soluciones directamente con sus servicios. La colaboración les
permite ofrecer no solo software de red, sino una solución completa de extremo a extremo
para una aplicación de IoT del mundo real, que incluye hardware de gateway y sensores.
4.2.4.2. Amazon Web Services [42].
En 2006, Amazon Web Services (AWS) comenzó a proporcionar servicios de infraestructura
de TI para empresas en forma de servicios web, más conocido hoy como informática en la
nube. Uno de los principales beneficios de la informática en la nube es la oportunidad de
reemplazar importantes gastos anticipados en infraestructura con costos variables reducidos
que se escalan con su negocio. Gracias a la nube, las empresas ya no tienen que planificar ni
adquirir servidores ni otras infraestructuras de TI con semanas o meses de antelación. Pueden
disponer en cuestión de minutos de cientos o de miles de servidores y ofrecer resultados más
rápidamente.
La plataforma de informática en la nube de AWS ofrece la flexibilidad de lanzar su aplicación
independientemente del sector al que pertenezca y de su caso de uso particular. Más
información sobre soluciones populares que los clientes ejecutan en AWS:
a. Alojamiento de aplicaciones.
b. Sitios Web.
c. Backup y almacenamiento.
d. TI empresarial.
e. Entrega de contenido.
f. Bases de datos.
4.2.4.2.1. AWS IoT [43].
AWS IoT proporciona una comunicación bidireccional segura entre los dispositivos
conectados a Internet (como sensores, actuadores, microcontroladores integrados o aparatos
inteligentes) y la nube de AWS. Esto le permite recopilar datos de telemetría de varios
dispositivos, y almacenar y analizar los datos. También puede crear aplicaciones que
permitan a sus usuarios controlar estos dispositivos desde sus teléfonos o tablets.
34
Los dispositivos indican su estado publicando mensajes en formato JSON, en temas MQTT.
Cada tema MQTT tiene un nombre jerárquico que identifica el dispositivo cuyo estado se
actualiza. Cuando un mensaje se publica en un tema de MQTT, el mensaje se envía al agente
de mensajes de MQTT de AWS IoT, el cual se encarga de enviar todos los mensajes
publicados en un tema de MQTT a todos los clientes suscritos a dicho tema.
Puede crear reglas que definan una o varias acciones que deban ejecutarse en función de los
datos de un mensaje. Por ejemplo, puede insertar, actualizar o consultar una tabla de
DynamoDB o invocar una función Lambda. Las reglas usan expresiones para filtrar los
mensajes. Cuando una regla coincide con un mensaje, el motor de reglas desencadena la
acción mediante las propiedades seleccionadas. Las reglas también contienen una función de
IAM que concede permiso a AWS IoT sobre los recursos de AWS utilizados para
desempeñar la acción.
Figura 17 Funcionamiento de AWS IoT [43].
4.2.4.2.2. Base de datos no relacional DynamoDB [44].
Amazon DynamoDB es un servicio de bases de datos NoSQL totalmente administrado que
ofrece un desempeño rápido y previsible, así como una escalabilidad óptima. DynamoDB le
permite trasladar a AWS las cargas administrativas que supone tener que utilizar y escalar
una base de datos distribuida, para que no tenga que preocuparse del aprovisionamiento, la
instalación y la configuración del hardware, ni tampoco de las tareas de replicación, revisión
del software o escalado de clústeres. Además, DynamoDB ofrece el cifrado en reposo, que
elimina la carga y la complejidad operativa que conlleva la protección de información
confidencial.
35
Con DynamoDB, puede crear tablas de base de datos capaces de almacenar y recuperar
cualquier cantidad de datos, así como de atender cualquier nivel de tráfico de solicitudes.
Puede escalar la capacidad de desempeño de las tablas para aumentarla o reducirla sin
tiempos de inactividad ni reducción del desempeño, así como utilizar la consola de
administración de AWS para monitorizar la utilización de recursos y las métricas de
desempeño.
4.2.4.3. API REST HTTP [45].
Se habla de REST (REpresentational State Transfer) como un conjunto de restricciones con
las que podemos crear un estilo de arquitectura software, la cual podremos usar para crear
aplicaciones web respetando HTTP.
Hoy por hoy la mayoría de las aplicaciones que se desarrollan para servicios profesionales
disponen de una API REST para el intercambio de información entre el front y el back. Lo
que la hace tan potente es precisamente el aislamiento que proporciona entre la lógica del
back-end y cualquier cliente consumidor de éste. Esto le permite ser usada por cualquier tipo
de cliente: web, móvil, etc. Así, cualquier dispositivo/cliente que entienda de HTTP puede
hacer uso de su propia API REST de manera muy simple. Esto ha hecho que en los últimos
años este tipo de arquitectura haya ganado peso frente a otras más complejas como SOAP,
para el intercambio y manipulación de datos.
Las principales características de API REST son:
1. Los objetos REST son manipulados a través de una URI (Uniform Resource
Identifier). Esta URI (endpoint) hace de identificador único de cada recurso del
sistema REST, por lo que no puede ser compartida por más de un recurso. La
estructura básica de una URI es la siguiente:
{protocolo}://{hostname}:{puerto}/{ruta del recurso}?{parámetros de filtrado
(opcional)}
El nombre de la URI no debe contener palabras que impliquen acciones, por lo que
deben evitarse los verbos en su construcción.
2. Uso de la especificación HTTP: para el desarrollo de una API REST es necesario
un conocimiento profundo de la especificación HTTP, sobre todo en lo referente a
métodos permitidos, códigos de estado y aceptación de tipos de contenido.
Los métodos son usados para manipular los diferentes recursos que conforman la
API. Los principales métodos soportados por HTTP y por ello usados por una API
REST son:
o POST: crear un recurso nuevo.
o PUT: modificar un recurso existente.
o GET: consultar información de un recurso.
o DELETE: eliminar un recurso determinado.
o PATCH: modificar solamente un atributo de un recurso.
36
Estos métodos junto con la URI, nos proporciona una interfaz uniforme que nos
permite la transferencia de datos en el sistema REST aplicando operaciones concretas
sobre un recurso determinado. Aunque la mayoría de las operaciones que componen
una API REST podrían llevarse a cabo mediante métodos GET y POST, el abuso de
ellos para operaciones que nada tienen que ver con el propósito con el que se
concibieron, puede provocar un mal uso del protocolo alejado del estándar o la
construcción de URIs con nomenclatura errónea mediante el uso de verbos.
3. Protocolo cliente/servidor sin estado: cada petición HTTP contiene toda la
información necesaria para ejecutarla, lo que permite que ni cliente ni servidor
necesiten recordar ningún estado previo para satisfacerla. Aunque esto es así, algunas
aplicaciones HTTP incorporan memoria caché. Se configura lo que se conoce como
protocolo cliente-caché-servidor sin estado: existe la posibilidad de definir algunas
respuestas a peticiones HTTP concretas como cacheables, con el objetivo de que el
cliente pueda ejecutar en un futuro la misma respuesta para peticiones idénticas.
4. Uso de recursos Hypermedia: haciendo uso de hipermedios se le permite al cliente
consumidor de una API REST acceder de manera fácil a la navegación entre recursos,
así como conectar unos recursos con otros que guardan algún tipo de relación entre
sí. Este intercambio de vínculos mediante el uso de hipermedios tiene sus cimientos
en el principio de HATEOAS (Hypermedia As The Engine Of Application State –
Hipermedia Como Motor del Estado de la Aplicación). Este principio permite que
cada vez que se hace una petición al servidor, parte de la respuesta que éste devuelve,
debe contener información sobre vínculos relacionados con el recurso que se está
consultando. Esto permite la navegación entre recursos.
4.2.4.4. Express y Node js [46].
Node js es un entorno que trabaja en tiempo de ejecución, de código abierto, multi-
plataforma, que permite a los desarrolladores crear toda clase de herramientas de lado
servidor y aplicaciones en JavaScript. La ejecución en tiempo real está pensada para usarse
fuera del contexto de un explorador web (es decir, ejecutarse directamente en una
computadora o sistema operativo de servidor). Como tal, el entorno omite las APIs de
JavaScript específicas del explorador web y añade soporte para APIs de sistema operativo
más tradicionales que incluyen HTTP y bibliotecas de sistemas de ficheros.
Desde una perspectiva de desarrollo de servidor web, Node tiene un gran número de ventajas:
1. ¡Gran rendimiento! Node ha sido diseñado para optimizar el rendimiento y la
escalabilidad en aplicaciones web y es un muy buen complemento para muchos
problemas comunes de desarrollo web (ej, aplicaciones web en tiempo real).
2. El código está escrito en "simple JavaScript", lo que significa que se pierde menos
tiempo ocupándose de las "conmutaciones de contexto" entre lenguajes cuando estás
escribiendo tanto el código del explorador web como del servidor.
37
3. JavaScript es un lenguaje de programación relativamente nuevo y se beneficia de los
avances en diseño de lenguajes cuando se compara con otros lenguajes de servidor
web tradicionales (ej, Python, PHP, etc.) Muchos otros lenguajes nuevos y populares
se compilan/convierten a JavaScript de manera que puedes también usar
CoffeeScript, ClosureScript, Scala, LiveScript, etc.
4. El gestor de paquetes de Node (NPM del inglés: Node Packet Manager) proporciona
acceso a cientos o miles de paquetes reutilizables. Tiene además la mejor en su clase
resolución de dependencias y puede usarse para automatizar la mayor parte de la
cadena de herramientas de compilación.
5. Es portable, con versiones que funcionan en Microsoft Windows, OS X, Linux,
Solaris, FreeBSD, OpenBSD, WebOS, y NonStop OS. Además, está bien soportado
por muchos de los proveedores de hospedaje web, que proporcionan infraestructura
específica y documentación para hospedaje de sitios Node.
Express es el framework web más popular de Node, y es la librería subyacente para un gran
número de otros frameworks web de Node populares. Proporciona mecanismos para:
1. Escritura de manejadores de peticiones con diferentes verbos HTTP en diferentes
caminos URL (rutas).
2. Integración con motores de renderización de "vistas" para generar respuestas
mediante la introducción de datos en plantillas.
3. Establecer ajustes de aplicaciones web como qué puerto usar para conectar, y la
localización de las plantillas que se utilizan para renderizar la respuesta.
4. Añadir procesamiento de peticiones "middleware" adicional en cualquier punto
dentro de la tubería de manejo de la petición.
A pesar de que Express es en sí mismo bastante minimalista, los desarrolladores han creado
paquetes de middleware compatibles para abordar casi cualquier problema de desarrollo web.
Hay librerías para trabajar con cookies, sesiones, inicios de sesión de usuario, parámetros
URL, datos POST, cabeceras de seguridad y muchos más. Puedes encontrar una lista de
paquetes middleware mantenida por el equipo de Express en Express Middleware (junto con
una lista de algunos de los paquetes más populares de terceros).
4.2.4.5. Túneles a LocalHost [47].
Los túneles permiten publicar en internet servidores alojados en el servidor local. Para esto
se utiliza una herramienta llamada Ngrok, que es una herramienta destinada a desarrolladores
y que simplifica la fase de pruebas del software, donde cada prueba que se realice en el sitio,
se reflejará en el URL público dado por el software.
Permite poder exponer el entorno local para así no tener que depender de un servidor de
desarrollo, de esta forma se puede ahorrar un coste importante, por no decir el tiempo que se
puede tardar cada vez que se tenga que hacer alguna actualización.
38
Otro caso muy útil es cuando se desarrollan aplicaciones móviles, no es posible desarrollar
una aplicación móvil utilizando emuladores o dispositivos reales y decirle a la app que la url
que debe utilizar es localhost, pero sí es posible decirle que la url es una de la que proporciona
NGROK.
Los túneles locales se establecen de la siguiente forma: primero se crea un conector (socket)
de escucha en la máquina local, asociado al puerto puerto_escucha y, opcionalmente, a la
dirección dirección_escucha. Cuando se realice una conexión al puerto en el que está
escuchando el conector, OpenSSH encauzará la conexión a través del canal seguro hacia la
máquina remota a la que el servidor tenga acceso, indicada por la IP máquina_remota y el
puerto puerto_máquina_remota.
Para demostrar cómo funcionan los túneles locales, me basaré en el siguiente diagrama
ilustrativo:
Figura 18 Funcionamiento de túneles locales [47].
4.2.4.5. Leaflet [48].
Leaflet es la biblioteca líder de JavaScript de código abierto para mapas interactivos
optimizados para dispositivos móviles. Con un peso de solo 38 KB de JS, tiene todas las
funciones de mapeo que la mayoría de los desarrolladores necesitan.
Algunas de las características de Leaflet son:
Capas fuera de la caja: Azulejos de capas, WMS, Marcadores, ventanas emergentes,
Capas de vectores: polilíneas, polígonos, círculos, rectángulos, Superposiciones de
imágenes y GeoJSON.
Funciones de personalización: Pura ventanas emergentes CSS3 y controles para un
fácil rediseño, marcadores basados en imágenes y HTML, una interfaz simple para
capas y controles de mapas personalizados, proyecciones de mapas personalizados
(con EPSG: 3857/4326/3395 fuera de la caja) y poderosas instalaciones de OOP para
extender las clases existentes.
Controles de mapa: Botones de zoom, atribución, conmutador de capas y escala.
39
Funciones de interacción: Arrastre de paneo con inercia, rueda de desplazamiento
zoom, pellizcar-acercar en el móvil, doble clic en el zoom, zoom al área
(desplazamiento-arrastre), navegación por el teclado, eventos (clic, mouseover, etc.)
y marcador arrastrando.
Características de rendimiento: La aceleración de hardware en dispositivos móviles
hace que se sienta tan bien como las aplicaciones nativas, utilizando las características
de CSS3 para hacer que la panorámica y el zoom sean realmente suaves, la
representación inteligente de polilínea / polígono con recorte dinámico y
simplificación lo hace muy rápido, sistema de construcción modular para omitir
características que no necesita y eliminación de retraso de tap en el móvil.
Características visuales: Zoom y pan animación, animación de fundido de azulejos y
ventanas emergentes, muy buen diseño predeterminado para marcadores, ventanas
emergentes y controles de mapa, soporte de resolución retina.
Soporte de escritorio: Firefox, Safari, 5+, Opera 12+, IE 7–11.
Soporte Móvil: Safari for iOS 7+, Android browser 2.2+, 3.1+, 4+, Chrome for
mobile, Firefox for mobile, IE10+ for Win8 devices.
40
5. ESTADO DEL ARTE
El sistema de transporte inteligente que se plantea implementar en este proyecto consta de
hardware y software modernos que permiten rastrear y monitorear el vehículo, así como
entregar información en tiempo real de lo que sucede con el sistema de transporte público a
los usuarios finales del servicio, lo que incluye una aplicación móvil que permitirá a dichos
pasajeros poder visualizar, de manera fácil y efectiva, la información recolectada a través de
una red de sensores. Este tipo avances en sistemas de transporte inteligentes se han venido
implementando en diferentes ciudades y países alrededor del mundo para hacer más eficiente
el servicio de transporte urbano al poner a disposición de usuarios y conductores información
en tiempo real de rutas, servicios disponibles, accidentes, condiciones climáticas, entre otros
factores que pueden afectar la movilidad dentro de la ciudad.
Teniendo en cuenta lo anteriormente planteado y la problemática descrita, se realiza un
análisis del estado actual y los avances que se han desarrollado con respecto a los sistemas
de transporte inteligente, haciendo un énfasis especial en las mejoras implementadas en el
servicio de transporte público urbano.
5.1.Sistema de seguimiento de Bus basado en GPS/GSM [49].
En el año 2013 investigadores de la Escuela de Ingeniería de Saveetha, proponen diseñar y
desarrollar un sistema de seguimiento eficiente y rentable, que permite conocer la ubicación
del bus a través de un celular cuando se envía un SMS a un número específico, sin necesidad
de servidores externos ni conexión a internet, reduciendo considerablemente el costo de
despliegue.
El sistema consiste de un GPS, un modem
GSM y un microcontrolador. El
microcontrolador tiene almacenada una tabla
en la que se actualiza a través de la información
proporcionada por el GPS ubicado en el
vehículo. Cuando el modem GSM recibe el
mensaje de petición de localización, el
microcontrolador se encarga de revisar, en la
tabla que tiene guardada, la ubicación más
cercana al usuario de acuerdo a la información
recibida de las coordenadas GPS. La
localización del bus seleccionada se envía al
Figura 19 Arquitectura del sistema [49].
41
usuario por SMS utilizando un modem GSM para completar la solicitud, enviando la
ubicación del vehículo en coordenadas de latitud y longitud.
5.2. Aplicación móvil para sistema de información de bus y seguimiento de ubicación
utilizando tecnología cliente – servidor [50].
La Revista Internacional de Tecnología Emergente e Ingeniería Avanzada (IJETAE) publica
en el año 2014 un artículo investigativo del Departamento de Ciencias de la Computación
del Instituto de Tecnologías de la Información en Pune, India, acerca de una aplicación
desarrollada para Android que presenta a los usuarios soluciones prácticas a los problemas
de tráfico tales como tiempos de espera en paraderos, número de rutas, cantidad y descripción
de rutas que van al destino final del usuario, tiempo que tarda una ruta en realizar su recorrido,
paraderos por los que la ruta escogida pasaría, entre otros, mostrando la información
requerida sobre un mapa.
La aplicación está basada en el sistema Linux, desarrollada en Java y Android SDK para la
interfaz de usuario, utiliza arquitectura cliente – servidor y cuenta con una base de datos
creada en SQLite que contiene toda la información sobre rutas, buses, paraderos, historial de
rutas, y demás datos de importancia para el cliente. Adicionalmente, para poder entregar la
ubicación del vehículo se necesita un Servicio Basado en Ubicación (LBS), que funciona
como un servicio de IP que utiliza la información geográfica para obtener la ubicación del
bus.
Para poder acceder al servicio que la aplicación presta se requiere de un registro previo, que
permite el acceso a la información almacenada en la base de datos, así como a la recepción
de datos en tiempo real sobre una ruta en particular. Al ingresar a dicha aplicación el usuario
Figura 20 Visualización de la aplicación. Izquierda: Ruta en el mapa. Derecha: Información de paradas. [50]
42
puede ingresar su lugar de destino, ya que por GPS esta accede a la ubicación actual, y
obtener información sobre las rutas que en el paradero en que se encuentra pueden llevarlo
al lugar de destino, mostrando las alternativas en un mapa; y en caso que desee conocer la
posición exacta de un bus cercano, debe seleccionar la ruta escogida y la aplicación le
informará el tiempo al que se encuentra el vehículo del paradero más cercano del usuario en
el momento de la consulta.
5.3.Servicio de información de transporte público en tiempo real basado en sensores
participativos [51].
Los problemas de infraestructura debidos a la gran cantidad de personas que se desplazan a
las grandes ciudades avanza continuamente, haciendo cada vez más difícil la movilidad y
toda el área del transporte público. A partir del análisis de esta problemática, los autores de
este artículo presentan un prototipo de una aplicación móvil para Smartphone que
implementa un sistema de información de transporte público en vivo basado en sensores
participativos, denominada TrafficInfo.
TrafficInfo utiliza Google Maps para proporcionar
información en tiempo real sobre una ruta
seleccionada por el usuario, mostrando sobre dicha
aplicación el mapa de la cuidad con datos como
horarios, tiempo estimado de llegada del bus al
paradero, retrasos en la ruta, entre otros, así como
enviar comentarios en caso de accidentes, daños o
congestión.
La arquitectura del proyecto consta de un servidor
estándar XMPP, que permite la recopilación y
publicación de datos de manera instantánea; un
emulador GTFS que provee la información inicial del
servicio; una aplicación móvil denominada
TrafficInfo, que permite al usuario comunicarse de
manera eficiente con el sistema y, un módulo de
medición de sensores que toma los valores reales
obtenidos por los dispositivos incorporados de los
teléfonos inteligentes, tales como: información
estación base y del vehículo, acelerómetro, detalles
de la red Wifi y datos de GPS.
Figura 21 Vista principal TrafficInfo. [51]
43
5.4. Novedoso esquema de guía de ruta en tiempo real en sistema de transporte inteligente
[52].
Los sistemas inteligentes de transporte permiten incrementar la eficiencia del tráfico, por lo
que se han diseñado un sin número de esquemas dinámicos de guía para indicar al usuario la
ruta más óptima para sus viajes. A partir de esta premisa, un grupo de investigadores
universitarios proponen un sistema de guía de rutas dinámico que permite medir información
del tráfico en tiempo real requerida en función de las condiciones actuales, entregar un
mensaje con la información recolectada, determinar los estados del tráfico con el fin de
encontrar la probabilidad de confianza (probabilidad de condiciones del tráfico) de los
segmentos de carretera y, como objetivo final, modificar la ruta óptima en tiempo real desde
la posición actual hasta el destino durante el viaje.
Para que este sistema pueda
implementarse, cada vehículo debe
contar con un GPS, que entrega la
ubicación actual del mismo; sensores,
capaces de medir parámetros del
vehículo tales como velocidad,
consumo de gasolina, entre otros; y
dispositivos de comunicación
inalámbrica, que permiten compartir la
información en tiempo real del tráfico
teniendo en cuenta los demás
vehículos en la vía. Este sistema
considera más eficiente dividir cada
ruta o calle en segmentos de igual longitud de un tamaño preestablecido al cual se le asignará
un identificador único, que permite a la aplicación realizar cálculos y operaciones para
entregar la probabilidad del tráfico en cada uno de dichos segmentos en un tiempo específico:
tiempo de eficiencia, eficiencia del balance (probabilidad de desvío del vehículo) y
determinar la ruta más óptima.
5.5.¿Dónde está mi bus? [53].
Usuarios de transporte público alrededor del mundo diariamente tienen incertidumbre sobre
este sistema, por lo que los autores plantean una nueva interfaz móvil para presentar
predicciones de tránsito en celulares a partir de resultados de operaciones discretas.
Figura 22 Modelo de sistema de transporte inteligente [52].
44
El sistema planteado tiene como finalidad mostrar probabilidades y estimaciones en el
servicio de transporte público, tales como cuando llegara el siguiente bus y estimación exacta
del tiempo que tarda el bus a la parada más cercana del usuario a partir de una aproximación
probabilística que disminuye el tiempo de error en aplicaciones ya existentes, de esta forma,
se puede determinar la posibilidad que el bus realmente llegue a la parada. Para realizar estas
estimaciones se toman datos reales, medidos a través de sensores distribuidos tanto en buses
como en paraderos, con datos tomados de ecuaciones probabilísticas para no incurrir en
malas predicciones.
La aplicación presenta al usuario dos opciones para visualizar la información actualizada en
tiempo real de la ruta que escogen: Bus Time Line, que describe el comportamiento de un
bus por fila en la pantalla y, Route Time Line, que muestra una interfaz más amigable al
usuario informando acerca de la frecuencia del bus y oportunidad de paso del mismo, de tal
forma que se facilita la visualización de cuánto tarda el siguiente bus.
5.6.Sistema de seguimiento de vehículo en tiempo real utilizando GPS [54].
El sistema de posicionamiento global GPS es utilizado actualmente para el manejo de flotas
de vehículos, recuperación de carros robados, vigilancia y rastreo, por esta razón, los autores
de este artículo publicado en la Revista Internacional de Investigación Avanzada en
Electrónica e Ingeniería de Comunicaciones IJARECE, utilizan GPS para diseñar e
implementar un sistema de rastreo en tiempo real utilizando Arduino.
La metodología propuesta para este sistema utiliza un receptor GPS, un módem GSM con un
Arduino MEGA2560 que están ubicado en el vehículo; para la estación central se dispone de
un teléfono móvil que es utilizado para enviar y recibir información. A partir de esto, el
sistema de posicionamiento envía las coordenadas de longitud y latitud correspondientes a la
ubicación del vehículo al módem GSM.
El sistema consiste principalmente en la comunicación
entre el usuario y la posición del vehículo: el cliente
puede enviar un mensaje al GPS instalado en el
automóvil, por medio de una SIM card. Este modem
GSM recibe el mensaje y lo envía al Arduino en el
vehículo, que está encargado de verificar la información
de ingreso del usuario y, si está todo en orden, devuelve
al teléfono móvil del usuario la locación en coordenadas
obtenidas gracias al mapa de Google.
Figura 23 Diagrama de bloques para el sistema [54].
45
5.7.Desarrollo y pruebas de campo de un sistema interactivo de información de estaciones
de tránsito (ITSIS) utilizando tecnologías de vehículos conectados [55].
El objetivo principal de ITSIS es mejorar la información de tránsito disponible a los viajeros
durante sus viajes y habilitar operaciones en el servicio de transporte dinámicas para los
usuarios. Para esto, se propone un sistema de información en tiempo real de información de
tránsito ubicado en paraderos en la ciudad de California, Estados Unidos, utilizando
tecnologías de vehículos conectados e innovados sistemas de comunicación.
El sistema está diseñado para la interacción entre usuario (por medio de la Estación de
Información Central SIH) y servidor (por medio del equipo a bordo del bus OBE) a través
del intercambio de mensajes que incluyen:
Mensajes de preguntas interactivas de pasajeros: iniciados en el SIH o aplicación
móvil para hacer preguntas sobre el viaje, información de tránsito y para responder
sobre el servicio de tránsito por demanda.
Mensajes interactivos personalizados de pasajeros: recibidos por el servidor de
información de pasajeros interactivos para responder preguntas por medio de
mensajes personalizados.
Mensajes de seguridad básica del bus: actualizan la ubicación del bus y las
frecuencias de rutas.
Mensajes de operadores para operación dinámica: destinados a actualizar a los
conductores sobre el servicio de rutas pedido por demanda.
El hardware del sistema se compone de una
pantalla táctil de 32” con su respectiva base
para colgar, un computador, una batería y una
caja contenedora, debido a que este sistema se
implementa en un paradero de bus. Para el
software se dispone de una aplicación móvil
desarrolla en Java, una base de datos con la
información de rutas, servicios, horarios,
conductores, entre otros, un servidor para el
manejo de los mensajes entre los implicados
del servicio.
Figura 24 Vista de la aplicación ITSIS.[55]
46
6. METODOLOGÍA
Para llevar a cabo el desarrollo exitoso del prototipo, se debe dividir la realización del
proyecto en diferentes fases que comprendan cada una de las etapas de investigación, diseño,
implementación y pruebas del prototipo.
6.1. Investigación sobre las tecnologías existentes en gestión de transporte público.
Es necesario tener referencias claras sobre los avances y tecnologías utilizadas a nivel
mundial en relación a los sistemas de transporte inteligente, por lo que se realizará una
investigación profunda que abarca temas de gestión de control del tráfico, posicionamiento
GPS de vehículos y paraderos, plataformas de comunicación y visualización de la
información, recolección de datos en tiempo real a través de diversos dispositivos.
Gracias al desarrollo en la implementación de sistemas de transporte inteligentes en países
como China, Estados Unidos, España, entre otros, es posible comparar y determinar las
falencias del sistema de transporte actual en la ciudad de Bogotá, con la finalidad de encontrar
una solución tecnología y económica que satisfaga las necesidades de los usuarios de este
servicio.
6.2. Analizar y estudiar la tecnología LoRa.
Para llevar a cabo del desarrollo del proyecto se requiere del estudio de una tecnología de
comunicaciones que permitirá interconectar sensores, encargados de recolectar la
información en tiempo real de los autobuses. Por esta razón, se escogió la tecnología LoRa
en conjunto con su protocolo de comunicación correspondiente denominado LoRaWAN,
debido a su bajo consumo de potencia, largo alcance y que, gracias a la interconexión entre
módulos, permite reducir costos de despliegue: la información recolectada será subida a la
red por medio de un gateway ubicado al final de la red de sensores.
6.3. Desarrollar una red LoRa.
6.3.1. Desarrollo del Gateway.
Como se ha mencionado previamente, el gateway tiene la función principal de transmitir la
información recolectada por la red de sensores y módulos y enviarla a la red para poder ser
visualizada por los usuarios. Como esto requiere de un procesamiento amplio de datos, se
dispone de una Raspberry que en conjunto con un módulo LoRa, realizarán dicha función.
47
La Raspberry tiene por lenguaje de programación nativo Python y se necesita de un teclado,
mouse y pantalla que permitirán el desarrollo del código de manera óptima, sin embargo,
para la implementación solo se dispondrá de la tarjeta con el programa cargado en su
memoria listo para utilizar.
6.3.1.1. Funcionamiento.
Para el correcto funcionamiento de hardware del Gateway se requiere conectar la Raspberry
Pi 3 B+ con el módulo Gateway RHF0M301, con el puente PRI 2 RHF4T002 y la antena
como se muestra en la figura siguiente.
Figura 25 Conexión del Hardware.
Ahora, para configurar el software [56] que permitirá que el dispositivo se enlace con el
servidor se requiere escribir en la memoria SD de la Raspberry Pi 3B+ la imagen del sistema
operativo nativo para la misma, raspbian. Este se puede descargar de la página web de
Raspberry Pi https://www.raspberrypi.org/downloads/raspbian/.
Figura 26 Inicio de Raspberry Pi 3.
48
Luego de tener la imagen de disco funcionando en la tarjeta SD de la Raspberry Pi, se debe
configurar el puerto SPI como habilitado para que la Raspberry pueda comunicarse con
RHF0M301. Para esto, se debe ejecutar en la terminal sudo raspi-config, seleccionar la
opción _Interfacing Options_ - _P4 SPI_ - _YES_ para habilitar dicho puerto.
Figura 27 Configuración SPI en Raspberry Pi 3B+.
Cuando finalice la instalación, en la misma terminal se debe descargar un paquete que
contiene la información necesaria para que el dispositivo conectado funcione como gateway.
Este paquete se puede descargar de la página
https://github.com/SeeedDocument/LoRaWAN_Gateway-868MHz_Kit_with_ Raspberry_
Pi_3/raw/master/res/libssl1.0.0.deb.
Figura 28 Descarga de paquete por medio de comandos en terminal.
49
El siguiente paso es descargar e instalar el Gateway LORIOT, para lo que se utilizan los
siguientes comandos en la terminal de la Raspberry:
1. sudo dpkg -i ./libssl1.0.0.deb
2. wget https://cn1.loriot.io/home/gwsw/loriot-pi-3-rhf1257-SPI-0-latest.bin -O
loriot-gw
3. chmod +x loriot-gw
4. ./loriot-gw -f`
Al ejecutar el tercer comando, el gateway empieza a enlazarse con los posibles servidores
que tiene LORIOT hasta encontrar en el cual está registrado. Este proceso puede tardar hasta
5 minutos, luego de este tiempo queda enlazado con el servidor el tiempo que el gateway
permanezca encendido y conectado a la red.
Figura 29 Configuración de Gateway en la Raspberry.
Como todo este proceso requiere de componentes adicionales al gateway como lo son mouse,
teclado y pantalla, se requiere que este se enlace al servidor sin necesidad de ejecutar ningún
comando por consola, lo que se logra por medio de la implementación de un script de inicio
50
[57]. Se debe ejecutar el siguiente comando en una terminal de la Raspberry: sudo nano
/etc/init.d/inicio, este genera un documento en la ruta /etc/init.d/ llamado "inicio", dentro del
cual se coloca el código que se muestra en la siguiente figura.
Figura 30 Documento inicio para el script de arranque.
Ahora debe colocarse este script de tal forma que cada vez que la Raspberry se inicie, este se
ejecute sin necesidad de ninguna intervención por parte del usuario, para lo que se tiene:
1. Generación de script ejecutable por medio del comando sudo chmod 755
/etc/init.d/inicio.
2. Verificación del correcto funcionamiento del script utilizando el comando sudo
/etc/init.d/inicio start.
3. Activación del arranque automático con el comando sudo update-rc.d inicio
defaults.
Finalmente, se reinicia la Raspberry y se verifica que el ejecutable del gateway corre de
manera correcta sin necesidad de utilizar ninguna intervención del usuario. Para esto se
ejecuta el script ./loriot-gw -f` como si no existiera el script previamente creado nos devuelve
una advertencia que indica que este ya está ejecutándose.
51
Figura 31 Comandos para que el ejecutable de gateway inicie automáticamente.
6.3.1.2. Conexión al servidor.
La conexión al servidor del gateway se realiza mediante un aprovisionador de servicios
LoRaWAN para IoT denominado LORIOT, que permite subir la información que se recopila
a través de la red LoRa a internet.
6.3.1.2.1. Configuración de la Raspberry.
Para poder realizar el registro exitoso del gateway en LORIOT, este solicita al usuario
información de la Raspberry por lo que se ejecuta el comando ifconfig y se almacena esta
información para un uso posterior.
Figura 32 Información de la Raspberry Pi 3 por medio del comando ifconfig
52
6.3.1.2.2. Registro usuario en LORIOT.
Todos los nuevos usuarios necesitan realizar un registro en LORIOT. Para esto, se ingresa
en la página https://cn1.loriot.io/register donde se deben llenar los datos allí solicitados y este
devolverá un correo al que se registró inicialmente para completar y activar el nuevo usuario.
Figura 33 Registro nuevo usuario LORIOT.
Luego de la confirmación del correo electrónico se debe ingresar a la página web y se obtiene
un acceso de nivel predeterminado, que admite 1 puerta de enlace y 10 nodos.
Figura 34 Tablero inicial de trabajo.
53
6.3.1.2.3. Registro del Gateway en LORIOT.
En la parte inferior de la pantalla se encuentra la opción para registrar un nuevo Gateway.
Al dar clic se despliega una nueva ventana en la que se especifica cual es la plataforma base
sobre la cual se va a desarrollar el proyecto, en esta etapa se debe seleccionar Raspeberry Pi
3 como se muestra a continuación.
Figura 35 Selección de plataforma base.
Al seleccionar la plataforma, el servidor requiere de información adicional sobre el sistema
a utilizar, por lo que solicita especificar el concentrador que utiliza y el tipo de conexión que
requiere para comunicarse con la Raspberry.
Figura 36 Selección del concentrador a utilizar.
54
Adicionalmente, solicita ingresar la dirección MAC del puerto Ethernet que se obtiene desde
la consola del dispositivo por medio de un comando. Al ingresar esta clave en el campo
especificado, se generan unas claves vinculadas a esta dirección que no se pueden modificar
ni asignar a otro dispositivo.
Figura 37 Solicitud dirección MAC.
Finalmente solicita que se indique el lugar exacto en que la puerta de enlace va a estar ubicada
que permita a todos los usuarios de la red una visión razonable de cobertura. Para este caso,
se selecciona la ubicación de la sede de Ingeniería de la Universidad Distrital Francisco José
de Caldas, en la ciudad de Bogotá.
Figura 38 Ubicación física del Gateway.
Al seleccionar la opción REGISTRAR GATEWAY y si todos los pasos previos se han
seguido de manera correcta, se despliega una vista como la que se observa a continuación
que contiene información sobre el mismo como latencia, última conexión, dirección de la
MAC, entre otros, lo que asegura que el Gateway se ha registrado correctamente en el
servidor.
55
Figura 39 Registro correcto del Gateway en LORIOT.
6.3.2. Desarrollo del nodo
6.3.2.1. Comandos utilizados módulo LoRa.
Los módulos transceptores de RF LoRa RN2903 deben configurarse para transmitir y recibir
información punto a punto. Este tipo de módulos están diseñados para utilizarse con la
plataforma de Arduino, por lo que se requiere de un estudio del funcionamiento de estos
dispositivos en este sistema para poder adecuarlos y utilizarlos con un microcontrolador.
Basados en la hoja de datos que el fabricante proporciona, se obtienen unas palabras claves
seguidas de parámetros opcionales para emitir comandos al módulo. Los comandos o
palabras clave distinguen entre mayúsculas y minúsculas, y los espacios no se deben usar en
los parámetros. Los datos de entrada hexadecimales pueden ser mayúsculas o minúsculas
[32].
Existen tres categorías generales de comandos:
1. De sistema: Emite acciones de comportamiento a nivel del sistema, recopila
información de estado sobre la versión de firmware y hardware, o accede a la
memoria EEPROM del usuario del módulo. Los comandos system comienzan con
la palabra <sys> e incluyen las categorías descritas a continuación:
56
Parámetros Descripción
sys sleep Coloca en reposo el sistema durante un número finito de
milisegundos.
sys reset Resetea y reinicia el módulo LoRa RN2903
sys eraseFW
Elimina el firmware actual del módulo RN2903 y lo prepara
para una actualización de software, de esta forma el gestor de
arranque del módulo está listo para recibir el nuevo
firmware.
sys
factoryRESET
Restablece los datos de configuración del módulo RN2903 y
la EEPROM del usuario a los valores predeterminados de
fábrica y reinicia el módulo RN2903.
sys set Establece valores de parámetros del sistema especificados.
sys get Obtiene valores de parámetros del sistema especificados.
Figura 40 Especificación de comandos de sistema [32].
2. Protocolo LoRaWAN: Se encargan de todo lo relacionado con los comportamientos
de comunicación de red del protocolo LoRaWAN, acciones y comandos de
configuración. Los comandos de protocolo LoRaWAN inician con la palabra <mac>
e incluyen las siguientes categorías:
Parámetros Descripción
mac reset
Restablece el módulo RN2903 y establece los valores
predeterminados para la mayoría de los parámetros de
LoRaWAN.
mac tx Envía la cadena de datos en un número de puerto
especificado.
mac join Informa al módulo RN2903 para unirse a la red configurada.
mac save Guarda los parámetros de configuración de LoRaWAN en la
EEPROM del usuario.
mac
forceENABLE
Habilita el módulo RN2903 después de que el servidor de red
LoRaWAN haya ordenado al dispositivo final que se silencie
de inmediato.
mac pause Pausa la funcionalidad de la pila LoRaWAN para permitir la
configuración del transceptor (radio).
mac resume Restaura la funcionalidad de la pila LoRaWAN.
mac set Accede y modifica parámetros específicos relacionados con
MAC.
mac get Lee los parámetros actuales relacionados con MAC del
módulo. Figura 41 Especificación de comandos de protocolo LoRaWAN [32].
3. Comandos del Transceptor: Emite configuraciones específicas de radio, accediendo
directamente y actualizando la configuración del transceptor. Estos comandos inician
con la palabra <radio> e incluyen las siguientes categorías:
57
Parámetros Descripción
radio rx
Este comando configura la radio para recibir paquetes de
radio simples de acuerdo con los ajustes de configuración
anteriores.
radio tx
Este comando configura una transmisión de paquetes de
radio simple de acuerdo con los ajustes de configuración
anteriores.
radio cw
Este comando colocará el módulo en una transmisión de
onda continua (cw) para el ajuste del sistema o el uso de
certificación.
radio set
Este comando permite modificar la configuración de la radio
directamente. Este comando permite al usuario cambiar el
método de operación de radio dentro de los límites de banda
de tipo de módulo.
radio get Este comando otorga la capacidad de leer los ajustes de radio
tal como están configurados actualmente.
6.3.2.2. Conexión módulo RN2903 con el Gateway.
Teniendo en cuenta esto, se realiza una configuración del módulo a través de comunicación
serial con el computador utilizando Hércules que es un terminal de puerto serie útil que
proporciona a los usuarios configurar el entorno de los puertos de terminales seriales UDP y
TCP, de igual forma que permite ver formatos de archivos, habilitar macros, transferir
archivos y usar las funciones de depuración de los terminales de puerto serie [58]. Como
debe utilizarse el programa Hércules, el equipo requiere de un controlador llamado
PROLIFIC PL2303, que actualiza el controlador para los puertos COM y LPT.
Figura 42 Controlador PROLIFIC PL2303.
58
Luego que el controlador ha sido instalado, debe ingresarse al Administrador de Dispositivos
del equipo y actualizar dicho controlador como se muestra en la siguiente figura:
Figura 43 Actualización controlador de dispositivo.
Ahora que el puerto serial ha sido actualizado exitosamente, se procede a la configuración
del módulo para lo que se realizan las configuraciones mostradas a continuación que permiten
la comunicación exitosa entre el módulo y el gateway:
1. mac get deveui
Para poder enlazar el dispositivo con el gateway se necesita de conocer el EUI programado
que tiene el módulo por defecto, por lo que se requiere utilizar el comando mac get deveui
que devuelve el número hexadecimal de 8 bytes que representa el identificador de la
aplicación para el módulo.
Figura 44 EUI del módulo RN2903.
59
2. Registro del dispositivo en LORIOT
El dispositivo necesita claves e identificadores únicos, por lo que se requiere registrar el
dispositivo en el servidor para que este genere de manera automática estos indicadores
llamados NwkSKey que es la clave de sesión de red, DevAddr que indica la dirección del
dispositivo final y AppSKey que es la clave de sesión de aplicación. El registro se realiza en
la página de LORIOT dentro de la sesión activa, ingresando en Application donde se
selecciona la opción Enroll Device. Al dar clic en esta opción, se despliega una nueva
ventana en la que se debe seleccionar la opción “Generate all parameters except DevEUI” y
en el campo que indica ingresar la EUI que se obtuvo en el paso anterior.
Figura 45 Registro de dispositivo en LORIOT.
Figura 46 Generación de claves e identificadores únicos para el módulo RN2903.
60
Al dar clic en ENROLL, el servidor genera las claves descritas previamente y, para acceder
a ellas se debe ingresar a Devices, seleccionar el dispositivo creado, y en esta ventana
seleccionar la opción de LoRaWAN Parameters.
Para continuar con la configuración del módulo RN2903 se debe volver a utilizar Hércules
como terminal de envío de datos serial.
3. sys get ver:
Como se explicó anteriormente, los comando sys get obtienen valores de parámetros del
sistema específicos. Para este caso particular se utiliza el comando sys get ver que entrega
la respuesta del módulo RN2903 en un formato especial:
RN2903 X.Y.Z MMM DD YYYY HH:MM:SS
Donde X.Y.Z indica la versión del firmware, MMM es el mes, DD es el día y YYYY es el
año que se refieren al lanzamiento del firmware. Este comando devuelve la información
relacionada con la plataforma de hardware, la versión del firmware, la fecha de lanzamiento
y la marca de tiempo en la creación del firmware.
4. mac reset:
Este comando establecerá los valores predeterminados para la mayoría de los parámetros de
LoRaWAN ™. Todo lo establecido antes de este comando perderá su valor establecido, al
reinicializarse al valor predeterminado, incluida la configuración de las claves criptográficas
en 0.
5. mac set
Los comandos mac set permiten acceder y modificar parámetros específicos relacionados
con la MAC. Para la aplicación a desarrollar se necesitan:
a. mac set nwkskey 187A725A3397D388743FB83C44EA6BC3
Este comando establece la clave de sesión de red para el módulo. Esta clave tiene una
longitud de 16 bytes y debe modificarse con cada sesión entre el módulo y la red. La
clave debe permanecer igual hasta que finalice la sesión de comunicación entre
dispositivos.
b. mac set appskey 116623F5388A6565B7D08BC2F808FF28
Este comando establece la clave de sesión de la aplicación para el módulo. Esta clave
es única, con una longitud de 16 bytes y creada para cada aparición de comunicación,
cuando la red solicita una acción realizada por la aplicación.
61
c. mac set devaddr 01955D22
Este comando configura el módulo con una dirección de dispositivo de red única de
4 bytes <address>. Esta <address> DEBE ser ÚNICA a la red actual. Esto debe
configurarse directamente únicamente para la activación por dispositivos de
personalización. Este parámetro no debe establecerse antes de intentar unirse
mediante activación por aire porque se sobrescribirá una vez que finalice el proceso
de unión.
6. radio set
Estos comandos permiten al usuario cambiar el método de operación de radio dentro de los
límites de banda de tipo de módulo y como se requiere modificar el nivel de potencia de
salida utilizado por la radio durante la transmisión se utiliza el comando radio set pwr y se
asigna el valor de 20, debido a que la salida tiene un rango de potencia de 2 a 20. De esta
forma, el comando a enviar es de la forma radio set pwr 20.
7. mac save
El comando de mac save se debe emitir después de que los parámetros de configuración se
hayan ingresado correctamente desde los comandos mac set <cmd>. Este comando guardará
los parámetros de configuración del protocolo LoRaWAN en EEPROM. En el próximo
reinicio del sistema, la configuración del protocolo LoRaWAN se iniciará con los últimos
parámetros guardados. Es decir, las claves proporcionadas y la dirección única del
dispositivo se almacenan en la memoria del dispositivo y quedan almacenados hasta un nuevo
comando mac reset.
8. mac join <mode>
En este tipo de comandos se requiere especificar el tipo de procedimiento de unión que se
utiliza ya sea otaa o abp. Este comando puede responder con dos respuestas. La primera
respuesta se recibirá inmediatamente después de ingresar el comando, en caso de que el
comando sea válido (ok), se recibirá una segunda respuesta después del final del
procedimiento de unión. El comando que se envía para indicar el tipo de procedimiento de
unión que se realiza es mac join abp.
Luego que se ha configurado el módulo RN2903 con el gateway, el dispositivo queda listo
para enviar información por medio del comando mac tx. Como notación importante, es clave
tener en cuenta que para enviar estos comandos por la interfaz de Hercules se requiere que al
final de cada uno se coloque <cr><lf> para que se envíe la trama de manera correcta.
62
Figura 47 Configuración correcta de un módulo RN2903 al Gateway.
Figura 48 Conexión módulo LoRa con Hércules protocolo serial.
63
6.3.2.3.Configuración módulo RN2903 con MCU.
El nodo del proyecto cuenta con un microcontrolador NXP MC9S08AW60 que permite el
envío de las tramas requeridas de forma automática, para esto se utiliza el entorno de
desarrollo CodeWarrior Development Studio que permite escribir el código que este
microcontrolador requiere en lenguaje C.
El primer código implementado cuenta con una función tipo void llamada UART_PutString
que permite enviar caracteres por el puerto serial, una función de tipo void llamada
Config_LoRa que envía la configuración realizada previamente al módulo para que este se
enlace de manera correcta con el gateway. Finalmente, en el main del proyecto se habilitan
los registros de Tx y Rx del microcontrolador, la velocidad del envío, se habilitan las
interrupciones, se inicializa la LCD que nos permite visualizar que la información enviada
llega de manera exitosa y, se activa la configuración del módulo LoRa RN2903.
Figura 49 Código para enviar información desde el microcontrolador por el módulo LoRa.
6.3.2.4.Conexión módulo LoRa con microcontrolador y GPS.
El nodo consta de un módulo LoRa RN2903, un módulo GPS NEO 6m y un microcontrolador
para enviar información recolectada desde este a internet para que el usuario final pueda
acceder a esta información en una página web.
El módulo GPS cuenta con una serie de tramas, de las cuales únicamente se utiliza la trama
GPRMC. Por ejemplo, si la trama que se recibe es
$GPRMC,203544.000,A,0438.9198,N,07404.3962,W,0.00,247.85,150517,,,A*62 esta
recoge información de la siguiente forma [59]:
64
- 203544.000, indica la hora en coordenadas universales es decir en este caso
tendremos las 20horas, 35minutos y 44.00 segundos.
- A o V indica el estado de nuestra conexión GPS si es activa (A) o sin señal (V).
- La trama 0438.9198,N,07404.3962,W indica la ubicación en latitud y longitud. La
latitud es 4 grados y 38.9198 minutos en el hemisferio Norte, de forma similar la
longitud es 74 grados y 04.3962 minutos en el hemisferio oeste. Se debe tener en
cuenta que el formato de coordenadas que se reconocen en los mapas es en grados,
por esta razón los datos que tiene el GPS se deben convertir, es decir, los minutos a
decimales de grados, en ese sentido se divide la latitud 38.9198/60=0.648663 (dado
que un grado tiene 60minutos), y de igual forma dividiremos la longitud así
04.3962/60=0.07327, luego mediante programación se concatenaran los números
enteros con los números obtenidos luego nuestra lectura quedará:
0438.9198,N,07404.3962,W = 04.648663, -74.07327. Como la ubicación del GPS
es en el hemisferio oeste se agrega un signo menos en la coordenada.
- Los siguientes dígitos 0.00 indican la velocidad experimentada en nudos para nuestro
caso como estuvimos estáticos nos registra 0.
- Los siguientes dígitos 247.85 es un ángulo de seguimiento, útil para estimar
posiciones siguientes, y finalmente 150517,,,A*62 indica los últimos datos nos
indican la fecha en formato DD/MM/AA y la variación magnética.
Dentro del main de los códigos que se presentan a continuación, se envían unos comandos
que corresponden a configuraciones para el módulo, de esta forma:
1. mac set dr <dataRate>
Este comando establece la velocidad de datos que se utilizará para la próxima transmisión,
donde <dataRate> es un número decimal que representa la velocidad de datos, de 0 a 4, pero
dentro de los límites del rango de velocidad de datos para los canales definido.
2. mac tx <type> <portno> <data>
Este comando envía la cadena de datos en un número de puerto especificado, donde <type>
es una cadena que representa el tipo de carga útil del enlace ascendente, ya sea cnf o uncnf
(cnf - confirmado, uncnf - no confirmado); <portno> es un número decimal que representa
el número de puerto, de 1 a 223; <data> es un valor hexadecimal cuya longitud de <data>
bytes que pueden ser transmitidos dependen de la velocidad de datos establecida.
Teniendo en cuenta esto, se desarrolla el programa necesario para dos posibles alternativas:
implementación del proyecto con microcontrolador NXP MC9S08AW60 que hace el nodo
eficiente y de bajo costo y, implementación del proyecto con PSoC5LP que, aunque cumple
con las necesidades requeridas, aumenta el costo del proyecto.
65
6.3.2.4.1. Programa desarrollado para microcontrolador NXP MC9S08AW60 con
conexión a GPS y módulo LoRa.
Los módulos, tanto el GPS como el LoRa, se deben conectar al microcontrolador por medio
el puerto serial por lo que en el main del proyecto deben habilitarse estos puertos, así como
la velocidad de cada uno; se necesita escuchar lo que los módulos envían (GPS envía al
microcontrolador las tramas y el RN2903 envía confirmaciones enviadas desde el gateway)
por lo que se requiere habilitar las interrupciones para cada caso y, como se utiliza una LCD
que permite verificar el correcto funcionamiento del nodo, esta debe inicializarse.
El main contiene un for infinito que se encarga de enviar las configuraciones de tipo mac que
se describieron previamente y que permiten que la comunicación nodo – gateway sea exitosa
y, como segunda función, envía constantemente y teniendo en cuenta los tiempos de espera
la trama útil recibida por el GPS luego de un proceso de conversión que se explica más
adelante.
Figura 50 Descripción main para microcontrolador.
El uso de la LCD para conectarse con el microcontrolador requiere de un extenso proceso de
configuración para una librería que permita manipular los registros y pines necesarios para
que esta funcione de manera correcta. Para trabajos previos ya se ha configurado dicha
librería, por lo que para este caso solo se requiere inicializarla como se muestra en la imagen
anterior.
66
Figura 51 Librerías utilizadas.
Luego de definir y habilitar todo lo necesario para que el programa se ejecute de manera
correcta, se deben inicializar variables que permitan la captura, lectura, modificación y envío
de datos por los puertos seriales del microcontrolador. Para esto se define el puerto serial 1
como el asignado para el módulo GPS NEO 6M y el puerto serial 2 para el módulo LoRa
RN2903.
Figura 52 Declaración de variables programa microcontrolador.
Se definen unas funciones PutChar y PutString para los dos puertos seriales que se tienen
en funcionamiento, encargadas de enviar caracteres de tipo char y String por el mismo. Estas
funciones permiten enviar la configuración del módulo LoRa, así como el envío de los datos
recolectados por el GPS para ser mostrados al usuario final. La configuración que se realizó
para el módulo LoRa se mantiene igual que la realizada en el primer código de prueba, en la
que se envían comandos que permiten iniciar el módulo en la red de manera correcta.
Figura 53 Funciones para envío de información por el puerto serial.
67
Figura 54 Envío comandos de configuración módulo LoRa RN2903.
Surge la necesidad de crear dos interrupciones para la captura de datos recibidas por los
módulos. La primera de ellas, llamada interrupt 20 void SCI2_RX captura los datos
recibidos por el módulo LoRa y los muestra en la LDC.
Figura 55 Interrupción para el módulo LoRa.
La siguiente interrupción se encarga de leer las tramas que envía el GPS por interfaz serial al
microcontrolador, de esta forma evalúa que tipo de trama llega y escoge la trama útil, estos
se van almacenando en un vector llamado buffer_rx. Como la información que se envía por
el módulo debe estar escrita en base hexadecimal se necesita una conversión de los datos
recibidos, esta se hace dentro de la interrupción y los caracteres convertidos se almacenan en
un nuevo vector que posteriormente se envía por el módulo hacia el gateway en el for infinito
del main.
La conversión que se realiza se hace byte por byte y consiste en evaluar cada una de las
posiciones del vector buffer_rx que recibe la información completa del GPS pero, como se
vio anteriormente, esta trama contiene caracteres innecesarios para la manipulación de la
información por lo que se realiza una selección de los datos con relevancia de la trama y solo
68
estos son almacenados en el vector buffer_tx. Luego de esta separación de datos de la trama,
se toma el vector buffer_tx y se evalúa posición a posición que carácter contiene para poder
realizar la equivalencia en hexadecimal y almacenarse en el buffer_tx2 utilizando dos
posiciones, es decir, si en el buffer_tx en la posición 0 se tiene almacenado un ‘1’ luego de
la conversión, ese mismo dato va a utilizar dos posiciones en buffer_tx2 y es respectivamente
‘3’’1’.
Para que el vector se lea de manera correcta este se evalúa posición a posición, donde la
posición va cambiando utilizando un contador que incrementa a medida que la trama es
recibida por el microcontrolador, mediante una seria de funciones if else if que contienen los
caracteres equivalentes de ASCII a hexadecimal como se puede observar en la siguiente
figura.
Figura 56 Introducción para el módulo GPS.
El código completo implementado para la utilización de microcontrolador NXP
MC9S08AW60 se presenta en el anexo 1 de este documento.
6.3.2.4.2. Programa desarrollado para PSoC5LP con conexión a GPS y módulo LoRa.
Una de las principales razones por las que se implementa el código para PSoC es debido a la
facilidad que se tiene para la utilización de los puertos seriales, así como para el manejo de
la LCD. De igual forma, se tiene en cuenta que el microcontrolador que se utiliza en el
desarrollo del proyecto no es utilizado comúnmente, pero reduce considerablemente los
costos de despliegue de un proyecto con estas características, pero para futuros fines
69
académicos la implementación y extensión de este proyecto puede desarrollarse con una
herramienta tan poderosa como el PSoC.
Para la implementación del proyecto se requiere de dos módulos seriales y un módulo para
la LCD que se va a utilizar. Dentro del entorno de desarrollo del PSoC, se colocan en el
diseño del esquema los elementos que se mencionó previamente y se modifican los nombres,
de tal forma que estos tengan relación con la función a desarrollar, se generan las
interrupciones necesarias para cada elemento y se realiza la configuración inicial de cada uno
de ellos.
Figura 57 Diseño esquemático programa para PSoC.
El funcionamiento del código desarrollado para el PSoC es, en esencia, igual al
implementado para el microcontrolador. Se cuenta con una clase C donde se aloja todo el
código de la aplicación, donde se tiene un main encargado de inicializar los módulos
mostrados en la figura anterior, así como las funciones de configuración del módulo LoRa e
interrupciones. Se dispone también de un for infinito para enviar la información recibida
por el módulo GPS hacia el gateway, utilizando el módulo RN2903, luego de una serie de
conversiones.
Figura 58 Descripción main para PSoC.
70
Se cuenta con una interrupción para leer e interpretar la trama entregada por el GPS, estos
valores son almacenados en un vector que posteriormente será analizado para realizar la
conversión de sistema que requiere la tecnología LoRaWAN para el envío de información
por medio de su red. Esta conversión se realiza a medida que van llegando los datos y es
enviada al gateway dentro del for infinito, utilizando funciones que tiene incluidas el PSoC
como lo es UART_2_PutString(buffer_tx2), donde el vector buffer_tx2 contiene los datos
en el formato correcto de envío.
Figura 59 Interrupción de Rx proveniente de GPS.
Es importante resaltar que la configuración del módulo LoRa, sin importar el programa que
se utilice o la interfaz, siempre lleva la misma secuencia y los parámetros que se envían son
los mismos para que se mantenga conectado con el gateway dentro de una misma red LoRa.
71
La conversión de los datos recibidos del módulo GPS NEO 6M por el PSoC, se realiza de la
misma forma que se explica para la recepción de datos mediante microcontrolador, por lo
que esta interrupción de recepción tiene la misma finalidad.
Figura 60 Interrupción para recepción de datos desde GPS.
Para finalizar la implementación del proyecto con PSoC, se deben seleccionar los pines de
entrada y salida que van a ser empleados, como se muestra en la siguiente figura.
Figura 61 Selección de pines para PSoC5LP.
72
El código completo implementado para la utilización de PSoC5LP se presenta en el anexo 2
de este documento.
6.3.2.4.3. Diseño PCB para los elementos del nodo.
El diseño del nodo a implementar con el microcontrolador se realiza en el programa Eagle y
los esquemáticos para dicho diseño se muestran a continuación:
Figura 62 Esquema de conexión de componentes en Eagle.
Figura 63 PCB de nodo.
73
6.4.Desarrollo de aplicación web.
El destino final del prototipo a implementar son los usuarios de servicio de transporte público
en la ciudad de Bogotá, por esto, es necesario diseñar una aplicación web que muestre
información en tiempo real y verídica del estado y ubicación del bus en la ruta deseada.
Como propósito y para que la aplicación sea más entendible para los usuarios, se propone
emplear un mapa, para presentar la información de ubicación del vehículo. El programa
permite al usuario ver la ubicación del vehículo en tiempo real, conocer la cantidad de
pasajeros y la distancia a la que se encuentra.
6.4.1. Obtención de datos desde LORIOT.
El servidor que se utiliza por configuración LORIOT permita la salida de la información
recopilada por la red de sensores por medio de API de Aplicaciones, como se muestra en la
siguiente imagen, y proporciona una breve explicación de cómo se debe configurar la salida
dependiendo de la escogida. Sin embargo, no todas las aplicaciones que proporciona son
gratuitas y el costo del servicio es bastante alto, y solo permite la salida por dos de ellas al
mismo tiempo.
Para el desarrollo del proyecto se seleccionaron dos salidas: una por Amazon AWS IoT y la
otra por HTTP Push, esto debido a la falta de flexibilidad de AWS IoT para el
almacenamiento y manipulación de la información recolectada en la que no se logra llegar a
implementar una aplicación web sino hasta el almacenamiento en la base de datos no
relacional. Por otro lado, el desarrollo del proyecto por la salida de HTTP Push permite,
mediante una serie de configuraciones que se describen más adelante, mostrar la información
recolectada al usuario utilizando un mapa en una aplicación web.
Figura 64 Aplicaciones de salida de información LORIOT.
74
6.4.1.1.Salida por AWS.
Teniendo en cuenta las instrucciones que ofrece el servidor al seleccionar la salida por
Amazon AWS IoT, se requiere realizar un registro para crear una cuenta AWS para poder
ingresar a los servicios de AWS IoT.
6.4.1.1.1. Registro usuario AWS.
El registro debe realizarse en la página web
https://portal.aws.amazon.com/billing/signup#/start donde solicitan un correo electrónico,
nombre de usuario y contraseña. De manera inmediata a dar clic en CONTINUE, el registro
continua Al realizar este paso se registra una tarjeta de crédito a la que se hace un débito
automático de 1 dólar por el uso del servicio, pero se tiene un año de acceso gratis a algunas
de las soluciones de desarrollo que tiene AWS.
Figura 65 Registro usuario en AWS.
6.4.1.1.2. Registro objeto AWS IoT.
Dentro de la Consola de Administración AWS se busca el servicio de AWS IoT. Este
servicio de AWS es una plataforma que permite conectar dispositivos a servicios de AWS y
a otros dispositivos, proteger datos e interacciones, procesar y actuar sobre datos de
información de dispositivos y habilitar las aplicaciones para que interactúen con dispositivos,
aunque no estén conectados.
ASW IoT presenta una serie de funciones que pueden emplearse para el desarrollo de la
aplicación. Lo primero que debe realizarse es el registro del dispositivo que se va a utilizar,
para lo que se debe ingresar en la opción de Administración, se selecciona Objeto y en la
parte superior derecha de la ventana aparece un botón CREAR para realizar dicho registro.
75
Figura 66 AWS IoT registro de objeto.
Cuando se presiona dicho botón se despliega una ventana como la que se muestra en la figura
a continuación, en la que se debe indicar que se realiza el registro de un único objeto para
poder continuar con el proceso.
Figura 67 Creación de objetos AWS IoT.
El objeto a crearse debe tener un nombre que permita identificarlo de los demás dispositivos
que pueden crearse más adelante, por lo que se decide colocar como nombre la dirección EUI
del módulo LoRa RN2903, que como se ha mencionado previamente es exclusiva para cada
dispositivo, y que de igual forma este dispositivo se encuentra registrado con ese mismo
nombre en el servidor LORIOT.
76
Figura 68 Adición del dispositivo al registro de objetos.
El siguiente paso es crear un certificado para el objeto, sin embargo, esto no es necesario para
el dispositivo que se está registrando. Los certificados que solicita AWS protegen la
comunicación entre el dispositivo y AWS IoT mediante certificados X.509. En caso de
requerir un certificado, este puede ser generado de manera manual o guiada por AWS IoT
teniendo en cuenta la guía del desarrollador [43].
77
Figura 69 Certificado para el objeto nuevo.
Al seleccionar crear un objeto sin certificado se concluye la configuración para el dispositivo.
Figura 70 Objeto creado correctamente.
6.4.1.1.3. Configuración en LORIOT para conexión con AWS.
Teniendo en cuenta el tutorial de configuración que se encuentra en el servidor LORIOT,
luego de crear el nuevo recurso se debe seleccionar para ingresar a los atributos nuevos que
78
adquiere este dispositivo al asociarse a AWS. Se debe hacer clic en INTERACTUAR y allí
se encuentra una cadena API REST con la que se logra asociar AWS y LORIOT.
Figura 71 Interacción para asociar AWS y LORIOT.
La cadena que se obtiene tiene un formato dado como [RANDOM STRING].iot.[REGION].
amazonaws.com y consta de dos partes fundamentales para la conexión entre ambos prestadores de servicios: una cadena aleatoria y la región de AWS en la que está.
Figura 72 Cadena API REST.
AWS cuenta con un servicio web que ayuda al usuario a controlar de forma segura el acceso
a los recursos de AWS, este servicio se llama IAM. Cuando se crea por primera vez una
cuenta de AWS, se comienza con una única identidad de inicio de sesión que tiene acceso
completo a todos los servicios y recursos de AWS de la cuenta. Esta identidad recibe el
nombre de AWS de la cuenta de usuario raíz y se obtiene acceso a ella iniciando sesión con
la dirección de correo electrónico y la contraseña que utilizó para crear la cuenta, sin
embargo, los permisos que requieren ciertas aplicaciones no están incluidos en este usuario
y se requiere de otro para poder acceder.
79
Al igual que AWS IoT, IAM cuenta con una consola llamada IAM Magnement Console en
la que se pueden gestionar tanto los usuarios como los roles y los permisos de acceso que
tienen cada uno de ellos. Para poder utilizar los servicios de LORIOT en AWS se requiere
crear un nuevo usuario denominado loriot, para la que se van a generar claves de acceso para
cada usuario.
Figura 73 Crear nuevo usuario AWS.
Al seleccionar Añadir usuario, se despliega una nueva ventana en la que se ingresa el
nombre loriot y se selecciona la opción en la que se habilita un ID de clave de acceso y una
clave de acceso secreta para el SDK, la CLI y la API de AWS. Este paso es clave para lograr
un enlace exitoso con LORIOT.
Figura 74 Registro nuevo usuario IAM.
Al dar clic en siguiente se despliega la ventana para otorgar al nuevo usuario los permisos
necesarios que se requieren para acceder a los servicios de AWS IoT, por lo que debe
80
asociarse una nueva política existente llamada AWSIoTDataAccess, como se muestra en la
siguiente figura.
Figura 75 Permisos para nuevo usuario IAM.
El siguiente paso corresponde a asignar, de manera opcional, a dicho usuario una etiqueta
que lo identifique de otros usuarios, pero como no se requiere sino un único usuario se
procede a dar siguiente. Finalmente, la consola de IAM permite revisar que la información
que se registro sea la correcta y que la política asociada si sea la que se necesita antes de
completar el registro de nuevo usuario. Si todo está de forma adecuada, se procede a
presionar Crear un usuario.
Figura 76 Revisión información de nuevo usuario.
81
Debido a que el registro del nuevo usuario se realiza de manera exitosa, se generan unas
claves tanto de ID de clave de acceso como la clave de acceso secreta. Estas claves son
necesarias para realizar el registro en LORIOT.
Figura 77 Generación de claves para asociación con LORIOT.
Como ya se tienen las claves necesarias para el registro, se procede a ingresar en LORIOT
los parámetros de configuración que este solicita así:
Figura 78 Configuración el LORIOT para comunicación con AWS IoT.
Al seleccionar Añadir salida, LORIOT asigna como salida predeterminada la de AWS IoT
que se acaba de configurar y se actualiza la información allí como se explica más adelante.
82
6.4.1.1.4. Verificación de conexión a través de la sombra del objeto.
LORIOT publica la información que recoge del dispositivo en el documento “sombra del
dispositivo” en AWS IoT. La sombra de un dispositivo es un documento JSON que se utiliza
para almacenar y recuperar información del estado actual de un dispositivo, de igual forma
se puede utilizar para obtener y establecer el estado de un dispositivo a través de MQTT o
HTTP, sin tener en cuenta si el dispositivo está o no conectado a internet.
Sabiendo que la sombra del dispositivo se actualiza automáticamente luego que la conexión
entre AWS IoT y LORIOT se ha realizado de forma exitosa, se verifica que esto sea de esa
forma. Para ello, en AWS IoT se ingresa al objeto creado, y en la parte izquierda de la
pantalla se selecciona la opción Sombra, donde se encuentra un documento de sombra que
contiene información sobre el envío del mensaje y el mensaje que se envía desde el nodo
hacia el servidor.
Figura 79 Verificación Sombra del dispositivo.
83
6.4.1.1.5. Creación de regla para almacenar información en la base de datos
DynamoDB.
La información que se recopila del nodo se actualiza en la sombra del dispositivo en AWS
IoT como se indicó previamente, sin embargo, esto no es suficiente. Para que el proyecto
funcione de manera correcta se necesita recopilar dicha información en una base de datos
para su posterior manipulación, por lo que se ve la necesidad de implementar una Regla que
permite al dispositivo interactuar con los servidores del AWS, estas se analizan y las acciones
se ejecutan en función del flujo de temas MQTT.
En el tablero principal de AWS IoT se selecciona la opción Actuar donde se despliega una
ventana en la que se puede crear la nueva Regla a implementar.
Figura 80 Creación de nueva regla.
6.4.1.1.5.1. Sentencia SQL de AWS IoT.
Cuando se crea una nueva regla, el servicio de AWS solicita que se asigne un nombre, una
descripción y una instrucción de consulta de regla, es decir, de donde la nueva regla va a
tomar la información para realizar determinada acción.
Esta instrucción está definida utilizando una sintaxis similar a SQL debido a que consta de
tres tipos de cláusulas: SELECT, extrae la información que se requiere; FROM, indica el
filtro de temas de mensajes MQTT sobre el que va a extraer la información y, WHERE, una
condición opcional que agrega una lógica adicional que determina si se llevan a cabo las
acciones especificadas por una regla.
Cuando se habla de un tema MQTT se hace referencia de un tema de mensaje específico en
el cual las aplicaciones y los objetos obtengan, actualicen o eliminen la información de estado
de un objeto. Estos temas MQTT para cada objeto se encuentran dentro de la opción
Interactuar del dispositivo.
84
Figura 81 Temas MQTT.
Figura 82 Sentencia SQL utilizada para creación de regla.
Sabiendo esta información se procede a realizar el registro para crear una nueva regla que
permita manipular la información que llega a la actualización de la sombra del dispositivo a
medida que el nodo va enviando información. De la figura anterior se selecciona el tema
'$aws/things/0004A30B001B390B/shadow/update/accepted', que por medio del servicio
85
Device Shadow envía mensajes a este tema cuando se realiza correctamente una solicitud de
la sombra.
Teniendo en cuenta esto, la sentencia SQL que se escribe para que la regla actue cada vez
que recibe actualizaciones del dispositivo es SELECT * FROM
'$aws/things/0004A30B001B390B/shadow/update/accepted'.
6.4.1.1.5.2.Definición de acción a realizar.
Luego de escribir la sentencia de la cual se va a obtener la información, se debe especificar
qué acción se va a realizar cada vez que se cumpla la sentencia. En la misma ventana del
paso anterior, se encuentra una opción denominada Definir una o varias acciones, se
selecciona y se despliega una nueva ventana en la que se muestran los diferentes servicios de
los que se puede hacer uso por medio de esta regla.
Figura 83 Definir la acción a realizar.
Figura 84 Servicios disponibles de AWS IoT para la nueva regla.
86
6.4.1.1.5.3. Creación de Base de Datos no relacional DynamoDB.
Al seleccionar la opción de DynamoDB se despliega una nueva ventana en la que se pide la
configuración de la base de datos no relacional destinada a almacenar el mensaje
seleccionado del paso anterior. Como no se ha creado ningún recurso de base de datos
previamente se selecciona la opción Crear un nuevo recurso que despliega una pestaña
nueva correspondiente al servicio de AWS DynamoDB.
Figura 85 Configuración acción.
Estando en el servicio de AWS DynamoDB se da clic en la opción Crear tabla, donde se
muestra un registro como el que se presenta en la figura. El nombre de la tabla no tiene
restricciones, pero para asignar la clave principal o clave de partición se debe tener en cuenta
el dato que se desea extraer del mensaje JSON de la sombra del dispositivo.
El dato útil para el proyecto se guarda dentro del mensaje JSON con el nombre de data y
contiene la información que se envía desde el nodo hasta el gateway en una cadena con el
mensaje escrito en base hexadecimal, como el protocolo LoRaWAN lo requiere. Al dar clic
en Crear, la tabla se genera y obtiene un nombre de recurso ARN para AWS.
87
Figura 86 Creación de tabla DynamoDB.
Figura 87 Creación de tabla completado.
Ahora se indica en la configuración de la acción el recurso de DynamoDB que se ha creado,
el servicio coloca automáticamente los valores de clave de partición y tipo de clave hash,
pero el valor de clave hash debe asignarse de acuerdo a la posición que este tiene dentro del
mensaje JSON de la sombra, es decir, el mensaje “data” no se encuentra dentro del primer
corchete, sino está dentro de una secuencia de dos más lo que se expresa en JSON con puntos,
por lo que este valor seria ${state.reported.data}.
88
Figura 88 Configuración de acción de DynamoDB completa.
6.4.1.1.5.4. Verificación almacenamiento de información en la base de datos.
Luego que se ha configurado todo lo necesario para recolectar a información enviada desde
el nodo al servidor en una base de datos no relacional, se procede a verificar que la
información que almacena sea la que en realidad se envía. Para esto, se comprueba que tanto
el mensaje que sale del nodo, como el que llega al servidor y el que se almacena en la base
de datos es el mismo.
Figura 89 Base de datos DynamoDB en funcionamiento.
89
Figura 90 Información recibida en servidor LORIOT.
Casi de manera inmediata la información que transmite el nodo se almacena en la base de
datos de AWS, lo que confirma una comunicación exitosa entre la salida y el servidor. A
pesar que la información es almacenada de manera correcta, la base de datos presenta un
modelo no relacional que dificulta la comunicación entre esta y una aplicación web de
terceros para desarrollar el mapa encargado de graficar los datos recolectados, por lo que el
desarrollo del proyecto utilizando este recurso se limita al almacenamiento de la información
escrita en hexadecimal en una base de datos de DynamoDB para su posterior manipulación.
6.4.1.2. Salida por HTTP Push.
La utilización de la salida de la información mediante HTTP Push requiere de una URL
destino capaz de escuchar las solicitudes HTTP POST enviadas por el servidor en tiempo
real. Para que esto se logre de manera exitosa se necesita de un servidor HTTP configurado
correctamente en el lado del usuario, de esta forma poder asignar la URL destino en el
servidor y la salida de la información se establece como se observa en la siguiente figura.
Figura 91 Salida de información HTTP Push.
90
6.4.1.2.1. Creación de servidor en express.
El sistema operativo más usado en servidores web es Linux gracias a su capacidad de manejar
grandes cantidades de procesos, su velocidad de reacción ante posibles fallas y, lo que para
este caso es lo más importante, maneja repositorios oficiales para sus aplicaciones lo que lo
hace flexible para usar, modificar o combinar lo que se necesite para satisfacer los
requerimientos.
El servidor web que se desarrolla con Node.js utilizando NPM (Node Package Manager) y
un framework web llamado express.js desde una terminal del sistema operativo Linux [60].
Siguiendo las instrucciones que se presentan a continuación, se logra la configuración y
puesta en marcha de un servidor web propio para Lo primero que se realiza es crear una
carpeta en el home del equipo, se debe acceder a ella e inicializar el proyecto utilizando el
comando npm init¸ que pide algunos datos que no hay necesidad de modificar sino solamente
dar “enter”.
Figura 92 Creación servidor web [60].
Figura 93 Datos solicitados por comando npm init [60].
91
El comando descrito previamente genera un archivo package.json que contiene la
información que se observa en la figura y que tiene la función de controlar los paquetes que
se instalan para el desarrollo del servidor, como el paquete express.js.
Figura 94 Instalación paquete express.js [60].
Figura 95 Archivo package.json con actualización de paquete instalado [60].
Con ese paquete instalado, se procede a crear el servidor web creando el archivo ./mi-
servidor-web/index.js así:
Figura 96 Creación servidor web con express.js [60].
La línea de código más importante es app.use(express.static(__dirname + '/public/')) que
le indica al servidor que cuando un usuario haga una petición de archivos estáticos, por
ejemplo, http://localhost:300/index.html enviará como respuesta el contenido de
./public/index.html, que es la página principal del dominio al cual se accede desde Internet,
lo se ve en primer lugar a la hora de acceder a ese nombre de dominio. Para la creación de
este archivo se crea una nueva carpeta llamada public y esta se coloca el archivo con el
siguiente contenido:
92
Figura 97 Archivo index.html [60].
El servidor esta creado. Para ejecutarlo, dentro de la carpeta mi-servidor-web se ejecuta el
comando $ node index.js que devuelve un mensaje en consola y, para verificar que el
servidor listo de manera local se accede al navegador web y se coloca la URL
http://localhost:3000.
Figura 98 Mensaje obtenido por consola [60].
Figura 99 Vista en el navegador del servidor web local[60].
Figura 100 Servidor básico propio de inicio.
93
A partir de los pasos descritos y luego de la realización de un servidor de prueba, se procede
a implementar el servidor web que funcionará de forma definitiva en el proyecto y se procede
a realizar las pruebas correspondientes de funcionamiento.
6.4.1.2.2. Verificación del servidor usando Postman.
Postman surge como una extensión para Google Chorme y actualmente se encuentra nativa
para Linux, MAC y Windows, se compone de diferentes herramientas y utilidades gratuitas
que permiten realizar diferentes tareas de API REST: creación de peticiones APIs internas o
de terceros, elaboración de test para validar el comportamiento de APIs, posibilidad de crear
entornos de trabajo diferentes.
La instalación de Postman [61] requiere descargar la versión disponible para Linux desde la
página web https://www.getpostman.com/downloads/?_ga=2.50160166.1842567090.1562
544119-1047324711.1562544119 y descomprimirlo. Luego debe crearse un archivo de
escritorio con el nombre de Postman.desktop en la ubicación
~/.local/share/applications/Postman.desktop y colocar en él, el siguiente contenido:
Figura 101 Contenido archivo Postman.desktop [61].
Luego que se ha creado el archivo, la aplicación Postman se puede abrir utilizando los
lanzadores de aplicaciones o desde el ícono que aparece en el escritorio.
El objetivo principal de utilizar Postman es verificar que el servidor web que se ha creado,
aún de manera local, tiene la capacidad de responder a solicitudes POST y GET que se
direccionan a la URL asignada: http://localhost:3000.
Cuando se envía una solicitud GET al servidor local se obtiene el documento html que está
contenida allí como se observa en la figura.
94
Figura 102 Verificación por medio de solicitud GET al servidor local.
Al realizar una solicitud POST el servidor responde por medio de una cadena de texto con
información que allí se encuentra.
Figura 103 Verificación por medio de solicitud POST al servidor local.
95
6.4.1.2.3. Túneles a localhost para publicar servidor en internet.
Manteniendo el servidor de manera local no hay posibilidad de acceder a la información que
el nodo está enviando constantemente, por lo que se requiere colocar un túnel para exponer
el servidor creado en la red, para lo que se utiliza una poderosa herramienta llamada NGROK.
La instalación de esta herramienta es muy sencilla. Se debe descargar el cliente ngrok desde
la página web https://ngrok.com/download [62] y descomprimir el archivo desde la terminal
de Linux.
Figura 104 Comando para descomprimir archivo desde terminal.
Debe crearse una cuenta en la página de ngrok para obtener un token de autenticación y poder
ejecutar el siguiente comando, que genera al archivo ngrok.yml un identificador.
Figura 105 Token de autenticación.
Finalmente resta ejecutar ngrok desde la terminal de comandos como ngrok http 3000 y se
verá una imagen como la siguiente:
Figura 106 Ejecución de ngrok en terminal.
A partir de aquí se tienen disponibles 3 urls, 127.0.0.1:4040 que permite acceder a la interfaz
de NGROK para ver qué está pasando en el túnel. Las otras 2 urls apuntan a la aplicación
que se tiene en marcha utilizando el puerto 3000, una con el protocolo https y otra con el
protocolo http.
6.4.1.2.4. Conexión de LORIOT a servidor express mediante URL de NGROK.
Como se indica en la explicación de la salida de LORIOT por HTTP Push se requiere de una
url de destino capaz de recibir solicitudes POST. Esta url que se requiere se crea justo en el
paso anterior, es decir, la url que entrega ngrok debe copiarse y colocarse en la casilla de
solicitud de url de LORIOT, sin embargo, esta url cambia cada vez que se reinicia el servidor
96
por lo que debe actualizarse la salida de LORIOT cada vez que sea necesario. Se da clic en
Add Output y la información que se recibe allí por parte del nodo ahora es accesible desde
el servidor web creado.
Figura 107 Configuración salida de LORIOT por HTTP Push.
Ahora que está enlazado el servidor de LORIOT con el servidor propio que se crea, se
escucha desde express una solicitud POST enviada desde LORIOT en mensaje json que
contiene la información enviada por el nodo. En la siguiente imagen se muestra el mensaje
json recibido desde el servidor sin ningún tipo de modificación en la recepción de la trama.
Figura 108 Mensaje json recibido por solicitud POST.
97
6.4.1.2.5. Implementación de funciones js en el servidor para procesar datos escuchados
de LORIOT.
El servidor web que se implementa requiere utilizar información obtenida desde LORIOT
para poder pasar esos datos a la aplicación web donde se pueden visualizar. Sin embargo, la
información que proviene de dicho servidor está escrita en hexadecimal y se requiere enviar
las coordenadas de posicionamiento del auto al mapa en el formato de grados, por esta razón
se crea una función que realiza la conversión de la trama recibida en hexadecimal a ASCII
y, dentro del POST se crea un script que separa las variables del vector.
Figura 109 Servidor web implementado parte 1.
Figura 110 Servidor web implementado parte 3 (conversión hexadecimal a ASCII).
98
Figura 111 Servidor web implementado parte 3 (POST).
Como se ha configurado la salida de LORIOT al servidor y el código para tratar las tramas
se ha completado en el lado del servidor se procede a realizar pruebas locales, sin utilizar el
mapa para mostrar la información, y se obtienen los siguientes resultados:
Figura 112 Verificación funcionamiento del servidor sin mapa.
99
6.4.1.2.6. Creación de mapa usando Leaflet.
En la creación del servidor web se genera un archivo html que contiene la información del
cuerpo y estructura de la página web encargada de permitir la visualización de los datos
recolectados. Como se requiere mostrar dicha información en un mapa, se utiliza una
biblioteca de código abierto de JavaScript para mapas interactivos aptos para dispositivos
móviles llamada Leaflet que, adicionalmente, es muy sencilla de utilizar.
Dentro de la cabecera del archivo html creado se deben incluir las siguientes líneas de código
para que este funcione inmediatamente:
Figura 113 Líneas html para funcionamiento de Leaflet [63].
Para poder enviar al mapa las coordenadas de latitud y longitud que se obtienen desde el nodo
se requiere agregar unos atributos al mapa:
1. set.View: permite asignar al mapa de Leaflet las variables de latitud y longitud
recibidas en el servidor.
2. L.tileLayer: permite escoger y dibuja el tipo de mapa que se puede utilizar ya que en
la página https://wiki.openstreetmap.org/wiki/Tiles se encuentran las diferentes
opciones de mapas para graficar.
3. L.marker: crea un marcador para indicar la posición exacta en la que se encuentra el
nodo enviando la información y permite agregar a dicho marcador un PopUp con
información para el usuario final.
Figura 114 Archivo html para visualización de datos en mapa de Leaflet.
100
Finalmente, la información recolectada por toda la red LoRa puede verse en el siguiente
mapa:
Figura 115 Mapa con posición actual de nodo en estado estático.
6.5.Verificación del prototipo.
El desarrollo del prototipo cuenta con una serie de etapas que permiten ir verificando el
correcto funcionamiento de los dispositivos y su respectivo enlace con la red. Teniendo en
cuenta esto, la verificación del prototipo no es una última fase sino es transversal a la
implementación de cada etapa de diseño.
6.5.1. Verificación de funcionamiento por medio de prototipos de prueba.
Antes de imprimir el PCB con el esquema final, se ve la necesidad de realizar pruebas con el
nodo completamente funcional en protoboard con el microcontrolador NXP MC9S08AW60
como con el PSoC5LP con la finalidad de establecer el funcionamiento exitoso del prototipo.
Se debe tener en cuenta que para el desarrollo de esta etapa el gateway que se configura
inicialmente debe permanecer encendido y tener línea de vista directa con el nodo.
La primera prueba que se realiza se hace con el prototipo del nodo completo implementado
en PSoC y consiste en la verificar que la información que se envía desde el nodo llega de
manera correcta hasta el servidor LORIOT. Esta primera prueba se realiza de manera local,
es decir, dentro de las instalaciones de un recinto cerrado de tal forma que las interferencias
101
de señal que pudieran presentarse o el rango de alcance de las antenas no afecta el resultado
de las pruebas.
En la siguiente imagen se observa la conexión física que se realiza para esta prueba de
funcionamiento: se utiliza una placa de desarrollo para colocar el PSoC debido a que ella
tiene conectados los pines para utilizar la LCD sin necesidad de realizar cableados punto a
punto, así como la posibilidad de ubicar los módulos de GPS y LoRa directamente sobre la
placa.
Figura 116 Implementación prototipo de pruebas con PSoC5LP.
Como el proyecto decide realizarse con el microcontrolador, es necesario realizar una
implementación similar con este dispositivo. Para ello se hace uso de una protoboard y
jumpers para realizar las conexiones necesarias desde el microcontrolador hacia el GPS, el
módulo LoRa y la LCD.
En la siguiente imagen se observa el prototipo de prueba en el que se realiza la verificación
de conexión exitosa entre el nodo, el gateway y la página web. Con este prototipo, se realiza
una prueba de alcance ubicando el gateway en la parte superior externa de una casa y el nodo
en el interior de un vehículo que se desplaza en línea recta sobre una calle residencial, como
se observa en las siguientes figuras.
102
Figura 117 Implementación prototipo de pruebas con microcontrolador M9SC08AW60.
Figura 118 Gateway ubicado para pruebas.
Figura 119 Nodo para pruebas en vehículo.
103
Figura 120 Alcance inicial de comunicación.
En la realización de esta prueba se utiliza una calle en línea recta, y manteniendo
comunicación exitosa se obtiene un alcance de 190 metros. Sin embargo, debido a la
inestabilidad del circuito y la cantidad de cables que se encuentran al aire, se decide
implementar una tarjeta PCB que contenga todos los elementos del nodo para verificar si se
puede lograr un alcance mayor.
6.5.2. Verificación de funcionamiento utilizando prototipo final.
El nodo es un dispositivo que debe ir ubicado en el vehículo y como este se encuentra en
constante movimiento se hace el diseño del PCB tal como se observa en la siguiente figura.
Figura 121 Tarjeta final implementada para el nodo.
104
Con el nodo funcionando en la tarjeta diseñada, se realizan pruebas de todo el proyecto. Debe
encenderse el gateway, el nodo, el servidor y se genera la url para el túnel por medio de
ngrok. Esta url se debe asignar en la salida de LORIOT y empiezan a llegar al servidor los
datos obtenidos por el GPS y son graficados en el mapa. Este proceso se muestra a
continuación con imágenes tomadas del funcionamiento del proyecto.
Figura 122 Configuración salida de LORIOT con url generada en ngrok.
Figura 123 Datos recibidos en el servidor de express.
105
Figura 124 Verificación de trama enviada a LORIOT.
Figura 125 Mapa de visualización con datos reales obtenidos desde el nodo.
Finalmente, se realiza una prueba de campo sobre una sección de la Autopista Sur debido al
rango de línea directa que tiene el nodo con el gateway con el fin de verificar el alcance que
tienen estas antenas y se encuentra que la distancia máxima en la que los dos dispositivos
tienen conexión es de 500 metros. Esta se realiza ubicando el gateway en un punto fijo,
compartiendo internet por medio de un dispositivo móvil, y el nodo en el vehículo realizando
el desplazamiento sobre la Autopista Sur en sentido norte – sur.
106
Figura 126 Prueba final de alcance de la red LoRa implementada.
107
7. ANÁLISIS DE RESULTADOS
Después de haberse realizado el análisis y estudio de los sistemas de transporte inteligentes
alrededor del mundo, se comparan diferentes alternativas de posibles desarrollos de redes de
sensores para la captura y manipulación de información desde estos vehículos, con lo que se
observan grandes desarrollos tecnológicos que hacen de estos sistemas de transporte todo un
éxito, razón por la cual se plantea un prototipo con tecnología LoRa para medir la posición
del vehículo en la ciudad de Bogotá.
A partir de esto, se realiza todo un diseño tanto de software como de hardware. Para
comenzar, el gateway está compuesto de una serie de dispositivos que lo hacen altamente
eficiente para trabajar con tecnología LoRa pero el fabricante de este dispositivo cierra la
posibilidad de utilizar otro tipo de servidor diferente a LORIOT para almacenar la
información, esto debido a que no se tiene acceso al código fuente con el que este es
programado y al activarse, este se enlaza directamente con este servidor.
LORIOT, a pesar de ser una plataforma diseñada a trabajar con tecnología IoT, tiene poca
especificación sobre las instrucciones para lograr capturar los datos que allí llegan desde un
servidor de aplicación, lo que genera dificultades y retrasos en el desarrollo del proyecto. Así
mismo, las salidas de información no son todas de acceso gratuito y, las que tienen esta
característica, no tienen especificaciones de uso.
Como se menciona anteriormente, se utiliza la salida de LORIOT otorgada para AWS que
presta una gran cantidad de servicios para todo tipo de aplicaciones, en especial se usa para
el proyecto un servicio destinado exclusivamente para aplicaciones de IoT, llamado AWS
IoT. Durante la configuración de la captura de datos desde LORIOT a este servicio se
presentan varias complicaciones con respecto a la manipulación de los datos que se alojan en
la sombra del dispositivo creado, esto debido al lenguaje de programación que se utiliza y la
falta de información concisa sobre como extraerse y almacenarse en una base de datos, que
queda a disposición para futuros proyectos.
Adicionalmente, el servicio no es completamente gratuito. Para este caso hubo la necesidad
de registrar un medio de pago, aunque lo que se utiliza no genera cobro, se limita bastante
los servicios de AWS IoT a los que se puede acceder. Por esta razón, se utiliza una base de
datos no relacional de DynamoDB que presenta el inconveniente de no poderse utilizar en
una aplicación web de terceros ni se puede modificar la información que allí se almacena,
por lo que el desarrollo del proyecto utilizando este servicio se ve limitada hasta ese paso.
108
Al no encontrar solución práctica y eficiente por la salida de LORIOT escogida previamente,
se decide indagar sobre otras posibilidades para capturar los datos que tenemos almacenados
en ese servidor. La salida de HTTP Push es la más conveniente para este caso debido a que
permite que los datos que tenemos ahí se puedan almacenar en un servidor web propio y se
puedan manipular, esto porque dicha información está en formato hexadecimal como el
protocolo LoRaWAN lo exige.
Para la implementación del servidor web propio se ve la necesidad de tener en el computador
destinado a almacenarlo el sistema operativo Linux que facilita la creación y manipulación
de los datos obtenidos. Sin embargo, como se debe crear un túnel que conecte este servidor
local con la red de Internet se utiliza ngrok que genera cada vez que el servidor se ejecuta, es
decir, cada vez que este se apaga y vuelve a iniciar, una nueva url que publica el servidor en
Internet. Esto implica que debe actualizarse la salida de LORIOT con la url generada por
ngrok cada vez que el servidor se cierra, pero una vez realizado este proceso, la información
es procesada correctamente y se puede visualizar en un mapa hospedado en la dirección url
otorgada.
Ahora se habla un poco del hardware. Los módulos LoRa RN2903 contienen la pila de
protocolo LoRaWAN necesaria para que estos puedan enlazarse entre sí y con un gateway,
así que deben actualizarse unos parámetros que el usuario define para la red a utilizar.
El GPS NEO 6M es un dispositivo bastante preciso y eficiente en la entrega de información,
sin embargo, el tiempo de establecimiento de este con los satélites esta entre 3 y 5 minutos,
lo que genera retrasos y datos erróneos tan pronto el nodo es conectado a la red. Luego de
este tiempo, este dispositivo entrega información verídica en tiempo real al servidor y esta se
actualiza en la página web.
Finalmente, cuando se realizan las pruebas de alcance máximo de conexión se observa que
las antenas que se tienen en el momento no tienen la suficiente potencia cubrir un área más
extensa y que adicionalmente necesitan estar con línea de vista directa.
109
8. CONCLUSIONES
En la actualidad debido al auge de las diferentes tecnologías de la información se hace
necesario sistemas de recolección y gestión de datos del transporte público en las ciudades,
es por esto que se deciden explorar nuevas tecnologías alternativas al uso de wifi que es la
tecnología más común, y se decide incursionar en el uso de la tecnología LoRa usando el
protocolo LoRaWan, con el cual se logra un largo alcance usando un mínimo de energía en
cada trasmisión, contando con la gran ventaja sobre otros sistemas de qué LoRa opera en
banda libre de 915Mhz, por lo tanto no se deben suscribir contratos de uso del radio espectro.
Tomando este modelo y adaptándolo al uso en la gestión del transporte público, se ubica un
nodo sensor en el vehículo a monitorear en el cual se integró un GPS y otros periféricos
secundarios que se encargaron de recolectar la información del vehículo y enviarla al
Gateway LoRa más cercano, que se encarga de subir esta información a internet y de
gestionarla a través del uso de servidores. Explorando las diferentes alternativas de
servidores disponibles se optó por usar software libre y emplear los recursos de Express
server basado en NodeJS implementado en Linux, al mismo tiempo que se usaron los
servicios de geo visualización de Leaflet disponibles también de forma gratuita.
Con el desarrollo de este proyecto se logra observar que la tecnología LoRa tiene una muy
buena cobertura a pesar de que presenta un ancho de banda muy reducido (de 11 bytes a 242
bytes maximo), suficientes para su uso en aplicaciones de IoT que demanden una baja tasa
de datos. Debido a la estructura del protocolo LoRaWAN para este tipo de proyectos, se hace
necesario el uso de un Gateway multicanal, debido a que el protocolo LoRaWan en cada
transmisión cambia de canal, de factor de propagación y de otros parámetros de transmisión
lo que provocaría que en un Gateway single-channel se pierdan alrededor del 90% de los
datos.
El Gateway utilizado de Seed Studio para Raspberry Pi 3b+ presenta limitaciones en cuanto
a la cantidad de nodos que se pueden enlazar a él, esta cantidad está limitada a 10 nodos, lo
que hace a este Gateway un dispositivo perfecto para pruebas académicas y test de proyectos
en curso, pero lo hace ineficiente para usos profesionales, al igual que el servidor de red que
tiene integrado “LORIOT” tiene la misma limitación de solo permitir el registro de un
Gateway por cuenta y de 10 nodos por Gateway al igual que presenta limitaciones en la
documentación de cómo se deben configurar las salidas del servidor LORIOT a otro tipo de
servicio.
110
El GPS utilizado presento un muy buen desempeño con una fácil configuración a través de
la interpretación de las tramas NMEA logrando una precisión de alrededor de 2 metros en
línea de vista con el satélite y de 5 metros dentro de construcciones de no más de 10 pisos.
En cuanto a la fase final del servidor de aplicación el uso de Express presentó excelentes
prestaciones en cuanto a eficiencia del servicio y facilidad de configuración ya que integra
JavaScript a través de NodeJS lo que facilita su integración Web, junto con el uso de la
herramienta ngrok que permite publicar el servidor en internet con el fin de realizar pruebas
sin necesidad de suscribir servicios privados de dominio. Así mismo, al utilizar este tipo de
herramientas es posible presentar un código más ordenado, preciso y comprensible para
modificaciones y mejoras a futuro.
Un aspecto fuerte de esta implementación es la cobertura que tiene al tratar de entrar en
muchos aspectos de la ingeniería, desde el diseño de base de datos, diseño de servidor y
diseño de software y de hardware.
111
9. REFERENCIAS
[1] Cabrera, D.R. “Hacia un marco de referencia para la generación de ventajas competitivas
sostenibles en los Sistemas Integrados de Transporte Público –SITP en Colombia. Aporte de
las capacidades dinámicas de innovación.” Dyna, vol. 84, núm. 200, marzo, 2017, pp. 169-
175. Universidad Nacional de Colombia. 2017.
[2] “Información General SITP”. [En línea] Tomado de:
http://www.sitp.gov.co/Publicaciones/el_ sistema/informacion_general. 2018.
[3] “Informe de Uso Global de Transporte Público.” [En línea] Tomado de:
https://docs.wixstatic.com/ugd/658d28_dcbbaa3eecfc40e694a79865896ef82d.pdf. 2016.
[4] Tecnología LoRa. [En línea] Tomado de: http://lorawan.es/
[5] Naranjo, J.T. “Inseguridad en el sistema de transporte público en Bogotá.” [En línea]
Tomado de:
https://repository.unimilitar.edu.co/bitstream/10654/16991/1/NaranjoFontalvoJosedelTransi
to2017.pdf. 2017.
[6] LoRa Transeivers. [En línea] Tomado de: https://www.semtech.com/products/wireless-
rf/lora-transceivers
[7] Sayeg, P. Charles P. “Sistemas de transporte inteligentes”. Medio Ambiente e
Infraestructura, división 44, proyecto sectorial: “Servicio de asesoría en Política de
Transporte”. Ministerio Federal de Cooperación Económica y Desarrollo de Alemania.
2013.
[8] Quintero, J. Prieto, L. “Sistemas inteligentes de transporte y nuevas tecnologías en el
control y administración del transporte.” Puente Revista Científica. Universidad Pontificia
Bolivariana. 2015.
[9] Gregor D. “Desarrollo de un sistema Middleware de ontologías cooperativas aplicado a
sistemas embebidos de transportes inteligentes.” Escuela Técnica Superior de Ingenieros.
Universidad de Sevilla. 2013.
[10] ETSI Technical Committee. “Intelligent Transportation System”. [En línea] Tomado de:
https://www.etsi.org/. 2014.
[11] Rojas, E. Cuadrado, J. “Gobernar las metrópolis.” Banco Interamericano de Desarrollo.
Universidad de Alcalá de Henares. [En línea] Tomado de:
http://cendoc.esan.edu.pe/fulltext/e-documents/BID/gobernarmetropolis.pdf#page=405.
[12] Javato, M. “Estudio de los Sistemas Inteligentes de Transporte”. Escuela de Ingenierías
Industriales. Universidad de Valladolid. 2015.
[13] Arquitectura ITS. [En línea] Tomado de: https://rno-its.piarc.org/es/sistemas-y-
estandares/arquitectura-its
[14] Russomano, D. “Arquitectura ITS.” [En línea] Tomado de:
http://www.itsargentina.org/pdf/megaciudades.pdf
112
[15] Soluciones inteligentes para el tráfico de hoy y mañana. Siemens España. [En línea]
Tomado de:
https://w5.siemens.com/spain/web/es/ic/logistica/aeropuertos_correos_trafico/trafico/pages/
default.aspx.
[16] Comunidad de Madrid. “Tecnología LED en los semáforos de la comunidad de
Madrid.” Capítulo 9. 2014.
[17] “¿Qué es una red de sensores inalámbricos?”. National Instruments. [En línea] Tomado
de: http://www.ni.com/white-paper/7142/es/
[18] Gómez, G. “Diseño y fabricación de capa de comunicaciones basada en LoRa para
plataforma modular de redes de sensores inalámbricos”. Universidad Politécnica de Madrid.
Ingeniería en Tecnologías Industriales. Especialidad Automática – Electrónica. 2017.
[19] Martínez, R. “Retos tecnológicos en IoT en el ámbito de las Redes de Sensores.”
Universidad Politécnica de Cartagena. [En línea] Tomado de:
http://repositorio.upct.es/bitstream/handle/10317/6039/rmc.pdf?sequence=1&isAllowed=y.
2016.
[20] Miorandi, D., Sicari, S., De Pellegrini, F., Chlamtac, I. "Internet of things: Vision,
applications and research challenges," Ad Hoc Networks pp. 1497–1516. 2012.
[21] Cruz, M. Oliete, P. Morales, C. González, C. “Las tecnologías IoT dentro de la industria
conectada 4.0.” [En línea] Tomado de: http://a.eoi.es/industria4. Madrid, España. 2015.
[22] Agustin, A. Yi, J. Clausen, T. Townsley, W. “A Study of LoRa: Long Range & Low
Power Networks for the Internet of Things.” MDPI. [En línea] Tomado de:
www.mdpi.com/journal/sensors. 2016.
[23] Bor, M. Vidler, J. Roedig, U. “LoRa for the Internet of Things.” Departamento de
Computación y Comunicaciones. Universidad de Lancaster. 2016.
[24] Ávila, P. “Evaluación del Rango de Transmisión de LoRa para Redes de Sensores
Inalámbricas con LoRaWAN en Ambientes Forestales.” Facultad de Ingeniería. Universidad
de Cuenca. 2017.
[25] Vangelista, L. Zanella, A. Zorzi, M. “Long – range IoT technologies: the dawn of
LoRa.” Proceedings of the 1st EAI International Conference of Future. Macedonia. 2015.
[26] “LoRaWANTM" Specification v1.0, LoRa Alliance, Inc. California.2015.
[27] Pérez, R. “Evaluación de LoRa/LoRaWAN para escenarios de Smart City.” [En línea]
Tomado de: https://upcommons.upc.edu/bitstream/handle/2117/100922/memo-
ria.pdf?sequence=1&isAllowed=y. 2017.
[28] Moya, M. “Evaluación de pasarela LoRa/LoRaWAN en entornos urbanos.”
Departamento de Comunicaciones. Universidad Politécnica de Valencia. 2018.
[29] Cancio, A. “Diseño, desarrollo y prototipado de un Gateway M2M multiprotocolo para
aplicaciones IoT.” Universidad Abierta de Cataluña. [En línea] Tomado de:
http://openaccess.uoc.edu/webapps/o2/bitstream/10609/81087/8/acancioTFG0618memoria.
pdf. 2018.
113
[30] “Haciendo IoT con LoRa: Tipos y Clases de Nodos.” [En línea] Tomado de:
https://medium.com/beelan/haciendo-iot-con-lora-capitulo-2-tipos-y-clases-de-nodos-3856-
aba0e5be. 2018.
[31] “Sistemas Embebidos. Controladores industriales de diseño de alto nivel.”
Departamento de Ingeniería Eléctrica, Electrónica y Control. [En línea] Tomado de:
http://www.ieec.uned.es/investigacion/Dipseil/PAC/archivos/Informacion_de_referencia_I
SE5_3_1.pdf. 2017.
[32] Microchip RN2903. [En línea] Tomado de:
http://ww1.microchip.com/downloads/en/DeviceDoc/50002390E.pdf
[33] Modulo transceptor de RF RN2903. [En línea] Tomado de:
https://www.digikey.com/es/product-highlight/m/microchip-technology/rn2903-rf-
transceiver-module.
[34] Gateway. [En línea] Tomado de: https://www.puertadeenlace.com/faq/general/46-que-
es-una-puerta-de-enlace-gateway.
[35] Hoja de datos Raspberry Pi 3. [En línea] Tomado de:
https://static.raspberrypi.org/files/product-briefs/Raspberry-Pi-Model-Bplus-Product-
Brief.pdf
[36] Raspberry Pi 3. [En línea] Tomado de: https://www.raspberrypi.org/products/raspberry-
pi-3-model-b/.
[37] Hoja de datos Microcontrolador MC9S08AW60. [En línea] Tomado de: freescale.com.
2006.
[38] Hoja de Datos Módulo GPS NEO 6M. [En línea] Tomado de: https://www.u-
blox.com/sites/default/files/products/documents/NEO-6_DataSheet_%28GPS.G6-HW-
09005%29.pdf
[39] “Adquisición y Procesado de Información de Posicionamiento GPS mediante
Dispositivo Electrónico basado en Arduino.” Universidad Politécnica de Valencia. Máster
en Ingeniería Mecatrónica. [En línea] Tomado de:
https://riunet.upv.es/bitstream/handle/10251/88976/ALAMBIAGA%20-%20Adquisici%C3
%B3n%20y%20procesado%20de%20informaci%C3%B3n%20de%20posicionamiento%20
GPS%20mediante%20dispositivo%20in....pdf?sequence=1. 2017.
[40] Aplicación Web. [En línea] Tomado de: https://edu.gcfglobal.org/es/informatica-
basica/que-son-las-aplicaciones-web/1/
[41] Servidor LORIOT. [En línea] Tomado de:
https://www.iotglobalnetwork.com/companies/single/id/492/loriot-io
[42] ¿Qué es AWS? [En línea] Tomado de: https://aws.amazon.com/es/about-aws/
[43] ¿Qué es AWS IoT? [En línea] Tomado de:
https://docs.aws.amazon.com/es_es/iot/latest/developerguide/what-is-aws-iot.html
114
[44] ¿Qué es Amazon DynamoDB? [En línea] Tomado de:
https://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/Introduction.h
tml
[45] ¿Qué son las APIs REST? [En línea] Tomado de: https://tech.tribalyte.eu/blog-que-es-
una-api-rest
[46] ¿Qué son Express y Node? [En línea] Tomado de:
https://developer.mozilla.org/es/docs/Learn/Server-side/Express_Nodejs/Introduction
[47] Túneles locales. [En línea] Tomado de: https://ngrok.com/docs#getting-started-expose
[48] ¿Qué es Leaflet y cómo usarlo? [En línea] Tomado de:
https://www.blogsig.com/2018/04/que-es-leaflet-y-como-usarlo.html
[49] Joseph, C. Ayyappan, A. Aswini, A. Bharathy, B. “GPS/GSM based bus tracking system
(BTS).” Revista Internacional de Investigación de Ciencia e Ingeniería, Volumen 4, Edición
12. [En línea] Tomado de: http://www.ijser.org. Diciembre 2013.
[50] Sarday, Y. Deshmukh, P. Mandlik, P. Shelar, S. Nerkar, M. “A mobile application for
bus information system and location tracking using client – server technology.” Revista
Internacional de Tecnología Emergente e Ingeniería Avanzada, Volumen 4, Edición 4. [En
línea] Tomado de: www.ijetae.com. Abril 2014.
[51] Farkas, K. Zsolt, A. Tomás, T. Szabó, R. “Participatory sensing based real – time public
transport information service.” IEEE. Conferencia Internacional de Sistemas Informáticos
Distribuidos. 2014.
[52] Lin, J. Yu, W. Yang, X. Yang, Q. Fu, X. Zhao, W. “A novel dynamic en – route
decision real – time route guidance scheme in intelligent transportation system.” IEEE. 35°
Conferencia Internacional sobre Sistemas Computacionales Distribuidos. 2015.
[53] Kay, M. Kola, T. Hullman, J. Munson, S. “When is my bus? User – centered
visualizations of uncertainly in everyday, mobile predictive systems.” [En línea] Tomado de:
http://dx.doi.org/10.1145/2858036.2858558. Mayo 2016.
[54] Alshamisi, H. Këpuska, V. “Real time GPS vehicle tracking system.” Revista
Internacional de Investigación Avanzada en Electrónica e Ingeniería de Comunicaciones
IJARECE, Volumen 6, Edición 3. Marzo 2017.
[55] Meng, H. Tsa, J. Zhow, K. Picar, J. Mizuno, B. Zhang, W. “Development and field
testing of an interactive transit station information system (ITSIS) using connected vehicle
technologies.” División de Investigación e Innovación. Departamento de Transporte de
California, Estados Unidos. 2018.
[56] Configuración instalación de paquetes y sistema operativo para Gateway LoRa. [En
línea] Tomado de: https://forum.seeedstudio.com/viewtopic.php?f=37&t=8050&sid=e4a22
f8d69fc71f1f7aa92c499c3b93b. Foro del fabricante.
[57] ¿Cómo ejecutar un script al iniciar nuestra Raspberry? [En línea] Tomado de:
https://www.spainlabs.com/foros/tema-TUTORIAL-Como-ejecutar-scripts-al-iniciar-
nuestra-Raspberry.
115
[58] Hercules SETUP. [En línea] Tomado de: https://www.filecroco.
https://www.filecroco.com/download-hercules-setup/com/download-hercules-setup/.
[59] Interpretación trama GNRMC. [En línea] Tomado de:
https://www.sigmaelectronica.net/trama-gps/
[60] ¿Cómo crear un servidor web con Node.js? [En línea] Tomado de:
https://www.pensemosweb.com/como-crear-servidor-web-5-minutos-nodejs/
[61] Centro de Aprendizaje Postman. [En línea] Tomado de: https://learning.getpostman.
com/docs/postman/launching_postman/installation_and_updates.
[62] ngrok. [En línea] Tomado de: https://ngrok.com/download
[63] Leaflet. [En línea] Tomado de: https://leafletjs.com/download.html
116
10. ANEXOS
ANEXO 1. Código completo implementado para la utilización de microcontrolador
NXP MC9S08AW60.
#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "math.h"
#include "LCD8bits.h" // libreria lcd 16x2 a 8 bits
#include "stdio.h"
#include "stdlib.h"
#define DisableWatchdog SOPT = 0 //Desactiva Watchdog
#define SetStackPointer asm("LDHX #0x870"); asm("TXS") //Reubica el
apuntador de pila al final de la RAM
#define LED PTCD_PTCD4 // se nombra el bit 4 del puerto c como led
int cont, cont1, cont2, cont3;
int x,dato,a,flag1, x2,a2;
char buffer_rx[70]; // buffer de recepcion del puerto serial 1 "GPS"
char buffer_rx2[70]; // buffer de recepcion del puerto serial 2 "LORA"
char buffer_tx[70]; // buffer de transmision en ascii del puerto serial
1 "GPS" ... toca pasa
char buffer_tx2[170]; // buffer con el vector del gps en hexadecimal
char out_int_rx[5]; // buffer auxiliar para quitar bandera de
interrupcion
void UART_PutChar(int x){
while(SCI1S1_TDRE ==0);
SCI1D = (char)x;
while(SCI1S1_TC==0);
}
void UART_PutString(char string[]){
cont2 =0;
while(string[cont]!=(char)0){
while(SCI1S1_TDRE ==0);
SCI1D = string[cont];
cont++;
while(SCI1S1_TC==0);
}
}
void UART2_PutString(char string2[]){
cont2 =0;
while(string2[cont2]!=(char)0){
while(SCI2S1_TDRE ==0);
SCI2D = string2[cont2];
cont2++;
while(SCI2S1_TC==0);
}
}
117
void UART2_PutChar(int x2){
while(SCI2S1_TDRE ==0);
SCI2D = (char)x2;
while(SCI2S1_TC==0);
}
void Config_Lora (void){
UART2_PutString("sys get ver\r\n");
tempo_ms(5000);
UART2_PutString("sys get ver\r\n");
tempo_ms(5000);
UART2_PutString("mac reset\r\n");
tempo_ms(5000);
UART2_PutString("mac set nwkskey
187A725A3397D388743FB83C44EA6BC3\r\n");
tempo_ms(5000);
UART2_PutString("mac set appskey
116623F5388A6565B7D08BC2F808FF28\r\n");
tempo_ms(5000);
UART2_PutString("mac set devaddr 01955D22\r\n");
tempo_ms(5000);
UART2_PutString("radio set pwr 20\r\n");
tempo_ms(5000);
UART2_PutString("mac save\r\n");
tempo_ms(5000);
UART2_PutString("mac join abp\r\n");
tempo_ms(5000);
}
void main(void) {
DisableWatchdog; // Desactiva el watchdog
SetStackPointer; // Reubica el apuntador de pila al final de esta
SCI2BD = 4; // velocidad a 57600 baudios del puerto serial 2
SCI1BD = 26; // velocidad a 9600 baudios del puerto serial 1
SCI1C2_TE = 0x01U; // habilita Tx del puerto serial 1
SCI1C2_RE = 0x01U; // habilita Rx del puerto serial 1
SCI2C2_TE = 0x01U; // habilita Tx del puerto serial 2
SCI2C2_RE = 0x01U; // habilita Rx de lpuerto serial 2
PTCDD=0b00010000; // se declaran el primer bit del puerto C como
salida
SCI1C2_RIE = 1; // habilita interrupcion por Rx del puerto serial
1
SCI2C2_RIE = 1; // habilita interrupcion por Rx del puerto serial
2
EnableInterrupts; //habilita interrupciones
init_lcd(0); // inicializa lcd
Config_Lora(); // envia comandos de configuracion del modulo LoRa
118
for(;;) {
UART2_PutString("mac set dr 2\r\n");
tempo_ms(1000);
UART2_PutString("mac tx cnf 1 ");
UART2_PutString(buffer_tx2);
UART2_PutString("\r\n");
tempo_ms(50000);
}
}
interrupt 20 void SCI2_RX(void){
while(SCI2S1_RDRF ==0);
if(SCI2D!='\n'){ // si el caracter recibido es
diferente de \n entonces guarda en el vector
buffer_rx2[cont3]= SCI2D;
cont3++;
}else if (SCI2D == '\n'){ // si el caracter
recibido es \n termina el vector reinicia
cont3 = 0; // contador de
posision en el vector y muestra en la lcd la trama recibida
efface_lcd();
xy_lcd(1,1);
efface_lcd();
aff_txt(buffer_rx2);
out_int_rx[2]= SCI2S1;
for(a2=0; a2<70; a2++){
buffer_rx2[a2]= '\0';
}
}
}
interrupt 17 void SCI_RX(void){
while(SCI1S1_RDRF ==0);
if(SCI1D!='$'){ // pregunta si hay un
inicio de trama nmea
if(SCI1D== 'R'){ // pregunta por una
trama en especifico GPRMC solo esta contiene R
for(a=0; a<60; a++){
buffer_rx[a]= '\0'; //
borra buffer de rx
}
flag1 = 1; // activa bandera de
llenado de buffer
}
if(flag1 == 1){ // pregunta si flag1 esta
activa para poder llenar
if(cont1 < 48){
buffer_rx[cont1] = SCI1D; // llena
el buffer de rx con los caracteres q va recibiendo
if(cont1 >= 4 && cont1 <= 9){
119
buffer_tx[cont1-4] =
buffer_rx[cont1]; // pasa el buffer de rx al de tx omitiendo caracteres
innecesarios
}else if (cont1 > 12){
buffer_tx[cont1-7] =
buffer_rx[cont1]; // continua seleccionando cararcteres innecesarios
}
/////////////////////
/*INICIA LA CONVERSION DEL
BUFFER DE TX EN ASCII A UN BUFFER DE TX2 EN HEXA*/
if(buffer_tx[cont1]=='R'){
/////// R
buffer_tx2[cont1+cont1]=
'5';
buffer_tx2[cont1+cont1+1]= '2';
}else
if(buffer_tx[cont1]=='M'){//// M
buffer_tx2[cont1+cont1]= '4';
buffer_tx2[cont1+cont1+1]= 'D';
}else
if(buffer_tx[cont1]=='C'){ ////// C
buffer_tx2[cont1+cont1]= '4';
buffer_tx2[cont1+cont1+1]= '3';
}else
if(buffer_tx[cont1]=='0'){ ////// 0
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '0';
}else
if(buffer_tx[cont1]=='1'){ /////// 1
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '1';
}else
if(buffer_tx[cont1]=='2'){ /////// 2
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '2';
}else
if(buffer_tx[cont1]=='3'){ ///////·3
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '3';
}else
if(buffer_tx[cont1]=='4'){ ///////·4
120
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '4';
}else
if(buffer_tx[cont1]=='5'){ ///////·5
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '5';
}else
if(buffer_tx[cont1]=='6'){ ///////·6
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '6';
}else
if(buffer_tx[cont1]=='7'){ ///////·7
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '7';
}else
if(buffer_tx[cont1]=='8'){ /////// 8
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '8';
}else
if(buffer_tx[cont1]=='9'){ /////// 9
buffer_tx2[cont1+cont1]= '3';
buffer_tx2[cont1+cont1+1]= '9';
}else
if(buffer_tx[cont1]==','){ /////// ,
buffer_tx2[cont1+cont1]= '2';
buffer_tx2[cont1+cont1+1]= 'C';
}else
if(buffer_tx[cont1]=='A'){ /////// A
buffer_tx2[cont1+cont1]= '4';
buffer_tx2[cont1+cont1+1]= '1';
}else
if(buffer_tx[cont1]=='N'){ /////// N
buffer_tx2[cont1+cont1]= '4';
buffer_tx2[cont1+cont1+1]= 'E';
}else
if(buffer_tx[cont1]=='W'){ /////// W
121
buffer_tx2[cont1+cont1]= '5';
buffer_tx2[cont1+cont1+1]= '7';
}else
if(buffer_tx[cont1]=='.'){ /////// .
buffer_tx2[cont1+cont1]= '2';
buffer_tx2[cont1+cont1+1]= 'E';
}
cont1++;
}
}
}else if(SCI1D == '$'){
cont1 = 0;
flag1 = 0;
}
out_int_rx[2]= SCI1S1; // Borra la bandera de
interrupcion de rx
}
ANEXO 2. Código completo implementado para la utilización de PSoC5LP.
#include "project.h"
#include "stdio.h"
#include "stdlib.h"
uint8 dato,dato2,cont,a,flag1,flag2,cont3,aux;
char buffer_rx[70];
char buffer_rx2[30];
char buffer_tx[70];
char buffer_tx2[170];
CY_ISR(INT_RX){
while((dato = UART_GPS_GetChar())==0);
if (dato != '$'){
if(dato == 'R'){
for(a=0; a<60; a++){
buffer_rx[a]= '\0';
}
flag1 = 1;
}
if(flag1 == 1){
if(cont < 48){
buffer_rx[cont] = dato;
if(cont >= 4 && cont <= 9){
buffer_tx[cont-4] = buffer_rx[cont];
}else if (cont > 12){
buffer_tx[cont-7] = buffer_rx[cont];
122
}
if(buffer_tx[cont]=='R'){ /////// R
buffer_tx2[cont+cont]= '5';
buffer_tx2[cont+cont+1]= '2';
}else if(buffer_tx[cont]=='M'){//// M
buffer_tx2[cont+cont]= '4';
buffer_tx2[cont+cont+1]= 'D';
}else if(buffer_tx[cont]=='C'){ ////// C
buffer_tx2[cont+cont]= '4';
buffer_tx2[cont+cont+1]= '3';
}else if(buffer_tx[cont]=='0'){ ////// 0
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '0';
}else if(buffer_tx[cont]=='1'){ /////// 1
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '1';
}else if(buffer_tx[cont]=='2'){ /////// 2
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '2';
}else if(buffer_tx[cont]=='3'){ ///////·3
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '3';
}else if(buffer_tx[cont]=='4'){ ///////·4
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '4';
}else if(buffer_tx[cont]=='5'){ ///////·5
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '5';
}else if(buffer_tx[cont]=='6'){ ///////·6
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '6';
}else if(buffer_tx[cont]=='7'){ ///////·7
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '7';
}else if(buffer_tx[cont]=='8'){ /////// 8
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '8';
}else if(buffer_tx[cont]=='9'){ /////// 9
buffer_tx2[cont+cont]= '3';
buffer_tx2[cont+cont+1]= '9';
}else if(buffer_tx[cont]==','){ /////// ,
buffer_tx2[cont+cont]= '2';
buffer_tx2[cont+cont+1]= 'C';
}else if(buffer_tx[cont]=='A'){ /////// A
buffer_tx2[cont+cont]= '4';
buffer_tx2[cont+cont+1]= '1';
}else if(buffer_tx[cont]=='N'){ /////// N
buffer_tx2[cont+cont]= '4';
buffer_tx2[cont+cont+1]= 'E';
}else if(buffer_tx[cont]=='W'){ /////// W
buffer_tx2[cont+cont]= '5';
buffer_tx2[cont+cont+1]= '7';
}else if(buffer_tx[cont]=='.'){ /////// .
buffer_tx2[cont+cont]= '2';
123
buffer_tx2[cont+cont+1]= 'E';
}
cont++;
}
}
}else if(dato == '$'){
cont = 0;
flag1 = 0;
}
ISR_ClearPending();
}
void Config_Lora (void){
UART_2_PutString("sys get ver\r\n");
CyDelay(1000);
UART_2_PutString("sys get ver\r\n");
CyDelay(1000);
UART_2_PutString("mac reset\r\n");
CyDelay(1000);
UART_2_PutString("mac set nwkskey
187A725A3397D388743FB83C44EA6BC3\r\n");
CyDelay(1000);
UART_2_PutString("mac set appskey
116623F5388A6565B7D08BC2F808FF28\r\n");
CyDelay(1000);
UART_2_PutString("mac set devaddr 01955D22\r\n");
CyDelay(1000);
UART_2_PutString("radio set pwr 20\r\n");
CyDelay(1000);
UART_2_PutString("mac save\r\n");
CyDelay(2000);
UART_2_PutString("mac join abp\r\n");
CyDelay(5000);
}
CY_ISR(INT_RX_2){
while((dato2 = UART_2_GetChar())==0);
if(dato2!='\n'){
buffer_rx2[cont3]= dato2;
cont3++;
}else if (dato2 == '\n'){
cont3 = 0;
LCD_ClearDisplay();
LCD_Position(0,0);
LCD_PrintString(buffer_rx2);
for(aux=0;aux<29;aux++){
buffer_rx2[aux]= '\0';
}
}
}
124
int main(void)
{
CyGlobalIntEnable; /* Enable global interrupts. */
LCD_Start();
UART_GPS_Start();
UART_2_Start();
ISR_StartEx(INT_RX);
ISR_2_StartEx(INT_RX_2);
Config_Lora();
for(;;)
{
UART_2_PutString("mac set dr 2\r\n");
CyDelay(100);
UART_2_PutString("mac tx cnf 1 ");
UART_2_PutString(buffer_tx2);
UART_2_PutString("\r\n");
CyDelay(30000);
}
}
ANEXO 3. Código completo implementado para el servidor en express.
const express = require("express");
const bodyParser = require('body-parser');
const app = express();
const decimal = require('ascii-decimal');
const path = require('path');
const engine = require('ejs-mate');
const router = express.Router();
app.engine('ejs', engine);
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
//app.use(require('./routes/'));
app.use(express.static(path.join(__dirname, 'public')));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
var Latitud;
var Longitud;
var Velocidad = 12;
125
app.get('/',(req, res) =>{
res.render('index',{Lati:Latitud,Longi:Longitud,velo:Velocidad});
});
app.post('/',(req,res)=>{
if(req.body.data !=undefined){
var Vector_Gps = hex_to_ascii(req.body.data);
var UniHour = decimal(Vector_Gps[1])-48;
var DecHour = decimal(Vector_Gps[0])-48;
var Horas = UniHour + (DecHour*10);
var UniMin = decimal(Vector_Gps[3])-48;
var DecMin = decimal(Vector_Gps[2])-48;
var Minutos = UniMin + (DecMin*10);
var UniSeg = decimal(Vector_Gps[5])-48;
var DecSeg = decimal(Vector_Gps[4])-48;
var Segundos = UniSeg + (DecSeg*10);
var Estado = (Vector_Gps[7]);
var GradosLa = ((decimal(Vector_Gps[9])-48)*10)+(decimal(Vector_Gps[10])-48);
var MinutosLa = ((decimal(Vector_Gps[11])-48)*10)+(decimal(Vector_Gps[12])-
48)+
((decimal(Vector_Gps[14])-48)*0.1)+((decimal(Vector_Gps[15])-
48)*0.01)+
((decimal(Vector_Gps[16])-48)*0.001)+((decimal(Vector_Gps[17])-
48)*0.0001)+
((decimal(Vector_Gps[18])-48)*0.00001);
MinutosLa = MinutosLa/60;
Latitud = GradosLa + MinutosLa;
var GradosLo = ((decimal(Vector_Gps[22])-48)*100)+((decimal(Vector_Gps[23])-
48)*10)+(decimal(Vector_Gps[24])-48);
var MinutosLo = ((decimal(Vector_Gps[25])-48)*10)+(decimal(Vector_Gps[26])-48)+
126
((decimal(Vector_Gps[28])-48)*0.1)+((decimal(Vector_Gps[29])-48)*0.01)+
((decimal(Vector_Gps[30])-48)*0.001)+((decimal(Vector_Gps[31])-
48)*0.0001)+
((decimal(Vector_Gps[32])-48)*0.00001);
MinutosLo = MinutosLo/60;
Longitud = (GradosLo + MinutosLo)*(-1);
Velocidad = (decimal(Vector_Gps[36])-48)+((decimal(Vector_Gps[38])-
48)*0.1)+((decimal(Vector_Gps[39])-48)*0.01)+
((decimal(Vector_Gps[40])-48)*0.001);
Velocidad = Velocidad*1.852;
console.log("hora:"+ Horas +":"+ Minutos +":"+ Segundos);
console.log("Estado: "+ Estado);
console.log("Latitud: "+Latitud);
console.log("Longitud: "+Longitud);
console.log("Velocidad: "+ Velocidad);
}
res.send("Latitud: "+Latitud +" Longitud: "+ Longitud+ " Velocidad: "+ Velocidad);
});
app.listen(3000,()=>{
console.log("el servidor esta en el puerto 3000");
});
function hex_to_ascii(str1)
{
var hex = str1.toString();
var str = '';
for (var n = 0; n < hex.length; n += 2) {
str += String.fromCharCode(parseInt(hex.substr(n, 2), 16));
}
return str;
}
