La estimacion de distancia basada en RSSI es la base de cada despliegue de Bluetooth Beacon, pero las lecturas de RSSI en bruto son notoriamente ruidosas. Un beacon colocado a 3 metros puede producir lecturas que oscilan entre -75 dBm y -55 dBm en segundos, debido al desvanecimiento multitrayecto, el sombreado corporal y la interferencia de RF. Sin un filtrado adecuado, la deteccion de proximidad se convierte en un lanzamiento de moneda y los errores de posicion superan facilmente los 5 metros. Este articulo recorre los algoritmos de filtrado que realmente funcionan en sistemas de beacon de produccion, desde promedios moviles simples hasta filtros de Kalman y de particulas, con parametros reales, tablas de equilibrio y guias de implementacion.
## 1. El Problema del Ruido RSSI
El RSSI (Received Signal Strength Indicator) mide el nivel de potencia de un paquete de publicidad Bluetooth recibido. En espacio libre, el RSSI sigue un modelo de perdida de trayectoria predecible:
RSSI(d) = TX_power - 10*n*log10(d/d0) - X_sigmaDonde n es el exponente de perdida de trayectoria (2.0 en espacio libre, 2.7-4.3 en interiores), d0 es la distancia de referencia (1 m), y X_sigma es una variable aleatoria gaussiana de media cero que representa el sombreado, con desviacion estandar σ = 4-8 dB en entornos interiores tipicos.
En la practica, la suposicion gaussiana es una aproximacion. Las distribuciones RSSI reales se describen mejor como una mezcla de dos componentes:
– Componente linea de vista (LOS): Cuando existe una trayectoria directa, el RSSI es relativamente estable (σ ≈ 2-3 dB).
– Componente sin linea de vista (NLOS): Cuando la trayectoria directa esta bloqueada, el RSSI cae 10-20 dB y se vuelve muy variable (σ ≈ 6-10 dB).
Este comportamiento bimodal es la causa raiz de las estimaciones de distancia «saltarinas». Una persona caminando entre el beacon y el receptor puede causar caidas instantaneas de RSSI de 15 dB, lo que se traduce en un cambio de distancia aparente de 3 m a 17 m bajo el modelo de perdida logaritmica.
### Caracteristicas RSSI medidas
| Entorno | Exponente de perdida (n) | Sombreado σ (dB) | Ratio LOS/NLOS |
|---|---|---|---|
| Oficina abierta (cubiculos) | 2.3 | 3.8 | 85/15 |
| Pasillo (estrecho) | 2.0 | 2.5 | 90/10 |
| Oficina mixta (divisiones) | 2.7 | 5.2 | 60/40 |
| Almacen (estanterias metalicas) | 3.1 | 7.0 | 45/55 |
| Industrial (maquinaria) | 3.4 | 8.1 | 35/65 |
Los entornos de almacen e industrial muestran por que los sistemas de posicion beacon comerciales a menudo fallan: mas de la mitad de las lecturas son NLOS, y σ supera los 7 dB.
## 2. Por Que Necesita Filtrado: El Costo del RSSI en Bruto
Considere una aplicacion de deteccion de proximidad con un umbral de activacion de 4 metros. Usando RSSI en bruto con n=2.7 y σ=5.2 dB:
– A 3 m (dentro de zona): P(RSSI < umbral) ≈ 18% → tasa de falso negativo
– A 5 m (fuera de zona): P(RSSI ≥ umbral) ≈ 12% → tasa de falso positivo
Una tasa de error combinada del 30% hace que el RSSI en bruto sea inutilizable para cualquier activador de proximidad fiable. El filtrado reduce el σ efectivo por un factor de √N para el promedio de N muestras, pero esto tiene un costo de latencia.
El equilibrio fundamental:
Estabilidad (σ reducido) ⟷ Latencia (respuesta retrasada)Cada filtro discutido a continuacion se situa en algun punto de esta curva de equilibrio. El arte esta en elegir el punto correcto para su aplicacion.
## 3. Promedio Movil Simple (SMA)
El enfoque mas simple: mantener una ventana deslizante de las ultimas N muestras de RSSI y mostrar su media aritmetica.
#define WINDOW_SIZE 8
typedef struct {
int8_t buffer[WINDOW_SIZE];
uint8_t index;
uint8_t count;
int32_t sum;
} sma_filter_t;
int8_t sma_update(sma_filter_t *f, int8_t rssi) {
if (f->count == WINDOW_SIZE) {
f->sum -= f->buffer[f->index];
} else {
f->count++;
}
f->buffer[f->index] = rssi;
f->sum += rssi;
f->index = (f->index + 1) % WINDOW_SIZE;
return (int8_t)(f->sum / f->count);
}
Caracteristicas:
| Parametro | Valor |
|---|---|
| Reduccion de σ efectivo | √N (8 muestras → 2.83x reduccion → σ_eff = σ/2.83) |
| Retardo de grupo | (N-1)/2 × intervalo de muestreo |
| Memoria | N bytes |
| Calculo por muestra | O(1) (con suma acumulada) |
Con N=8 y un intervalo de publicidad de 100 ms, el retardo de grupo es 350 ms. Esto es aceptable para deteccion de proximidad pero demasiado lento para posicionamiento en tiempo real.
Problema: El SMA da el mismo peso a todas las muestras. Una lectura de 200 ms atras tiene la misma influencia que la mas reciente, lo que hace que el SMA sea lento cuando el beacon realmente se mueve.
## 4. Promedio Movil Ponderado (WMA)
El WMA asigna mayores pesos a las muestras recientes, mejorando la capacidad de respuesta:
// Pesos lineales: w[i] = i+1, peso total = N*(N+1)/2
int8_t wma_update(sma_filter_t *f, int8_t rssi) {
for (int i = WINDOW_SIZE - 1; i > 0; i--) {
f->buffer[i] = f->buffer[i-1];
}
f->buffer[0] = rssi;
int32_t weighted_sum = 0;
for (int i = 0; i < WINDOW_SIZE; i++) {
weighted_sum += f->buffer[i] * (WINDOW_SIZE - i);
}
return (int8_t)(weighted_sum / (WINDOW_SIZE * (WINDOW_SIZE + 1) / 2));
}
El WMA reduce el retardo de grupo aproximadamente 30% comparado con el SMA para el mismo tamano de ventana, a costa de una ligera menor reduccion de ruido (N efectivo reducido ~15%).
| Filtro | N=8 reduccion σ | Retardo de grupo (intervalo 100ms) | Capacidad de respuesta |
|---|---|---|---|
| SMA | 2.83x | 350 ms | Baja |
| WMA | 2.45x | 240 ms | Media |
## 5. Promedio Movil Exponencial (EWMA)
El EWMA es el filtro RSSI mas popular en SDKs de beacon comerciales (incluyendo Apple iBeacon, Google Eddystone) porque requiere solo una variable de estado y no tiene buffer:
typedef struct {
float filtered;
float alpha;
uint8_t initialized;
} ewma_filter_t;
float ewma_update(ewma_filter_t *f, float rssi) {
if (!f->initialized) {
f->filtered = rssi;
f->initialized = 1;
} else {
f->filtered = f->alpha * rssi + (1.0f - f->alpha) * f->filtered;
}
return f->filtered;
}
El factor de suavizado α controla el equilibrio:
– α = 1.0: Sin filtrado (RSSI en bruto)
– α = 0.3: Suavizado moderado (equivalente a SMA N≈6)
– α = 0.1: Suavizado fuerte (equivalente a SMA N≈20)
– α = 0.05: Muy fuerte (equivalente a SMA N≈40)
La «N equivalente» para EWMA es aproximadamente N_eq ≈ (2-α)/α, que da la misma reduccion de varianza que un SMA de N muestras.
### Seleccion de α
| Aplicacion | α recomendado | Tiempo de asentamiento | σ efectivo |
|---|---|---|---|
| Posicionamiento en tiempo real (seguimiento de activos) | 0.3-0.4 | 0.3-0.5 s | σ/2.0 |
| Deteccion de proximidad (notificaciones push) | 0.15-0.25 | 0.8-1.5 s | σ/3.5 |
| Navegacion interior (guiado) | 0.2-0.3 | 0.5-1.0 s | σ/2.8 |
| Monitoreo estatico (deteccion de ocupacion) | 0.05-0.1 | 2-4 s | σ/5.0 |
El tiempo de asentamiento es aproximadamente 5/α × intervalo. Para α=0.2 a intervalo de 100 ms, el filtro tarda unos 2.5 segundos en converger a un nuevo estado estable despues de un cambio escalon.
El EWMA no es simetrico: responde rapidamente a aumentos de RSSI (beacon acercandose) pero lentamente a disminuciones de RSSI (beacon alejandose), porque el filtro siempre se retrasa. Para deteccion de entrada/salida de proximidad, esta asimetria causa «salidas pegajosas»: el sistema sigue reportando el beacon como cercano durante varios segundos despues de que se ha alejado.
## 6. Filtro de Mediana para Rechazo de Valores Atipicos
Los filtros de mediana son fundamentalmente diferentes de los promedios: muestran la mediana de la ventana, no la media. Esto los hace inmunes a los valores atipicos.
// Ordenamiento por insercion simple para N pequeno
int8_t median_filter(int8_t *buf, uint8_t n) {
int8_t temp[n];
memcpy(temp, buf, n);
for (int i = 1; i < n; i++) {
int8_t key = temp[i];
int j = i - 1;
while (j >= 0 && temp[j] > key) {
temp[j+1] = temp[j];
j--;
}
temp[j+1] = key;
}
return temp[n / 2];
}
Por que la mediana funciona para RSSI: La distribucion bimodal LOS/NLOS significa que las lecturas NLOS son esencialmente valores atipicos, caidas repentinas de 10-20 dB. Un filtro basado en media incorpora estos valores atipicos, sesgando la estimacion a la baja (distancia mayor). Un filtro de mediana con N≥5 simplemente los descarta.
| Tipo de filtro | Entrada: [-70, -72, -55, -71, -68, -73, -70] | Salida | RSSI real ≈ -71 |
|---|---|---|---|
| SMA (N=7) | Media = -68.4 | -68.4 dBm | Sesgo 2.6 dB |
| EWMA (α=0.3) | -67.8 dBm | Sesgo 3.2 dB | |
| Mediana (N=7) | Ordenado: [-73,-72,-71,-70,-68,-55] | -70 dBm | Sesgo 1.0 dB |
El valor atipico de -55 dBm (probablemente una reflexion multitrayecto) crea un sesgo positivo de 2-3 dB en filtros basados en media, lo que se traduce en una subestimacion de distancia del 25%. El filtro de mediana apenas se ve afectado.
Enfoque hibrido: Aplicar primero un filtro de mediana (N=5) para rechazar valores atipicos, luego EWMA (α=0.2) sobre la salida de mediana para suavizar. Este diseno de dos etapas combina rechazo de valores atipicos con seguimiento de baja latencia, y es el enfoque recomendado para sistemas de produccion.
## 7. Filtro de Kalman para Estimacion RSSI
El filtro de Kalman modela el RSSI como un estado con ruido de proceso y ruido de medicion, produciendo la estimacion de error cuadratico medio minimo (MMSE) bajo suposiciones gaussianas lineales.
### Modelo de estado
Estado: x[k] = x[k-1] + w[k] (RSSI constante + ruido de proceso)
Medicion: z[k] = x[k] + v[k] (RSSI observado + ruido de medicion)
Ruido de proceso: w ~ N(0, Q)
Ruido de medicion: v ~ N(0, R)
Para un beacon estacionario, Q debe ser pequeno (0.1-0.5) ya que el RSSI no cambia rapidamente. Para un beacon en movimiento, Q debe ser mayor (1.0-5.0) para permitir que el filtro rastree cambios.
### Implementacion
typedef struct {
float x; // Estimacion de estado
float p; // Incertidumbre de estimacion
float q; // Varianza del ruido de proceso
float r; // Varianza del ruido de medicion
} kalman_rssi_t;
float kalman_update(kalman_rssi_t *kf, float measurement) {
// Predecir
kf->p = kf->p + kf->q;
// Actualizar
float k = kf->p / (kf->p + kf->r); // Ganancia de Kalman
kf->x = kf->x + k * (measurement - kf->x);
kf->p = (1.0f - k) * kf->p;
return kf->x;
}
### Ajuste de Q y R
La relacion Q/R determina el comportamiento del filtro:
| Relacion Q/R | Comportamiento | Aplicacion |
|---|---|---|
| 0.01 | Muy suave, respuesta lenta | Monitoreo de activos estaticos |
| 0.1 | Equilibrado | Posicionamiento interior general |
| 0.5 | Responsivo, ruido moderado | Seguimiento de activos en movimiento |
| 1.0+ | Poco filtrado, respuesta rapida | Escenarios de alta movilidad |
Con R establecido desde σ² medido (ej.: σ=5.2 → R=27.0) y Q=2.7 (Q/R=0.1), el filtro de Kalman alcanza un σ_eff de aproximadamente 2.3 dB, una reduccion de 2.3x, con un tiempo de asentamiento de unos 1.5 segundos.
### Ventajas sobre EWMA
El filtro de Kalman adapta su ganancia dinamicamente: cuando la incertidumbre de estimacion es alta (justo despues de la inicializacion o un cambio escalon), la ganancia es alta y el filtro responde rapidamente. A medida que aumenta la confianza, la ganancia disminuye y el filtro se vuelve mas suave. EWMA usa un α fijo, que no puede adaptarse.
| Propiedad | EWMA (α=0.2) | Kalman (Q=2.7, R=27.0) |
|---|---|---|
| σ_eff en estado estacionario | 2.6 dB | 2.3 dB |
| Respuesta escalon (90% subida) | 2.5 s | 1.2 s |
| Ganancia adaptativa | No | Si |
| Memoria | 4 bytes | 16 bytes |
| Calculo por muestra | 2 ops | 5 ops |
## 8. Filtro de Particulas para Entornos No Lineales
En entornos con multitrayecto severo (almacenes, fabricas), la suposicion gaussiana se rompe. Las distribuciones RSSI se vuelven multimodales, y los filtros lineales (EWMA, Kalman) convergen al valor equivocado.
El filtro de particulas representa la distribucion de probabilidad RSSI como un conjunto de muestras ponderadas (particulas):
import numpy as np
class ParticleFilterRSSI:
def __init__(self, n_particles=100, rssi_range=(-100, -30)):
self.n = n_particles
self.particles = np.random.uniform(rssi_range[0], rssi_range[1], n_particles)
self.weights = np.ones(n_particles) / n_particles
def predict(self, process_std=2.0):
self.particles += np.random.normal(0, process_std, self.n)
def update(self, measurement, measurement_std=5.0):
likelihood = np.exp(-0.5 * ((self.particles - measurement) / measurement_std) ** 2)
self.weights *= likelihood
self.weights /= self.weights.sum()
def estimate(self):
return np.sum(self.particles * self.weights)
def resample(self):
indices = np.random.choice(self.n, self.n, p=self.weights)
self.particles = self.particles[indices]
self.weights.fill(1.0 / self.n)
def step(self, measurement):
self.predict()
self.update(measurement)
est = self.estimate()
n_eff = 1.0 / np.sum(self.weights ** 2)
if n_eff < self.n / 2:
self.resample()
return est
### Rendimiento en entornos dominados por NLOS
En una prueba de almacen (55% NLOS), rastreando un beacon a 4 m de distancia:
| Filtro | Error medio (m) | Error P95 (m) | Tiempo de convergencia |
|---|---|---|---|
| SMA (N=8) | 2.1 | 5.8 | 0.8 s |
| EWMA (α=0.2) | 1.9 | 5.2 | 1.0 s |
| Kalman (Q/R=0.1) | 1.6 | 4.5 | 1.2 s |
| Particulas (100 particulas) | 0.9 | 2.1 | 1.5 s |
El filtro de particulas reduce el error medio en 43% comparado con EWMA en este entorno adverso. Sin embargo, requiere 100x mas memoria y calculo, haciendolo impracticable en etiquetas beacon con recursos limitados.
Recomendacion: Usar filtros de particulas en el lado del receptor/gateway (smartphones, gateways Raspberry Pi) donde hay capacidad de calculo. En las etiquetas beacon mismas, EWMA o Kalman es suficiente ya que la etiqueta solo transmite; el filtrado ocurre en el receptor.
## 9. Comparacion de Filtros: Tabla de Equilibrio Completa
| Filtro | Reduccion σ (σ=5.2 dB) | Latencia | Memoria | Calculo | Resistente a atipicos | Adaptativo |
|---|---|---|---|---|---|---|
| RSSI en bruto | 1.0x (5.2 dB) | 0 ms | 0 B | 0 ops | No | N/A |
| SMA (N=4) | 2.0x (2.6 dB) | 150 ms | 4 B | 1 op | No | No |
| SMA (N=8) | 2.8x (1.8 dB) | 350 ms | 8 B | 1 op | No | No |
| WMA (N=8) | 2.5x (2.1 dB) | 240 ms | 8 B | 8 ops | No | No |
| EWMA (α=0.3) | 1.8x (2.9 dB) | 100 ms | 4 B | 2 ops | No | No |
| EWMA (α=0.15) | 2.9x (1.8 dB) | 800 ms | 4 B | 2 ops | No | No |
| Mediana (N=5) | 1.7x (3.1 dB) | 200 ms | 5 B | 10 ops | Si | No |
| Mediana+EWMA | 2.7x (1.9 dB) | 300 ms | 9 B | 12 ops | Si | No |
| Kalman | 2.3x (2.3 dB) | 150 ms | 16 B | 5 ops | Parcial | Si |
| Particulas (100) | 3.5x (1.5 dB) | 400 ms | 800 B | 300 ops | Si | Si |
Observaciones clave:
– Mediana+EWMA ofrece el mejor equilibrio para sistemas embebidos: rendimiento cercano a Kalman con implementacion mas simple y rechazo de valores atipicos.
– Kalman es optimo cuando puede ajustar Q/R adecuadamente y necesita comportamiento adaptativo.
– Filtro de particulas destaca en multitrayecto adverso pero es solo para gateway debido al costo computacional.
– SMA es adecuado para monitoreo estatico donde la latencia no importa.
## 10. Estrategias de Filtrado Adaptativo
Los filtros de parametros fijos son suboptimos porque las estadisticas RSSI cambian con el entorno y la movilidad del beacon. Las estrategias adaptativas mejoran significativamente el rendimiento:
### 10.1 EWMA consciente de movilidad
Detectar el movimiento del beacon usando la varianza RSSI en una ventana corta, luego ajustar α dinamicamente:
float adaptive_alpha(float *recent_rssi, uint8_t n) {
float mean = 0;
for (int i = 0; i < n; i++) mean += recent_rssi[i];
mean /= n;
float var = 0;
for (int i = 0; i < n; i++) {
float d = recent_rssi[i] - mean;
var += d * d;
}
var /= n;
if (var > 25.0f) return 0.4f; // Movimiento rapido
else if (var > 10.0f) return 0.25f; // Movimiento lento
else return 0.1f; // Estatico
}
### 10.2 Kalman consciente del entorno
Ajustar R basandose en la probabilidad NLOS local. Cuando las mediciones recientes muestran grandes desviaciones del estado predicho, aumentar R temporalmente:
void adaptive_kalman(kalman_rssi_t *kf, float measurement, float *residuals, uint8_t n) {
float mean_res = 0;
for (int i = 0; i < n; i++) mean_res += residuals[i];
mean_res /= n;
float res_var = 0;
for (int i = 0; i < n; i++) {
float d = residuals[i] - mean_res;
res_var += d * d;
}
res_var /= n;
if (res_var > kf->r * 1.5f) {
kf->r = kf->r * 1.3f;
} else {
kf->r = kf->r * 0.95f;
}
if (kf->r < 5.0f) kf->r = 5.0f;
if (kf->r > 100.0f) kf->r = 100.0f;
kalman_update(kf, measurement);
}
### 10.3 Deteccion LOS/NLOS basada en HMM
Un Modelo de Markov Oculto puede clasificar cada medicion como LOS o NLOS, luego aplicar diferentes filtros:
– Estado LOS: Aplicar Kalman con R bajo (confiando en la medicion)
– Estado NLOS: Aplicar Kalman con R alto (descontando la medicion) o descartarla
La matriz de transicion se aprende empiricamente de datos de entrenamiento. Probabilidades de transicion tipicas para un entorno de oficina:
| Siguiente: LOS | Siguiente: NLOS | |
|---|---|---|
| Actual: LOS | 0.92 | 0.08 |
| Actual: NLOS | 0.35 | 0.65 |
Esto significa que LOS tiende a persistir (92% de probabilidad de permanecer LOS), mientras que NLOS tambien es algo persistente (65%). El HMM alcanza 85-90% de precision de clasificacion, mejorando significativamente el rendimiento del filtro en entornos mixtos.
## 11. Consideraciones de Implementacion
### 11.1 Aritmetica entera para MCUs con recursos limitados
En MCUs de 8 o 16 bits (comunes en etiquetas beacon), las operaciones de punto flotante son costosas. EWMA puede implementarse en punto fijo:
// EWMA de punto fijo con formato Q8 (8 bits fraccionarios)
// alpha = 0.2 → alpha_q8 = 51 (0.2 * 256)
typedef struct {
int16_t filtered;
uint8_t initialized;
} ewma_fixed_t;
int8_t ewma_fixed_update(ewma_fixed_t *f, int8_t rssi) {
int16_t rssi_q8 = (int16_t)rssi << 8;
if (!f->initialized) {
f->filtered = rssi_q8;
f->initialized = 1;
} else {
f->filtered = (51 * rssi_q8 + 205 * f->filtered) >> 8;
}
return (int8_t)(f->filtered >> 8);
}
Esto usa solo multiplicacion y desplazamiento de enteros, sin necesidad de biblioteca de punto flotante.
### 11.2 Manejo de intervalos de publicidad
Los intervalos de publicidad de beacon varian de 20 ms (posicionamiento de alta tasa) a 1000 ms (modo de ahorro de bateria). Los parametros del filtro deben escalar con el intervalo:
– Intervalo 100 ms con α=0.2: constante de tiempo = 0.5 s
– Intervalo 1000 ms con α=0.2: constante de tiempo = 5.0 s (demasiado lento)
Solucion: Calcular α a partir de una constante de tiempo deseada τ:
α = 1 - exp(-Δt / τ)Donde Δt es el intervalo de publicidad y τ es la constante de tiempo deseada (ej.: 0.5 s). Esto asegura un comportamiento de filtro consistente independientemente del intervalo.
### 11.3 Filtrado multi-beacon
Al rastrear multiples beacons simultaneamente, cada beacon necesita su propia instancia de filtro. Presupuesto de memoria en un gateway tipico (ESP32, 520 KB SRAM):
| Tipo de filtro | Memoria por beacon | Max beacons (presupuesto 50 KB) |
|---|---|---|
| EWMA (float) | 8 B | 6,250 |
| Kalman (float) | 32 B | 1,562 |
| Mediana+EWMA (N=5, int8) | 14 B | 3,571 |
| Particulas (100, float) | 1,600 B | 31 |
EWMA y Kalman escalan bien a miles de beacons. Los filtros de particulas se limitan a decenas.
## 12. Recomendaciones de Despliegue
Basado en pruebas de campo en entornos de oficina, retail, almacen e industrial, aqui estan las configuraciones de filtro recomendadas:
### Deteccion de proximidad (notificaciones push, entrada/salida de zona)
Filtro: Mediana (N=5) + EWMA (α=0.15)
Intervalo: 100-200 ms
σ_eff: ~2.0 dB
Latencia: ~400 ms
Notas: La mediana rechaza valores atipicos NLOS; EWMA suaviza el ruido restante.
Usar historesis en el umbral de distancia (entrada a 3m, salida a 5m)
para evitar rebotes.
### Posicionamiento interior (trilateracion, fingerprinting)
Filtro: Kalman (Q=0.5, R=σ_medido²)
Intervalo: 100-300 ms
σ_eff: ~2.3 dB
Latencia: ~150 ms
Notas: Ajustar R por entorno. Usar R adaptativo para areas con mucho NLOS.
La tasa de actualizacion de posicion debe ser 2-5 Hz para UI fluida.
### Seguimiento de activos (RTLS, seguimiento de montacargas)
Filtro: EWMA adaptativo (α: 0.1-0.4, consciente de movilidad)
Intervalo: 200-500 ms
σ_eff: ~2.5 dB (dinamico)
Latencia: 100-800 ms (dinamico)
Notas: Detectar movimiento via varianza RSSI, cambiar α en consecuencia.
Usar filtro de particulas en gateway si el multitrayecto es severo.
### Monitoreo estatico (deteccion de ocupacion, presencia a nivel de sala)
Filtro: EWMA (α=0.05) o SMA (N=20)
Intervalo: 500-1000 ms
σ_eff: ~1.2 dB
Latencia: 2-5 s
Notas: La latencia es aceptable para deteccion de presencia.
Ultra bajo σ permite clasificacion fiable a nivel de sala.
### Multitrayecto severo (almacen, fabrica)
Filtro: Filtro de particulas (50-100 particulas) en gateway
+ Kalman en receptor movil
Intervalo: 100-200 ms
σ_eff: ~1.5 dB
Latencia: ~400 ms
Notas: El filtro de particulas maneja distribuciones RSSI multimodales.
El procesamiento en el lado del gateway descarga computo de las etiquetas.
## Conclusion
El filtrado RSSI no es opcional: es el paso de procesamiento de senal de mayor impacto en cualquier sistema de beacon. La eleccion del algoritmo depende de la tolerancia a latencia de la aplicacion, el presupuesto de calculo y el entorno de RF:
– Para prototipos rapidos y proximidad simple: EWMA con α=0.2 es suficiente.
– Para deteccion de proximidad en produccion: el hibrido Mediana + EWMA es la mejor opcion de proposito general.
– Para sistemas de posicionamiento: Filtro de Kalman con Q/R ajustado al entorno.
– Para multitrayecto adverso: Filtro de particulas en el lado del gateway.
El error mas comun es usar un solo filtro fijo para todos los escenarios. Los entornos reales cambian: la gente se mueve, las puertas se abren, los canales Wi-Fi cambian. Las estrategias adaptativas que detectan movilidad y condiciones NLOS pueden reducir el error de posicionamiento en 30-50% comparado con filtros de parametros fijos, sin costo adicional de hardware.
Recuerde que ningun filtro puede recuperar informacion que no esta alli. Si el beacon solo publica una vez por segundo, ninguna cantidad de filtrado le dara latencia sub-segundo. Comience con una tasa de publicidad adecuada, elija el filtro mas simple que cumpla sus requisitos de precision, y agregue complejidad solo cuando las mediciones demuestren que es necesaria. Al seleccionar hardware, considere un modulo Bluetooth fiable que soporte intervalos de publicidad y potencia de salida configurables; estos parametros afectan directamente la calidad del RSSI en bruto con la que su filtro tiene que trabajar.
