WiFi Sense Lab

Dal simulatore al sensing reale

Questa app è una simulazione: i numeri sono generati localmente. Se vuoi passare a un sistema che lavora su segnali Wi-Fi veri, il percorso open source è ben tracciato — hardware accessibile, tool maturi, dataset pubblici, pipeline Python. La dashboard che hai davanti può poi essere riusata come front-end, sostituendo i dati simulati con un feed reale.

1. 1

   Hardware capace di esporre CSI

   I router commerciali standard espongono solo RSSI (un singolo numero). Per il sensing serio serve la Channel State Information (CSI): ampiezza e fase per ogni sottoportante OFDM. Opzioni accessibili:

   • ESP32-S3 / ESP32-C3 — scheda da pochi euro, espone CSI nativamente via SDK Espressif. Punto di partenza ideale.
   • Router OpenWrt con chip supportato (es. Broadcom + firmware Nexmon) per CSI su Wi-Fi 5.
   • SDR (USRP, HackRF) — più flessibile ma molto più complesso e costoso.
2. 2

   Toolchain open source

   Progetti che fanno il lavoro sporco di estrarre il CSI dal firmware e renderlo accessibile da userspace:

   • ESP32-CSI-Tool — sniffer CSI per ESP32, output CSV pronto per analisi.
   • Nexmon CSI — patch firmware per chip Broadcom (Raspberry Pi 3B+/4, alcuni router e smartphone) che abilita l'estrazione CSI.
   • Atheros CSI Tool — strumento storico per schede Atheros (kernel patchato), usato in moltissimi paper.
   • PicoScenes / linux-80211n-csitool (Intel 5300) — alternative per setup PC.
3. 3

   Letteratura e dataset

   Prima di addestrare un modello, leggi qualche paper e parti da dataset pubblici per evitare di raccogliere ore di registrazioni.

   • Query di partenza: "WiFi CSI human activity recognition", "device-free localization", "WiFi respiration estimation".
   • SignFi — dataset di linguaggio dei segni via CSI (276 gesti).
   • Widar 3.0 (Tsinghua) — riconoscimento gesti cross-domain, dataset esteso e citatissimo.
   • FallDeFi, WiAR — focus su cadute e attività quotidiane.
4. 4

   Pipeline Python

   Una pipeline minima riceve i pacchetti CSI, li ripulisce, estrae feature e classifica. Esempio scheletrico:

   import numpy as np, pandas as pd
   from scipy.signal import butter, filtfilt
   from sklearn.ensemble import RandomForestClassifier
   
   # 1. Acquisizione: serial (ESP32) o UDP (Nexmon)
   csi = read_csi_stream(source="serial:/dev/ttyUSB0")  # shape: (T, subcarriers)
   
   # 2. Pre-processing: ampiezza, denoise, detrend
   amp = np.abs(csi)
   b, a = butter(4, [0.5, 5], btype="band", fs=100)     # banda 0.5–5 Hz (movimento)
   amp_f = filtfilt(b, a, amp, axis=0)
   
   # 3. Feature: varianza, entropia, PCA, spettrogrammi STFT…
   features = extract_features(amp_f, win=2.0, hop=0.5)
   
   # 4. Modello: da Random Forest a CNN/LSTM su spettrogrammi
   clf = RandomForestClassifier().fit(X_train, y_train)
   pred = clf.predict(features)
   
   # 5. Output: stato + confidenza → WebSocket verso la dashboard
   publish({"state": pred[-1], "confidence": float(clf.predict_proba(features)[-1].max())})
   

   In progetti più maturi si usano CNN, LSTM o Transformer su spettrogrammi tempo-frequenza, con tecniche di domain adaptation per generalizzare tra ambienti diversi.

5. 5

   Dashboard: questa PWA, alimentata da dati veri

   Il front-end che stai usando può diventare la UI del sistema reale. L'interfaccia tra pipeline e dashboard è banale:

   • WebSocket dal servizio Python → { state, confidence, rssi, ts } a ~20 Hz.
   • Il loop di rendering della PWA legge dal socket invece che dal generatore simulato — i grafici e l'indicatore di stato restano identici.
   • Per deploy edge: container Python + reverse proxy + la PWA servita statica. Nessun cloud richiesto.

   In altre parole: il modello mentale costruito qui (RSSI, Δ, σ, confidenza, classi di stato) è già quello di un sistema reale. Cambia solo la sorgente del segnale.