En el escenario inicial básico, se plantea disponer de un dispositivo LoRa básico que se conecta a varios gateways LoRa. Desde cada paquete recibido se toman los valores Rssi y SNR en cada medición realizada en áreas de diferentes característica o entornos dentro del campus ESPOL.
Siendo el dispositivo usado de tipo básico, no dispone de un módulo GPS o elementos adicionales para localización.
Un dispositivo LoRa puede estar ubicado en áreas del campus de diferente entorno, por ejemplo, vegetación o edificios, a diferentes alturas por la irregularidad del terreno.
Las condiciones del entorno en cada área presentan varios escenarios a los modelos de espacio libre.
Un sensor general implementado con un dispositivo LoRa al transmitir puede añadir al envío de su estado las lecturas de Rssi y SNR tomadas de los paquetes recibidos desde un gateway. En sentido opuesto, un gateway al recibir un paquete transmitido desde un sensor puede registrar lecturas de Rssi y SNR de recepción. De existir varios gateways, al menos tres, un dispositivo al transmitir datos permitiría estimar su ubicación relativa a cada uno usando las lecturas recibidas.
Esquema de Prototipo
Para el esquema inicial de prototipo, se simplifica usando mediciones LoRa punto multipunto usando módulos básicos. En una segunda fase se podría ampliar a LoRaWAN usando esquemas abiertos de gateways.
Para el planteamiento del modelo, se realizan mediciones en varios puntos en las áreas de interés, marcando cada uno de ellos un mapa. Las referencias en el mapa se mejoran usando las coordenadas tomadas con un GPS Diferencial que tiene una mayor precisión que un GPS básico dados los diferentes entornos en el campus.
En las siguientes secciones de describen los pasos realizados para realizar un modelo que permita estimar la ubicación de un dispositivo en diferentes áreas.
Para realizar el prototipo planteado se desarrollan dos partes principales:
Es un ejemplo ampliado de LoRa punto a punto. Implementa el envío de mensajes hacia un dispositivo LoRa que realiza las funciones de "gateway" hacia Wifi, que convierte el mensaje a MQTT hacia un broker Mosquitto ya planteado en los Tutoriales.
LoRaWan
LoRa en modalidad LoRaWan requiere un "gateway" más elaborado para envio de mensajes hacia internet. En la sección de Broker/Gestión, se implementa un Gateway a partir del módulo Heltec (HT-M01) y un gestor de Gateways (ChirpStack) de esquema abierto. LoraWan – Gateway esquema abierto
que es el mensaje original enviado desde el dispositivo
2. Mensajes MQTT con Python
De disponer de acceso al servidor MQTT se pueden capturar los mensajes y procesarlos por ejemplo para realizar estadísticas de RSSI y SNR de cada dispositivo respecto al Gateway.
Se requiere una conexión autenticada al servidor MQTT, para caso experimental se recurre a Python con la librería PAHO para acceder como cliente.
# grabando mensajes MQTT
# configurar los parámetros para la creacion de archivo de texto
import paho.mqtt.client as mqtt
# INGRESO
# Parametros para la conexión
servidormqtt = "192.168.xx.xx"
topicolee = "#"
# Para el archivo.txt
cuentamensaje = 0
nombrearchivo = 'unreporte.txt'
archivo = open(nombrearchivo,'w')
archivo.close() # Cierra el archivo
tramabuscada = ['application/1/device/c9c2a03913ac2ec5/event/up',
'application/1/device/b35915f22af620d1/event/up',
'application/1/device/b5a2349b828d97ea/event/up',
'application/1/device/f2f724028c0e996c/event/up']
cuentaDisp = [0,0,0,0]
cuentagtw = 0
# BLOQUE BÁSICO DE PROGRAMA
# Al recibir CONNACK desde el servidor.
def on_connect(client, userdata, flags, rc):
print("Conexión/código de resultado: "+str(rc))
# Inicio o renovación de subscripción
client.subscribe(topicolee)
return()
# el tópico tiene una publicación
def on_message(client, userdata, msg):
global cuentamensaje
print(msg.topic) #+" "+str(msg.payload))
unmensaje = msg.topic+" "+str(msg.payload)
# Archivo en modo añadir 'append'
archivo = open(nombrearchivo,'a')
unalinea = unmensaje + '\n'
archivo.write(unalinea)
if (msg.topic in tramabuscada):
cual = tramabuscada.index(msg.topic)
cuentaDisp[cual] = cuentaDisp[cual] + 1
cuentamensaje = cuentamensaje + 1
print('\n mensajes recibidos: ', cuentamensaje)
print(' cuenta por dispositivos: ', cuentaDisp)
print()
return()
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect(servidormqtt, 1883, 60)
client.loop_forever()
3. Mensajes MQTT y reporte txt con Python
Para procesar el archivo del reporte.txt se puede leer mensaje por mensaje y extraer el registro de RSSI y SNR de cada dispositivo usando Python.
# procesar un archivo de mensajes mqtt
import numpy as np
import json as json
# INGRESO
# Parametros para la conexión
servidormqtt = "192.168.xx.xx"
topicolee = "#"
# Para el archivo.txt
nombrearchivo = 'unreporte.txt'
conteo = {"lineas":{'cuenta':0},
"gateway":{'cuenta':0},
"application":{'cuenta':0}
}
tipotrama = []
# para tabular
tabla = []
registros = {}
frecuencias = []
tramabuscada = ['application/1/device/c9c2a03913ac2ec5/event/up',
'application/1/device/b35915f22af620d1/event/up',
'application/1/device/b5a2349b828d97ea/event/up',
'application/1/device/f2f724028c0e996c/event/up']
# PROCEDIMIENTO
archivo = open(nombrearchivo,'r')
unalinea = archivo.readline()
while not(unalinea==''):
conteo["lineas"]['cuenta'] = conteo["lineas"]['cuenta'] + 1
unalinea = archivo.readline()
unalinea = unalinea.strip('\n')
desde = unalinea.find(" b'{")
untipotrama = unalinea[0:desde]
if not(untipotrama in tipotrama) and (untipotrama != ''):
tipotrama.append(untipotrama)
conteo[untipotrama] = {'cuenta':0}
for entrada in conteo:
if unalinea.startswith(entrada):
conteo[entrada]['cuenta'] = conteo[entrada]['cuenta']+1
for unapptrama in tramabuscada:
tamanot = len(unapptrama)
if unalinea.startswith(unapptrama):
datostxt = unalinea[tamanot+3:].strip("'")
datosjson = json.loads(datostxt)
undeviceName = datosjson["deviceName"]
unrssi = datosjson["rxInfo"][0]["rssi"]
unloRaSNR = datosjson["rxInfo"][0]["loRaSNR"]
unfrequency = datosjson["txInfo"]["frequency"]
undr = datosjson["txInfo"]["dr"]
if not(unfrequency in frecuencias):
frecuencias.append(unfrequency)
if undeviceName in registros:
registros[undeviceName]['conteo'] = registros[undeviceName]['conteo']+1
registros[undeviceName]['rssi'].append([unfrequency,unrssi,
unloRaSNR,undr])
else:
registros[undeviceName]={'rssi':[],
'conteo':0,
'resumen':[0,0,0,0],
}
archivo.close() # Cierra el archivo
# Calcula resumen por dispositivo
frecuencias.sort()
frecuencia = [902300000, 902500000, 902700000, 902900000,
903100000, 903300000, 903500000, 903700000]
canalobserva = len(frecuencia)
for dispositivo in registros:
vector = np.array(registros[dispositivo]['rssi'])
cuenta = np.zeros(canalobserva, dtype=int)
suma = np.zeros(canalobserva,dtype=int)
channelid = np.arange(1, canalobserva+1)
cadaRSSI = [[],[],[],[],[],[],[],[],[]]
cadaSNR = [[],[],[],[],[],[],[],[],[]]
cadadr = [[],[],[],[],[],[],[],[],[]]
resumen = []
# Clasificando
k = len(vector)
for j in range (0,k,1):
cual = frecuencia.index(vector[j][0])
valorRssi = vector[j][1]
valorSNR = vector[j][2]
valordr = vector[j][3]
cadaRSSI[cual].append(valorRssi)
cadaSNR[cual].append(valorSNR)
cadadr[cual].append(valordr)
for j in range(0,canalobserva,1):
vectorRSSI = np.array(cadaRSSI[j])
vectorSNR = np.array(cadaSNR[j])
vectordr = np.array(cadadr[j])
if len(vectorRSSI)>0:
promedioRSSI = np.average(vectorRSSI)
maximoRSSI = np.max(vectorRSSI)
cantidadRSSI = len(vectorRSSI)
minimoRSSI = np.min(vectorRSSI)
promedioSNR = np.average(vectorSNR)
maximoSNR = np.max(vectorSNR)
cantidadSNR = len(vectorSNR)
minimoSNR = np.min(vectorSNR)
promediodr = np.average(vectordr)
maximodr = np.max(vectordr)
cantidaddr = len(vectordr)
minimodr = np.min(vectordr)
resumen.append(np.array([ j+1,
cantidadRSSI,
promedioRSSI,
minimoRSSI,
maximoRSSI,
promedioSNR,
minimoSNR,
maximoSNR,
promediodr,
]))
resumen = np.array(resumen)
registros[dispositivo]['resumen'] = resumen
# SALIDA
np.set_printoptions(precision = 2)
print('conteo de tramas')
for entrada in conteo:
print(entrada,": ", conteo[entrada]['cuenta'])
print('frecuencias: ',frecuencia)
print('\nTabulando ---------')
for dispositivo in registros:
print()
print('dispositivo_id: '+str(dispositivo))
print('total muestras: '+str(registros[dispositivo]['conteo']))
print('Promedios RSSI y SNR: ')
print('[canal muestras\t RSSI \t min \t max \t SNR min max DR ]')
print(registros[dispositivo]['resumen'])
registros[dispositivo]['conteo']
Una forma de registrar los datos que transmite un dispositivo en Home Assistant es mediante la subscripción al mensaje MQTT correspondiente a la trama LoRaWAN.
En la sección anterior se describe la forma de enviar los datos por LoRaWAN. mediante la subscripción al mensaje MQTT desde Home Assistant donde se registra y muestra el dato.
Para añadir el dispositivo a Home Assitant, se añade en el archivo de configuración las características del dispositivo y el mensaje MQTT al que se debe conectar. Esto se realiza editando el archivo de dispositivos con la intrucción:
Los datos de sensor/acción se ordenan en una trama LoRa en forma de bytes antes de la transmisión. Se pretende minimizar la cantidad de bytes usados por mensaje, siguiendo la directiva LoRa de mensajes de corta duración.
Un mensaje se puede simplificar, por ejemplo un "ON"/"OFF" presentado en LoRa puede ser 1 "o" 0, que es tan solo un bit. Los mensajes se administran por ChirpStack y los puede traducir nuevamente en mensajes "ON"/"OFF" para ser actualizados en un Broker como Home Assistant.
Un ejemplo básico de instrucciones para un dispositivo genérico permite presentar el uso de librerías LoRaWAN de HELTEC.
Trama de datos en dispositivo
Los datos son enviados en una trama como un tren de bits escritos en orden. Por ejemplo, en el dispositivo se tiene los valores de contador1, contador2 y unalectura como datos a ser transmitidos, por lo que se plantea el siguiente esquema:
Las instrucciones en el IDE arduino para el ejemplo de la trama de datos Sigue el mismo orden.
//orden de trama appDataSize = 4 //AppDataSize max value is 64 appData[0] = contador1; //0x01; appData[1] = contador2; appData[2] = highByte(unalectura); appData[3] = lowByte(unalectura);
// mostrar en puerto USB Serial.println(contador1); Serial.println(contador2); Serial.println(unalectura); }
En casos particulares hay que ajustar la trama de acuerdo a las lecturas de sensores o información que se requiera transmitir
Trama de datos en ChirpStack application - server
La trama de datos llega en binario hasta el componente application-server y de forma predeterminada se presenta en formato Base64.
Para leer los datos se puede usar el convertidor en línea o utilizar un decodificador/codificador con instrucciones en JavaScript.
https://v2.cryptii.com/base64/decimal
En ChirpStack en la sección Device-profiles/codec se puede escribir un decodificador para la trama de datos y reconstruirlo en la forma con las variables originales.
para el ejemplo presentado y siguiendo el esquema inicial, las instrucciones en JavaScript son:
function Decode(fPort, bytes, variables) {
var contador1 = bytes[0];
var contador2 = bytes[1];
var unalectura = (bytes[2] << 8) |(bytes[3]);
var appData = {'contador1':contador1, 'contador2':contador2, 'unalectura': unalectura}
return appData;
}
Con lo que en Chirpstack se obtiene para datos del dispositivo de una trama en particular:
Para capturar los datos en un broker, por ejemplo Home Assistant, se puede usar el mensaje MQTT del application-server. Es posible leer las tramas MQTT de application-server o integrar las plataformas entre si por medio de "integration"
Lecturas de mensajes MQTT
Para observar la estructura del mensaje se realiza una subscripción al mensaje MQTT de la aplicación para un dispositivo:
Para añadir un dispositivo en el Broker ChirpStack, el ejemplo básico envía una trama solo para leer los datos de niveles de señal RSSI y SNR.
1. Application Service Profile
El perfil de servicio en la aplicación se asigna un nombre acorde a la aplicación que la usará.
se ingresan los parámetros requeridos, por simplicidad solo se añade un nombre. Ejemplo:
2. Device Profile
El perfil de dispositivos describe la forma de conexión y autenticación de un grupo de dispositivos.
Por ejemplo, si los dispositivos autentican por medio de OTTA/ABP, si se incluirán dispositivos clase B, clase C y las instrucciones para codificar o decodificar los datos del dispositivo (CODEC).
La aplicación agrupa dispositivos que realizan funciones semejantes, mediante el perfil del dispositivo, donde se encuentra también el CODEC de los datos.
Se asigna un nombre y una descripción de lo que va a realizar con los dispositivos:
para finalmente registrar la aplicación
4. Añadir dispositivos a la aplicación
Hay que crear cada dispositivo con identificadores únicos y autenticar en la red.
los primeros datos corresponden a nombre y nombre y descripción.
El identificador único de dispositivo: Device EUI es primordial para la conexión por OTAA. El Device EUI se puede generar con el botón mostrado en la pantalla y se usa en la programación del dispositivo.
El perfil del dispositivo se selecciona desde la pestaña y se despliegan las opciones.
los parámetros para OTAA se pueden visualizar, generar en la pestaña correspondiente. Hay un botón para visualizar el que se esté usando, o en otro caso se puede generar para usar en la programación del dispositivo.
Si el dispositivo no ha sido conectado al menos una vez, la pestaña de activación aparece vacía. Para obtener los datos de activación es necesario realizar al menos un intento de conexión, con lo que la ventana llena los datos para completar la programación del dispositivo.
Para observar los datos de activación debe usar el botón de visualización en la parte derecha de la ventana.
Los intentos de conexión se pueden visualizar en la pestaña de LoRaWAN Frames
mientras que los datos recibidos se observan en la pestaña de Device Data
Hay que considerar que la primera vez que se conecta el dispositivo, la autenticación puede llevar algunos intentos, por lo que hay que esperar para que se comiencen a recibir los datos, a pesar que las tramas LoRaWAN si se registran en el programa.
5. Instrucciones Arduino IDE ejemplo básico
Los datos para la configuración del dispositivo se obtienen en el proceso descrito anteriormente, por lo que es necesario actualizar los datos.
En el caso de dispositivos HELTEC es necesario obtener los datos de licencia que se encuentran al inicio de las instrucciones. La licencia de cada dispositivo se puede revisar en: https://resource.heltec.cn/search/
/* * HelTec Automation(TM) LoRaWAN 1.0.2 OTAA example use OTAA, CLASS A * Solo ESP32+LoRa series boards con licencia http://www.heltec.cn/search/); *https://github.com/HelTecAutomation/ESP32_LoRaWAN
*/
#include<ESP32_LoRaWAN.h>#include"Arduino.h"/*licencia Heltec ESP32 LoRaWan http://resource.heltec.cn/searchuint32_t license[4] = {0xBE21335B, 0xAEC3C5CE, 0xCC0A1CF4, 0xB836F981};
/* OTAA parametros uint8_t DevEui[] = { 0x01, 0x20, 0x08, 0x93, 0xdf, 0x80, 0x37, 0x74 };
uint8_t AppEui[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t AppKey[] = { 0x05, 0x8e, 0xeb, 0xff, 0x24, 0xf1, 0x01, 0x84, 0xd0, 0x07, 0xbe, 0xd4, 0x65, 0xe7, 0x6b, 0xb5 };
/* ABP parametros uint32_t DevAddr = ( uint32_t )0x0174b1fd;
uint8_t NwkSKey[] = { 0xc1, 0x45, 0x31, 0x28, 0x5f, 0xb2, 0x56, 0x3b, 0x9d, 0x5f, 0x27, 0x15, 0xed, 0x3a, 0x0e, 0xbc};
uint8_t AppSKey[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
//LoraWan channelsmask, default channels 0-7/uint16_tuserChannelsMask[6]={ 0x00FF,0x0000,0x0000,0x0000,0x0000,0x0000 };
DeviceClass_t loraWanClass = CLASS_A; /*Soporte de A and C uint32_tappTxDutyCycle = 15000; /*15000; en [ms] booloverTheAirActivation = true; /*OTAA or ABP boolloraWanAdr = true; /*ADR enable boolisTxConfirmed = true; /*confirmed or unconfirmed messages uint8_tappPort = 2; /* Application port /* reintentos de transmisión, en caso de no recibir ack uint8_tconfirmedNbTrials = 8;
/* Seleccionado de Arduino IDE tools uint8_t debugLevel = LoRaWAN_DEBUG_LEVEL;
LoRaMacRegion_t loraWanRegion = ACTIVE_REGION;
// variables de sensor/actuadorbyte contador1 = 0;
uint8_t contador2 = 0;
int unalectura = 221;
voidsetup(){
Serial.begin(115200);
while (!Serial);
SPI.begin(SCK,MISO,MOSI,SS);
Mcu.init(SS,RST_LoRa,DIO0,DIO1,license);
deviceState = DEVICE_STATE_INIT;
}
voidloop(){
switch( deviceState ) {
case DEVICE_STATE_INIT: {
LoRaWAN.init(loraWanClass,loraWanRegion);
break;
}
case DEVICE_STATE_JOIN: {
LoRaWAN.join();
break;
}
case DEVICE_STATE_SEND: {
prepareTxFrame( appPort );
LoRaWAN.send(loraWanClass);
deviceState = DEVICE_STATE_CYCLE;
break;
}
case DEVICE_STATE_CYCLE: {
// Schedule next packet transmission
txDutyCycleTime = appTxDutyCycle +randr( -APP_TX_DUTYCYCLE_RND,
APP_TX_DUTYCYCLE_RND );
LoRaWAN.cycle(txDutyCycleTime);
deviceState = DEVICE_STATE_SLEEP;
break;
}
case DEVICE_STATE_SLEEP: {
LoRaWAN.sleep(loraWanClass,debugLevel);
break;
}
default: {
deviceState = DEVICE_STATE_INIT;
break;
}
}
}
staticvoid prepareTxFrame( uint8_t port ){
contador1 = contador1 + 1;
contador2 = contador2 - 1;
//orden de trama
appDataSize = 4 //AppDataSize max value is 64
appData[0] = contador1; //0x01;
appData[1] = contador2;
appData[2] = highByte(unalectura);
appData[3] = lowByte(unalectura);
// mostrar en puerto USB
Serial.println(contador1);
Serial.println(contador2);
Serial.println(unalectura);
}
dsn="postgres://chirpstack_as:dbpassword@localhost/chirpstack_as?sslmode=disable"
marshaler="json"<
# JWT secret used for api authentication / authorization
# You could generate this by executing 'openssl rand -base64 32' for example
jwt_secret="------------------"
Para revisar el estado o reiniciar el componente, se usa el la instrucción:
sudo systemctl status chirpstack-application-server
sudo systemctl restart chirpstack-application-server
De encontrarse todo en funcionamiento, debe ser posible acceder a la versión web de Chirpstack en la dirección IP y puerto (8080)
El network-server es el componente que se dedica a revisar los mensajes duplicados en la red, ya sea por re-intentos de transmisión desde un mismo dispositivo o por recepción de mensajes en más de un gateway.
Además de encargarse de la autenticación , capa MAC, comunicación con el componente de aplicaciones y gestión de colas de mensajes de envió hacia dispositivos.
Base de datos de mensajes
Para manejar los mensajes es necesario disponer de una base de datos. PostgreSQL es la base de datos predeterminada.
En caso de no disponer de la base de datos, la puede instalar siguiendo las instrucciones en:
Usada para guardar los datos de cada sesión , datos no persistentes, de duplicación y meta-data.
sudo apt install redis-server
Instalación de ChirpStack-network-server
Semejante al componente anterior, se añaden las referencias del repositorio de los archivos de instalación para ejecutar luego el proceso de instalación.
[general]
log_level=4
[postgresql]
dsn="postgres://chirpstack_ns:dbpassword@localhost/chirpstack_ns?sslmode=disable"
[network_server.band]
name="US915"
cambiar a comentario la seccion:
# Extra channel configuration.
Revisar el detalle de la línea dsn, pues el usuario al final de la línea vienen escrito con doble _ns_ns.
Añadir al final del archivo los datos de usuario y contraseña para el servicio MQTT
Para revisar el estado del componente se usa el la instrucción:
sudo systemctl status chirpstack-network-server
sudo systemctl restart chirpstack-network-server
debiendo obtener una respuesta semejante a
Para revisar el historial de actividad (log) y verificar operatividad
