L’estimation de distance basee sur le RSSI est le fondement de chaque deploiement de Bluetooth Beacon, mais les mesures RSSI brutes sont notoirement bruitees. Une balise placee a 3 metres peut produire des mesures oscillant entre -75 dBm et -55 dBm en quelques secondes, dues a l’evanouissement multitrajet, l’ombrage corporel et l’interference RF. Sans filtrage adequat, la detection de proximite devient un jeu de pile ou face et les erreurs de positionnement depassent facilement 5 metres. Cet article parcourt les algorithmes de filtrage qui fonctionnent reellement dans les systemes de balises en production, des moyennes mobiles simples aux filtres de Kalman et de particules, avec des parametres reels, des tableaux de compromis et des guides d’implementation.
1. Le Probleme du Bruit RSSI
Le RSSI (Received Signal Strength Indicator) mesure le niveau de puissance d’un paquet de publicite Bluetooth recu. En espace libre, le RSSI suit un modele d’affaiblissement de trajet previsible :
RSSI(d) = TX_power - 10*n*log10(d/d0) - X_sigmaOu n est l’exposant d’affaiblissement de trajet (2.0 en espace libre, 2.7-4.3 en interieur), d0 est la distance de reference (1 m), et X_sigma est une variable aleatoire gaussienne de moyenne nulle representant l’ombrage, avec un ecart-type σ = 4-8 dB dans des environnements interieurs typiques.
En pratique, l’hypothese gaussienne est une approximation. Les distributions RSSI reelles sont mieux decrites comme un melange de deux composantes :
– Composante ligne de vue (LOS) : Lorsqu’un trajet direct existe, le RSSI est relativement stable (σ ≈ 2-3 dB).
– Composante sans ligne de vue (NLOS) : Lorsque le trajet direct est bloque, le RSSI chute de 10-20 dB et devient tres variable (σ ≈ 6-10 dB).
Ce comportement bimodal est la cause profonde des estimations de distance « sauteuses ». Une personne marchant entre la balise et le recepteur peut causer des chutes instantanees de RSSI de 15 dB, ce qui se traduit par un changement de distance apparente de 3 m a 17 m sous le modele de perte logarithmique.
Caracteristiques RSSI mesurees
| Environnement | Exposant d’affaiblissement (n) | Ombrage σ (dB) | Ratio LOS/NLOS |
|---|---|---|---|
| Bureau ouvert (cubicles) | 2.3 | 3.8 | 85/15 |
| Couloir (etroit) | 2.0 | 2.5 | 90/10 |
| Bureau mixte (cloisons) | 2.7 | 5.2 | 60/40 |
| Entrepot (racks metalliques) | 3.1 | 7.0 | 45/55 |
| Industriel (machines) | 3.4 | 8.1 | 35/65 |
Les environnements d’entrepot et industriel montrent pourquoi les systemes de positionnement par balises commerciaux echouent souvent : plus de la moitie des mesures sont NLOS, et σ depasse 7 dB.
2. Pourquoi le Filtrage est Necessaire : Le Cout du RSSI Brut
Considerons une application de detection de proximite avec un seuil de declenchement de 4 metres. En utilisant le RSSI brut avec n=2.7 et σ=5.2 dB :
– A 3 m (dans la zone) : P(RSSI < seuil) ≈ 18% → taux de faux negatif
– A 5 m (hors zone) : P(RSSI ≥ seuil) ≈ 12% → taux de faux positif
Un taux d’erreur combine de 30% rend le RSSI brut inutilisable pour tout declencheur de proximite fiable. Le filtrage reduit le σ effectif d’un facteur √N pour la moyenne de N echantillons, mais cela a un cout de latence.
Le compromis fondamental :
Stabilite (σ reduit) ⟷ Latence (reponse retardee)Chaque filtre discute ci-dessous se situe quelque part sur cette courbe de compromis. L’art consiste a choisir le bon point pour votre application.
3. Moyenne Mobile Simple (SMA)
L’approche la plus simple : maintenir une fenetre glissante des N derniers echantillons RSSI et sortir leur moyenne arithmetique.
#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);
}
Caracteristiques :
| Parametre | Valeur |
|---|---|
| Reduction de σ effectif | √N (8 echantillons → reduction 2.83x → σ_eff = σ/2.83) |
| Retard de groupe | (N-1)/2 × intervalle d’echantillonnage |
| Memoire | N octets |
| Calcul par echantillon | O(1) (avec somme courante) |
Avec N=8 et un intervalle de publicite de 100 ms, le retard de groupe est de 350 ms. C’est acceptable pour la detection de proximite mais trop lent pour le positionnement en temps reel.
Probleme : Le SMA donne un poids egal a tous les echantillons. Une mesure de 200 ms en arriere a la meme influence que la plus recente, ce qui rend le SMA lent lorsque la balise se deplace reellement.
4. Moyenne Mobile Ponderee (WMA)
Le WMA attribue des poids plus eleves aux echantillons recents, ameliorant la reactivite :
// Poids lineaires : w[i] = i+1, poids 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));
}
Le WMA reduit le retard de groupe d’environ 30% par rapport au SMA pour la meme taille de fenetre, au prix d’une reduction de bruit legerement inferieure (N effectif reduit de ~15%).
| Filtre | N=8 reduction σ | Retard de groupe (intervalle 100ms) | Reactivite |
|---|---|---|---|
| SMA | 2.83x | 350 ms | Faible |
| WMA | 2.45x | 240 ms | Moyenne |
5. Moyenne Mobile Exponentielle Ponderee (EWMA)
L’EWMA est le filtre RSSI le plus populaire dans les SDK de balises commerciaux (y compris Apple iBeacon, Google Eddystone) car il ne necessite qu’une seule variable d’etat et n’a pas de tampon :
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;
}
Le facteur de lissage α controle le compromis :
– α = 1.0 : Pas de filtrage (RSSI brut)
– α = 0.3 : Lissage modere (equivalent a SMA N≈6)
– α = 0.1 : Lissage fort (equivalent a SMA N≈20)
– α = 0.05 : Tres fort (equivalent a SMA N≈40)
Le « N equivalent » pour l’EWMA est approximativement N_eq ≈ (2-α)/α, qui donne la meme reduction de variance qu’un SMA de N echantillons.
Choix de α
| Application | α recommande | Temps de stabilisation | σ effectif |
|---|---|---|---|
| Positionnement temps reel (suivi d’actifs) | 0.3-0.4 | 0.3-0.5 s | σ/2.0 |
| Detection de proximite (notifications push) | 0.15-0.25 | 0.8-1.5 s | σ/3.5 |
| Navigation interieure (guidage) | 0.2-0.3 | 0.5-1.0 s | σ/2.8 |
| Surveillance statique (detection de presence) | 0.05-0.1 | 2-4 s | σ/5.0 |
Le temps de stabilisation est approximativement 5/α × intervalle. Pour α=0.2 a intervalle de 100 ms, le filtre prend environ 2.5 secondes pour converger vers un nouvel etat stationnaire apres un changement en echelon.
L’EWMA n’est pas symetrique : il repond rapidement aux augmentations de RSSI (balise s’approchant) mais lentement aux diminutions de RSSI (balise s’eloignant), car le filtre est toujours en retard. Pour la detection d’entree/sortie de proximite, cette asymetrie cause des « sorties collees » : le systeme continue de signaler la balise comme proche pendant plusieurs secondes apres qu’elle s’est eloignee.
6. Filtre Median pour le Rejet des Valeurs Aberrantes
Les filtres median sont fondamentalement differents des moyennes : ils sortent la mediane de la fenetre, non la moyenne. Cela les rend immunises aux valeurs aberrantes.
// Tri par insertion simple pour petit N
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];
}
Pourquoi le median fonctionne pour le RSSI : La distribution bimodale LOS/NLOS signifie que les mesures NLOS sont essentiellement des valeurs aberrantes – des chutes soudaines de 10-20 dB. Un filtre base sur la moyenne incorpore ces valeurs aberrantes, biaisanl l’estimation vers le bas (distance plus grande). Un filtre median avec N≥5 les rejette simplement.
| Type de filtre | Entree : [-70, -72, -55, -71, -68, -73, -70] | Sortie | RSSI reel ≈ -71 |
|---|---|---|---|
| SMA (N=7) | Moyenne = -68.4 | -68.4 dBm | Biais 2.6 dB |
| EWMA (α=0.3) | -67.8 dBm | Biais 3.2 dB | |
| Median (N=7) | Trie : [-73,-72,-71,-70,-68,-55] | -70 dBm | Biais 1.0 dB |
La valeur aberrante de -55 dBm (probablement une reflexion multitrajet) cree un biais positif de 2-3 dB dans les filtres bases sur la moyenne, ce qui correspond a une sous-estimation de distance de 25%. Le filtre median est a peine affecte.
Approche hybride : Appliquer d’abord un filtre median (N=5) pour rejeter les valeurs aberrantes, puis EWMA (α=0.2) sur la sortie mediane pour le lissage. Cette conception a deux etages combine le rejet des valeurs aberrantes avec un suivi a faible latence, et est l’approche recommandee pour les systemes en production.
7. Filtre de Kalman pour l’Estimation RSSI
Le filtre de Kalman modelise le RSSI comme un etat avec bruit de processus et bruit de mesure, produisant l’estimation d’erreur quadratique moyenne minimale (MMSE) sous des hypotheses gaussiennes lineaires.
Modele d’etat
Etat : x[k] = x[k-1] + w[k] (RSSI constant + bruit de processus)
Mesure : z[k] = x[k] + v[k] (RSSI observe + bruit de mesure)
Bruit de processus : w ~ N(0, Q)
Bruit de mesure : v ~ N(0, R)
Pour une balise stationnaire, Q doit etre petit (0.1-0.5) car le RSSI ne change pas rapidement. Pour une balise en mouvement, Q doit etre plus grand (1.0-5.0) pour permettre au filtre de suivre les changements.
Implementation
typedef struct {
float x; // Estimation d'etat
float p; // Incertitude d'estimation
float q; // Variance du bruit de processus
float r; // Variance du bruit de mesure
} kalman_rssi_t;
float kalman_update(kalman_rssi_t *kf, float measurement) {
// Predire
kf->p = kf->p + kf->q;
// Mettre a jour
float k = kf->p / (kf->p + kf->r); // Gain de Kalman
kf->x = kf->x + k * (measurement - kf->x);
kf->p = (1.0f - k) * kf->p;
return kf->x;
}
Reglage de Q et R
Le rapport Q/R determine le comportement du filtre :
| Rapport Q/R | Comportement | Application |
|---|---|---|
| 0.01 | Tres lisse, reponse lente | Surveillance d’actifs statiques |
| 0.1 | Equilibre | Positionnement interieur general |
| 0.5 | Reactif, bruit modere | Suivi d’actifs en mouvement |
| 1.0+ | Peu de filtrage, reponse rapide | Scenarios de haute mobilite |
Avec R defini a partir du σ² mesure (ex. : σ=5.2 → R=27.0) et Q=2.7 (Q/R=0.1), le filtre de Kalman atteint un σ_eff d’environ 2.3 dB – une reduction de 2.3x – avec un temps de stabilisation d’environ 1.5 secondes.
Avantages par rapport a l’EWMA
Le filtre de Kalman adapte son gain dynamiquement : lorsque l’incertitude d’estimation est elevee (juste apres l’initialisation ou un changement en echelon), le gain est eleve et le filtre repond rapidement. A mesure que la confiance augmente, le gain diminue et le filtre devient plus lisse. L’EWMA utilise un α fixe, qui ne peut pas s’adapter.
| Propriete | EWMA (α=0.2) | Kalman (Q=2.7, R=27.0) |
|---|---|---|
| σ_eff en regime permanent | 2.6 dB | 2.3 dB |
| Reponse echelon (90% montee) | 2.5 s | 1.2 s |
| Gain adaptatif | Non | Oui |
| Memoire | 4 octets | 16 octets |
| Calcul par echantillon | 2 ops | 5 ops |
8. Filtre de Particules pour les Environnements Non Lineaires
Dans les environnements avec multitrajet severe (entrepots, usines), l’hypothese gaussienne s’effondre. Les distributions RSSI deviennent multimodales, et les filtres lineaires (EWMA, Kalman) convergent vers la mauvaise valeur.
Le filtre de particules represente la distribution de probabilite RSSI comme un ensemble d’echantillons ponderes (particules) :
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
Performance dans les environnements domines par NLOS
Dans un test d’entrepot (55% NLOS), suivi d’une balise a 4 m de distance :
| Filtre | Erreur moyenne (m) | Erreur P95 (m) | Temps de convergence |
|---|---|---|---|
| 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 |
| Particules (100 particules) | 0.9 | 2.1 | 1.5 s |
Le filtre de particules reduit l’erreur moyenne de 43% par rapport a l’EWMA dans cet environnement difficile. Cependant, il necessite 100x plus de memoire et de calcul, le rendant impraticable sur des etiquettes balise a ressources limitees.
Recommandation : Utiliser les filtres de particules du cote recepteur/passrelle (smartphones, passrelles Raspberry Pi) ou le calcul est disponible. Sur les etiquettes balise elles-memes, l’EWMA ou le Kalman suffit car l’etiquette ne fait qu’emettre – le filtrage se fait au recepteur.
9. Comparaison des Filtres : Tableau de Compromis Complet
| Filtre | Reduction σ (σ=5.2 dB) | Latence | Memoire | Calcul | Resistant aux aberrants | Adaptatif |
|---|---|---|---|---|---|---|
| RSSI brut | 1.0x (5.2 dB) | 0 ms | 0 o | 0 ops | Non | N/A |
| SMA (N=4) | 2.0x (2.6 dB) | 150 ms | 4 o | 1 op | Non | Non |
| SMA (N=8) | 2.8x (1.8 dB) | 350 ms | 8 o | 1 op | Non | Non |
| WMA (N=8) | 2.5x (2.1 dB) | 240 ms | 8 o | 8 ops | Non | Non |
| EWMA (α=0.3) | 1.8x (2.9 dB) | 100 ms | 4 o | 2 ops | Non | Non |
| EWMA (α=0.15) | 2.9x (1.8 dB) | 800 ms | 4 o | 2 ops | Non | Non |
| Median (N=5) | 1.7x (3.1 dB) | 200 ms | 5 o | 10 ops | Oui | Non |
| Median+EWMA | 2.7x (1.9 dB) | 300 ms | 9 o | 12 ops | Oui | Non |
| Kalman | 2.3x (2.3 dB) | 150 ms | 16 o | 5 ops | Partiel | Oui |
| Particules (100) | 3.5x (1.5 dB) | 400 ms | 800 o | 300 ops | Oui | Oui |
Observations cles :
– Median+EWMA offre le meilleur equilibre pour les systemes embarques : performance proche du Kalman avec une implementation plus simple et un rejet des valeurs aberrantes.
– Kalman est optimal lorsque vous pouvez regler Q/R correctement et avez besoin d’un comportement adaptatif.
– Filtre de particules excelle en multitrajet severe mais est reserve aux passrelles en raison du cout de calcul.
– SMA est adequat pour la surveillance statique ou la latence n’a pas d’importance.
10. Strategies de Filtrage Adaptatif
Les filtres a parametres fixes sont sous-optimaux car les statistiques RSSI changent avec l’environnement et la mobilite de la balise. Les strategies adaptatives ameliorent significativement les performances :
10.1 EWMA conscient de la mobilite
Detecter le mouvement de la balise en utilisant la variance RSSI sur une fenetre courte, puis ajuster α dynamiquement :
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; // Mouvement rapide
else if (var > 10.0f) return 0.25f; // Mouvement lent
else return 0.1f; // Statique
}
10.2 Kalman conscient de l’environnement
Ajuster R en fonction de la probabilite NLOS locale. Lorsque les mesures recentes montrent de grands ecarts par rapport a l’etat predit, augmenter R temporairement :
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 Detection LOS/NLOS basee sur HMM
Un Modele de Markov Cache peut classer chaque mesure comme LOS ou NLOS, puis appliquer differents filtres :
– Etat LOS : Appliquer Kalman avec R faible (confiance dans la mesure)
– Etat NLOS : Appliquer Kalman avec R eleve (mesure decomptee) ou la rejeter
La matrice de transition est apprise empiriquement a partir de donnees d’entrainement. Probabilites de transition typiques pour un environnement de bureau :
| Suivant : LOS | Suivant : NLOS | |
|---|---|---|
| Actuel : LOS | 0.92 | 0.08 |
| Actuel : NLOS | 0.35 | 0.65 |
Cela signifie que LOS tend a persister (92% de probabilite de rester LOS), tandis que NLOS est egalement quelque peu persistant (65%). Le HMM atteint 85-90% de precision de classification, ameliorant significativement les performances du filtre dans les environnements mixtes.
11. Considerations d’Implementation
11.1 Arithmetique entiere pour MCUs a ressources limitees
Sur des MCUs 8 ou 16 bits (courants dans les etiquettes balise), les operations a virgule flottante sont couteuses. L’EWMA peut etre implemente en virgule fixe :
// EWMA a virgule fixe avec format Q8 (8 bits fractionnaires)
// 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);
}
Cela utilise uniquement la multiplication et le decalage d’entiers – aucune bibliotheque a virgule flottante necessaire.
11.2 Gestion des intervalles de publicite
Les intervalles de publicite des balises varient de 20 ms (positionnement a haut debit) a 1000 ms (mode d’economie de batterie). Les parametres du filtre doivent s’adapter a l’intervalle :
– Intervalle 100 ms avec α=0.2 : constante de temps = 0.5 s
– Intervalle 1000 ms avec α=0.2 : constante de temps = 5.0 s (trop lent)
Solution : Calculer α a partir d’une constante de temps souhaitee τ :
α = 1 - exp(-Δt / τ)Ou Δt est l’intervalle de publicite et τ est la constante de temps souhaitee (ex. : 0.5 s). Cela assure un comportement de filtre coherent independamment de l’intervalle.
11.3 Filtrage multi-balises
Lors du suivi de plusieurs balises simultanement, chaque balise necessite sa propre instance de filtre. Budget memoire sur une passrelle typique (ESP32, 520 Ko SRAM) :
| Type de filtre | Memoire par balise | Max balises (budget 50 Ko) |
|---|---|---|
| EWMA (float) | 8 o | 6 250 |
| Kalman (float) | 32 o | 1 562 |
| Median+EWMA (N=5, int8) | 14 o | 3 571 |
| Particules (100, float) | 1 600 o | 31 |
L’EWMA et le Kalman passent a l’echelle pour des milliers de balises. Les filtres de particules sont limites a des dizaines.
12. Recommandations de Deploiement
Base sur des tests sur le terrain dans des environnements de bureau, de commerce de detail, d’entrepot et industriels, voici les configurations de filtre recommandees :
Detection de proximite (notifications push, entree/sortie de zone)
Filtre : Median (N=5) + EWMA (α=0.15)
Intervalle : 100-200 ms
σ_eff : ~2.0 dB
Latence : ~400 ms
Notes : Le median rejette les valeurs aberrantes NLOS ; l'EWMA lisse le bruit restant.
Utiliser une hysterese sur le seuil de distance (entree a 3m, sortie a 5m)
pour eviter les rebonds.
Positionnement interieur (trilateration, fingerprinting)
Filtre : Kalman (Q=0.5, R=σ_mesure²)
Intervalle : 100-300 ms
σ_eff : ~2.3 dB
Latence : ~150 ms
Notes : Regler R par environnement. Utiliser R adaptatif pour les zones riches en NLOS.
Le taux de mise a jour de position devrait etre de 2-5 Hz pour une UI fluide.
Suivi d’actifs (RTLS, suivi de chariots eleveurs)
Filtre : EWMA adaptatif (α : 0.1-0.4, conscient de la mobilite)
Intervalle : 200-500 ms
σ_eff : ~2.5 dB (dynamique)
Latence : 100-800 ms (dynamique)
Notes : Detecter le mouvement via la variance RSSI, basculer α en consequence.
Utiliser un filtre de particules sur la passrelle si le multitrajet est severe.
Surveillance statique (detection de presence, niveau de piece)
Filtre : EWMA (α=0.05) ou SMA (N=20)
Intervalle : 500-1000 ms
σ_eff : ~1.2 dB
Latence : 2-5 s
Notes : La latence est acceptable pour la detection de presence.
Ultra bas σ permet une classification fiable au niveau de la piece.
Multitrajet severe (entrepot, usine)
Filtre : Filtre de particules (50-100 particules) sur passrelle
+ Kalman sur recepteur mobile
Intervalle : 100-200 ms
σ_eff : ~1.5 dB
Latence : ~400 ms
Notes : Le filtre de particules gere les distributions RSSI multimodales.
Le traitement cote passrelle decharge les etiquettes du calcul.
Conclusion
Le filtrage RSSI n’est pas optionnel – c’est l’etape de traitement du signal la plus impactante dans tout systeme de balises. Le choix de l’algorithme depend de la tolerance a la latence de l’application, du budget de calcul et de l’environnement RF :
– Pour les prototypes rapides et la proximite simple : EWMA avec α=0.2 suffit.
– Pour la detection de proximite en production : l’hybride Median + EWMA est le meilleur choix generaliste.
– Pour les systemes de positionnement : Filtre de Kalman avec Q/R regle pour l’environnement.
– Pour le multitrajet severe : Filtre de particules du cote passrelle.
L’erreur la plus courante est d’utiliser un seul filtre fixe pour tous les scenarios. Les environnements reels changent – les gens bougent, les portes s’ouvrent, les canaux Wi-Fi changent. Les strategies adaptatives qui detectent la mobilite et les conditions NLOS peuvent reduire l’erreur de positionnement de 30-50% par rapport aux filtres a parametres fixes, sans cout materiel supplementaire.
N’oubliez pas qu’aucun filtre ne peut recuperer des informations qui ne sont pas la. Si la balise n’emet qu’une fois par seconde, aucune quantite de filtrage ne donnera une latence sub-seconde. Commencez avec un taux de publicite approprie, choisissez le filtre le plus simple qui reponde a vos exigences de precision, et ajoutez de la complexite uniquement lorsque les mesures prouvent que c’est necessaire. Lors de la selection du materiel, envisagez un module Bluetooth fiable qui prend en charge des intervalles de publicite et une puissance de sortie configurables ; ces parametres affectent directement la qualite du RSSI brut avec laquelle votre filtre doit travailler.
