Los archivos de las capturas de datos por USB-Serial que se obtienen en las campañas de medición en cada punto, se requieren: procesar, ordenar y obtener los valores representativos del comportamiento del RSSI y SNR.
Cada archivo contiene al menos 100 lecturas a cada baliza. Los archivos se encuentran en una carpeta desde donde se procesarán y se obtendrá un archivo "resumen".
Para procesar los archivos de deben indicar los siguientes parámetros:
medida a observar: rssi, snr
descriptor estadistico a usar: mean, std, count, max, min, ...
trama: rx
una 'carpeta' donde se encuentran los archivos a procesar
nombre del archivo de resultados
Un ejemplo de los resultados en el resumen por punto del promedio Rssi es:
Para simplificar el algoritmo, se realizó una librería de funciones, "girni_lora_libreria.py", que se debe de ubicar en la misma carpeta del algoritmo que lo usa.
Para almacenar los datos tabulados, se crea también el archivo de ésta tabla en formato .json, en caso de que se requiera realizar otro tipo de análisis a los datos.
'''
Procesa Archivo.txt de LoRa Rssi y SNR
de muestras desde un puerto Serial
Girni 2020-10-07 propuesta: edelros@espol.edu.ec
medida: 'rssi', 'snr'
unestadistico: 'count', 'mean', 'std',
'min', '25%', '50%', '75%', 'max'
modo: rx baliza a dispositivo
tx difusion hacia balizas
'''
import os
import numpy as np
import pandas as pd
import girni_lora_libreria as girni
# INGRESO
# revisar parametros al inicio
medida = 'rssi'
descriptor = 'mean'
trama = 'rx'
# carpeta de Archivos entrada
carpeta = 'Lecturas_dispositivo'
# Archivos para resultados
arch_rsmUnestadistico = 'resumen_'+medida+descriptor+'02.txt'
arch_detalle = 'tabla_puntosdatos2.json'
# PROCEDIMIENTO
# lista los archivos entrada en la carpeta
archivosPuntos = os.listdir(carpeta)
# Lee cada archivo de un punto y tabula
# las lecturas por cada trama: rx, tx
# cada remitente de paquete: baliza
tabula = {}
for unarchivo in archivosPuntos:
unpunto = girni.tabulaPunto(unarchivo,carpeta)
p_nombre = unpunto['nombre']
tabula[p_nombre] = unpunto
tabula = pd.DataFrame(tabula)
tabula = tabula.drop(['nombre'])
tabula = tabula.T
# Estadistica descriptiva de cada punto tabulado
descrito = {}
for cadapunto in tabula.index:
punto = tabula.loc[cadapunto]
descrito[cadapunto] = girni.describePunto(punto)
# resumen de una medida: rssi, snr
rsm_medida = pd.DataFrame()
for cadapunto in descrito.keys():
punto = descrito[cadapunto][trama]
unafila = girni.resumen_medida(punto,medida,descriptor)
rsm_medida[cadapunto] = unafila
rsm_medida = rsm_medida.T
rsm_medida = rsm_medida.sort_index(axis=1)
# SALIDA
# muestra en pantalla solo un ejemplo.head()
print('resumen trama: ', trama,', medida: ', medida)
print(rsm_medida.head(n=10))
# Se escribe todo el archivo a csv
rsm_medida.to_csv(arch_rsmUnestadistico)
# Para grabar en formato .json
tabula.to_json(arch_detalle)
La relación de valores de Rssi y distancia hacia cada punto de referencia (baliza), se estima a partir de las mediciones en varios puntos establecidos y ubicados en un mapa.
En cada punto, los valores se estiman considerando usar al menos 100 lecturas hacia cada baliza en cada punto.
En éste proceso usa un computador portátil que captura las tramas de cada paquete recibido por el dispositivo desde el puerto USB-Serial a un archivo.txt.
Cada baliza periódicamente emite un paquete que permite al dispositivo registrar los valores de Rssi y SNR. Cada captura se registra en una línea de texto como un paquete recibido y etiquetado como "rx".
Para registrar el Rssi y SNR desde el otro extremo, la baliza, se emite un paquete de difusión desde el dispositivo, con el que la baliza al recibirlo toma los valores de Rssi y SNR y los envía al dispositivo en el próximo envío. El paquete de difusión del dispositivo se etiqueta como 'tx' en el archivo txt.
En la pantalla del computador portátil se muestra el estado del registro de datos en cada evento de recepción.
Configuración del algoritmo en Python
La captura de datos desde USB se realiza usando instrucciones en Python, con la que se pre-procesa cada paquete y se almacena en un archivo.
En el bloque de INGRESO es necesario indicar:
el puerto 'com' y los baudios del dispositivo conectado por USB
el nombre del archivo de texto que registra la captura de datos
las direcciones de las balizas, identificadores indicados en la sección anterior
la cantidad mínima de lecturas desde cada baliza
El puerto 'com' se puede verificar antes de iniciar la captura, usando el IDE de Arduino, al conectar lo muestra en el menu de herramientas/puerto.
El proceso de captura se ejecuta en un lazo, en caso de ser necesario detener se pueden usar las teclas "Ctrl-c".
En cada punto de referencia se requiere asignar un nombre a cada archivo, iniciando el nombre con "multipunto" añadiendo letras para identificar el sector y un número como identificador del punto.
En los puntos de prueba el nombre del archivo inicia con "mpcircuito". Observe que ambas palabras de inicio contienen la misma cantidad de caracteres, pues facilita el procesamiento de los archivos.
Los archivos se almacenan en una carpeta de donde se puedan leer por lotes en el siguiente proceso de los datos.
Algoritmo en Python
''' Rssi y SNR LoRa punto a punto
paquete de datos desde puerto Serial
generados desde dispositivo LoRa
modelo Heltec Lora 32 v.2
Girni 2020-10-07 propuesta: edelros@espol.edu.ec
'''
import numpy as np
import matplotlib.pyplot as plt
import serial, time
# INGRESO
# Puerto de captura de datos USB-Serial
puerto = 'com3'
baudios = 115200
# Archivo para el registro de cada evento rx,tx
nombrearchivo = 'multipuntoFIEC101.txt'
# identificadores de balizas
baliza = ['d1','d2','d3']
# Mínimo de lecturas por baliza
lecturasMin = 100
# PROCEDIMIENTO
# Crea registro de lecturas
n = len (baliza)
registro = {}
for elemento in baliza:
registro[elemento] = {'cuenta': 0 ,
'rssi': np.array([0.0,0.0]),
'snr': np.array([0.0,0.0]),
'SumaRssi': np.array([0.0,0.0]),
'SumaSnr': np.array([0.0,0.0]),
'minmaxRssi': np.array([0.0,-200.0,0.0,-200.0]),
'minmaxSnr': np.array([100.0,0.0,100.0,0.0])
}
# inicializa archivo.txt a vacio
archivo = open(nombrearchivo,'w')
archivo.close() # Cierra el archivo
# Abre puerto Serial
arduino = serial.Serial(puerto, baudios)
arduino.setDTR(False)
time.sleep(0.3)
# limpia buffer de datos anteriores
arduino.flushInput()
arduino.setDTR()
time.sleep(0.3)
print('\nEstado del puerto: ',arduino.isOpen())
print('Nombre del dispositivo conectado: ', arduino.name)
print('Dump de la configuración:\n ',arduino)
print('\n###############################################\n')
# Lectura de datos
np.set_printoptions(precision=2)
conteo = 0
difunde = 0
while conteo<lecturasMin:
#esperar hasta recibir un paquete
while (arduino.inWaiting()==0):
pass
# leer linea desde puerto serial
linea = arduino.readline()
# binario a texto, elimina /r/n
texto = linea.decode()
texto = linea.strip()
# identificar la trama como rx, tx
cond1 = texto.startswith('tx')
cond2 = texto.startswith('rx')
if cond1 or cond2:
archivo = open(nombrearchivo,'a')
archivo.write(texto+'\n')
archivo.close()
if (texto.startswith('tx')):
difunde = difunde + 1
if (texto.startswith('rx')):
texto = texto.split(',')
tipo = texto[0]
dir_remite = texto[2]
paqrcbvID = texto[3]
rssi_tx = float(texto[4])
snr_tx = float(texto[5])
rssi_rx = float(texto[6])
snr_rx = float(texto[7])
if tipo == "rx":
# conteo de lecturas
cual = dir_remite
registro[cual]['cuenta']=registro[cual]['cuenta']+1
if registro[cual]['cuenta']<conteo:
conteo = registro[cual]['cuenta']
# acumulado
registro[cual]['SumaRssi'][0] = registro[cual]['SumaRssi'][0]+rssi_tx
registro[cual]['SumaSnr'][0] = registro[cual]['SumaSnr'][0]+snr_tx
registro[cual]['SumaRssi'][1] = registro[cual]['SumaRssi'][1]+rssi_rx
registro[cual]['SumaSnr'][1] = registro[cual]['SumaSnr'][1]+snr_rx
# promedios
cuantos = registro[cual]['cuenta']
registro[cual]['rssi'] = registro[cual]['SumaRssi']/cuantos
registro[cual]['snr'] = registro[cual]['SumaSnr']/cuantos
# minimos y maximos
registro[cual]['minmaxRssi'][0] = np.min([rssi_tx,registro[cual]['minmaxRssi'][0]])
registro[cual]['minmaxRssi'][1] = np.max([rssi_tx,registro[cual]['minmaxRssi'][1]])
registro[cual]['minmaxRssi'][2] = np.min([rssi_rx,registro[cual]['minmaxRssi'][2]])
registro[cual]['minmaxRssi'][3] = np.max([rssi_rx,registro[cual]['minmaxRssi'][3]])
registro[cual]['minmaxSnr'][0] = np.min([snr_tx,registro[cual]['minmaxSnr'][0]])
registro[cual]['minmaxSnr'][1] = np.max([snr_tx,registro[cual]['minmaxSnr'][1]])
registro[cual]['minmaxSnr'][2] = np.min([snr_rx,registro[cual]['minmaxSnr'][2]])
registro[cual]['minmaxSnr'][3] = np.max([snr_rx,registro[cual]['minmaxSnr'][3]])
# Muestra en pantalla el estado de recepción
print('\n difusion: ',difunde)
print(texto)
for elemento in baliza:
print(elemento,registro[elemento]['cuenta'],
'\tprom Rssi[tx,rx] \t Snr[tx,rx]')
print("prom :",registro[elemento]['rssi'],"\t ",
registro[elemento]['snr'])
print("min,max:",registro[elemento]['minmaxRssi'],
registro[elemento]['minmaxSnr'])
# Cerrar el puerto serial.
serial.Serial.close
El esquema para baliza y dispositivo propuesto para el modelo de localización usa el modelo multipunto de LoRa que usa direcciones para identificar la función de cada elemento:
Baliza: d1,d2,d3
Dispositivo: c1
El esquema se muestra simplificado para un solo punto, se plantea usar el dispositivo 'C1' como punto de captura de datos hacia un archivo tipo texto mediante la conexión USB a un computador portátil.
En el dispositivo, por cada paquete recibido se toman los datos del paquete y valores medidos, creando un registro de trama con: el tipo rx/tx, id receptor, remitente, los datos recibidos y lecturas de RSSI y SNR del paquete recibido desde el remitente que es cada baliza.
El registro de la trama de datos recibida en el computador se compone de la parte de datos recibido y las lecturas de Rssi-SNR del paquete. El orden de los datos se muestra en la tabla:
Para obtener los valores de Rssi y SNR de recepción desde cada baliza, se emite periódicamente un paquete de difusión ('ff') desde el dispositivo c1. Los valores recibidos en la baliza se replican en los datos del próximo paquete de la baliza hacia el dispositivo c1, que corresponden a dato2 y dato3.
Para revisar la secuencia del paquete se registra un contador desde el emisor, enviado en la posición de dato1.
Configurar la función de baliza o dispositivo
se establece mediante las direcciones de envío y recepción descritas en la sección principal del algoritmo.
Para el dispositivo la dirección local es C1 , para las balizas serán D1, D2, D3.
En el dispositivo se usa la dirección local 'C1', y como destino una trama de difusión 'FF' hacia todas las balizas de tal manera que cada baliza pueda medir el nivel de recepción de la señal emitida desde el dispositivo.
Otros parámetros como tiempo entre paquetes, se configuran de acuerdo a las lecturas que se tomarán en un intervalo de tiempo. El parámetro t_ciclotx establece el intervalo de tiempo en que cada dispositivo o baliza emite un paquete.
Para LoRa, los tiempos de envio de paquetes son bastante largos de acuerdo al diseño básico de la red estándar, sin embargo durante el experimiento para tomar las lecturas más rápido en cada ubicación de prueba se puede reducir a por ejemplo, 10 segundos (10000ms)
int t_ciclotx =10000;
otros detalles de configuración del dispositivo se pueden revisar en la sección de referencias al final de la hoja.
Módulos LoRa
El prototipo se implementó con los módulos de desarrollo Heltec Lora 32 V2 disponibles al momento de las pruebas. Los módulos son de 915MHz, y se usaron también con las pruebas de conexión multipunto descritas en LoRa Multipunto – Esquema
Instrucciones en Arduino
Las instrucciones del dispositivo escritas usando el IDE Arduino se presentan en secciones o bloques:
Principal: LoRa_Listener02
Receptor: LoRaReceptor
Transmisor: LoRaTransmisor
Sensor: Sensores
Sección principal
/* Pruebas de Rssi y SNR multipunto, esquema de triangulación
Nodo- Receptor. http://blog.espol.edu.ec/girni/
Septiembre-2020 */
#include "heltec.h"
// SENSOR Parpadeo
String sensorBlink = "ON"; // inicializa on/off: 1/0
// Direcciones Enviar mensaje
byte dir_local = 0xC1; // Concentrador 1
byte dir_destino = 0xFF; // Broadcast para medir Rssi
byte msjtxContador = 0;
int t_ciclotx = 10000;
long t_anterior = 0;
int t_intervalo = 3000;
// Direcciones Mensaje Recibido
byte dir_envio = 0xC1;
int dir_remite = 0xFF;
String paqueteRcb = "";
byte paqrcbID = 0;
byte paqrcbEstado = 0;
// 0:vacio, 1: nuevo, 2:incompleto
// 3:otro destinatario, 4:Broadcast
int rssi_lorarx = 0;
float snr_lorarx = 0;
// Mensajes por Puerto Serial
volatile boolean serial_msj = true;
#define BAND 915E6 // 868E6,915E6
void setup() {
Heltec.begin(false /*DisplayEnable Enable*/,
true /*Heltec.LoRa Disable*/,
serial_msj /*Serial Enable*/,
true /*PABOOST Enable*/,
BAND /*long BAND*/);
LoRa.setSpreadingFactor(8);
LoRa.receive();
}
void loop() {
// LoRa enviar mensajes entre intervalos
long t_ahora = millis();
long t_transcurrido = t_ahora - t_anterior;
if (t_transcurrido >= t_intervalo){
t_anterior = t_ahora;
t_intervalo = t_ciclotx + random(1000);
// sensorParpadea(); //actualiza sensor
sensorBlink = String(rssi_lorarx)+","+String(snr_lorarx);
String paqueteEnv = String(sensorBlink).c_str() ;
enviarlora(dir_destino, dir_local,
msjtxContador, paqueteEnv);
yield();
// mensaje a serial
if (serial_msj==true){
// muestra todos paqrcbEstado
Serial.print("tx,");
Serial.print(String(dir_destino,HEX)+",");
Serial.print(String(dir_local,HEX)+",");
Serial.print(String(msjtxContador)+",");
Serial.print(String(paqueteEnv)+",");
Serial.print(String(rssi_lorarx)+",");
Serial.println(snr_lorarx);
}
msjtxContador = msjtxContador + 1;
// LED parpadea envio LoRa
digitalWrite(LED, HIGH); delay(100);
digitalWrite(LED, LOW); delay(100);
yield(); // procesa wifi
}
// LoRa revisar mensajes entrantes
int msjRcbLoRa = LoRa.parsePacket();
if (msjRcbLoRa !=0){ //¿mensaje no vacio?
recibirlora(msjRcbLoRa);
rssi_lorarx = LoRa.packetRssi();
snr_lorarx = LoRa.packetSnr();
if (serial_msj==true){
// muestra todos los tipos
//Serial.print("Paquete recibido, Estado: ");
//Serial.println(paqrcbEstado);
Serial.print("rx,");
Serial.print(String(dir_envio,HEX)+",");
Serial.print(String(dir_remite,HEX)+",");
Serial.print(String(paqrcbID)+",");
Serial.print(String(paqueteRcb)+",");
Serial.print(String(rssi_lorarx)+",");
Serial.println(String(snr_lorarx));
}
yield(); // procesa wifi
}
}
Sección Receptor
En esta sección se revisa la trama, separando cada una de las partes del paquete recibido: dirección de envío, dirección de remitente, identificador del paquete generado por un contador de secuencia.
Se verifica que el destinatario del paquete, si el tamaño de la trama indica que el mensaje está completo, si la trama es de difusión (broadcast) usada para registrar los niveles de recepción.
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:
