Usando las fórmulas encontradas para Rssi(d), usando intervalos y aplicando el algoritmo de trilateración se pueden obtener los siguientes resultados para el área de vegetación en FIEC:
los resultadosindican que se ubican puntos por al menos el 82.5% con errores promedio de 30 mts.
el detalle de los puntos encontrados se muestra en la tabla, donde la columna i*std indica si el radio para intersectar los círculos requería se añada i veces la desviación estándar. La columna «fuera» indica si la distancia fué calculada en una extensión del intervalo de la ecuación.
La cota de error se determina como la distancia máxima a los vertices del triángulo formado con la intersección de los círculos. La cota de error de puede comparar con el error real obtenido usando las coordenadas tomadas con un gps diferencial.
Como referencia para revisión de lo efectivo de la ecuación se añaden las columnas u_d# donde se indica si se usó el punto para generar la fórmula.
Errores localizacion
Errores estimado: Cota-Trilatera-polígono y Trilatera_vs_GPS
La trilateración se basa en determinar las posiciones relativas a objetos, para éste caso las balizas d1, d2 y d3 y mediante geometria encontrar el punto central de la intersección de los círculos generados por las posiciones relativas a cada objeto.
Para una baliza en particular, por ejemplo d2 en color naranja, la distancia relativa permite trazar un círculo a su alrededor. El círculo d2 se intersecta con los otros círculos d1 y d3 generando un área de intersección de tres puntos.
Los tres puntos forman un triángulo cuyo baricentro o centroide permite estimar la ubicación del punto «trilatera» a partir de las distancias relativas a balizas.
En la gráfica se añade la posición del dispositivo medida con un gps diferencial de mayor precisión, mostrando la cercanía entre los puntos.
Cota de Error
En concepto se puede establecer una cota de error a partir del baricentro de la intercepción de los tres círculos.
Una forma conservadora toma la mayor distancia del baricentro a uno de los vértices. Observe que es una cota máxima, como un estimador del error máximo, valores que se comprobarían con los datos del experimento.
Las siguientes secciones desarrollan el algoritmo en Python para el concepto mostrado.
Los valores atípicos se los discrimina a partir de la desviación estándar, indicando el número de veces que se la considera como medida de dispersión.
Los puntos identificados en cada sector se seleccionan en ‘grp‘: FIEC, FCNM, RECT.
El tipo de medición tomada, ‘tip‘, se identifica por: punto, 1m, gtw, dispositivo.
Un parámetro auxiliar es ‘LOS’, que indica los puntos seleccionados con Línea de vista (1) y sin linea de vista (0). Para incluir todos de debe ingrear [1,0]. Este parametro se puede modificar en el archivo de entrada: arch_medidaubica.
Los datos de cada eje se seleccionan mediante la función pares_usar(tabla, baliza, analiza, unabaliza, medida, modo) que entrega como resultado los arreglos de pares ordenados y las etiquetas con los nombres, par_etiqueta).
La linealización se realiza con el método de los mínimos cuadrados, con lo que se establece el |error| promedio y desviación estándar.
∣error∣=∣yi−f(xi)∣∣errormedio∣=n1∑∣yi−f(xi)∣
Procedimiento aplicado
Para el análisis primero se consideran todos los puntos disponibles para obtener la primera ecuación, mostrada en el ejemplo con la línea azul.
Con ésto es posible determinar un error de estimación, para luego proceder a discriminar los puntos atípicos.
Se realiza una nueva estimación de linealización habiendo discriminado los puntos atípicos y se observa el resultado.
Resultados para baliza: gtwFIEC
El resultado del algoritmo se presenta como gráfica, en pantalla y un archivo con los datos de las fórmulas.
los resultados se pueden observar en lo mostrado.:
baliza: gtwFIEC
Puntos usados: todos
$ -10(4.908).log_{10}(d)+(1.406)$
|error| promedio: 4.84 , std: 5.56
Puntos usados: NoAtipico
$ -10(5.12).log_{10}(d)+(6.714)$
|error| promedio: 2.98 , std: 3.31
>>>
Se observa que los valores fuera de la banda de valores con una desviación estándar (σ) se muestran distruidos en tres grupos: dos grupos a la izquierda y derecha de la gráfica por debajo de la banda y un grupo en el centro por sobre la banda.
Se considera explorar la división del intervalo en dos, puesto que existen dos entornos: uno principalmente conformado con vegetación y otro con edificaciones.
los resultados que se van al archivo, incluyen todos los decimales:
Los datos se leen desde el archivo y se incorporan a una estructura de datos en Pandas.
Para cada baliza se determina si se ha indicado ‘analizar’, con lo que se seleccionan los pares ordenados y etiquetas a usar mediante la función girni.pares_usar().
Con los datos seleccionados, se aplica mínimos cuadrados y se obtienen los errores mediante la función girni.linealiza_lstsq(). Mediante el criterio de desviación estándar se discriminan los datos atípicos y se vuelve a evaluar los datos sin atipicos, entregando el resultado mediante archivos y gráficas.
# LoRa-Multipunto, Rssi vs distancia# linealización Rssi vs log10(distancia)# por mínimos cuadrados, Graficas 2D y 3D# Girni 2020-10-07 propuesta: edelros@espol.edu.ecimport numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import girni_lora_libreria as girni
# INGRESO# archivos de entrada
modo = 'rx'
medida = 'rssi'
arch_medidaubica = 'resumen_rssiUbica01.txt'# archivos de salida
arch_ecuaciones = 'resumen_ecuacionSimple05.json'
analiza = {'gtwRECT':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','RECT'],
'tip' : ['punto'],
'LOS' : [1,0]},
'gtwFIEC':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]},
'gtwFCNM':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]}
}
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# Parámetros de grafica
tipograf = '2D'# '2D','3D'
escala = 'log'# 'normal','log'
escalabase = 10 # 10, np.exp()# PROCEDIMIENTO# Resultados de análisis
ecuacion = {}
eq_graf = {}
# leer datos
tabla = pd.read_csv(arch_medidaubica, index_col='etiqueta')
tabla = pd.DataFrame(tabla)
# Analizar datos hacia una balizafor unabaliza in analiza:
# Parámetros
analizar = analiza[unabaliza]['analizar']
atipico_std = analiza[unabaliza]['atipico_std']
if analizar:
ecuacion[unabaliza] ={}
eq_graf[unabaliza] = {}
# pares a usar
[pares,par_etiqueta] = girni.pares_usar(tabla,baliza,
analiza,unabaliza,
medida,modo)
# analiza puntos para mínimos cuadrados
xi = pares[:,0]
yi = pares[:,1]
ecuacion0 = girni.linealiza_lstsq(xi,yi)
fdist0 = ecuacion0['eq_lambda']
yi0 = fdist0(xi)
# Selecciona atipicos
dyi0std = ecuacion0['error_std']
dyi0 = yi - yi0
atipicos = np.abs(dyi0) >= dyi0std*atipico_std
xi0_e = xi[atipicos]
yi0_e = yi[atipicos]
etiq0_e = par_etiqueta[atipicos]
# datos sin atipicos ----------
atipicoNo = np.abs(dyi0) <= dyi0std*atipico_std
xi1 = xi[atipicoNo]
yi1 = yi[atipicoNo]
etiq1 = par_etiqueta[atipicoNo]
ecuacion1 = girni.linealiza_lstsq(xi1,yi1)
fdist1 = ecuacion1['eq_lambda']
yi1 = fdist1(xi)
# para exportar
ecuacion[unabaliza] = {'todos': ecuacion0,
'NoAtipico': ecuacion1
}
eq_graf[unabaliza] = {'puntos': [xi,yi],
'todos' : yi0,
'atipicos':[xi0_e,yi0_e],
'atip_etiq': etiq0_e,
'NoAtipico':yi1
}
# SALIDAfor unabaliza in ecuacion:
print('baliza: ',unabaliza)
for unaecuacion in ecuacion[unabaliza]:
error_medio = ecuacion[unabaliza][unaecuacion]['error_medio']
error_std = ecuacion[unabaliza][unaecuacion]['error_std']
print('Puntos usados:', unaecuacion)
print(ecuacion[unabaliza][unaecuacion]['eq_latex'])
print('|error| promedio: ',np.round(error_medio,2),
' , std:',np.round(error_std,2))
print('\n',ecuacion[unabaliza],'\n')
print()
# salida a archivo
ecuacion = pd.DataFrame.from_dict(ecuacion)
ecuacion.to_json(arch_ecuaciones)
# GRAFICAR# Referencias para gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
mostrargrpeti = ['FIEC','FCNM','RECT']
mostrartipeti = ['1m','gtw']
for unabaliza in ecuacion:
figura,grafica = plt.subplots()
if escala == 'log':
grafica.set_xscale(escala,base=escalabase)
# todos los puntos
[xi, yi] = eq_graf[unabaliza]['puntos']
grafica.scatter(xi,yi,marker='.')
fdtxt = ecuacion[unabaliza]['todos']['eq_latex']
# linea con todos los puntos
yi0 = eq_graf[unabaliza]['todos']
grafica.plot(xi,yi0,color='blue', label = fdtxt)
[xi0_e,yi0_e] = eq_graf[unabaliza]['atipicos']
etiq0_e = eq_graf[unabaliza]['atip_etiq']
# cotas de error
atipico_std = analiza[unabaliza]['atipico_std']
dyi0std = ecuacion[unabaliza]['todos']['error_std']
grafica.plot(xi,yi0 + dyi0std*atipico_std,
color='blue',linestyle='dotted')
grafica.plot(xi,yi0 - dyi0std*atipico_std,
color='blue',linestyle='dotted')
# atipicos
grafica.scatter(xi0_e,yi0_e, color='red')
# atipicos etiquetas
m = len(xi0_e)
for i inrange(0,m,1):
grafica.annotate(etiq0_e[i],
(xi0_e[i],yi0_e[i]),)
# linea Sin Atipicos
yi1 = eq_graf[unabaliza]['NoAtipico']
fdtxt1 = ecuacion[unabaliza]['NoAtipico']['eq_latex']
grafica.plot(xi,yi1, color='orange', label = fdtxt1)
# etiquetas y títulos
grafica.legend()
grafica.set_ylabel(medida+'_'+modo)
grafica.set_xlabel('distancia')
untitulo = unabaliza+': '+medida+'_'+modo + ' vs distancia'
grafica.set_title(untitulo)
grafica.grid(True,linestyle='dotted',
axis='x', which='both')
plt.show()
El algoritmo para realizar dos o más intervalos considera usar un estimado de frontera a lo largo de las mediciones.
Se implementa añadiendo al bloque de ingreso dos parámetros en el bloque ‘analiza’:
1. frontera es un vector donde se indican las distancia de los puntos de corte de los subintervalos sin considerar los extremos, corresponden a la frontera estimada en el mapa. El algoritmo actualiza la frontera con la intersección de la linealización de dos subintervalos consecutivos. Si frontera es un vector vacío [] se asume que se trabaja con todo el intervalo.
2. ‘atipInterv_std’ es un vector para la discriminación de los valores atipicos aplicada en cada subintervalo.
Como referencia para comparar, el resultado del análisis de todo el intervalo se denomina ‘r0’. Los subintervalosse identifican por ‘r1′,’r2’, etc, en orden al alejarse de la baliza.
En el resultado como valor complementario de revisión se añade el coeficiente de correlación de los puntos usados en el análisis.
Algoritmo en Python
# LoRa-Multipunto, Rssi vs distancia# linealización Rssi vs log10(distancia)# por mínimos cuadrados# Graficas 2D y 3D# Girni 2020-10-07 propuesta: edelros@espol.edu.ecimport numpy as np
import pandas as pd
import json
import matplotlib.pyplot as plt
import girni_lora_libreria as girni
# INGRESO# archivos de entrada
modo = 'rx'
medida = 'rssi'
descriptor = 'mean'
arch_medidaubica = 'rsmP06_'+medida+'Ubica01Intervalo.txt'# archivos de salida
arch_ecuaciones = 'rsmP07_ecuacion01Intervalos.json'# Analizar por segmentos
analiza = {'gtwRECT':{'analizar' : 1,
'atipico_std' : 1,
'frontera' : [320],
'atipInterv_std': [1,1],
'p_amplia': 4,
'grp' : ['RECT','FIEC'],
'tip' : ['punto'],
'LOS' : [1]},
'gtwFIEC':{'analizar' : 1,
'atipico_std' : 1,
'frontera' : [190],
'atipInterv_std': [1,1],
'p_amplia': 4,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]},
'gtwFCNM':{'analizar' : 1,
'atipico_std' : 1,
'frontera' : [235.0],
'atipInterv_std': [2,2],
'p_amplia': 4,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]}
}
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# Parámetros de grafica
tipograf = '2D'# '2D','3D'
escala = 'log'# 'normal','log'
escalabase = 10 # 10, np.exp()
casicero = 1e-4
precision = 3
intersectar = 1 # 0:Falso, 1: Verdadero# Referencias de gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
mostrargrpeti = ['FIEC','FCNM','RECT']
mostrartipeti = ['1m','gtw']
# PROCEDIMIENTO# Resultados de análisis
ecuacion = {}
eq_graf = {}
# leer datos
tabla = pd.read_csv(arch_medidaubica, index_col='etiqueta')
tabla = pd.DataFrame(tabla)
# analiza datos hacia una balizafor unabaliza in analiza:
# Parámetros
analizar = analiza[unabaliza]['analizar']
if analizar:
ecuacion[unabaliza] = {}
eq_graf[unabaliza] = {}
# pares a usar de baliza
[pares,par_etiqueta] = girni.pares_usar(tabla,baliza,
analiza,unabaliza,
medida = medida ,
modo = modo)
# todos los puntos# analiza puntos para mínimos cuadrados
xi = pares[:,0]
yi = pares[:,1]
n_xi = len(xi)
# coeficiente de correlación
correlacion = np.corrcoef(xi,yi)[0,1]
# minimos cuadrados
ecuacion0 = girni.linealiza_lstsq(xi,yi)
# selecciona atipicos
atipico_std = analiza[unabaliza]['atipico_std']
alpha = ecuacion0['alpha']
beta = ecuacion0['beta']
fdist0 = lambda d: -10*alpha*(np.log10(d))+beta
yi0 = fdist0(xi)
dyi0std = ecuacion0['error_std']
dyi0 = yi - yi0
atipicos = np.abs(dyi0) >= dyi0std*atipico_std
xi0_e = xi[atipicos]
yi0_e = yi[atipicos]
etiq0_e = par_etiqueta[atipicos]
unintervalo = 'r0'# todos# para exportar hacia archivo o gráfica
ecuacion[unabaliza] = {unintervalo: ecuacion0}
ecuacion[unabaliza][unintervalo]['correlacion'] = correlacion
eq_graf[unabaliza] = {unintervalo: {'xi_graf':xi,
'yi_graf':yi,
'etiqueta': par_etiqueta,
'linea' : yi0,
'atipicos':[xi0_e,yi0_e],
'atip_etiq': etiq0_e}
}
# Intervalos radiales en sector
intervalo = [np.min(xi),np.max(xi)]
frontera = analiza[unabaliza]['frontera']
iflen(frontera)>0:
# revisar si frontera esta dentro intervalo
frontera = np.array(frontera, dtype=float)
revisar = (frontera>=np.min(xi)) & (frontera<=np.max(xi))
enintervalo = list(frontera[revisar])
intervalo.extend(enintervalo)
intervalo = np.array(intervalo)
ordenar = np.argsort(intervalo)
intervalo = intervalo[ordenar]
n_intervalo = len(intervalo)
# analizar cada subintervalo
p_inicio = 0
p_desde = 0
p_amplia = analiza[unabaliza]['p_amplia']
atipIntv_std = analiza[unabaliza]['atipInterv_std']
for i inrange(0,n_intervalo-1,1):
i_eq = 'r'+str(i+1) # indice en texto# puntos en subintervalo [a,b]
a = intervalo[i]
b = intervalo[i+1]
subintervalo = (xi >= a) & (xi <= b)
xi_sub = xi[subintervalo]
yi_sub = yi[subintervalo]
n_sub = len(xi_sub)
etiq_sub = par_etiqueta[p_inicio:p_inicio + n_sub]
# amplia sub-intervalo, mejora intersecta rectas
detras = p_inicio
retrocede = detras
if detras > p_amplia:
retrocede = p_amplia
delante = n_xi - (p_inicio+n_sub)# -1)
avanza = delante
if delante >= p_amplia:
avanza = p_amplia
p_desde = p_inicio - retrocede
p_hasta = p_inicio + (n_sub) + avanza
p_inicio = p_inicio + (n_sub-1)
# subintervalo, amplia puntos
xi_a = xi[p_desde:p_hasta]
yi_a = yi[p_desde:p_hasta]
etiq_a = par_etiqueta[p_desde:p_hasta]
# coeficiente de correlación
correlacion1 = np.corrcoef(xi_a,yi_a)[0,1]
# analiza subintervalo
ecuacion1 = girni.linealiza_lstsq(xi_a,yi_a)
ecuacion[unabaliza][i_eq] = ecuacion1
ecuacion[unabaliza][i_eq]['correlacion'] = correlacion1
# atipicos del subintervalo extendido
alpha = ecuacion1['alpha']
beta = ecuacion1['beta']
fdist1 = lambda d: -10*alpha*(np.log10(d))+beta
yi1 = fdist1(xi_a)
dyi1std = ecuacion1['error_std']
atipico_std = analiza[unabaliza]['atipInterv_std'][i]
dyi1 = yi_a - yi1
atipicos = np.zeros(len(xi_a),dtype=bool)
if np.abs(dyi1std) > casicero:
atipicos = np.abs(dyi1) >= dyi1std*atipico_std
xi1_e = xi_a[atipicos]
yi1_e = yi_a[atipicos]
etiq1_e = etiq_a[atipicos]
# para gráfica, atipicos sin extender puntos
atipicos_sub = (xi1_e >= a) & (xi1_e<=b)
xi_sub1_e = xi1_e[atipicos_sub]
yi_sub1_e = yi1_e[atipicos_sub]
etiq_sub1e = etiq1_e[atipicos_sub]
eq_graf[unabaliza][i_eq] = {'atipicos': [xi_sub1_e,yi_sub1_e],
'atip_etiq':etiq_sub1e}
# subintervalo sin atipicosiflen(xi1_e)>0:
atipicoNo = np.abs(dyi1) <= dyi1std*atipico_std
xi2 = xi_a[atipicoNo]
yi2 = yi_a[atipicoNo]
etiq2 = etiq_a[atipicoNo]
# coeficiente de correlación
correlacion2 = np.corrcoef(xi2,yi2)[0,1]
ecuacion2 = girni.linealiza_lstsq(xi2,yi2)
# actualiza ecuación sin atipicos intervaloy
intervalox = ecuacion1['intervalox']
ecuacion2['intervalox'] = intervalox.copy()
alpha = ecuacion2['alpha']
beta = ecuacion2['beta']
fdist = lambda d: -10*alpha*(np.log10(d))+beta
intervaloy = fdist(intervalox)
ordenar = np.argsort(intervaloy)
intervaloy = list(intervaloy[ordenar])
ecuacion2['intervaloy'] = intervaloy
ecuacion[unabaliza][i_eq] = ecuacion2
#ecuacion[unabaliza][i_eq]['correlacion1'] = correlacion1
ecuacion[unabaliza][i_eq]['correlacion'] = correlacion2
# Revisa frontera entre subintervalos,# usa intersección de rectas como nueva frontera
interv_calc = np.copy(intervalo)
iflen(intervalo) >2 and intersectar==1 :
for i inrange(0,n_intervalo-2,1):
ai = 'r'+str(i+1)
bi = 'r'+str(i+2)
ma = ecuacion[unabaliza][ai]['alpha']
ba = ecuacion[unabaliza][ai]['beta']
mb = ecuacion[unabaliza][bi]['alpha']
bb = ecuacion[unabaliza][bi]['beta']
# punto de intersección o cruce
cruzanx = 10**((bb-ba)/(10*(mb-ma)))
dfrontera = frontera-cruzanx
# cruce dentro de intervalo de ecuacionif cruzanx > intervalo[-1]:
cruzanx = intervalo[-1]
if cruzanx < intervalo[0]:
cruzanx = intervalo[0]
interv_calc[i+1] = cruzanx
# para grafica evalua cada subintervalo sin atipicos
n_interv_calc = len(interv_calc)
for i inrange(0,n_interv_calc-1,1):
i_eq = 'r'+str(i+1)
a = interv_calc[i]
b = interv_calc[i+1]
subintervalo = (xi >= a) & (xi <= b)
xi_sub = xi[subintervalo]
yi_sub = yi[subintervalo]
xi_graf = np.copy(xi[subintervalo])
ifnot(a in xi_sub):
xi_graf = np.concatenate(([a],xi_graf),axis=0)
ifnot(b in xi_sub):
xi_graf = np.concatenate((xi_graf,[b]),axis=0)
# Evalua subintervalo con la ecuacion sin atipicos
alpha = ecuacion[unabaliza][i_eq]['alpha']
beta = ecuacion[unabaliza][i_eq]['beta']
fdist = lambda d: -10*alpha*(np.log10(d))+beta
yi1_sub = fdist(xi_sub)
yi_graf = fdist(xi_graf)
eq_graf[unabaliza][i_eq]['xi_graf'] = xi_graf
eq_graf[unabaliza][i_eq]['yi_graf'] = yi_graf
a = np.round(np.min([xi_graf]),precision)
b = np.round(np.max([xi_graf]),precision)
ecuacion[unabaliza][i_eq]['intervalox'] = [a,b]
ay = np.round(np.min([yi_graf]),precision)
by = np.round(np.max([yi_graf]),precision)
ecuacion[unabaliza][i_eq]['intervaloy'] = [ay,by]
# SALIDAfor unabaliza in ecuacion:
print('baliza: ',unabaliza)
for unaecuacion in ecuacion[unabaliza]:
unintervalo = ecuacion[unabaliza][unaecuacion]['intervalox']
unintervaloy = ecuacion[unabaliza][unaecuacion]['intervaloy']
error_medio = ecuacion[unabaliza][unaecuacion]['error_medio']
error_std = ecuacion[unabaliza][unaecuacion]['error_std']
eq_latex = ecuacion[unabaliza][unaecuacion]['eq_latex']
errorx_medio = ecuacion[unabaliza][unaecuacion]['errorx_medio']
errorx_std = ecuacion[unabaliza][unaecuacion]['errorx_std']
correlacion = ecuacion[unabaliza][unaecuacion]['correlacion']
print(' intervalo: ',unaecuacion)
print(' ' + eq_latex)
print(' ','intervalox: ',np.round(unintervalo,precision))
print(' ','intervaloy: ',np.round(unintervaloy,precision))
print(' correlación: ',np.round(correlacion,precision))
print(' |error_rssi| promedio: ',np.round(error_medio,precision),
' , std:',np.round(error_std,precision))
print(' |error_dist| promedio: ',np.round(errorx_medio,precision),
' , std:',np.round(errorx_std,precision))
print()
# salida hacia archivowithopen(arch_ecuaciones, 'w') as outfile:
json.dump(ecuacion, outfile)
# GRAFICA# Referencias para gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
mostrargrpeti = ['FIEC','FCNM','RECT']
mostrartipeti = ['1m','gtw']
if tipograf=='2D':
for unabaliza in ecuacion:
figura,grafica = plt.subplots()
if escala == 'log':
grafica.set_xscale(escala,base=escalabase)
# todos los puntos
unintervalo = 'r0'
xi = eq_graf[unabaliza][unintervalo]['xi_graf']
yi = eq_graf[unabaliza][unintervalo]['yi_graf']
etiqueta = eq_graf[unabaliza][unintervalo]['etiqueta']
grafica.scatter(xi,yi,marker='.')
m = len(xi)
for i inrange(0,m,1):
grafica.annotate(etiqueta[i],
(xi[i],yi[i]))
# linea con todos los puntos
fdtxt = ecuacion[unabaliza][unintervalo]['eq_latex']
yi0 = eq_graf[unabaliza][unintervalo]['linea']
a = np.round(np.min([xi]),2)
b = np.round(np.max([xi]),2)
eq_texto = fdtxt+' ; ['+str(a)+','+str(b)+']'
grafica.plot(xi,yi0,
label = eq_texto,
linestyle='dotted')
# lineas por cada subintervalo
eq_interv = list(ecuacion[unabaliza].keys())
eq_interv.pop(0)
n_intervalo = len(eq_interv)
for i_eq in eq_interv:
fdtxt = ecuacion[unabaliza][i_eq]['eq_latex']
xi_graf = eq_graf[unabaliza][i_eq]['xi_graf']
yi_graf = eq_graf[unabaliza][i_eq]['yi_graf']
a = np.round(np.min([xi_graf]),precision)
b = np.round(np.max([xi_graf]),precision)
eq_texto = fdtxt+' ; ['+str(a)+','+str(b)+']'
grafica.plot(xi_graf,yi_graf,
label = eq_texto)
# atipicos marcados en subintervalo
[xi1_e,yi1_e] = eq_graf[unabaliza][i_eq]['atipicos']
etiq1_e = eq_graf[unabaliza][i_eq]['atip_etiq']
grafica.scatter(xi1_e,yi1_e, color='red')
m = len(etiq1_e)
for i inrange(0,m,1):
grafica.annotate(etiq1_e[i],
(xi1_e[i],yi1_e[i]),
color='red')
# lineas de frontera
grafica.axvline(a, color='lightblue')
valor_frontera = str(np.round(a,precision))
grafica.annotate(valor_frontera,
(a,np.max([yi,yi0])),
color='lightblue')
grafica.axvline(b, color='lightblue')
valor_frontera = str(np.round(b,precision))
grafica.annotate(valor_frontera,
(b,np.max([yi,yi0])),
color='lightblue')
# etiquetas y títulos
grafica.legend()
grafica.set_ylabel(medida+'_'+modo)
grafica.set_xlabel('distancia')
grafica.grid(True,linestyle='dotted',
axis='x', which='both')
untitulo = unabaliza+': '+medida+'_'+modo + ' vs distancia'
grafica.set_title(untitulo)
plt.show()
Para el modelo de perdidas de propagación, en cada punto se registra en el archivo las mediciones de Rssi y SNR. Cada archivo de datos procesan, tabulando y ordenanto los valores representativos del comportamiento del RSSI y SNR para revisar sus descriptores de estadística.
Para realizar el procesamiento de los datos, se crearon algunas funciones y procedimientos para simplificar la escritura de instrucciones, las que se resumen en el archivo girni_lora_libreria.
Las coordenadas geográficas de dada punto se registraron con un GPS diferencial usando el formato UTM en un archivo tipo texto.
El procesamiento de los datos ser realiza en varios pasos donde se revisan los resultados parciales.
El primero de ellos consiste en tabular los datos de Rssi y SNR de cada punto en un solo archivo, luego se añaden las coordenadas y distancias cada punto medido, para finalmente integrar ambos resultados en un solo archivo con RSSI, distancias, coordenadas de cada punto.
Cada sección permite disponer de archivos intermedios que pueden ser usados para observar y procesar resultados que permitan realizar observaciones y mejoras a los modelos planteados. Entre los pasos intemedios está por ejemplo: observar en gráficas las ubicaciones de los puntos en el plano XY usando sus coordenadas, o en otro caso observar los valores de Rssi distribuidos en el espacio formado por el plano del ejemplo anterior y en el eje Z los valores promedios RSSI.
Las siguientes secciones describen lo realizado para:
El esquema prototipo para el modelo de pérdidas de señal en propagación, se registra los niveles de señal Rssi a diferentes distancias, condiciones y escenarios.
El esquema básico consta de tres balizas y un dispositivo de captura de datos. Cada baliza emite una señal a intervalos de tiempo que al ser captadas por el dispositivo permite obtener los valores Rssi y SNR. Dado que el objetivo final es revisar un modelo de localización, se requieren al menos tres balizas en el esquema.
El modelo de propagación require realizar mediciones en varios puntos a diferentes distancias que en campus presenta diferentes entornos.
Las mediciones de Rssi en un mismo punto no son constantes, por lo que se registran «muchos» valores, al menos 100 lecturas para estimar el comportamiento y usar valores representativos como el promedio y la desviación estándar..
La captura de los datos se simplifica usando un dispositivo LoRa y un computador portátil que almacena los datos en un archivo txt.
El dispositivo LoRa se programa para tomar lecturas de Rssi y SNR de cada baliza e inmediatamente enviarlos por la conexión serial/USB, al mismo tiempo que el dispositivo se alimenta de energía por el puerto USB.
Desde un computador portátil se leen los datos capturados por el dispositivo y leídos por la conexión USB y se almacenan en un archivo.txt. La lectura de datos serial/USB se realiza con un algoritmo en Python, que secuencialmente añade datos al archivo.txt para posterior procesamiento.
Las siguientes secciones describen lo realizado para:
En áreas extensas de medición donde existen diferentes ambientes o entornos como vegetación en una parte y edificios en otros, el resultado de básico de un solo intervalo puede mejorarse al utilizar subintervalos para cada entorno.
El cambio de entorno forma una frontera, observando la distancia al gateway (baliza) se la toma el valor como punto de partida para estimar la linealización de cada sub-intervalo. Se determinan las ecuaciones para cada intervalo, para calcular los puntos de intersección de cada linea teniendo como resultado una frontera entre diferentes ambientes calculada a partir de las mediciones realizadas.
baliza: ‘gtwFIEC’
Por ejemplo, para ‘gtwFIEC’ y su entorno mostrado en la imagen, en los puntos cercanos existe un ambiente con principalmente vegetación, que luego en puntos más alejados hay ambientes urbanos con edificios de aulas y administrativos.
Partiendo del ‘gtwFIEC’ se estima una frontera inicial a 176 metros para usar dos subintervalos y realizar la linealización.
Los parámetros para el algoritmo se establecen en el diccionario ‘analiza’. frontera es el vector donde se indica los puntos de corte del intervalo bajo estudio. Si frontera es vacio [], se asume que se analiza todo el intervalo.
Los parámetros usados en el algoritmo para obtener los resultados presentados corresponden a:
En la siguiente sección se detalla el algoritmo usado para generar las ecuaciones en cada segmento, las ecuaciones son usadas para estimar la ubicación relativa a cada baliza.
La relación de Rssi y distancia se puede observar usando los puntos en una gráfica 2D. El modelo teórico básico de larelación en espacio libre considera linealizar usando log10(distancia) para el eje x.
Método Empírico para ecuación Rssi(distancia)
La ecuación empírica con la que se realiza la primera estimación se modela como:
RSSI(d)=−10αlog10(d)+P01<d<L
1. Gráfica de todos los puntos en gtwFIEC
Para observar el resultado integral de todos los puntos medidos en las áreas de vegetación de FIEC y edificios FCNM realiza un primer modelo de linealización con todos los puntos. Para el eje x se usa log10(d)
Como ejemplo se presenta la gráfica para la baliza ‘d2’ etiquetada como gtwFIEC.
La linealización se realiza usando el método de los mínimos cuadrados (least square).
Al tomar como cota de error una desviación estándar por encima y por debajo de la línealización, se pueden discriminar los datos más alejados como atípicos. Se puede realizar nuevamente la linealización sin considerar los datos atípicos resultando un aumento en el valor de la pendiente α.
Al observar los datos de la gráfica que se encuentran fuera de la banda de una desviación estándar (σ) se tiene que se encuentran distribuidos en grupos: izquierda, centro y derecha. La observación lleva a considerar usar dos intervalos para realizar linealización, que es acorde los entornos de medición; los primeros puntos con etiqueta FIEC se realizaron en zona de vegetación, y los etiquetados como FCNM se realizaron en zona de edificios de aulas y administrativos.
El análisis de los datos se divide en dos secciones:
Análisis con un solo entorno, un intervalo para eje distancia
Análisis con dos entornos, dos intervalos para eje distancia
Se integran los archivos de Rssi y coordenadas en un solo archivo. Este proceso permite procesar Rssi vs distancias para generar el modelo de la ecuación que los describe.
Verificar los parámetros con los que se integran las tablas: nombres de archivos de entrada y salida, medidas.
La tabla general se constuye concatenando los componentes por colunnas.
La primera parte se conforma con los datos del punto de las columnas de grupos, tipos y LOS que provienen del archivo de ubicaciones de los puntos.
La segunda parte corresponde a la tabla de medidas de Rssi, y finalmente se complementa la tercera parte con la información de las coordenadas.
La tabla resultante se almacena en un archivo de resumen.
# Rssi y SNR LoRa punto a punto# LoRa-Multipunto, integra Ubicacion y Rssi# Girni 2020-10-07 propuesta: edelros@espol.edu.ecimport numpy as np
import pandas as pd
# INGRESO# revisar parametros al inicio
medida = 'rssi'
descriptor = 'mean'# archivos de entrada
arch_rsmpuntos = 'resumen_rssimean02.txt'
arch_rsmgps = 'resumen_ubica01.txt'# archivos de salida
arch_rssiubica = 'resumen_'+medida+'Ubica02.txt'# referencias
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# PROCEDIMIENTO# lectura de ubicacion
ubica = pd.read_csv(arch_rsmgps, index_col='etiqueta')
ubica = pd.DataFrame(ubica)
n=len(ubica)
# lectura de medida
rsm_medida = pd.read_csv(arch_rsmpuntos)
rsm_medida = pd.DataFrame(rsm_medida)
rsm_medida.rename(columns={'Unnamed: 0':'etiqueta'},
inplace=True)
rsm_medida['etiqueta'] = rsm_medida.etiqueta.astype(str)
rsm_medida = rsm_medida.set_index('etiqueta')
m=len(rsm_medida)
# tabla concatenada por columnas Y UNION# para mantener referencias de coordenadas de vertices
vertices = list(baliza.keys())
ultimovertice = vertices[-1]
etiquetas = list(ubica.keys())
donde = etiquetas.index('LOS_'+ultimovertice)
# inicia con grupos, tipos y LOS
tabla = ubica[etiquetas[:donde+1]]
# continua con los datos de medida
tabla = pd.concat([tabla,rsm_medida],
axis=1,join='outer')
# completa con lo que resta de ubica
tabla = pd.concat([tabla,
ubica[etiquetas[donde+1:]]],
axis=1,join='outer')
tabla = tabla.rename_axis('etiqueta')
k = len(tabla)
# SALIDAprint('registros: ',k)
print('indices: ',tabla.keys())
print('\n Ejemplo de tabla: ')
print(tabla.head())
tabla.to_csv(arch_rssiubica)
Para revisar los datos de coordenadas y ubicaciones obtenidos en el proceso anterior, se grafica la ubicación de los puntos usando las coordenadas este, norte y altura registradas con el GPS diferencial.
Las gráficas se pueden realizar en 2D y en 3D, se adjunta los resultados:
Como referencia se usan las etiquetas de los gateways que permiten observar la posición relativa de cada punto.
Los grupos de puntos a mostrar se pueden seleccionar en el bloque de ingreso dentro de los parámetros de la gráfica, permitiendo obervar con mayor detalle la ubicación de cada punto
Una observación en 3D de los puntos permite revisar que lso valores de altura presentan menor precisión que la de posición, principalmente en puntos ubicados entre vegetación.
Se observa que las medidas de alturas tienen valores muy variables, por lo que el uso de los valores de altura se descarta inicialmente de los modelos. Se podría realizar posteriormente un análisis más detallado de lo presentado con los valores de las alturas.
En el caso de gráficas 3D, para crear el archivo.gif animado es necesario instalar imagemagic. El nombre del archivo animado es ‘rotando3D.gif’ que se guarda en el mismo directorio del algoritmo.py.
# Datos desde GPS Diferencial archivo.txt# Graficas de coordenadas 2D o 3D# Girni 2020-10-07 edelros@espol.edu.ecimport numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.animation as animation
# INGRESO# Archivo procesado con distancias
arch_gpsrsm = 'resumen_ubica01.txt'# Parametros de gráfica
mostrargrp = ['FIEC','FCNM','RECT']
# ['FIEC','FCNM','RECT','CIRC']
mostrartip = ['punto','1m','dispositivo','gtw']
# ['punto','1m','dispositivo','gtw']
tipograf = '3D'# '2D','3D'
arch_rotacion = 'rotando3D.gif'# Referencias
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
# PROCEDIMIENTO# leer coordenadas
ubica = pd.read_csv(arch_gpsrsm, index_col='etiqueta')
ubica = pd.DataFrame(ubica)
n = len(ubica)
# puntos de vertices
vertices = ubica.loc[baliza.values()]
# segmento de grupo/tipo
ubica['usar'] = False
ubica['color'] = 'yellow'
ubica['marca'] = 'o'for fila in ubica.index:
unaeti = str(fila)
ungrupo = ubica['grupo'][fila]
untipo = ubica['tipo'][fila]
cond1 = ungrupo in mostrargrp
cond2 = untipo in mostrartip
if cond1:
cual = grupo.index(ungrupo)
ubica.loc[fila,'color'] = colores[cual]
if cond2:
cual = tipo.index(untipo)
ubica.loc[fila,'marca'] = marcas[cual]
if (cond1 and cond2):
ubica.loc[fila,'usar'] = True# SALIDAprint(ubica.head())
# Grafica 2D --------------------------if tipograf == '2D':
figura, grafica = plt.subplots()
for fila in ubica.index:
unalon = ubica['c_este'][fila]
unalat = ubica['c_norte'][fila]
unaalt = ubica['altitud'][fila]
usar = ubica['usar'][fila]
uncolor = ubica['color'][fila]
unamarca = ubica['marca'][fila]
untipo = ubica['tipo'][fila]
if usar:
grafica.scatter(unalon,unalat,
color = uncolor,
marker = unamarca,
label = fila)
if usar and untipo=='gtw':
grafica.annotate(fila,
(unalon,unalat))
plt.xlabel('UTM_este')
plt.ylabel('UTM_norte')
plt.title('Ubicacion UTM')
plt.show()
# Grafica 3D --------------------------if tipograf == '3D':
figura = plt.figure()
grafica = Axes3D(figura)
for fila in ubica.index:
unalon = ubica['c_este'][fila]
unalat = ubica['c_norte'][fila]
unaalt = ubica['altitud'][fila]
usar = ubica['usar'][fila]
uncolor = ubica['color'][fila]
unamarca = ubica['marca'][fila]
untipo = ubica['tipo'][fila]
if usar:
grafica.scatter(unalon,unalat,
unaalt,
marker = unamarca,
color = uncolor,
label = fila)
if (usar and (untipo=='gtw')):
grafica.text(unalon,unalat,
unaalt,fila)
grafica.set_xlabel('UTM_este')
grafica.set_ylabel('UTM_norte')
grafica.set_zlabel('altitud')
grafica.set_title('Ubicacion UTM')
defrotate(angle):
grafica.view_init(azim=angle)
print("realizando animation")
rot_animation = animation.FuncAnimation(figura,
rotate,
frames = np.arange(45,360+45,10),
interval = 200)
rot_animation.save(arch_rotacion, dpi=80,
writer = animation.PillowWriter(fps=5))
plt.show()
